From a92363fc3c6c26cbcff9e19bc6dc1650aefab2fb Mon Sep 17 00:00:00 2001
From: DevTKSS <info@technische-konstruktion.com>
Date: Wed, 8 Jan 2025 00:05:22 +0100
Subject: [PATCH] docs(CTK): formatting and spellchecking on Converters pages

---
 doc/articles/uno-community-toolkit-v8.md      |  84 ++-
 .../DateTimePatternParser/PatternNodes.cs     | 429 +++++++++++
 .../DateTimePatternParser/PatternParser.cs    | 514 +++++++++++++
 .../DateTimeTemplateParser/TemplateNodes.cs   | 574 +++++++++++++++
 .../DateTimeTemplateParser/TemplateParser.cs  | 674 ++++++++++++++++++
 .../DateTimeFormatting/TimeZoneFormat.cs      |   9 +
 .../Helpers/StartStopDelegateWrapper.cs       |  90 +++
 .../Helpers/StartStopTypedEventWrapper.cs     |  35 +
 8 files changed, 2365 insertions(+), 44 deletions(-)
 create mode 100644 src/Uno.UWP/Globalization/DateTimeFormatting/DateTimePatternParser/PatternNodes.cs
 create mode 100644 src/Uno.UWP/Globalization/DateTimeFormatting/DateTimePatternParser/PatternParser.cs
 create mode 100644 src/Uno.UWP/Globalization/DateTimeFormatting/DateTimeTemplateParser/TemplateNodes.cs
 create mode 100644 src/Uno.UWP/Globalization/DateTimeFormatting/DateTimeTemplateParser/TemplateParser.cs
 create mode 100644 src/Uno.UWP/Globalization/DateTimeFormatting/TimeZoneFormat.cs
 create mode 100644 src/Uno.UWP/Helpers/StartStopDelegateWrapper.cs
 create mode 100644 src/Uno.UWP/Helpers/StartStopTypedEventWrapper.cs

diff --git a/doc/articles/uno-community-toolkit-v8.md b/doc/articles/uno-community-toolkit-v8.md
index 490aa255adc6..68ed72673e97 100644
--- a/doc/articles/uno-community-toolkit-v8.md
+++ b/doc/articles/uno-community-toolkit-v8.md
@@ -186,7 +186,7 @@ A complete working sample, along with additional examples, is available on GitHu
 
 ## Using Non-UI Elements from the CommunityToolkit: Converters
 
-The CommunityToolkit is providing some ready-to-use Converters for e.g. x:Bind in Xaml, whithout having to write already existing basic Converters yourself. 
+The CommunityToolkit is providing some ready-to-use Converters for e.g. x:Bind in Xaml, whithout having to write already existing basic Converters yourself.
 [List of CommunityToolkit Converters | Windows Toolkit Documentation](https://learn.microsoft.com/en-us/dotnet/communitytoolkit/windows/converters/)
 
 The implementation of those are quite similar to the example of the SettingsControl above, but there are small adjustments to be done to use them:
@@ -194,15 +194,15 @@ The implementation of those are quite similar to the example of the SettingsCont
 1. Import of the Package
 
    Change this:
-   
+
    ```CommunityToolkit.WinUI.Controls.SettingsControls```
-   
+
    to Converters namespace:
 
    ```CommunityToolkit.WinUI.Converters```
 
    while the Version will stay the same as above.
-   
+
 1. Add the related needed namespace(s)
 
     > [!NOTE]
@@ -218,65 +218,61 @@ The implementation of those are quite similar to the example of the SettingsCont
 
       In case you are developing a App that's using C# Markup and you want to use the Converters, you can now switch to [C#-Markup Converters](https://platform.uno/docs/articles/external/uno.extensions/doc/Learn/Markup/Converters.html) Documentation for future Usage Guide, the general Import is done from here on.
 
-  1. Xaml Definition
-     
-Important Difference to the previous seen SettingsCard Control Example, a Non-UI Converter has to be imported to the Page.Ressources Section to StaticRessources like this for using it, since there is no single Namespace per Converter like on the Controls:
+1. Xaml Definition
+
+Important Difference to the previous seen SettingsCard Control Example, a Non-UI Converter has to be imported to the Page.Resources Section to StaticResources like this for using it, since there is no single Namespace per Converter like on the Controls:
 
 ### [Example StringToVisibilityConverter](#tab/string-visible-conv)
 
 StringToVisibilityConverter is a Converter that has to be bound to a String typed Property and will return a Visibility State.
 
-        ```
-        <Page.Resources>
-          <converters:StringVisibilityConverter x:Key="YourStringVisibilityConverter"/>
-        </Page.Resources>
-        ```
+```xml
+<Page.Resources>
+  <converters:StringVisibilityConverter x:Key="YourStringVisibilityConverter"/>
+</Page.Resources>
+```
 
 Somewhere in your Page Content:
-        
-        ```xml
-                <TextBox x:Name="tbName"
-                         Text="{Binding Name, Mode=TwoWay}" 
-                         PlaceholderText="Enter your name:"/>
-                <Button x:Name="StartButton"
-                        Content="Start a cool simple Game!"
-                        AutomationProperties.AutomationId="StartAGameButton"
-                        Command="{Binding GoToStart}"
-                        HorizontalAlignment="Center"
-                        Visibility="{x:Bind tbName.Text, Converter={StaticResource StringVisibilityConverter}, Mode=OneWay}"/>
-        ```
-        
+
+```xml
+  <TextBox x:Name="tbName"
+           Text="{Binding Name, Mode=TwoWay}" 
+           PlaceholderText="Enter your name:"/>
+  <Button x:Name="StartButton"
+          Content="Start a cool simple Game!"
+          AutomationProperties.AutomationId="StartAGameButton"
+          Command="{Binding GoToStart}"
+          HorizontalAlignment="Center"
+          Visibility="{x:Bind tbName.Text, Converter={StaticResource StringVisibilityConverter}, Mode=OneWay}"/>
+```
+
 ### [Example BoolToObjectConverter](#tab/bool-obj-conv)
 
 BoolToObjectConverter is a Converter that has to be bound to a Boolean typed Property and can return any Object you will give to it.
 You only have to tell it what to return on True or False. If you would like to use it for switching color on validation:
 
-    ```
-    BoolToObjectConverter x:Key="BoolToColorConverter" TrueValue="{ThemeResource SystemFillColorSuccessBackgroundBrush}"
-                                                        FalseValue="{ThemeResource SystemFillColorCriticalBackgroundBrush}"/>
-    ```
+```xml
+BoolToObjectConverter x:Key="BoolToColorConverter" TrueValue="{ThemeResource SystemFillColorSuccessBackgroundBrush}"
+                                                   FalseValue="{ThemeResource SystemFillColorCriticalBackgroundBrush}"/>
+```
 
 > [!NOTE]
 > The used ThemeResource Brushes can be found in the WinUI Gallery for example.
 > Feel free to use your own Colors e.g. from ColorPaletteOverrides
 
 Somewhere in your Page Content:
-    
-    ```xml
-            <TextBox x:Name="tbName"
-                     Text="{Binding Name, Mode=TwoWay}" 
-                     PlaceholderText="Enter your name:"
-                     BackgroundColor="{x:Bind tbName.Text, Converter={StaticResource BoolToColorConverter},Mode=OneWay}/>
-            <Button x:Name="StartButton"
-                    Content="Start a cool simple Game!"
-                    AutomationProperties.AutomationId="StartAGameButton"
-                    Command="{Binding GoToStart}"
-                    HorizontalAlignment="Center"/>
-    ```
-    
----
 
-[!include[getting-help](includes/getting-help.md)]
+```xml
+  <TextBox x:Name="tbName"
+           Text="{Binding Name, Mode=TwoWay}" 
+           PlaceholderText="Enter your name:"
+           BackgroundColor="{x:Bind tbName.Text, Converter={StaticResource BoolToColorConverter},Mode=OneWay}/>
+  <Button x:Name="StartButton"
+          Content="Start a cool simple Game!"
+          AutomationProperties.AutomationId="StartAGameButton"
+          Command="{Binding GoToStart}"
+          HorizontalAlignment="Center"/>
+```
 
 ---
 
diff --git a/src/Uno.UWP/Globalization/DateTimeFormatting/DateTimePatternParser/PatternNodes.cs b/src/Uno.UWP/Globalization/DateTimeFormatting/DateTimePatternParser/PatternNodes.cs
new file mode 100644
index 000000000000..a2c3cf8d6557
--- /dev/null
+++ b/src/Uno.UWP/Globalization/DateTimeFormatting/DateTimePatternParser/PatternNodes.cs
@@ -0,0 +1,429 @@
+#nullable enable
+
+using System;
+using System.Globalization;
+using System.Text;
+
+namespace Windows.Globalization.DateTimeFormatting;
+
+// <pattern> ::= [<literal-text>] <datetime-pattern> [<literal-text>] |
+//               [<literal-text>] <datetime-pattern> <pattern>
+internal sealed class PatternRootNode
+{
+	public PatternRootNode(
+		PatternLiteralTextNode? optionalPrefixLiteralText,
+		PatternDateTimeNode dateTimeNode,
+		PatternLiteralTextNode? optionalSuffixLiteralText)
+	{
+		OptionalPrefixLiteralText = optionalPrefixLiteralText;
+		DateTimeNode = dateTimeNode;
+		OptionalSuffixLiteralText = optionalSuffixLiteralText;
+	}
+
+	public PatternRootNode(
+		PatternLiteralTextNode? optionalPrefixLiteralText,
+		PatternDateTimeNode dateTimeNode,
+		PatternRootNode? optionalSuffixPattern)
+	{
+		OptionalPrefixLiteralText = optionalPrefixLiteralText;
+		DateTimeNode = dateTimeNode;
+		OptionalSuffixPattern = optionalSuffixPattern;
+	}
+
+	public PatternLiteralTextNode? OptionalPrefixLiteralText { get; }
+	public PatternDateTimeNode DateTimeNode { get; }
+
+	// Either both are null, or only one is null.
+	// The two cannot be non-null at the same time
+	public PatternLiteralTextNode? OptionalSuffixLiteralText { get; }
+	public PatternRootNode? OptionalSuffixPattern { get; }
+
+	internal string Format(DateTimeOffset dateTime, CultureInfo culture, bool isTwentyFourHours)
+	{
+		var builder = new StringBuilder();
+		Format(builder, dateTime, culture, isTwentyFourHours);
+		return builder.ToString();
+	}
+
+	internal void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture, bool isTwentyFourHours)
+	{
+		OptionalPrefixLiteralText?.Format(builder, dateTime, culture, isTwentyFourHours);
+		DateTimeNode.Format(builder, dateTime, culture, isTwentyFourHours);
+		OptionalSuffixLiteralText?.Format(builder, dateTime, culture, isTwentyFourHours);
+		OptionalSuffixPattern?.Format(builder, dateTime, culture, isTwentyFourHours);
+	}
+}
+
+// <literal-text> ::= <literal-character>+
+// <literal-character> ::= [^{}] | "{openbrace}" | "{closebrace}"
+internal sealed class PatternLiteralTextNode
+{
+	public PatternLiteralTextNode(string text)
+	{
+		Text = text;
+	}
+
+	public string Text { get; }
+
+	internal void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture, bool isTwentyFourHours)
+		=> builder.Append(Text);
+}
+
+// <datetime-pattern> ::= <era> | <year> | <month> | <day> | <dayofweek> |
+//                        <period> | <hour> | <minute> | <second> | <timezone>
+internal abstract class PatternDateTimeNode
+{
+	internal abstract void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture, bool isTwentyFourHours);
+}
+
+// <era> ::= "{era.abbreviated" [<ideal-length>] "}"
+internal sealed class PatternEraNode : PatternDateTimeNode
+{
+	public PatternEraNode(int? idealLength)
+	{
+		IdealLength = idealLength;
+	}
+
+	// Era is always "era.abbreviated", so no need to distinguish.
+	public int? IdealLength { get; }
+
+	internal override void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture, bool isTwentyFourHours)
+	{
+		// C# can't represent negative dates (i.e, before christ).
+		// So, looks like Era will always be "AD" (Anno Domini).
+		builder.Append(IdealLength.HasValue && IdealLength.Value < 4 ? "AD" : "A.D.");
+	}
+}
+
+// <year> ::= "{year.full" [<ideal-length>] "}" |
+//           "{year.abbreviated" [<ideal-length>] "}" |
+internal sealed class PatternYearNode : PatternDateTimeNode
+{
+	internal enum YearKind
+	{
+		Full,
+		Abbreviated
+	}
+
+	public PatternYearNode(YearKind kind, int? idealLength)
+	{
+		Kind = kind;
+		IdealLength = idealLength;
+	}
+
+	public YearKind Kind { get; }
+	public int? IdealLength { get; }
+
+	internal override void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture, bool isTwentyFourHours)
+	{
+		if (Kind == YearKind.Full)
+		{
+			if (IdealLength.HasValue)
+			{
+				builder.Append(dateTime.Year.ToString(new string('0', IdealLength.Value), culture));
+			}
+			else
+			{
+				builder.Append(dateTime.Year);
+			}
+		}
+		else if (Kind == YearKind.Abbreviated)
+		{
+			if (IdealLength.HasValue)
+			{
+				// TODO: This might not always be the right approach for all calendars.
+				// This implementation assumes gregorian calendar. The "correct" approach isn't yet known.
+				builder.Append((dateTime.Year % (10 * IdealLength.Value)).ToString(new string('0', IdealLength.Value), culture));
+			}
+			else
+			{
+				builder.Append((dateTime.Year % 100).ToString("00", culture));
+			}
+		}
+	}
+}
+
+// <month> ::= "{month.full}" |
+//             "{month.solo.full}" |
+//             "{month.abbreviated" [<ideal-length>] "}"
+//             "{month.solo.abbreviated" [<ideal-length>] "}"
+//             "{month.integer" [<ideal-length>] "}"
+internal sealed class PatternMonthNode : PatternDateTimeNode
+{
+	internal enum MonthKind
+	{
+		Full,
+		SoloFull,
+		Abbreviated,
+		SoloAbbreviated,
+		Integer,
+	}
+
+	public PatternMonthNode(MonthKind kind, int? idealLength = null)
+	{
+		Kind = kind;
+		IdealLength = idealLength;
+	}
+
+	public MonthKind Kind { get; }
+
+	// Always null for full and solo.full
+	public int? IdealLength { get; }
+
+	internal override void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture, bool isTwentyFourHours)
+	{
+		if (Kind == MonthKind.Full)
+		{
+			builder.Append(dateTime.ToString("MMMM", culture));
+		}
+		else if (Kind == MonthKind.SoloFull)
+		{
+			builder.Append(dateTime.ToString("MMMM", culture));
+		}
+		else if (Kind == MonthKind.Abbreviated)
+		{
+			builder.Append(dateTime.ToString("MMM", culture));
+		}
+		else if (Kind == MonthKind.SoloAbbreviated)
+		{
+			builder.Append(dateTime.ToString("MMM", culture));
+		}
+		else if (Kind == MonthKind.Integer)
+		{
+			if (IdealLength.HasValue)
+			{
+				var idealLength = IdealLength.Value;
+				if (idealLength >= 2)
+				{
+					builder.Append(dateTime.ToString("MM", culture));
+				}
+				else
+				{
+					builder.Append(dateTime.Month);
+				}
+			}
+			else
+			{
+				builder.Append(dateTime.Month);
+			}
+		}
+	}
+}
+
+// <dayofweek> ::= "{dayofweek.full}" |
+//                 "{dayofweek.solo.full}" |
+//                 "{dayofweek.abbreviated" [<ideal-length>] "}"
+//                 "{dayofweek.solo.abbreviated" [<ideal-length>] "}"
+internal sealed class PatternDayOfWeekNode : PatternDateTimeNode
+{
+	internal enum DayOfWeekKind
+	{
+		Full,
+		SoloFull,
+		Abbreviated,
+		SoloAbbreviated,
+	}
+
+	public PatternDayOfWeekNode(DayOfWeekKind kind, int? idealLength = null)
+	{
+		Kind = kind;
+		IdealLength = idealLength;
+	}
+
+	public DayOfWeekKind Kind { get; }
+
+	// Always null for full and solo.full
+	public int? IdealLength { get; }
+
+	internal override void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture, bool isTwentyFourHours)
+	{
+		if (Kind == DayOfWeekKind.Full)
+		{
+			builder.Append(dateTime.ToString("dddd", culture));
+		}
+		else if (Kind == DayOfWeekKind.SoloFull)
+		{
+			builder.Append(dateTime.ToString("dddd", culture));
+		}
+		else if (Kind == DayOfWeekKind.Abbreviated)
+		{
+			builder.Append(dateTime.ToString("ddd", culture));
+		}
+		else if (Kind == DayOfWeekKind.SoloAbbreviated)
+		{
+			builder.Append(dateTime.ToString("ddd", culture));
+		}
+	}
+}
+
+// <day> ::= "{day.integer" [<ideal-length>] "}"
+internal sealed class PatternDayNode : PatternDateTimeNode
+{
+	public PatternDayNode(int? idealLength)
+	{
+		IdealLength = idealLength;
+	}
+
+	public int? IdealLength { get; }
+
+	internal override void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture, bool isTwentyFourHours)
+	{
+		if (IdealLength.HasValue)
+		{
+			builder.Append(dateTime.Day.ToString(new string('0', IdealLength.Value), culture));
+		}
+		else
+		{
+			builder.Append(dateTime.Day);
+		}
+	}
+}
+
+// <period> ::= "{period.abbreviated" [<ideal-length>] "}"
+internal sealed class PatternPeriodNode : PatternDateTimeNode
+{
+	public PatternPeriodNode(int? idealLength)
+	{
+		IdealLength = idealLength;
+	}
+
+	public int? IdealLength { get; }
+
+	internal override void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture, bool isTwentyFourHours)
+	{
+		if (isTwentyFourHours)
+		{
+			return;
+		}
+
+		string period = dateTime.ToString("tt", culture);
+		if (IdealLength.HasValue && IdealLength.Value < period.Length)
+		{
+			builder.Append(period.Substring(0, IdealLength.Value));
+		}
+		else
+		{
+			builder.Append(period);
+		}
+	}
+}
+
+// <hour> ::= "{hour.integer" [<ideal-length>] "}"
+internal sealed class PatternHourNode : PatternDateTimeNode
+{
+	public PatternHourNode(int? idealLength)
+	{
+		IdealLength = idealLength;
+	}
+
+	public int? IdealLength { get; }
+
+	internal override void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture, bool isTwentyFourHours)
+	{
+		int hour = dateTime.Hour;
+		if (!isTwentyFourHours && hour > 12)
+		{
+			hour = hour - 12;
+		}
+
+		if (IdealLength.HasValue)
+		{
+			builder.Append(hour.ToString(new string('0', IdealLength.Value), culture));
+		}
+		else
+		{
+			builder.Append(hour);
+		}
+	}
+}
+
+// <minute> ::= "{minute.integer" [<ideal-length>] "}"
+internal sealed class PatternMinuteNode : PatternDateTimeNode
+{
+	public PatternMinuteNode(int? idealLength)
+	{
+		IdealLength = idealLength;
+	}
+
+	public int? IdealLength { get; }
+
+	internal override void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture, bool isTwentyFourHours)
+	{
+		if (IdealLength.HasValue)
+		{
+			builder.Append(dateTime.Minute.ToString(new string('0', IdealLength.Value), culture));
+		}
+		else
+		{
+			builder.Append(dateTime.Minute);
+		}
+	}
+}
+
+// <second> ::= "{second.integer" [<ideal-length>] "}"
+internal sealed class PatternSecondNode : PatternDateTimeNode
+{
+	public PatternSecondNode(int? idealLength)
+	{
+		IdealLength = idealLength;
+	}
+
+	public int? IdealLength { get; }
+
+	internal override void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture, bool isTwentyFourHours)
+	{
+		if (IdealLength.HasValue)
+		{
+			builder.Append(dateTime.Second.ToString(new string('0', IdealLength.Value), culture));
+		}
+		else
+		{
+			builder.Append(dateTime.Second);
+		}
+	}
+}
+
+// <timezone> ::= "{timezone.full}" |
+//                 "{timezone.abbreviated" [<ideal-length>] "}"
+internal sealed class PatternTimeZoneNode : PatternDateTimeNode
+{
+	internal enum TimeZoneKind
+	{
+		Full,
+		Abbreviated,
+	}
+
+	public PatternTimeZoneNode(TimeZoneKind kind, int? idealLength = null)
+	{
+		Kind = kind;
+		IdealLength = idealLength;
+	}
+
+	public TimeZoneKind Kind { get; }
+
+	// Always null for full
+	public int? IdealLength { get; }
+
+	internal override void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture, bool isTwentyFourHours)
+	{
+		// Important: dateTime parameter shouldn't be used here.
+		// WinUI uses the local time zone info.
+		// The offset part of DateTimeOffset will actually be lost when marshalling to WinUI.
+		// The marshalling of DateTimeOffset to C++ is just a simple "UniversalTime" that doesn't have
+		// information about time zones. It's simply UtcTicks - ManagedUtcTicksAtNativeZero (which is 504911232000000000)
+		if (Kind == TimeZoneKind.Full)
+		{
+			builder.Append(TimeZoneInfo.Local.StandardName);
+		}
+		else if (Kind == TimeZoneKind.Abbreviated)
+		{
+			// Note: Couldn't notice any behavior difference on WinUI using different values of ideal length.
+			// So it's unused for now until it's known how the value should be used and how it affects WinUI behavior.
+			builder.Append("GMT+");
+			builder.Append(TimeZoneInfo.Local.BaseUtcOffset.TotalHours);
+		}
+	}
+}
+
+// <ideal-length> ::= "(" <non-zero-digit> ")"
+// <non-zero-digit> ::= "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
diff --git a/src/Uno.UWP/Globalization/DateTimeFormatting/DateTimePatternParser/PatternParser.cs b/src/Uno.UWP/Globalization/DateTimeFormatting/DateTimePatternParser/PatternParser.cs
new file mode 100644
index 000000000000..f5c33414fbcc
--- /dev/null
+++ b/src/Uno.UWP/Globalization/DateTimeFormatting/DateTimePatternParser/PatternParser.cs
@@ -0,0 +1,514 @@
+#nullable enable
+
+using System;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Text;
+
+namespace Windows.Globalization.DateTimeFormatting;
+
+// We are kinda combining a lexer and a parser here as the grammar is simple enough.
+internal sealed class PatternParser
+{
+	private int _index;
+	private string _pattern;
+
+	public bool Completed => _index >= _pattern.Length;
+
+	public PatternParser(string pattern)
+	{
+		_pattern = pattern;
+	}
+
+	public PatternRootNode Parse()
+	{
+		PatternLiteralTextNode? prefixLiteralText = ParseLiteralText();
+		PatternDateTimeNode dateTimeNode = ParseDateTimePattern();
+		object? suffix = TryParseLiteralTextOrPattern();
+		if (suffix is null)
+		{
+			return new PatternRootNode(prefixLiteralText, dateTimeNode, (PatternLiteralTextNode?)null);
+		}
+		else if (suffix is PatternLiteralTextNode suffixLiteralText)
+		{
+			return new PatternRootNode(prefixLiteralText, dateTimeNode, suffixLiteralText);
+		}
+		else if (suffix is PatternRootNode suffixPattern)
+		{
+			return new PatternRootNode(prefixLiteralText, dateTimeNode, suffixPattern);
+		}
+		else
+		{
+			throw new InvalidOperationException("Unreachable.");
+		}
+	}
+
+	private object? TryParseLiteralTextOrPattern()
+	{
+		PatternLiteralTextNode? prefixLiteralText = ParseLiteralText();
+
+		if (Completed)
+		{
+			return prefixLiteralText;
+		}
+
+		PatternDateTimeNode dateTimeNode = ParseDateTimePattern();
+		object? suffix = TryParseLiteralTextOrPattern();
+		if (suffix is null)
+		{
+			return new PatternRootNode(prefixLiteralText, dateTimeNode, (PatternLiteralTextNode?)null);
+		}
+		else if (suffix is PatternLiteralTextNode suffixLiteralText)
+		{
+			return new PatternRootNode(prefixLiteralText, dateTimeNode, suffixLiteralText);
+		}
+		else if (suffix is PatternRootNode suffixPattern)
+		{
+			return new PatternRootNode(prefixLiteralText, dateTimeNode, suffixPattern);
+		}
+		else
+		{
+			throw new InvalidOperationException("Unreachable.");
+		}
+	}
+
+	// <datetime-pattern> ::= <era> | <year> | <month> | <day> | <dayofweek> |
+	//                        <period> | <hour> | <minute> | <second> | <timezone>
+	private PatternDateTimeNode ParseDateTimePattern()
+	{
+		if (Completed)
+		{
+			throw new ArgumentException($"Failed to parse date time pattern. Already reached the end of the pattern '{_pattern}'.");
+		}
+
+		if (TryParseEra(out var era))
+		{
+			return era;
+		}
+		else if (TryParseYear(out var year))
+		{
+			return year;
+		}
+		else if (TryParseMonth(out var month))
+		{
+			return month;
+		}
+		else if (TryParseDay(out var day))
+		{
+			return day;
+		}
+		else if (TryParseDayOfWeek(out var dayOfWeek))
+		{
+			return dayOfWeek;
+		}
+		else if (TryParsePeriod(out var period))
+		{
+			return period;
+		}
+		else if (TryParseHour(out var hour))
+		{
+			return hour;
+		}
+		else if (TryParseMinute(out var minute))
+		{
+			return minute;
+		}
+		else if (TryParseSecond(out var second))
+		{
+			return second;
+		}
+		else if (TryParseTimeZone(out var timeZone))
+		{
+			return timeZone;
+		}
+
+		throw new ArgumentException($"Failed to parse date time pattern component for pattern '{_pattern}'.");
+	}
+
+	private bool TryParseEra([NotNullWhen(true)] out PatternEraNode? era)
+	{
+		if (_pattern[_index] != '{')
+		{
+			era = null;
+			return false;
+		}
+
+		if (IsWordAfterOpenBrace(_index, "era.abbreviated"))
+		{
+			_index += "{era.abbreviated".Length;
+			int? idealLength = TryGetIdealLengthAndAdvance();
+			ExpectCharacterAndAdvance('}');
+
+			era = new PatternEraNode(idealLength);
+			return true;
+		}
+
+		era = null;
+		return false;
+	}
+
+	private bool TryParseYear([NotNullWhen(true)] out PatternYearNode? year)
+	{
+		if (_pattern[_index] != '{')
+		{
+			year = null;
+			return false;
+		}
+
+		if (IsWordAfterOpenBrace(_index, "year.full"))
+		{
+			_index += "{year.full".Length;
+			int? idealLength = TryGetIdealLengthAndAdvance();
+			ExpectCharacterAndAdvance('}');
+			year = new PatternYearNode(PatternYearNode.YearKind.Full, idealLength);
+			return true;
+		}
+		else if (IsWordAfterOpenBrace(_index, "year.abbreviated"))
+		{
+			_index += "{year.abbreviated".Length;
+			int? idealLength = TryGetIdealLengthAndAdvance();
+			ExpectCharacterAndAdvance('}');
+			year = new PatternYearNode(PatternYearNode.YearKind.Abbreviated, idealLength);
+			return true;
+		}
+
+		year = null;
+		return false;
+	}
+
+	private bool TryParseMonth([NotNullWhen(true)] out PatternMonthNode? month)
+	{
+		if (_pattern[_index] != '{')
+		{
+			month = null;
+			return false;
+		}
+
+		if (IsWordAfterOpenBrace(_index, "month.full"))
+		{
+			_index += "{month.full".Length;
+			ExpectCharacterAndAdvance('}');
+			month = new PatternMonthNode(PatternMonthNode.MonthKind.Full);
+			return true;
+		}
+		else if (IsWordAfterOpenBrace(_index, "month.solo.full"))
+		{
+			_index += "{month.solo.full".Length;
+			ExpectCharacterAndAdvance('}');
+			month = new PatternMonthNode(PatternMonthNode.MonthKind.SoloFull);
+			return true;
+		}
+		else if (IsWordAfterOpenBrace(_index, "month.abbreviated"))
+		{
+			_index += "{month.abbreviated".Length;
+			int? idealLength = TryGetIdealLengthAndAdvance();
+			ExpectCharacterAndAdvance('}');
+			month = new PatternMonthNode(PatternMonthNode.MonthKind.Abbreviated, idealLength);
+			return true;
+		}
+		else if (IsWordAfterOpenBrace(_index, "month.solo.abbreviated"))
+		{
+			_index += "{month.solo.abbreviated".Length;
+			int? idealLength = TryGetIdealLengthAndAdvance();
+			ExpectCharacterAndAdvance('}');
+			month = new PatternMonthNode(PatternMonthNode.MonthKind.SoloAbbreviated, idealLength);
+			return true;
+		}
+		else if (IsWordAfterOpenBrace(_index, "month.integer"))
+		{
+			_index += "{month.integer".Length;
+			int? idealLength = TryGetIdealLengthAndAdvance();
+			ExpectCharacterAndAdvance('}');
+			month = new PatternMonthNode(PatternMonthNode.MonthKind.Integer, idealLength);
+			return true;
+		}
+
+		month = null;
+		return false;
+	}
+
+	private bool TryParseDayOfWeek([NotNullWhen(true)] out PatternDayOfWeekNode? dayOfWeek)
+	{
+		if (_pattern[_index] != '{')
+		{
+			dayOfWeek = null;
+			return false;
+		}
+
+		if (IsWordAfterOpenBrace(_index, "dayofweek.full"))
+		{
+			_index += "{dayofweek.full".Length;
+			ExpectCharacterAndAdvance('}');
+			dayOfWeek = new PatternDayOfWeekNode(PatternDayOfWeekNode.DayOfWeekKind.Full);
+			return true;
+		}
+		else if (IsWordAfterOpenBrace(_index, "dayofweek.solo.full"))
+		{
+			_index += "{dayofweek.solo.full".Length;
+			ExpectCharacterAndAdvance('}');
+			dayOfWeek = new PatternDayOfWeekNode(PatternDayOfWeekNode.DayOfWeekKind.SoloFull);
+			return true;
+		}
+		else if (IsWordAfterOpenBrace(_index, "dayofweek.abbreviated"))
+		{
+			_index += "{dayofweek.abbreviated".Length;
+			int? idealLength = TryGetIdealLengthAndAdvance();
+			ExpectCharacterAndAdvance('}');
+			dayOfWeek = new PatternDayOfWeekNode(PatternDayOfWeekNode.DayOfWeekKind.Abbreviated, idealLength);
+			return true;
+		}
+		else if (IsWordAfterOpenBrace(_index, "dayofweek.solo.abbreviated"))
+		{
+			_index += "{dayofweek.solo.abbreviated".Length;
+			int? idealLength = TryGetIdealLengthAndAdvance();
+			ExpectCharacterAndAdvance('}');
+			dayOfWeek = new PatternDayOfWeekNode(PatternDayOfWeekNode.DayOfWeekKind.SoloAbbreviated, idealLength);
+			return true;
+		}
+
+		dayOfWeek = null;
+		return false;
+	}
+
+	private bool TryParseDay([NotNullWhen(true)] out PatternDayNode? day)
+	{
+		if (_pattern[_index] != '{')
+		{
+			day = null;
+			return false;
+		}
+
+		if (IsWordAfterOpenBrace(_index, "day.integer"))
+		{
+			_index += "{day.integer".Length;
+			int? idealLength = TryGetIdealLengthAndAdvance();
+			ExpectCharacterAndAdvance('}');
+
+			day = new PatternDayNode(idealLength);
+			return true;
+		}
+
+		day = null;
+		return false;
+	}
+
+	private bool TryParsePeriod([NotNullWhen(true)] out PatternPeriodNode? period)
+	{
+		if (_pattern[_index] != '{')
+		{
+			period = null;
+			return false;
+		}
+
+		if (IsWordAfterOpenBrace(_index, "period.abbreviated"))
+		{
+			_index += "{period.abbreviated".Length;
+			int? idealLength = TryGetIdealLengthAndAdvance();
+			ExpectCharacterAndAdvance('}');
+
+			period = new PatternPeriodNode(idealLength);
+			return true;
+		}
+
+		period = null;
+		return false;
+	}
+
+	private bool TryParseHour([NotNullWhen(true)] out PatternHourNode? hour)
+	{
+		if (_pattern[_index] != '{')
+		{
+			hour = null;
+			return false;
+		}
+
+		if (IsWordAfterOpenBrace(_index, "hour.integer"))
+		{
+			_index += "{hour.integer".Length;
+			int? idealLength = TryGetIdealLengthAndAdvance();
+			ExpectCharacterAndAdvance('}');
+
+			hour = new PatternHourNode(idealLength);
+			return true;
+		}
+
+		hour = null;
+		return false;
+	}
+
+	private bool TryParseMinute([NotNullWhen(true)] out PatternMinuteNode? minute)
+	{
+		if (_pattern[_index] != '{')
+		{
+			minute = null;
+			return false;
+		}
+
+		if (IsWordAfterOpenBrace(_index, "minute.integer"))
+		{
+			_index += "{minute.integer".Length;
+			int? idealLength = TryGetIdealLengthAndAdvance();
+			ExpectCharacterAndAdvance('}');
+
+			minute = new PatternMinuteNode(idealLength);
+			return true;
+		}
+
+		minute = null;
+		return false;
+	}
+
+	private bool TryParseSecond([NotNullWhen(true)] out PatternSecondNode? second)
+	{
+		if (_pattern[_index] != '{')
+		{
+			second = null;
+			return false;
+		}
+
+		if (IsWordAfterOpenBrace(_index, "second.integer"))
+		{
+			_index += "{second.integer".Length;
+			int? idealLength = TryGetIdealLengthAndAdvance();
+			ExpectCharacterAndAdvance('}');
+
+			second = new PatternSecondNode(idealLength);
+			return true;
+		}
+
+		second = null;
+		return false;
+	}
+
+	private bool TryParseTimeZone([NotNullWhen(true)] out PatternTimeZoneNode? timeZone)
+	{
+		if (_pattern[_index] != '{')
+		{
+			timeZone = null;
+			return false;
+		}
+
+		if (IsWordAfterOpenBrace(_index, "timezone.full"))
+		{
+			_index += "{timezone.full".Length;
+			ExpectCharacterAndAdvance('}');
+
+			timeZone = new PatternTimeZoneNode(PatternTimeZoneNode.TimeZoneKind.Full);
+			return true;
+		}
+		else if (IsWordAfterOpenBrace(_index, "timezone.abbreviated"))
+		{
+			_index += "{timezone.abbreviated".Length;
+			int? idealLength = TryGetIdealLengthAndAdvance();
+			ExpectCharacterAndAdvance('}');
+
+			timeZone = new PatternTimeZoneNode(PatternTimeZoneNode.TimeZoneKind.Full, idealLength);
+			return true;
+		}
+
+		timeZone = null;
+		return false;
+	}
+
+	private void ExpectCharacterAndAdvance(char c)
+	{
+		if (_index >= _pattern.Length ||
+			_pattern[_index] != c)
+		{
+			throw new ArgumentException($"Expected character '{c}' at index {_index} of pattern '{_pattern}'.");
+		}
+
+		_index++;
+	}
+
+	private int? TryGetIdealLengthAndAdvance()
+	{
+		if (_pattern[_index] != '(' ||
+			_index + 2 >= _pattern.Length ||
+			_pattern[_index + 2] != ')')
+		{
+			return null;
+		}
+
+		char idealLengthChar = _pattern[_index + 1];
+		_index += 3;
+		if (idealLengthChar >= '1' && idealLengthChar <= '9')
+		{
+			return idealLengthChar - '0';
+		}
+
+		throw new ArgumentException($"The character '{idealLengthChar}' is not a valid ideal-length digit");
+	}
+
+	private PatternLiteralTextNode? ParseLiteralText()
+	{
+		// Keep looking for "{openbrace}", "{closebrace}", or any character that is not "{" or "}".
+		StringBuilder builder = new();
+		int i = _index;
+		while (i < _pattern.Length)
+		{
+			if (_pattern[i] == '{')
+			{
+				if (IsOpenBraceLiteral(i))
+				{
+					builder.Append('{');
+					i += "{openbrace}".Length;
+					continue;
+				}
+				else if (IsCloseBraceLiteral(i))
+				{
+					builder.Append('}');
+					i += "{closebrace}".Length;
+					continue;
+				}
+				else
+				{
+					// NOT a literal.
+					break;
+				}
+			}
+			else if (_pattern[i] != '}')
+			{
+				// Not '{' and not '}', so part of the literal text.
+				builder.Append(_pattern[i]);
+				i++;
+			}
+		}
+
+		_index = i;
+		return builder.Length == 0 ? null : new PatternLiteralTextNode(builder.ToString());
+	}
+
+	private bool IsWordAfterOpenBrace(int i, string word)
+	{
+		// i should be pointing at the index of '{'.
+		// We want to return true if we are at "{word".
+		// Note that we don't check for the "}" here
+		// This is because some callsites will continue parsing something between word and "}".
+		Debug.Assert(_pattern[i] == '{');
+
+		int wordLength = word.Length;
+		if (i + wordLength >= _pattern.Length)
+		{
+			return false;
+		}
+
+		return _pattern.AsSpan().Slice(i + 1, wordLength).SequenceEqual(word);
+	}
+
+	private bool IsOpenBraceLiteral(int i)
+	{
+		int openBraceLength = "openbrace".Length;
+		return IsWordAfterOpenBrace(i, "openbrace") &&
+			i + openBraceLength + 1 < _pattern.Length &&
+			_pattern[i + openBraceLength + 1] == '}';
+	}
+
+	private bool IsCloseBraceLiteral(int i)
+	{
+		int closeBraceLength = "closebrace".Length;
+		return IsWordAfterOpenBrace(i, "closebrace") &&
+			i + closeBraceLength + 1 < _pattern.Length &&
+			_pattern[i + closeBraceLength + 1] == '}';
+	}
+}
diff --git a/src/Uno.UWP/Globalization/DateTimeFormatting/DateTimeTemplateParser/TemplateNodes.cs b/src/Uno.UWP/Globalization/DateTimeFormatting/DateTimeTemplateParser/TemplateNodes.cs
new file mode 100644
index 000000000000..2a020273afb5
--- /dev/null
+++ b/src/Uno.UWP/Globalization/DateTimeFormatting/DateTimeTemplateParser/TemplateNodes.cs
@@ -0,0 +1,574 @@
+#nullable enable
+
+using System;
+using System.Collections.Immutable;
+
+namespace Windows.Globalization.DateTimeFormatting;
+
+internal sealed class DateTimeTemplateInfo
+{
+	public YearFormat IncludeYear { get; set; }
+
+	public MonthFormat IncludeMonth { get; set; }
+
+	public DayFormat IncludeDay { get; set; }
+
+	public DayOfWeekFormat IncludeDayOfWeek { get; set; }
+
+	public HourFormat IncludeHour { get; set; }
+
+	public MinuteFormat IncludeMinute { get; set; }
+
+	public SecondFormat IncludeSecond { get; set; }
+
+	public TimeZoneFormat IncludeTimeZone { get; set; }
+
+	public bool IsLongTime { get; set; }
+
+	public bool IsShortTime { get; set; }
+
+	public bool IsLongDate { get; set; }
+
+	public bool IsShortDate { get; set; }
+}
+
+internal abstract class TemplateNode
+{
+	internal abstract void Traverse(DateTimeTemplateInfo state);
+}
+
+// <template> ::= <opt-whitespace> <date> <opt-whitespace> |
+//                <opt-whitespace> <time> <opt-whitespace> |
+//                <opt-whitespace> <specific-date> <whitespace> <time> <opt-whitespace> |
+//                <opt-whitespace> <time> <whitespace> <specific-date> <opt-whitespace> |
+//                <opt-whitespace> <relative-date> <whitespace> <time> <opt-whitespace> |
+//                <opt-whitespace> <time> <whitespace> <relative-date> <opt-whitespace>
+//
+// <opt-whitespace> ::= [<whitespace>] 
+//
+// <whitespace> ::= " "+ 
+internal sealed class TemplateRootNode : TemplateNode
+{
+	public TemplateRootNode(TemplateNode first, TemplateNode? second = null)
+	{
+		First = first;
+		Second = second;
+	}
+
+	// The options for these properties per the grammar above is:
+	// 1. First is TemplateDateNode,         Second is null.
+	// 2. First is TemplateTimeNode,         Second is null.
+	// 3. First is TemplateSpecificDateNode, Second is TemplateTimeNode.
+	// 4. First is TemplateTimeNode,         Second is TemplateSpecificDateNode.
+	// 5. First is TemplateRelativeDateNode, Second is TemplateTimeNode.
+	// 6. First is TemplateTimeNode,         Second is TemplateRelativeDateNode.
+	public TemplateNode First { get; }
+	public TemplateNode? Second { get; }
+
+	internal override void Traverse(DateTimeTemplateInfo state)
+	{
+		First.Traverse(state);
+		Second?.Traverse(state);
+	}
+}
+
+// <date> ::= <year> | <month> | <day> | <month-year> | <relative-date> | <specific-date>
+internal abstract class TemplateDateNode : TemplateNode
+{
+}
+
+// <relative-date> ::= <dayofweek> | <month-day> | <relative-longdate>
+internal abstract class TemplateRelativeDateNode : TemplateDateNode
+{
+}
+
+// <specific-date> ::= <shortdate> | <longdate>
+internal abstract class TemplateSpecificDateNode : TemplateDateNode
+{
+
+}
+
+// <month-day> ::= <month> <whitespace> <day> |
+//                 <day> <whitespace> <month>
+internal sealed class TemplateMonthDayNode : TemplateRelativeDateNode
+{
+	public TemplateMonthDayNode(TemplateDateNode left, TemplateDateNode right)
+	{
+		Left = left;
+		Right = right;
+	}
+
+	public TemplateDateNode Left { get; }
+	public TemplateDateNode Right { get; }
+
+	internal override void Traverse(DateTimeTemplateInfo state)
+	{
+		Left.Traverse(state);
+		Right.Traverse(state);
+	}
+}
+
+// <relative-longdate> ::= <month> <whitespace> <day> <whitespace> <dayofweek> |
+//                         <month> <whitespace> <dayofweek> <whitespace> <day> |
+//                         <day> <whitespace> <month> <whitespace> <dayofweek> |
+//                         <day> <whitespace> <dayofweek> <whitespace> <month> |
+//                         <dayofweek> <whitespace> <day> <whitespace> <month> |
+//                         <dayofweek> <whitespace> <month> <whitespace> <day>
+internal sealed class TemplateRelativeLongDateNode : TemplateRelativeDateNode
+{
+	public TemplateRelativeLongDateNode(TemplateDateNode left, TemplateDateNode middle, TemplateDateNode right)
+	{
+		Left = left;
+		Middle = middle;
+		Right = right;
+	}
+
+	public TemplateDateNode Left { get; }
+	public TemplateDateNode Middle { get; }
+	public TemplateDateNode Right { get; }
+
+	internal override void Traverse(DateTimeTemplateInfo state)
+	{
+		Left.Traverse(state);
+		Middle.Traverse(state);
+		Right.Traverse(state);
+	}
+}
+
+// <month-year> ::= <month> <whitespace> <year> |
+//                  <year> <whitespace> <month>
+internal sealed class TemplateMonthYearNode : TemplateDateNode
+{
+	public TemplateMonthYearNode(TemplateNode left, TemplateNode right)
+	{
+		Left = left;
+		Right = right;
+	}
+
+	public TemplateNode Left { get; }
+	public TemplateNode Right { get; }
+
+	internal override void Traverse(DateTimeTemplateInfo state)
+	{
+		Left.Traverse(state);
+		Right.Traverse(state);
+	}
+}
+
+// <shortdate> ::= "shortdate" |
+//                 <month> <whitespace> <day> <whitespace> <year> |
+//                 <month> <whitespace> <year> <whitespace> <day> |
+//                 <day> <whitespace> <month> <whitespace> <year> |
+//                 <day> <whitespace> <year> <whitespace> <month> |
+//                 <year> <whitespace> <day> <whitespace> <month> |
+//                 <year> <whitespace> <month> <whitespace> <day>
+internal sealed class TemplateShortDateNode : TemplateSpecificDateNode
+{
+	public static TemplateShortDateNode DefaultShortDateInstance { get; } = new(null, null, null);
+
+	public TemplateShortDateNode(TemplateDateNode? left, TemplateDateNode? middle, TemplateDateNode? right)
+	{
+		Left = left;
+		Middle = middle;
+		Right = right;
+	}
+
+	public TemplateDateNode? Left { get; }
+	public TemplateDateNode? Middle { get; }
+	public TemplateDateNode? Right { get; }
+
+	internal override void Traverse(DateTimeTemplateInfo state)
+	{
+		if (ReferenceEquals(this, DefaultShortDateInstance))
+		{
+			state.IsShortDate = true;
+		}
+		else
+		{
+			Left!.Traverse(state);
+			Middle!.Traverse(state);
+			Right!.Traverse(state);
+		}
+	}
+}
+
+// <longdate> ::= "longdate" |
+//                <year> <whitespace> <month> <whitespace> <day> <whitespace> <dayofweek> |
+//                <year> <whitespace> <month> <whitespace> <dayofweek> <whitespace> <day> |
+//                <year> <whitespace> <day> <whitespace> <month> <whitespace> <dayofweek> |
+//                <year> <whitespace> <day> <whitespace> <dayofweek> <whitespace> <month> |
+//                <year> <whitespace> <dayofweek> <whitespace> <day> <whitespace> <month> |
+//                <year> <whitespace> <dayofweek> <whitespace> <month> <whitespace> <day> |
+//                <month> <whitespace> <year> <whitespace> <day> <whitespace> <dayofweek> |
+//                <month> <whitespace> <year> <whitespace> <dayofweek> <whitespace> <day> |
+//                <day> <whitespace> <year> <whitespace> <month> <whitespace> <dayofweek> |
+//                <day> <whitespace> <year> <whitespace> <dayofweek> <whitespace> <month> |
+//                <dayofweek> <whitespace> <year> <whitespace> <day> <whitespace> <month> |
+//                <dayofweek> <whitespace> <year> <whitespace> <month> <whitespace> <day> |
+//                <month> <whitespace> <day> <whitespace> <year> <whitespace> <dayofweek> |
+//                <month> <whitespace> <dayofweek> <whitespace> <year> <whitespace> <day> |
+//                <day> <whitespace> <month> <whitespace> <year> <whitespace> <dayofweek> |
+//                <day> <whitespace> <dayofweek> <whitespace> <year> <whitespace> <month> |
+//                <dayofweek> <whitespace> <day> <whitespace> <year> <whitespace> <month> |
+//                <dayofweek> <whitespace> <month> <whitespace> <year> <whitespace> <day> |
+//                <month> <whitespace> <day> <whitespace> <dayofweek> <whitespace> <year> |
+//                <month> <whitespace> <dayofweek> <whitespace> <day> <whitespace> <year> |
+//                <day> <whitespace> <month> <whitespace> <dayofweek> <whitespace> <year> |
+//                <day> <whitespace> <dayofweek> <whitespace> <month> <whitespace> <year> |
+//                <dayofweek> <whitespace> <day> <whitespace> <month> <whitespace> <year> |
+//                <dayofweek> <whitespace> <month> <whitespace> <day> <whitespace> <year>
+internal sealed class TemplateLongDateNode : TemplateSpecificDateNode
+{
+	public static TemplateLongDateNode DefaultLongDateInstance { get; } = new(null, null, null, null);
+
+	public TemplateLongDateNode(TemplateDateNode? first, TemplateDateNode? second, TemplateDateNode? third, TemplateDateNode? forth)
+	{
+		First = first;
+		Second = second;
+		Third = third;
+		Forth = forth;
+	}
+
+	public TemplateDateNode? First { get; }
+	public TemplateDateNode? Second { get; }
+	public TemplateDateNode? Third { get; }
+	public TemplateDateNode? Forth { get; }
+
+	internal override void Traverse(DateTimeTemplateInfo state)
+	{
+		if (ReferenceEquals(this, DefaultLongDateInstance))
+		{
+			state.IsLongDate = true;
+		}
+		else
+		{
+			First!.Traverse(state);
+			Second!.Traverse(state);
+			Third!.Traverse(state);
+			Forth!.Traverse(state);
+		}
+	}
+}
+
+// <time> ::= <hour> | 
+//            <hour> <whitespace> <timezone> |
+//            <timezone> <whitespace> <hour> |
+//            <shorttime> |
+//            <longtime>
+internal sealed class TemplateTimeNode : TemplateNode
+{
+	public TemplateTimeNode(TemplateNode first, TemplateNode? second = null)
+	{
+		First = first;
+		Second = second;
+	}
+
+	public TemplateNode First { get; }
+
+	public TemplateNode? Second { get; }
+
+	internal override void Traverse(DateTimeTemplateInfo state)
+	{
+		First.Traverse(state);
+		Second?.Traverse(state);
+	}
+}
+
+// <shorttime> ::= "shorttime" |
+//                 <hour> <whitespace> <minute> |
+//                 <minute> <whitespace> <hour> |
+//                 <timezone> <whitespace> <hour> <whitespace> <minute> |
+//                 <timezone> <whitespace> <minute> <whitespace> <hour> |
+//                 <hour> <whitespace> <timezone> <whitespace> <minute> |
+//                 <minute> <whitespace> <timezone> <whitespace> <hour> |
+//                 <hour> <whitespace> <minute> <whitespace> <timezone> |
+//                 <minute> <whitespace> <hour> <whitespace> <timezone>
+internal sealed class TemplateShortTimeNode : TemplateNode
+{
+	public static TemplateShortTimeNode DefaultShortTimeInstance { get; } = new(null, null, null);
+
+	public TemplateShortTimeNode(TemplateNode? first, TemplateNode? second, TemplateNode? third = null)
+	{
+		First = first;
+		Second = second;
+		Third = third;
+	}
+
+	public TemplateNode? First { get; }
+	public TemplateNode? Second { get; }
+	public TemplateNode? Third { get; }
+
+	internal override void Traverse(DateTimeTemplateInfo state)
+	{
+		if (ReferenceEquals(this, DefaultShortTimeInstance))
+		{
+			state.IsShortTime = true;
+		}
+		else
+		{
+			First!.Traverse(state);
+			Second!.Traverse(state);
+			Third?.Traverse(state);
+		}
+	}
+}
+
+// <longtime> ::= "longtime" |
+//                <hour> <whitespace> <minute> <whitespace> <second> |
+//                <hour> <whitespace> <second> <whitespace> <minute> |
+//                <minute> <whitespace> <hour> <whitespace> <second> |
+//                <minute> <whitespace> <second> <whitespace> <hour> |
+//                <second> <whitespace> <minute> <whitespace> <hour> |
+//                <second> <whitespace> <hour> <whitespace> <minute> |
+//                <timezone> <whitespace> <hour> <whitespace> <minute> <whitespace> <second> |
+//                <timezone> <whitespace> <hour> <whitespace> <second> <whitespace> <minute> |
+//                <timezone> <whitespace> <minute> <whitespace> <hour> <whitespace> <second> |
+//                <timezone> <whitespace> <minute> <whitespace> <second> <whitespace> <hour> |
+//                <timezone> <whitespace> <second> <whitespace> <minute> <whitespace> <hour> |
+//                <timezone> <whitespace> <second> <whitespace> <hour> <whitespace> <minute> |
+//                <hour> <whitespace> <timezone> <whitespace> <minute> <whitespace> <second> |
+//                <hour> <whitespace> <timezone> <whitespace> <second> <whitespace> <minute> |
+//                <minute> <whitespace> <timezone> <whitespace> <hour> <whitespace> <second> |
+//                <minute> <whitespace> <timezone> <whitespace> <second> <whitespace> <hour> |
+//                <second> <whitespace> <timezone> <whitespace> <minute> <whitespace> <hour> |
+//                <second> <whitespace> <timezone> <whitespace> <hour> <whitespace> <minute> |
+//                <hour> <whitespace> <minute> <whitespace> <timezone> <whitespace> <second> |
+//                <hour> <whitespace> <second> <whitespace> <timezone> <whitespace> <minute> |
+//                <minute> <whitespace> <hour> <whitespace> <timezone> <whitespace> <second> |
+//                <minute> <whitespace> <second> <whitespace> <timezone> <whitespace> <hour> |
+//                <second> <whitespace> <minute> <whitespace> <timezone> <whitespace> <hour> |
+//                <second> <whitespace> <hour> <whitespace> <timezone> <whitespace> <minute> |
+//                <hour> <whitespace> <minute> <whitespace> <second> <whitespace> <timezone> |
+//                <hour> <whitespace> <second> <whitespace> <minute> <whitespace> <timezone> |
+//                <minute> <whitespace> <hour> <whitespace> <second> <whitespace> <timezone> |
+//                <minute> <whitespace> <second> <whitespace> <hour> <whitespace> <timezone> |
+//                <second> <whitespace> <minute> <whitespace> <hour> <whitespace> <timezone> |
+//                <second> <whitespace> <hour> <whitespace> <minute> <whitespace> <timezone>
+internal sealed class TemplateLongTimeNode : TemplateNode
+{
+	public static TemplateLongTimeNode DefaultLongTimeInstance { get; } = new(null, null, null, null);
+
+	public TemplateLongTimeNode(TemplateNode? first, TemplateNode? second, TemplateNode? third, TemplateNode? forth = null)
+	{
+		First = first;
+		Second = second;
+		Third = third;
+		Forth = forth;
+	}
+
+	public TemplateNode? First { get; }
+	public TemplateNode? Second { get; }
+	public TemplateNode? Third { get; }
+	public TemplateNode? Forth { get; }
+
+	internal override void Traverse(DateTimeTemplateInfo state)
+	{
+		if (ReferenceEquals(this, DefaultLongTimeInstance))
+		{
+			state.IsLongTime = true;
+		}
+		else
+		{
+			First!.Traverse(state);
+			Second!.Traverse(state);
+			Third!.Traverse(state);
+			Forth?.Traverse(state);
+		}
+	}
+}
+
+
+// <year> ::= "year" | "year.full" | "year.abbreviated"
+internal sealed class TemplateYearNode : TemplateDateNode
+{
+	public static TemplateYearNode NormalInstance { get; } = new(YearKind.Normal);
+	public static TemplateYearNode FullInstance { get; } = new(YearKind.Full);
+	public static TemplateYearNode AbbreviatedInstance { get; } = new(YearKind.Abbreviated);
+
+	internal enum YearKind
+	{
+		Normal,
+		Full,
+		Abbreviated,
+	}
+
+	private TemplateYearNode(YearKind kind)
+	{
+		Kind = kind;
+	}
+
+	public YearKind Kind { get; }
+
+	internal override void Traverse(DateTimeTemplateInfo state)
+	{
+		state.IncludeYear = Kind switch
+		{
+			YearKind.Normal => YearFormat.Default,
+			YearKind.Full => YearFormat.Full,
+			YearKind.Abbreviated => YearFormat.Abbreviated,
+			_ => throw new InvalidOperationException(),
+		};
+	}
+}
+
+// <month> ::= "month" | "month.full" | "month.abbreviated" | "month.numeric"
+internal sealed class TemplateMonthNode : TemplateDateNode
+{
+	public static TemplateMonthNode NormalInstance { get; } = new(MonthKind.Normal);
+	public static TemplateMonthNode FullInstance { get; } = new(MonthKind.Full);
+	public static TemplateMonthNode AbbreviatedInstance { get; } = new(MonthKind.Abbreviated);
+	public static TemplateMonthNode NumericInstance { get; } = new(MonthKind.Numeric);
+
+	internal enum MonthKind
+	{
+		Normal,
+		Full,
+		Abbreviated,
+		Numeric,
+	}
+
+	private TemplateMonthNode(MonthKind kind)
+	{
+		Kind = kind;
+	}
+
+	public MonthKind Kind { get; }
+
+	internal override void Traverse(DateTimeTemplateInfo state)
+	{
+		state.IncludeMonth = Kind switch
+		{
+			MonthKind.Normal => MonthFormat.Default,
+			MonthKind.Full => MonthFormat.Full,
+			MonthKind.Abbreviated => MonthFormat.Abbreviated,
+			MonthKind.Numeric => MonthFormat.Numeric,
+			_ => throw new InvalidOperationException(),
+		};
+	}
+}
+
+// <day> ::= "day"
+internal sealed class TemplateDayNode : TemplateDateNode
+{
+	private TemplateDayNode()
+	{
+	}
+
+	public static TemplateDayNode Instance { get; } = new();
+
+	internal override void Traverse(DateTimeTemplateInfo state)
+	{
+		state.IncludeDay = DayFormat.Default;
+	}
+}
+
+// <dayofweek> ::= "dayofweek" | "dayofweek.full" | "dayofweek.abbreviated"
+internal sealed class TemplateDayOfWeekNode : TemplateRelativeDateNode
+{
+	public static TemplateDayOfWeekNode NormalInstance { get; } = new(DayOfWeekKind.Normal);
+	public static TemplateDayOfWeekNode FullInstance { get; } = new(DayOfWeekKind.Full);
+	public static TemplateDayOfWeekNode AbbreviatedInstance { get; } = new(DayOfWeekKind.Abbreviated);
+
+	internal enum DayOfWeekKind
+	{
+		Normal,
+		Full,
+		Abbreviated,
+	}
+
+	private TemplateDayOfWeekNode(DayOfWeekKind kind)
+	{
+		Kind = kind;
+	}
+
+	public DayOfWeekKind Kind { get; }
+
+	internal override void Traverse(DateTimeTemplateInfo state)
+	{
+		state.IncludeDayOfWeek = Kind switch
+		{
+			DayOfWeekKind.Normal => DayOfWeekFormat.Default,
+			DayOfWeekKind.Full => DayOfWeekFormat.Full,
+			DayOfWeekKind.Abbreviated => DayOfWeekFormat.Abbreviated,
+			_ => throw new InvalidOperationException(),
+		};
+	}
+}
+
+// <hour> ::= "hour"
+internal sealed class TemplateHourNode : TemplateNode
+{
+	private TemplateHourNode()
+	{
+	}
+
+	public static TemplateHourNode Instance { get; } = new();
+
+	internal override void Traverse(DateTimeTemplateInfo state)
+	{
+		state.IncludeHour = HourFormat.Default;
+	}
+}
+
+// <minute> ::= "minute"
+internal sealed class TemplateMinuteNode : TemplateNode
+{
+	private TemplateMinuteNode()
+	{
+	}
+
+	public static TemplateMinuteNode Instance { get; } = new();
+
+	internal override void Traverse(DateTimeTemplateInfo state)
+	{
+		state.IncludeMinute = MinuteFormat.Default;
+	}
+}
+
+// <second> ::= "second"
+internal sealed class TemplateSecondNode : TemplateNode
+{
+	private TemplateSecondNode()
+	{
+	}
+
+	public static TemplateSecondNode Instance { get; } = new();
+
+	internal override void Traverse(DateTimeTemplateInfo state)
+	{
+		state.IncludeSecond = SecondFormat.Default;
+	}
+}
+
+// <timezone> ::= "timezone" | "timezone.full" | "timezone.abbreviated"
+internal sealed class TemplateTimeZoneNode : TemplateNode
+{
+	public static TemplateTimeZoneNode NormalInstance { get; } = new(TimeZoneKind.Normal);
+	public static TemplateTimeZoneNode FullInstance { get; } = new(TimeZoneKind.Full);
+	public static TemplateTimeZoneNode AbbreviatedInstance { get; } = new(TimeZoneKind.Abbreviated);
+
+	internal enum TimeZoneKind
+	{
+		Normal,
+		Full,
+		Abbreviated,
+	}
+
+	private TemplateTimeZoneNode(TimeZoneKind kind)
+	{
+		Kind = kind;
+	}
+
+	public TimeZoneKind Kind { get; }
+
+	internal override void Traverse(DateTimeTemplateInfo state)
+	{
+		state.IncludeTimeZone = Kind switch
+		{
+			TimeZoneKind.Normal => TimeZoneFormat.Default,
+			TimeZoneKind.Full => TimeZoneFormat.Full,
+			TimeZoneKind.Abbreviated => TimeZoneFormat.Abbreviated,
+			_ => throw new InvalidOperationException(),
+		};
+	}
+}
diff --git a/src/Uno.UWP/Globalization/DateTimeFormatting/DateTimeTemplateParser/TemplateParser.cs b/src/Uno.UWP/Globalization/DateTimeFormatting/DateTimeTemplateParser/TemplateParser.cs
new file mode 100644
index 000000000000..1f8fd7184ebf
--- /dev/null
+++ b/src/Uno.UWP/Globalization/DateTimeFormatting/DateTimeTemplateParser/TemplateParser.cs
@@ -0,0 +1,674 @@
+#nullable enable
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Windows.Globalization.DateTimeFormatting;
+
+// We are kinda combining a lexer and a parser here as the grammar is simple enough.
+internal sealed class TemplateParser
+{
+	private int _index;
+	private string _template;
+
+	public bool Completed => _index >= _template.Length;
+
+	public DateTimeTemplateInfo Info { get; } = new();
+
+	public TemplateParser(string template)
+	{
+		_template = template;
+	}
+
+	private TemplateRootNode EnsureCompleted(TemplateRootNode root)
+	{
+		if (!Completed)
+		{
+			throw new ArgumentException($"Failed to parse '{_template}'. Couldn't consume all characters. Stopped at index '{_index}'.");
+		}
+
+		root.Traverse(Info);
+		return root;
+	}
+
+	public TemplateRootNode Parse()
+	{
+		_ = SkipWhitespace();
+		if (TryParseDate(out var date))
+		{
+			bool hasWhitespace = SkipWhitespace();
+			if (hasWhitespace && date is TemplateSpecificDateNode or TemplateRelativeDateNode &&
+				TryParseTime(out var time))
+			{
+				_ = SkipWhitespace();
+				return EnsureCompleted(new TemplateRootNode(date, time));
+			}
+
+			return EnsureCompleted(new TemplateRootNode(date));
+		}
+		else if (TryParseTime(out var time))
+		{
+			bool hasWhitespace = SkipWhitespace();
+			if (hasWhitespace)
+			{
+				if (TryParseSpecificDate(out var specificDate))
+				{
+					_ = SkipWhitespace();
+					return EnsureCompleted(new TemplateRootNode(time, date));
+				}
+				else if (TryParseRelativeDate(out var relativeDate))
+				{
+					_ = SkipWhitespace();
+					return EnsureCompleted(new TemplateRootNode(time, date));
+				}
+			}
+
+			return EnsureCompleted(new TemplateRootNode(time));
+		}
+
+		throw new ArgumentException($"Failed to parse date time template '{_template}'");
+	}
+
+	private bool TryParseTime([NotNullWhen(true)] out TemplateTimeNode? time)
+	{
+		var originalIndex = _index;
+		if (TryParseLongTime(out var longTime))
+		{
+			time = new TemplateTimeNode(longTime);
+			return true;
+		}
+		else if (TryParseShortTime(out var shortTime))
+		{
+			time = new TemplateTimeNode(shortTime);
+			return true;
+		}
+		else if (TryParseTimeZone(out var timeZone))
+		{
+			if (SkipWhitespace() && TryParseHour(out var hour))
+			{
+				time = new TemplateTimeNode(timeZone, hour);
+				return true;
+			}
+		}
+		else if (TryParseHour(out var hour))
+		{
+			int originalIndexAfterHour = _index;
+			if (SkipWhitespace() && TryParseTimeZone(out timeZone))
+			{
+				time = new TemplateTimeNode(hour, timeZone);
+				return true;
+			}
+
+			_index = originalIndexAfterHour;
+			time = new TemplateTimeNode(hour);
+			return true;
+		}
+
+		_index = originalIndex;
+		time = null;
+		return false;
+	}
+
+	private bool TryParseLongTime([NotNullWhen(true)] out TemplateLongTimeNode? longTime)
+	{
+		if (IsWordAt(_index, "longtime"))
+		{
+			_index += "longtime".Length;
+			longTime = TemplateLongTimeNode.DefaultLongTimeInstance;
+			return true;
+		}
+
+		if (TryParseFourComponentsSeparatedByWhitespaceInAnyOrder<TemplateTimeZoneNode, TemplateHourNode, TemplateMinuteNode, TemplateSecondNode, TemplateNode, TemplateLongTimeNode>(
+			TryParseTimeZone,
+			TryParseHour,
+			TryParseMinute,
+			TryParseSecond,
+			static (first, second, third, forth) => new TemplateLongTimeNode(first, second, third, forth),
+			out longTime))
+		{
+			return true;
+		}
+
+		if (TryParseThreeComponentsSeparatedByWhitespaceInAnyOrder<TemplateHourNode, TemplateMinuteNode, TemplateSecondNode, TemplateNode, TemplateLongTimeNode>(
+			TryParseHour,
+			TryParseMinute,
+			TryParseSecond,
+			static (first, second, third) => new TemplateLongTimeNode(first, second, third),
+			out longTime))
+		{
+			return true;
+		}
+
+		return false;
+	}
+
+	private bool TryParseShortTime([NotNullWhen(true)] out TemplateShortTimeNode? shortTime)
+	{
+		if (IsWordAt(_index, "shorttime"))
+		{
+			_index += "shorttime".Length;
+			shortTime = TemplateShortTimeNode.DefaultShortTimeInstance;
+			return true;
+		}
+
+		if (TryParseThreeComponentsSeparatedByWhitespaceInAnyOrder<TemplateTimeZoneNode, TemplateHourNode, TemplateMinuteNode, TemplateNode, TemplateShortTimeNode>(
+			TryParseTimeZone,
+			TryParseHour,
+			TryParseMinute,
+			static (first, second, third) => new TemplateShortTimeNode(first, second, third),
+			out shortTime))
+		{
+			return true;
+		}
+
+		return TryParseTwoComponentsSeparatedByWhitespaceInAnyOrder<TemplateHourNode, TemplateMinuteNode, TemplateNode, TemplateShortTimeNode>(
+			TryParseHour,
+			TryParseMinute,
+			static (first, second) => new TemplateShortTimeNode(first, second),
+			out shortTime);
+	}
+
+	private bool TryParseDate([NotNullWhen(true)] out TemplateDateNode? date)
+	{
+		// The order of calls here matter.
+		if (TryParseSpecificDate(out var specificDate))
+		{
+			date = specificDate;
+			return true;
+		}
+		else if (TryParseRelativeDate(out var relativeDate))
+		{
+			date = relativeDate;
+			return true;
+		}
+		else if (TryParseMonthYear(out var monthYear))
+		{
+			date = monthYear;
+			return true;
+		}
+		else if (TryParseYear(out var year))
+		{
+			date = year;
+			return true;
+		}
+		else if (TryParseMonth(out var month))
+		{
+			date = month;
+			return true;
+		}
+		else if (TryParseDay(out var day))
+		{
+			date = day;
+			return true;
+		}
+
+		date = null;
+		return false;
+	}
+
+	private bool TryParseMonthYear([NotNullWhen(true)] out TemplateMonthYearNode? monthYear)
+	{
+		return TryParseTwoComponentsSeparatedByWhitespaceInAnyOrder<TemplateMonthNode, TemplateYearNode, TemplateNode, TemplateMonthYearNode>(
+			TryParseMonth,
+			TryParseYear,
+			static (first, second) => new TemplateMonthYearNode(first, second),
+			out monthYear);
+	}
+
+	private bool TryParseRelativeDate([NotNullWhen(true)] out TemplateRelativeDateNode? relativeDate)
+	{
+		if (TryParseDayOfWeek(out var dayOfWeek))
+		{
+			relativeDate = dayOfWeek;
+			return true;
+		}
+		else if (TryParseMonthDay(out var monthDay))
+		{
+			relativeDate = monthDay;
+			return true;
+		}
+		else if (TryParseRelativeLongDate(out var relativeLongDate))
+		{
+			relativeDate = relativeLongDate;
+			return true;
+		}
+
+		relativeDate = null;
+		return false;
+	}
+
+	private bool TryParseRelativeLongDate([NotNullWhen(true)] out TemplateRelativeLongDateNode? date)
+	{
+		return TryParseThreeComponentsSeparatedByWhitespaceInAnyOrder<TemplateMonthNode, TemplateDayNode, TemplateDayOfWeekNode, TemplateDateNode, TemplateRelativeLongDateNode>(
+			TryParseMonth,
+			TryParseDay,
+			TryParseDayOfWeek,
+			static (first, second, third) => new TemplateRelativeLongDateNode(first, second, third),
+			out date);
+	}
+
+	private bool TryParseMonthDay([NotNullWhen(true)] out TemplateMonthDayNode? date)
+	{
+		return TryParseTwoComponentsSeparatedByWhitespaceInAnyOrder<TemplateMonthNode, TemplateDayNode, TemplateDateNode, TemplateMonthDayNode>(
+			TryParseMonth,
+			TryParseDay,
+			static (first, second) => new TemplateMonthDayNode(first, second),
+			out date
+			);
+	}
+
+	private bool TryParseSpecificDate([NotNullWhen(true)] out TemplateSpecificDateNode? date)
+	{
+		if (TryParseLongDate(out var longDate))
+		{
+			date = longDate;
+			return true;
+		}
+		else if (TryParseShortDate(out var shortDate))
+		{
+			date = shortDate;
+			return true;
+		}
+
+		date = null;
+		return false;
+	}
+
+	private bool TryParseLongDate([NotNullWhen(true)] out TemplateLongDateNode? longDate)
+	{
+		if (IsWordAt(_index, "longdate"))
+		{
+			_index += "longdate".Length;
+			longDate = TemplateLongDateNode.DefaultLongDateInstance;
+			return true;
+		}
+
+		return TryParseFourComponentsSeparatedByWhitespaceInAnyOrder<TemplateYearNode, TemplateMonthNode, TemplateDayNode, TemplateDayOfWeekNode, TemplateDateNode, TemplateLongDateNode>(
+			TryParseYear,
+			TryParseMonth,
+			TryParseDay,
+			TryParseDayOfWeek,
+			static (first, second, third, forth) => new TemplateLongDateNode(first, second, third, forth),
+			out longDate);
+	}
+
+	private bool TryParseShortDate([NotNullWhen(true)] out TemplateShortDateNode? shortDate)
+	{
+		if (IsWordAt(_index, "shortdate"))
+		{
+			_index += "shortdate".Length;
+			shortDate = TemplateShortDateNode.DefaultShortDateInstance;
+			return true;
+		}
+
+		return TryParseThreeComponentsSeparatedByWhitespaceInAnyOrder<TemplateMonthNode, TemplateDayNode, TemplateYearNode, TemplateDateNode, TemplateShortDateNode>(
+			TryParseMonth,
+			TryParseDay,
+			TryParseYear,
+			static (first, second, third) => new TemplateShortDateNode(first, second, third),
+			out shortDate);
+	}
+
+	private bool TryParseYear([NotNullWhen(true)] out TemplateYearNode? year)
+	{
+		if (IsWordAt(_index, "year.full"))
+		{
+			_index += "year.full".Length;
+			year = TemplateYearNode.FullInstance;
+			return true;
+		}
+		else if (IsWordAt(_index, "year.abbreviated"))
+		{
+			_index += "year.abbreviated".Length;
+			year = TemplateYearNode.AbbreviatedInstance;
+			return true;
+		}
+		else if (IsWordAt(_index, "year"))
+		{
+			_index += "year".Length;
+			year = TemplateYearNode.NormalInstance;
+			return true;
+		}
+
+		year = null;
+		return false;
+	}
+
+	private bool TryParseMonth([NotNullWhen(true)] out TemplateMonthNode? month)
+	{
+		if (IsWordAt(_index, "month.full"))
+		{
+			_index += "month.full".Length;
+			month = TemplateMonthNode.FullInstance;
+			return true;
+		}
+		else if (IsWordAt(_index, "month.abbreviated"))
+		{
+			_index += "month.abbreviated".Length;
+			month = TemplateMonthNode.AbbreviatedInstance;
+			return true;
+		}
+		else if (IsWordAt(_index, "month.numeric"))
+		{
+			_index += "month.numeric".Length;
+			month = TemplateMonthNode.NumericInstance;
+			return true;
+		}
+		else if (IsWordAt(_index, "month"))
+		{
+			_index += "month".Length;
+			month = TemplateMonthNode.NormalInstance;
+			return true;
+		}
+
+		month = null;
+		return false;
+	}
+
+	private bool TryParseDay([NotNullWhen(true)] out TemplateDayNode? day)
+	{
+		if (IsWordAt(_index, "day"))
+		{
+			_index += "day".Length;
+			day = TemplateDayNode.Instance;
+			return true;
+		}
+
+		day = null;
+		return false;
+	}
+
+	private bool TryParseDayOfWeek([NotNullWhen(true)] out TemplateDayOfWeekNode? dayOfWeek)
+	{
+		if (IsWordAt(_index, "dayofweek.full"))
+		{
+			_index += "dayofweek.full".Length;
+			dayOfWeek = TemplateDayOfWeekNode.FullInstance;
+			return true;
+		}
+		else if (IsWordAt(_index, "dayofweek.abbreviated"))
+		{
+			_index += "dayofweek.abbreviated".Length;
+			dayOfWeek = TemplateDayOfWeekNode.AbbreviatedInstance;
+			return true;
+		}
+		else if (IsWordAt(_index, "dayofweek"))
+		{
+			_index += "dayofweek".Length;
+			dayOfWeek = TemplateDayOfWeekNode.NormalInstance;
+			return true;
+		}
+
+		dayOfWeek = null;
+		return false;
+	}
+
+	private bool TryParseHour([NotNullWhen(true)] out TemplateHourNode? hour)
+	{
+		if (IsWordAt(_index, "hour"))
+		{
+			_index += "hour".Length;
+			hour = TemplateHourNode.Instance;
+			return true;
+		}
+
+		hour = null;
+		return false;
+	}
+
+	private bool TryParseMinute([NotNullWhen(true)] out TemplateMinuteNode? minute)
+	{
+		if (IsWordAt(_index, "minute"))
+		{
+			_index += "minute".Length;
+			minute = TemplateMinuteNode.Instance;
+			return true;
+		}
+
+		minute = null;
+		return false;
+	}
+
+	private bool TryParseSecond([NotNullWhen(true)] out TemplateSecondNode? second)
+	{
+		if (IsWordAt(_index, "second"))
+		{
+			_index += "second".Length;
+			second = TemplateSecondNode.Instance;
+			return true;
+		}
+
+		second = null;
+		return false;
+	}
+
+	private bool TryParseTimeZone([NotNullWhen(true)] out TemplateTimeZoneNode? timeZone)
+	{
+		if (IsWordAt(_index, "timezone.full"))
+		{
+			_index += "timezone.full".Length;
+			timeZone = TemplateTimeZoneNode.FullInstance;
+			return true;
+		}
+		else if (IsWordAt(_index, "timezone.abbreviated"))
+		{
+			_index += "timezone.abbreviated".Length;
+			timeZone = TemplateTimeZoneNode.AbbreviatedInstance;
+			return true;
+		}
+		else if (IsWordAt(_index, "timezone"))
+		{
+			_index += "timezone".Length;
+			timeZone = TemplateTimeZoneNode.NormalInstance;
+			return true;
+		}
+
+		timeZone = null;
+		return false;
+	}
+
+	private bool SkipWhitespace()
+	{
+		bool hasWhitespace = false;
+		while (_index < _template.Length && _template[_index] == ' ')
+		{
+			hasWhitespace = true;
+			_index++;
+		}
+
+		return hasWhitespace;
+	}
+
+	private bool IsWordAt(int i, string word)
+	{
+		int wordLength = word.Length;
+		if (i + wordLength > _template.Length)
+		{
+			return false;
+		}
+
+		return _template.AsSpan().Slice(i, wordLength).SequenceEqual(word);
+	}
+
+	internal delegate bool TryParseDelegate<T>([NotNullWhen(true)] out T? result);
+
+	private bool TryParseThreeComponentsSeparatedByWhitespaceInExactOrder<T1, T2, T3, TCommon, TResult>(
+		TryParseDelegate<T1> tryParseFirst,
+		TryParseDelegate<T2> tryParseSecond,
+		TryParseDelegate<T3> tryParseThird,
+		Func<TCommon, TCommon, TCommon, TResult> resultCreator,
+		[NotNullWhen(true)] out TResult? result
+		)
+		where T1 : TCommon
+		where T2 : TCommon
+		where T3 : TCommon
+		where TResult : class
+		where TCommon : class
+	{
+		int originalIndex = _index;
+		if (tryParseFirst(out var first))
+		{
+			if (SkipWhitespace())
+			{
+				if (tryParseSecond(out var second))
+				{
+					if (SkipWhitespace() && tryParseThird(out var third))
+					{
+						result = resultCreator(first, second, third);
+						return true;
+					}
+				}
+				else if (tryParseThird(out var third))
+				{
+					if (SkipWhitespace() && tryParseSecond(out second))
+					{
+						result = resultCreator(first, third, second);
+						return true;
+					}
+				}
+			}
+		}
+
+		_index = originalIndex;
+		result = null;
+		return false;
+	}
+
+	private bool TryParseThreeComponentsSeparatedByWhitespaceInAnyOrder<T1, T2, T3, TCommon, TResult>(
+		TryParseDelegate<T1> tryParseFirst,
+		TryParseDelegate<T2> tryParseSecond,
+		TryParseDelegate<T3> tryParseThird,
+		Func<TCommon, TCommon, TCommon, TResult> resultCreator,
+		[NotNullWhen(true)] out TResult? result
+		)
+		where T1 : TCommon
+		where T2 : TCommon
+		where T3 : TCommon
+		where TResult : class
+		where TCommon : class
+	{
+		return
+			TryParseThreeComponentsSeparatedByWhitespaceInExactOrder(tryParseFirst, tryParseSecond, tryParseThird, resultCreator, out result) ||
+			TryParseThreeComponentsSeparatedByWhitespaceInExactOrder(tryParseFirst, tryParseThird, tryParseSecond, resultCreator, out result) ||
+			TryParseThreeComponentsSeparatedByWhitespaceInExactOrder(tryParseSecond, tryParseFirst, tryParseThird, resultCreator, out result) ||
+			TryParseThreeComponentsSeparatedByWhitespaceInExactOrder(tryParseSecond, tryParseThird, tryParseFirst, resultCreator, out result) ||
+			TryParseThreeComponentsSeparatedByWhitespaceInExactOrder(tryParseThird, tryParseFirst, tryParseSecond, resultCreator, out result) ||
+			TryParseThreeComponentsSeparatedByWhitespaceInExactOrder(tryParseThird, tryParseSecond, tryParseFirst, resultCreator, out result);
+	}
+
+	private bool TryParseThreeComponentsSeparatedByWhitespaceInAnyOrder<T1, T2, T3, TCommon, TResult>(
+		TCommon firstArgument,
+		TryParseDelegate<T1> tryParseFirst,
+		TryParseDelegate<T2> tryParseSecond,
+		TryParseDelegate<T3> tryParseThird,
+		Func<TCommon, TCommon, TCommon, TCommon, TResult> resultCreator,
+		[NotNullWhen(true)] out TResult? result
+		)
+		where T1 : TCommon
+		where T2 : TCommon
+		where T3 : TCommon
+		where TResult : class
+		where TCommon : class
+	{
+		return
+			TryParseThreeComponentsSeparatedByWhitespaceInExactOrder<T1, T2, T3, TCommon, TResult>(tryParseFirst, tryParseSecond, tryParseThird, (first, second, third) => resultCreator(firstArgument, first, second, third), out result) ||
+			TryParseThreeComponentsSeparatedByWhitespaceInExactOrder<T1, T3, T2, TCommon, TResult>(tryParseFirst, tryParseThird, tryParseSecond, (first, second, third) => resultCreator(firstArgument, first, second, third), out result) ||
+			TryParseThreeComponentsSeparatedByWhitespaceInExactOrder<T2, T1, T3, TCommon, TResult>(tryParseSecond, tryParseFirst, tryParseThird, (first, second, third) => resultCreator(firstArgument, first, second, third), out result) ||
+			TryParseThreeComponentsSeparatedByWhitespaceInExactOrder<T2, T3, T1, TCommon, TResult>(tryParseSecond, tryParseThird, tryParseFirst, (first, second, third) => resultCreator(firstArgument, first, second, third), out result) ||
+			TryParseThreeComponentsSeparatedByWhitespaceInExactOrder<T3, T1, T2, TCommon, TResult>(tryParseThird, tryParseFirst, tryParseSecond, (first, second, third) => resultCreator(firstArgument, first, second, third), out result) ||
+			TryParseThreeComponentsSeparatedByWhitespaceInExactOrder<T3, T2, T1, TCommon, TResult>(tryParseThird, tryParseSecond, tryParseFirst, (first, second, third) => resultCreator(firstArgument, first, second, third), out result);
+	}
+
+	private bool TryParseTwoComponentsSeparatedByWhitespaceInExactOrder<T1, T2, TCommon, TResult>(
+		TryParseDelegate<T1> tryParseFirst,
+		TryParseDelegate<T2> tryParseSecond,
+		Func<TCommon, TCommon, TResult> resultCreator,
+		[NotNullWhen(true)] out TResult? result
+		)
+		where T1 : TCommon
+		where T2 : TCommon
+		where TResult : class
+		where TCommon : class
+	{
+		int originalIndex = _index;
+		if (tryParseFirst(out var first) && SkipWhitespace() && tryParseSecond(out var second))
+		{
+			result = resultCreator(first, second);
+			return true;
+		}
+
+		_index = originalIndex;
+		result = null;
+		return false;
+	}
+
+	private bool TryParseTwoComponentsSeparatedByWhitespaceInAnyOrder<T1, T2, TCommon, TResult>(
+		TryParseDelegate<T1> tryParseFirst,
+		TryParseDelegate<T2> tryParseSecond,
+		Func<TCommon, TCommon, TResult> resultCreator,
+		[NotNullWhen(true)] out TResult? result
+		)
+		where T1 : TCommon
+		where T2 : TCommon
+		where TResult : class
+		where TCommon : class
+	{
+		return
+			TryParseTwoComponentsSeparatedByWhitespaceInExactOrder(tryParseFirst, tryParseSecond, resultCreator, out result) ||
+			TryParseTwoComponentsSeparatedByWhitespaceInExactOrder(tryParseSecond, tryParseFirst, resultCreator, out result);
+	}
+
+	private bool TryParseFourComponentsSeparatedByWhitespaceInAnyOrder<T1, T2, T3, T4, TCommon, TResult>(
+		TryParseDelegate<T1> tryParseFirst,
+		TryParseDelegate<T2> tryParseSecond,
+		TryParseDelegate<T3> tryParseThird,
+		TryParseDelegate<T4> tryParseForth,
+		Func<TCommon, TCommon, TCommon, TCommon, TResult> resultCreator,
+		[NotNullWhen(true)] out TResult? result
+		)
+		where T1 : TCommon
+		where T2 : TCommon
+		where T3 : TCommon
+		where T4 : TCommon
+		where TResult : class
+		where TCommon : class
+	{
+		int originalIndex = _index;
+		if (tryParseFirst(out var first))
+		{
+			if (SkipWhitespace() &&
+				TryParseThreeComponentsSeparatedByWhitespaceInAnyOrder(first, tryParseSecond, tryParseThird, tryParseForth, resultCreator, out result))
+			{
+				return true;
+			}
+		}
+		else if (tryParseSecond(out var second))
+		{
+			if (SkipWhitespace() &&
+				TryParseThreeComponentsSeparatedByWhitespaceInAnyOrder(second, tryParseFirst, tryParseThird, tryParseForth, resultCreator, out result))
+			{
+				return true;
+			}
+		}
+		if (tryParseThird(out var third))
+		{
+			if (SkipWhitespace() &&
+				TryParseThreeComponentsSeparatedByWhitespaceInAnyOrder(third, tryParseFirst, tryParseSecond, tryParseForth, resultCreator, out result))
+			{
+				return true;
+			}
+		}
+		if (tryParseForth(out var forth))
+		{
+			if (SkipWhitespace() &&
+				TryParseThreeComponentsSeparatedByWhitespaceInAnyOrder(forth, tryParseFirst, tryParseSecond, tryParseThird, resultCreator, out result))
+			{
+				return true;
+			}
+		}
+
+		_index = originalIndex;
+		result = null;
+		return false;
+	}
+}
diff --git a/src/Uno.UWP/Globalization/DateTimeFormatting/TimeZoneFormat.cs b/src/Uno.UWP/Globalization/DateTimeFormatting/TimeZoneFormat.cs
new file mode 100644
index 000000000000..435cc82b18cb
--- /dev/null
+++ b/src/Uno.UWP/Globalization/DateTimeFormatting/TimeZoneFormat.cs
@@ -0,0 +1,9 @@
+namespace Windows.Globalization.DateTimeFormatting;
+
+internal enum TimeZoneFormat
+{
+	None,
+	Default,
+	Abbreviated,
+	Full,
+}
diff --git a/src/Uno.UWP/Helpers/StartStopDelegateWrapper.cs b/src/Uno.UWP/Helpers/StartStopDelegateWrapper.cs
new file mode 100644
index 000000000000..cf92b6fb72d9
--- /dev/null
+++ b/src/Uno.UWP/Helpers/StartStopDelegateWrapper.cs
@@ -0,0 +1,90 @@
+#nullable enable
+
+using System;
+
+namespace Uno.Helpers;
+
+/// <summary>
+/// Creates a wrapper around a generic event, which needs to be synchronized
+/// and needs to run an action when first subscriber is added and when
+/// last subscriber is removed. The operations executed when first subscriber
+/// is added and last subscriber is removed will execute within
+/// a synchronization lock, so please avoid blocking within the actions.
+/// </summary>
+internal class StartStopDelegateWrapper<TDelegate>
+	where TDelegate : Delegate
+{
+	private readonly object _syncLock;
+	private readonly Action _onFirst;
+	private readonly Action _onLast;
+
+	/// <summary>
+	/// Creates a new instance of start-stop delegate wrapper.
+	/// </summary>
+	/// <param name="onFirst">Action to run when first subscriber is added.
+	/// This will run within a synchronization lock so it should not involve blocking operations.</param>
+	/// <param name="onLast">Action to run when last subscriber is removed.
+	/// This will run within a synchronization lock so it should not involve blocking operations.</param>
+	/// <param name="sharedLock">Optional shared object to lock on (when multiple events
+	/// rely on the same native platform operation.</param>
+	public StartStopDelegateWrapper(
+		Action onFirst,
+		Action onLast,
+		object? sharedLock = null)
+	{
+		_onFirst = onFirst;
+		_onLast = onLast;
+		_syncLock = sharedLock ?? new object();
+	}
+
+	/// <summary>
+	/// Backing delegate.
+	/// </summary>
+	public TDelegate? Event { get; private set; }
+
+	/// <summary>
+	/// Indicates if there is at least one active subscription.
+	/// </summary>
+	public bool IsActive => Event != null;
+
+	/// <summary>
+	/// Synchronization lock.
+	/// </summary>
+	public object SyncLock => _syncLock;
+
+	/// <summary>
+	/// Adds a handler.
+	/// </summary>
+	/// <param name="handler">Handler.</param>
+	public void AddHandler(TDelegate handler)
+	{
+		lock (_syncLock)
+		{
+			var firstSubscriber = Event == null;
+			Event = (TDelegate)Delegate.Combine(Event, handler);
+			if (firstSubscriber)
+			{
+				_onFirst();
+			}
+		}
+	}
+
+	/// <summary>
+	/// Removes a handler.
+	/// </summary>
+	/// <param name="handler">Handler.</param>
+	public void RemoveHandler(TDelegate handler)
+	{
+		lock (_syncLock)
+		{
+			if (Event != null)
+			{
+				Event = (TDelegate?)Delegate.Remove(Event, handler);
+				if (Event == null)
+				{
+					_onLast();
+				}
+			}
+		}
+	}
+}
diff --git a/src/Uno.UWP/Helpers/StartStopTypedEventWrapper.cs b/src/Uno.UWP/Helpers/StartStopTypedEventWrapper.cs
new file mode 100644
index 000000000000..5bad9a87be33
--- /dev/null
+++ b/src/Uno.UWP/Helpers/StartStopTypedEventWrapper.cs
@@ -0,0 +1,35 @@
+#nullable enable
+
+using System;
+using Windows.Foundation;
+
+namespace Uno.Helpers;
+
+/// <summary>
+/// Start stop wrapper for TypedEventHandler`2 events.
+/// </summary>
+/// <typeparam name="TSender">Sender type.</typeparam>
+/// <typeparam name="TResult">Event args type.</typeparam>
+internal class StartStopTypedEventWrapper<TSender, TResult> : StartStopDelegateWrapper<TypedEventHandler<TSender, TResult>>
+{
+	/// <summary>
+	/// Creates a new instance of start-stop event wrapper.
+	/// </summary>
+	/// <param name="onFirst">Action to run when first subscriber is added.
+	/// This will run within a synchronization lock so it should not involve blocking operations.</param>
+	/// <param name="onLast">Action to run when last subscriber is removed.
+	/// This will run within a synchronization lock so it should not involve blocking operations.</param>
+	/// <param name="sharedLock">Optional shared object to lock on (when multiple events
+	/// rely on the same native platform operation.</param>
+	public StartStopTypedEventWrapper(Action onFirst, Action onLast, object? sharedLock = null) :
+		base(onFirst, onLast, sharedLock)
+	{
+	}
+
+	/// <summary>
+	/// Invokes the event.
+	/// </summary>
+	/// <param name="sender">Sender.</param>
+	/// <param name="args">Args.</param>
+	public void Invoke(TSender sender, TResult args) => Event?.Invoke(sender, args);
+}