From 3b9648e4324552c0f39f29396b611916b9187e05 Mon Sep 17 00:00:00 2001
From: DevTKSS <info@technische-konstruktion.com>
Date: Thu, 7 Nov 2024 02:42:10 +0100
Subject: [PATCH 01/12] docs(uno-community-toolkit-v8): Added example(s) for
 usage of converters

the documentation was only including UI things. Non-UI elements are slightly different and especially for beginners this example is expected to fill the missing piece in this topic and is expected to improve the learning curve, because they can see how to implement this different two types (UI and Non-UI). Also added the Link to the CommunityToolkit Documentation, so its easyer to find similar Non-UI tools.
---
 doc/articles/uno-community-toolkit-v8.md | 94 ++++++++++++++++++++++++
 1 file changed, 94 insertions(+)

diff --git a/doc/articles/uno-community-toolkit-v8.md b/doc/articles/uno-community-toolkit-v8.md
index a628bba775e7..490aa255adc6 100644
--- a/doc/articles/uno-community-toolkit-v8.md
+++ b/doc/articles/uno-community-toolkit-v8.md
@@ -184,6 +184,100 @@ You can set the `Header`, `HeaderIcon`, `Description`, and `Content` properties
 
 A complete working sample, along with additional examples, is available on GitHub: [Uno Windows Community Toolkit SettingsCard Sample](https://github.com/unoplatform/Uno.Samples/tree/master/UI/WindowsCommunityToolkit/Version-8.x/UnoWCTSettingsCardSample)
 
+## 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. 
+[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:
+
+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]
+    > In WCT version 8.x, the namespaces between UWP and WinAppSDK were merged.
+
+    ### WinUI / WinAppSDK / UWP
+
+      In XAML:  
+        ```xmlns:converters="using:CommunityToolkit.WinUI.Converters"```
+
+      In C#:  
+        ```using CommunityToolkit.WinUI.Converters;```
+
+      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:
+
+### [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>
+        ```
+
+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}"/>
+        ```
+        
+### [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}"/>
+    ```
+
+> [!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)]
+
 ---
 
 [!include[getting-help](includes/getting-help.md)]

From 171bf5cf37db6bbaba25d2b770c1a35f11b4908f Mon Sep 17 00:00:00 2001
From: DevTKSS <info@technische-konstruktion.com>
Date: Mon, 6 Jan 2025 19:08:33 +0100
Subject: [PATCH 02/12] Deleted trailing space at line 189 Deleted duplicated
 link to get-help.md at line281-284

---
 doc/articles/uno-community-toolkit-v8.md | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/doc/articles/uno-community-toolkit-v8.md b/doc/articles/uno-community-toolkit-v8.md
index 490aa255adc6..ffd167cb2d71 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:
@@ -277,7 +277,3 @@ Somewhere in your Page Content:
 ---
 
 [!include[getting-help](includes/getting-help.md)]
-
----
-
-[!include[getting-help](includes/getting-help.md)]

From 2b54d65b466e109db3c70a3b314928cf239f178b Mon Sep 17 00:00:00 2001
From: DevTKSS <info@technische-konstruktion.com>
Date: Mon, 6 Jan 2025 21:47:40 +0100
Subject: [PATCH 03/12] deleted azure listed intents and spacings

---
 doc/articles/uno-community-toolkit-v8.md | 78 ++++++++++++------------
 1 file changed, 39 insertions(+), 39 deletions(-)

diff --git a/doc/articles/uno-community-toolkit-v8.md b/doc/articles/uno-community-toolkit-v8.md
index ffd167cb2d71..6568e84a2ec0 100644
--- a/doc/articles/uno-community-toolkit-v8.md
+++ b/doc/articles/uno-community-toolkit-v8.md
@@ -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,61 +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
-     
+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:
 
 ### [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>
-        ```
+```
+<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}"/>
-    ```
+```
+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"/>
-    ```
+
+```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"/>
+```
     
 ---
 

From e08b3d57b77a5fe3fc51665cf4a44bebae3bd18e Mon Sep 17 00:00:00 2001
From: DevTKSS <info@technische-konstruktion.com>
Date: Mon, 6 Jan 2025 19:08:33 +0100
Subject: [PATCH 04/12] chore(CTK): Deleted trailing space at line 189

Deleted duplicated link to get-help.md at line281-284
---
 doc/articles/uno-community-toolkit-v8.md | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/doc/articles/uno-community-toolkit-v8.md b/doc/articles/uno-community-toolkit-v8.md
index 490aa255adc6..ffd167cb2d71 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:
@@ -277,7 +277,3 @@ Somewhere in your Page Content:
 ---
 
 [!include[getting-help](includes/getting-help.md)]
-
----
-
-[!include[getting-help](includes/getting-help.md)]

From 24edaa74ab219e6cf14da7be8c579d6b1dc326e0 Mon Sep 17 00:00:00 2001
From: DevTKSS <info@technische-konstruktion.com>
Date: Mon, 6 Jan 2025 21:47:40 +0100
Subject: [PATCH 05/12] chore(CTK): Deleted azure listed intents and spacings

---
 doc/articles/uno-community-toolkit-v8.md | 78 ++++++++++++------------
 1 file changed, 39 insertions(+), 39 deletions(-)

diff --git a/doc/articles/uno-community-toolkit-v8.md b/doc/articles/uno-community-toolkit-v8.md
index ffd167cb2d71..9b5e3eb16901 100644
--- a/doc/articles/uno-community-toolkit-v8.md
+++ b/doc/articles/uno-community-toolkit-v8.md
@@ -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,61 +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
-     
+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:
 
 ### [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"/>
-    ```
+
+```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"/>
+```
     
 ---
 

From f125f262b25c1dd427b26f44c1e06996ac844ce6 Mon Sep 17 00:00:00 2001
From: DevTKSS <info@technische-konstruktion.com>
Date: Tue, 7 Jan 2025 00:04:17 +0100
Subject: [PATCH 06/12] chore(CTK): Updated uno-community-toolkit-v8.md

---
 doc/articles/uno-community-toolkit-v8.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/articles/uno-community-toolkit-v8.md b/doc/articles/uno-community-toolkit-v8.md
index 9b5e3eb16901..9adc4fed22ab 100644
--- a/doc/articles/uno-community-toolkit-v8.md
+++ b/doc/articles/uno-community-toolkit-v8.md
@@ -220,7 +220,7 @@ The implementation of those are quite similar to the example of the SettingsCont
 
 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:
+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)
 

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 07/12] 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);
+}

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

---
 doc/articles/uno-community-toolkit-v8.md | 25 ++++++++++++++----------
 1 file changed, 15 insertions(+), 10 deletions(-)

diff --git a/doc/articles/uno-community-toolkit-v8.md b/doc/articles/uno-community-toolkit-v8.md
index 68ed72673e97..9b7c0f40ffd1 100644
--- a/doc/articles/uno-community-toolkit-v8.md
+++ b/doc/articles/uno-community-toolkit-v8.md
@@ -195,6 +195,7 @@ The implementation of those are quite similar to the example of the SettingsCont
 
    Change this:
 
+
    ```CommunityToolkit.WinUI.Controls.SettingsControls```
 
    to Converters namespace:
@@ -236,7 +237,7 @@ Somewhere in your Page Content:
 
 ```xml
   <TextBox x:Name="tbName"
-           Text="{Binding Name, Mode=TwoWay}" 
+           Text="{Binding Name, Mode=TwoWay}"
            PlaceholderText="Enter your name:"/>
   <Button x:Name="StartButton"
           Content="Start a cool simple Game!"
@@ -263,17 +264,21 @@ BoolToObjectConverter x:Key="BoolToColorConverter" TrueValue="{ThemeResource Sys
 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"/>
+<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)]
+
+---
+
+[!include[getting-help](includes/getting-help.md)]

From 367a965b2c23fd444b50219bbe61cd19cb7dab9c Mon Sep 17 00:00:00 2001
From: DevTKSS <info@technische-konstruktion.com>
Date: Mon, 6 Jan 2025 21:47:40 +0100
Subject: [PATCH 09/12] chore(CTK): spellchecking and formatting

---
 doc/articles/uno-community-toolkit-v8.md | 34 +++++++++++-------------
 1 file changed, 15 insertions(+), 19 deletions(-)

diff --git a/doc/articles/uno-community-toolkit-v8.md b/doc/articles/uno-community-toolkit-v8.md
index 9b7c0f40ffd1..12f2dcbc0690 100644
--- a/doc/articles/uno-community-toolkit-v8.md
+++ b/doc/articles/uno-community-toolkit-v8.md
@@ -211,17 +211,17 @@ The implementation of those are quite similar to the example of the SettingsCont
 
     ### WinUI / WinAppSDK / UWP
 
-      In XAML:  
+      In XAML:
         ```xmlns:converters="using:CommunityToolkit.WinUI.Converters"```
 
-      In C#:  
+      In C#:
         ```using CommunityToolkit.WinUI.Converters;```
 
       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.Resources Section to StaticResources like this for using it, since there is no single Namespace per Converter like on the Controls:
+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:
 
 ### [Example StringToVisibilityConverter](#tab/string-visible-conv)
 
@@ -229,22 +229,22 @@ StringToVisibilityConverter is a Converter that has to be bound to a String type
 
 ```xml
 <Page.Resources>
-  <converters:StringVisibilityConverter x:Key="YourStringVisibilityConverter"/>
+    <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}"/>
+<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)
@@ -252,9 +252,9 @@ Somewhere in your Page Content:
 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:
 
-```xml
+```
 BoolToObjectConverter x:Key="BoolToColorConverter" TrueValue="{ThemeResource SystemFillColorSuccessBackgroundBrush}"
-                                                   FalseValue="{ThemeResource SystemFillColorCriticalBackgroundBrush}"/>
+                                                    FalseValue="{ThemeResource SystemFillColorCriticalBackgroundBrush}"/>
 ```
 
 > [!NOTE]
@@ -278,7 +278,3 @@ Somewhere in your Page Content:
 ---
 
 [!include[getting-help](includes/getting-help.md)]
-
----
-
-[!include[getting-help](includes/getting-help.md)]

From f074bc79ebe0284b208552421d424b14284bc82e Mon Sep 17 00:00:00 2001
From: DevTKSS <info@technische-konstruktion.com>
Date: Mon, 6 Jan 2025 21:47:40 +0100
Subject: [PATCH 10/12] chore(CTK): Deleted azure listed intents and spacings

---
 doc/articles/uno-community-toolkit-v8.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/articles/uno-community-toolkit-v8.md b/doc/articles/uno-community-toolkit-v8.md
index 12f2dcbc0690..f19ac1211aee 100644
--- a/doc/articles/uno-community-toolkit-v8.md
+++ b/doc/articles/uno-community-toolkit-v8.md
@@ -252,9 +252,9 @@ Somewhere in your Page Content:
 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:
 
-```
+```xml
 BoolToObjectConverter x:Key="BoolToColorConverter" TrueValue="{ThemeResource SystemFillColorSuccessBackgroundBrush}"
-                                                    FalseValue="{ThemeResource SystemFillColorCriticalBackgroundBrush}"/>
+                                                   FalseValue="{ThemeResource SystemFillColorCriticalBackgroundBrush}"/>
 ```
 
 > [!NOTE]

From 5bf7a807f5f645f542913ea9e3f1be11885975a7 Mon Sep 17 00:00:00 2001
From: Martin Zikmund <martin@zikmund.dev>
Date: Sun, 19 Sep 2021 17:17:32 +0200
Subject: [PATCH 11/12] refactor: Concrete versions of StartStopDelegateWrapper

---
 .../Helpers/StartStopDelegateWrapper.cs       | 114 ++++++++----------
 src/Uno.UWP/Helpers/StartStopEventWrapper.cs  |  39 +++---
 .../Helpers/StartStopTypedEventWrapper.cs     |  48 ++++----
 3 files changed, 96 insertions(+), 105 deletions(-)

diff --git a/src/Uno.UWP/Helpers/StartStopDelegateWrapper.cs b/src/Uno.UWP/Helpers/StartStopDelegateWrapper.cs
index cf92b6fb72d9..2689b68025e6 100644
--- a/src/Uno.UWP/Helpers/StartStopDelegateWrapper.cs
+++ b/src/Uno.UWP/Helpers/StartStopDelegateWrapper.cs
@@ -2,89 +2,73 @@
 
 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
+namespace Uno.Helpers
 {
-	private readonly object _syncLock;
-	private readonly Action _onFirst;
-	private readonly Action _onLast;
-
 	/// <summary>
-	/// Creates a new instance of start-stop delegate wrapper.
+	/// 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>
-	/// <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)
+	internal class StartStopDelegateWrapper<TDelegate>
+		where TDelegate : Delegate
 	{
-		_onFirst = onFirst;
-		_onLast = onLast;
-		_syncLock = sharedLock ?? new object();
-	}
+		private readonly object _syncLock;
+		private readonly Action _onFirst;
+		private readonly Action _onLast;
 
-	/// <summary>
-	/// Backing delegate.
-	/// </summary>
-	public TDelegate? Event { get; private set; }
+		/// <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>
-	/// Indicates if there is at least one active subscription.
-	/// </summary>
-	public bool IsActive => Event != null;
+		public TDelegate? Event { get; private set; } = null;
 
-	/// <summary>
-	/// Synchronization lock.
-	/// </summary>
-	public object SyncLock => _syncLock;
+		public object SyncLock => _syncLock;
 
-	/// <summary>
-	/// Adds a handler.
-	/// </summary>
-	/// <param name="handler">Handler.</param>
-	public void AddHandler(TDelegate handler)
-	{
-		lock (_syncLock)
+		public void AddHandler(TDelegate handler)
 		{
-			var firstSubscriber = Event == null;
-			Event = (TDelegate)Delegate.Combine(Event, handler);
-			if (firstSubscriber)
+			lock (_syncLock)
 			{
-				_onFirst();
+				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)
+		public void RemoveHandler(TDelegate handler)
 		{
-			if (Event != null)
+			lock (_syncLock)
 			{
-				Event = (TDelegate?)Delegate.Remove(Event, handler);
-				if (Event == null)
+				if (Event != null)
 				{
-					_onLast();
+					Event = (TDelegate?)Delegate.Remove(Event, handler);
+					if (Event == null)
+					{
+						_onLast();
+					}
 				}
 			}
 		}
+
+		public bool IsActive => Event != null;
 	}
 }
diff --git a/src/Uno.UWP/Helpers/StartStopEventWrapper.cs b/src/Uno.UWP/Helpers/StartStopEventWrapper.cs
index 7cf69c395885..027cddc23c87 100644
--- a/src/Uno.UWP/Helpers/StartStopEventWrapper.cs
+++ b/src/Uno.UWP/Helpers/StartStopEventWrapper.cs
@@ -11,23 +11,30 @@ namespace Uno.Helpers;
 internal class StartStopEventWrapper<TEventArgs> : StartStopDelegateWrapper<EventHandler<TEventArgs>>
 {
 	/// <summary>
-	/// Creates a new instance of start-stop event wrapper.
+	/// Start stop wrapper for EventHandler<T> events.
 	/// </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 StartStopEventWrapper(Action onFirst, Action onLast, object? sharedLock = null) :
-		base(onFirst, onLast, sharedLock)
+	/// <typeparam name="TEventArgs">Event args type.</typeparam>
+	internal class StartStopEventWrapper<TEventArgs> : StartStopDelegateWrapper<EventHandler<TEventArgs>>
 	{
-	}
+		/// <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 StartStopEventWrapper(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(object sender, TEventArgs args) => Event?.Invoke(sender, args);
+		/// <summary>
+		/// Invokes the event.
+		/// </summary>
+		/// <param name="sender">Sender.</param>
+		/// <param name="args">Args.</param>
+		public void Invoke(object sender, TEventArgs args) => Event?.Invoke(sender, args);
+	}
 }
diff --git a/src/Uno.UWP/Helpers/StartStopTypedEventWrapper.cs b/src/Uno.UWP/Helpers/StartStopTypedEventWrapper.cs
index 5bad9a87be33..5b2a53fd9249 100644
--- a/src/Uno.UWP/Helpers/StartStopTypedEventWrapper.cs
+++ b/src/Uno.UWP/Helpers/StartStopTypedEventWrapper.cs
@@ -3,33 +3,33 @@
 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>>
+namespace Uno.Helpers
 {
 	/// <summary>
-	/// Creates a new instance of start-stop event wrapper.
+	/// Start stop wrapper for TypedEventHandler<T> events.
 	/// </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)
+	/// <typeparam name="TEventArgs">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);
+		/// <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);
+	}
 }

From 33d3a861f5da0fd1c658d1d203b14efa6e3609be Mon Sep 17 00:00:00 2001
From: Youssef1313 <youssefvictor00@gmail.com>
Date: Sat, 4 Jan 2025 14:19:25 +0100
Subject: [PATCH 12/12] feat: Implement pattern/template grammar for
 DateTimeFormatter

---
 .../DateTimeFormatting/DateTimeFormatter.cs   | 611 +++++-------------
 .../DateTimePatternParser/PatternNodes.cs     |  88 +--
 .../DateTimePatternParser/PatternParser.cs    |   7 +-
 .../DateTimeTemplateParser/TemplateNodes.cs   | 182 ------
 .../DateTimeTemplateParser/TemplateParser.cs  | 239 ++++++-
 5 files changed, 439 insertions(+), 688 deletions(-)

diff --git a/src/Uno.UWP/Globalization/DateTimeFormatting/DateTimeFormatter.cs b/src/Uno.UWP/Globalization/DateTimeFormatting/DateTimeFormatter.cs
index bc00ca60796a..a8ed7c91b438 100644
--- a/src/Uno.UWP/Globalization/DateTimeFormatting/DateTimeFormatter.cs
+++ b/src/Uno.UWP/Globalization/DateTimeFormatting/DateTimeFormatter.cs
@@ -18,14 +18,15 @@ public sealed partial class DateTimeFormatter
 {
 	private readonly CultureInfo _firstCulture;
 
-	private readonly PatternRootNode _patternRootNode;
+	private readonly TemplateRootNode? _templateRootNode;
+	private readonly PatternRootNode? _patternRootNode;
 
 	/// <summary>
 	/// Creates a DateTimeFormatter object that is initialized by a format template string.
 	/// </summary>
 	/// <param name="formatTemplate">
-	/// A format template string that specifies the requested components. 
-	/// The order of the components is irrelevant. 
+	/// A format template string that specifies the requested components.
+	/// The order of the components is irrelevant.
 	/// This can also be a format pattern.
 	/// </param>
 	public DateTimeFormatter(string formatTemplate)
@@ -37,8 +38,8 @@ public DateTimeFormatter(string formatTemplate)
 	/// Creates a DateTimeFormatter object that is initialized by a format template string.
 	/// </summary>
 	/// <param name="formatTemplate">
-	/// A format template string that specifies the requested components. 
-	/// The order of the components is irrelevant. 
+	/// A format template string that specifies the requested components.
+	/// The order of the components is irrelevant.
 	/// This can also be a format pattern.
 	/// </param>
 	/// <param name="languages">
@@ -51,59 +52,43 @@ public DateTimeFormatter(
 	{
 		ArgumentNullException.ThrowIfNull(formatTemplate);
 
-		if (languages != null)
-		{
-			Languages = languages.Distinct().ToArray();
-		}
-
-		_firstCulture = new CultureInfo(Languages[0]);
-
 		try
 		{
 			// Template example:
 			// "year month day dayofweek hour timezone" (that's just an example)
 			var templateParser = new TemplateParser(formatTemplate);
-			templateParser.Parse();
-			IncludeYear = templateParser.Info.IncludeYear;
-			IncludeMonth = templateParser.Info.IncludeMonth;
-			IncludeDay = templateParser.Info.IncludeDay;
-			IncludeDayOfWeek = templateParser.Info.IncludeDayOfWeek;
-			IncludeHour = templateParser.Info.IncludeHour;
-			IncludeMinute = templateParser.Info.IncludeMinute;
-			IncludeSecond = templateParser.Info.IncludeSecond;
-			IncludeTimeZone = templateParser.Info.IncludeTimeZone;
-			IsShortDate = templateParser.Info.IsShortDate;
-			IsLongDate = templateParser.Info.IsLongDate;
-			IsShortTime = templateParser.Info.IsShortTime;
-			IsShortDate = templateParser.Info.IsShortDate;
-
-			// NOTE: We intentionally don't set the user provided template.
-			// Instead, we parse and re-build the template string.
-			// That's how WinUI works.
-			// Basically, the order of tokens in the template string does NOT matter.
-			// So, this kinda normalizes the order the right way.
+			_templateRootNode = templateParser.Parse();
+			IncludeYear = templateParser.IncludeYear;
+			IncludeMonth = templateParser.IncludeMonth;
+			IncludeDay = templateParser.IncludeDay;
+			IncludeDayOfWeek = templateParser.IncludeDayOfWeek;
+			IncludeHour = templateParser.IncludeHour;
+			IncludeMinute = templateParser.IncludeMinute;
+			IncludeSecond = templateParser.IncludeSecond;
+			IncludeTimeZone = templateParser.IncludeTimeZone;
+			IsShortDate = templateParser.IsShortDate;
+			IsLongDate = templateParser.IsLongDate;
+			IsShortTime = templateParser.IsShortTime;
+			IsShortDate = templateParser.IsShortDate;
 			Template = BuildTemplate();
-
-			string patternBuiltFromTemplate = BuildPattern();
-			Patterns = [patternBuiltFromTemplate];
-			_patternRootNode = new PatternParser(patternBuiltFromTemplate).Parse();
 		}
-		catch (Exception ex)
+		catch (Exception)
 		{
-			try
-			{
-				// Pattern example:
-				// "Hello {year.full} Hello2 {month.full}" (that's just an example)
-				_patternRootNode = new PatternParser(formatTemplate).Parse();
-				Template = formatTemplate;
-				Patterns = [formatTemplate];
-			}
-			catch (Exception ex2)
-			{
-				throw new AggregateException(ex, ex2);
-			}
+			// Pattern example:
+			// "Hello {year.full} Hello2 {month.full}" (that's just an example)
+			_patternRootNode = new PatternParser(formatTemplate).Parse();
+			Template = formatTemplate;
+		}
+
+		Patterns = [formatTemplate];
+		if (languages != null)
+		{
+			Languages = languages.Distinct().ToArray();
 		}
 
+		_firstCulture = new CultureInfo(Languages[0]);
+
+
 		var calendar = new Calendar(Languages);
 		Calendar = calendar.GetCalendarSystem();
 		Clock = calendar.GetClock();
@@ -136,9 +121,7 @@ public DateTimeFormatter(
 		IncludeDay = dayFormat;
 		IncludeDayOfWeek = dayOfWeekFormat;
 		Template = BuildTemplate();
-		string patternBuiltFromTemplate = BuildPattern();
-		Patterns = [patternBuiltFromTemplate];
-		_patternRootNode = new PatternParser(patternBuiltFromTemplate).Parse();
+		Patterns = [Template];
 		_firstCulture = new CultureInfo(Languages[0]);
 
 		// TODO:MZ:
@@ -156,9 +139,7 @@ public DateTimeFormatter(
 		IncludeMinute = minuteFormat;
 		IncludeSecond = secondFormat;
 		Template = BuildTemplate();
-		string patternBuiltFromTemplate = BuildPattern();
-		Patterns = [patternBuiltFromTemplate];
-		_patternRootNode = new PatternParser(patternBuiltFromTemplate).Parse();
+		Patterns = [Template];
 		_firstCulture = new CultureInfo(Languages[0]);
 
 		// TODO:MZ:
@@ -186,9 +167,7 @@ public DateTimeFormatter(
 		IncludeSecond = secondFormat;
 		Languages = languages.ToArray();
 		Template = BuildTemplate();
-		string patternBuiltFromTemplate = BuildPattern();
-		Patterns = [patternBuiltFromTemplate];
-		_patternRootNode = new PatternParser(patternBuiltFromTemplate).Parse();
+		Patterns = [Template];
 		_firstCulture = new CultureInfo(Languages[0]);
 
 		// TODO:MZ:
@@ -222,9 +201,7 @@ public DateTimeFormatter(
 		Calendar = calendar;
 		Clock = clock;
 		Template = BuildTemplate();
-		string patternBuiltFromTemplate = BuildPattern();
-		Patterns = [patternBuiltFromTemplate];
-		_patternRootNode = new PatternParser(patternBuiltFromTemplate).Parse();
+		Patterns = [Template];
 		_firstCulture = new CultureInfo(Languages[0]);
 	}
 
@@ -288,6 +265,16 @@ public DateTimeFormatter(
 
 	internal bool IsLongDate { get; }
 
+	internal TimeZoneFormat IncludeTimeZone { get; }
+
+	internal bool IsShortTime { get; }
+
+	internal bool IsLongTime { get; }
+
+	internal bool IsShortDate { get; }
+
+	internal bool IsLongDate { get; }
+
 	/// <summary>
 	/// Gets the priority list of language identifiers that is used when formatting dates and times.
 	/// </summary>
@@ -342,7 +329,129 @@ public string Format(DateTimeOffset value)
 	{
 		try
 		{
-			return _patternRootNode.Format(value, _firstCulture, isTwentyFourHours: Clock == ClockIdentifiers.TwentyFourHour);
+			if (_templateRootNode is not null)
+			{
+				string date;
+				if (IsLongDate)
+				{
+					date = value.ToString(_firstCulture.DateTimeFormat.LongDatePattern, _firstCulture);
+				}
+				else if (IsShortDate)
+				{
+					date = value.ToString(_firstCulture.DateTimeFormat.ShortDatePattern, _firstCulture);
+				}
+				else
+				{
+					// NOTE: The original order that was specified in the template string does NOT matter.
+					// That's why all we need to care about is the values of the mentioned properties.
+					// However, we should actually be checking the actual enum value and not just being "None" or not.
+					// But the actual correct implementation that will 100% match WinUI isn't yet clear.
+					// This is a best effort approach.
+					bool hasYear = IncludeYear != YearFormat.None;
+					bool hasMonth = IncludeMonth != MonthFormat.None;
+					bool hasDay = IncludeDay != DayFormat.None;
+					bool hasDayOfWeek = IncludeDayOfWeek != DayOfWeekFormat.None;
+
+					if (hasYear && hasMonth && hasDay && hasDayOfWeek)
+					{
+						date = value.ToString(_firstCulture.DateTimeFormat.LongDatePattern, _firstCulture);
+					}
+					else if (hasYear && hasMonth && hasDay)
+					{
+						date = value.ToString(_firstCulture.DateTimeFormat.ShortDatePattern, _firstCulture);
+					}
+					else if (hasYear && hasMonth && !hasDayOfWeek)
+					{
+						date = value.ToString(_firstCulture.DateTimeFormat.YearMonthPattern, _firstCulture);
+					}
+					else if (hasYear && !hasMonth && !hasDay && !hasDayOfWeek)
+					{
+						date = value.ToString("yyyy", _firstCulture);
+					}
+					else if (hasMonth && hasDay && !hasYear && !hasDayOfWeek)
+					{
+						date = value.ToString(_firstCulture.DateTimeFormat.MonthDayPattern, _firstCulture);
+					}
+					else
+					{
+						// Fallback case.
+						// Add more cases as they arise.
+						date = value.ToString(_firstCulture.DateTimeFormat.LongDatePattern, _firstCulture);
+					}
+				}
+
+				string time;
+				if (IsLongTime)
+				{
+					time = value.ToString(_firstCulture.DateTimeFormat.LongTimePattern, _firstCulture);
+				}
+				else if (IsShortTime)
+				{
+					time = value.ToString(_firstCulture.DateTimeFormat.ShortTimePattern, _firstCulture);
+				}
+				else
+				{
+					// NOTE: The original order that was specified in the template string does NOT matter.
+					// That's why all we need to care about is the values of the mentioned properties.
+					bool hasHour = IncludeHour != HourFormat.None;
+					bool hasMinute = IncludeMinute != MinuteFormat.None;
+					bool hasSecond = IncludeSecond != SecondFormat.None;
+					bool hasTimeZone = IncludeTimeZone != TimeZoneFormat.None;
+
+					if (hasHour && hasMinute && hasSecond)
+					{
+						time = value.ToString(_firstCulture.DateTimeFormat.LongTimePattern, _firstCulture);
+					}
+					else if (hasHour && hasMinute)
+					{
+						time = value.ToString(_firstCulture.DateTimeFormat.ShortTimePattern, _firstCulture);
+					}
+					else if (hasHour)
+					{
+						time = value.ToString("%H", _firstCulture);
+					}
+					else if (!hasHour && !hasMinute && !hasSecond)
+					{
+						time = string.Empty;
+					}
+					else
+					{
+						// Shouldn't really be reachable. But a fallback in place just in case.
+						time = value.ToString(_firstCulture.DateTimeFormat.LongTimePattern, _firstCulture);
+					}
+
+					if (hasTimeZone)
+					{
+						if (time.Length == 0)
+						{
+							time = $"GMT+{TimeZoneInfo.Local.BaseUtcOffset.TotalHours}";
+						}
+						else
+						{
+							time = $"{time} GMT+{TimeZoneInfo.Local.BaseUtcOffset.TotalHours}";
+						}
+					}
+				}
+
+				if (date.Length > 0 && time.Length > 0)
+				{
+					return $"{date} {time}";
+				}
+				else if (date.Length > 0)
+				{
+					return date;
+				}
+				else
+				{
+					return time;
+				}
+			}
+			else if (_patternRootNode is not null)
+			{
+				return _patternRootNode.Format(value, _firstCulture);
+			}
+
+			throw new InvalidOperationException("This cannot happen. The constructor sets either _templateRootNode or _patternRootNode to non-null.");
 		}
 		catch (Exception e)
 		{
@@ -432,39 +541,18 @@ private static string ToTemplateString(TimeZoneFormat timeZoneFormat)
 	private string BuildTemplate()
 	{
 		var templateBuilder = new StringBuilder();
-		if (IsLongDate)
-			Append("longdate");
-		else if (IsShortDate)
-			Append("shortdate");
-		else
-		{
-			Append(ToTemplateString(IncludeYear));
-			Append(ToTemplateString(IncludeMonth));
-			Append(ToTemplateString(IncludeDay));
-			Append(ToTemplateString(IncludeDayOfWeek));
-		}
-
-		if (IsLongTime)
-			Append("longtime");
-		else if (IsShortTime)
-			Append("shorttime");
-		else
-		{
-			Append(ToTemplateString(IncludeHour));
-			Append(ToTemplateString(IncludeMinute));
-			Append(ToTemplateString(IncludeSecond));
-			Append(ToTemplateString(IncludeTimeZone));
-		}
-
+		Append(ToTemplateString(IncludeYear));
+		Append(ToTemplateString(IncludeMonth));
+		Append(ToTemplateString(IncludeDay));
+		Append(ToTemplateString(IncludeDayOfWeek));
+		Append(ToTemplateString(IncludeHour));
+		Append(ToTemplateString(IncludeMinute));
+		Append(ToTemplateString(IncludeSecond));
+		Append(ToTemplateString(IncludeTimeZone));
 		return templateBuilder.ToString();
 
 		void Append(string value)
 		{
-			if (value.Length == 0)
-			{
-				return;
-			}
-
 			if (templateBuilder.Length != 0)
 			{
 				templateBuilder.Append(' ');
@@ -473,347 +561,4 @@ void Append(string value)
 			templateBuilder.Append(value);
 		}
 	}
-
-	private string BuildPattern()
-	{
-		string datePattern;
-		if (IsLongDate)
-		{
-			datePattern = _firstCulture.DateTimeFormat.LongDatePattern;
-		}
-		else if (IsShortDate)
-		{
-			datePattern = _firstCulture.DateTimeFormat.ShortDatePattern;
-		}
-		else
-		{
-			// NOTE: The original order that was specified in the template string does NOT matter.
-			// That's why all we need to care about is the values of the mentioned properties.
-			// However, we should actually be checking the actual enum value and not just being "None" or not.
-			// But the actual correct implementation that will 100% match WinUI isn't yet clear.
-			// This is a best effort approach.
-			bool hasYear = IncludeYear != YearFormat.None;
-			bool hasMonth = IncludeMonth != MonthFormat.None;
-			bool hasDay = IncludeDay != DayFormat.None;
-			bool hasDayOfWeek = IncludeDayOfWeek != DayOfWeekFormat.None;
-
-			if (hasYear && hasMonth && hasDay && hasDayOfWeek)
-			{
-				datePattern = _firstCulture.DateTimeFormat.LongDatePattern;
-			}
-			else if (hasYear && hasMonth && hasDay)
-			{
-				datePattern = _firstCulture.DateTimeFormat.ShortDatePattern;
-			}
-			else if (hasYear && hasMonth && !hasDayOfWeek)
-			{
-				datePattern = _firstCulture.DateTimeFormat.YearMonthPattern;
-			}
-			else if (hasYear && !hasMonth && !hasDay && !hasDayOfWeek)
-			{
-				datePattern = "yyyy";
-			}
-			else if (hasMonth && hasDay && !hasYear && !hasDayOfWeek)
-			{
-				datePattern = _firstCulture.DateTimeFormat.MonthDayPattern;
-			}
-			else
-			{
-				// Fallback case.
-				// Add more cases as they arise.
-				datePattern = _firstCulture.DateTimeFormat.LongDatePattern;
-			}
-		}
-
-		string timePattern;
-		if (IsLongTime)
-		{
-			timePattern = _firstCulture.DateTimeFormat.LongTimePattern;
-		}
-		else if (IsShortTime)
-		{
-			timePattern = _firstCulture.DateTimeFormat.ShortTimePattern;
-		}
-		else
-		{
-			// NOTE: The original order that was specified in the template string does NOT matter.
-			// That's why all we need to care about is the values of the mentioned properties.
-			bool hasHour = IncludeHour != HourFormat.None;
-			bool hasMinute = IncludeMinute != MinuteFormat.None;
-			bool hasSecond = IncludeSecond != SecondFormat.None;
-			bool hasTimeZone = IncludeTimeZone != TimeZoneFormat.None;
-
-			if (hasHour && hasMinute && hasSecond)
-			{
-				timePattern = _firstCulture.DateTimeFormat.LongTimePattern;
-			}
-			else if (hasHour && hasMinute)
-			{
-				timePattern = _firstCulture.DateTimeFormat.ShortTimePattern;
-			}
-			else if (hasHour)
-			{
-				timePattern = "h";
-			}
-			else if (!hasHour && !hasMinute && !hasSecond)
-			{
-				timePattern = string.Empty;
-			}
-			else
-			{
-				// Shouldn't really be reachable. But a fallback in place just in case.
-				timePattern = _firstCulture.DateTimeFormat.LongTimePattern;
-			}
-
-			if (hasTimeZone)
-			{
-				if (timePattern.Length == 0)
-				{
-					timePattern = "zzz";
-				}
-				else
-				{
-					timePattern = $"{timePattern} zzz";
-				}
-			}
-		}
-
-		string finalSystemFormat;
-		if (datePattern.Length > 0 && timePattern.Length > 0)
-		{
-			finalSystemFormat = $"{datePattern} {timePattern}";
-		}
-		else if (datePattern.Length > 0)
-		{
-			finalSystemFormat = datePattern;
-		}
-		else
-		{
-			finalSystemFormat = timePattern;
-		}
-
-		return ConstructPattern(finalSystemFormat);
-
-		void AddToBuilder(StringBuilder builder, char lastChar, int count)
-		{
-			// Best effort implementation.
-			switch (lastChar)
-			{
-				case 'g':
-					while (count >= 2)
-					{
-						builder.Append("{era.abbreviated}");
-						count -= 2;
-					}
-
-					while (count >= 1)
-					{
-						builder.Append("{era.abbreviated}");
-						count -= 1;
-					}
-
-					break;
-
-				case 'y':
-					while (count >= 5)
-					{
-						builder.Append("{year.full(5)}");
-						count -= 5;
-					}
-
-					while (count >= 4)
-					{
-						builder.Append("{year.full}");
-						count -= 4;
-					}
-
-					while (count >= 3)
-					{
-						builder.Append("{year.full(3)}");
-						count -= 3;
-					}
-
-					while (count >= 2)
-					{
-						builder.Append("{year.full(2)}");
-						count -= 2;
-					}
-
-					while (count >= 1)
-					{
-						builder.Append("{year.full(1)}");
-						count -= 1;
-					}
-
-					break;
-
-				case 'M':
-					while (count >= 4)
-					{
-						builder.Append("{month.full}");
-						count -= 4;
-					}
-
-					while (count >= 3)
-					{
-						builder.Append("{month.abbreviated}");
-						count -= 3;
-					}
-
-					while (count >= 2)
-					{
-						builder.Append("{month.integer(2)}");
-						count -= 2;
-					}
-
-					while (count >= 1)
-					{
-						builder.Append("{month.integer}");
-						count -= 1;
-					}
-
-					break;
-
-				case 'd':
-					while (count >= 4)
-					{
-						builder.Append("{dayofweek.full}");
-						count -= 4;
-					}
-
-					while (count >= 3)
-					{
-						builder.Append("{dayofweek.abbreviated}");
-						count -= 3;
-					}
-
-					while (count >= 2)
-					{
-						builder.Append("{day.integer(2)}");
-						count -= 2;
-					}
-
-					while (count >= 1)
-					{
-						builder.Append("{day.integer}");
-						count -= 1;
-					}
-
-					break;
-
-				case 't':
-					while (count >= 2)
-					{
-						builder.Append("{period.abbreviated(2)}");
-						count -= 2;
-					}
-
-					while (count >= 1)
-					{
-						builder.Append("{period.abbreviated(1)}");
-						count -= 1;
-					}
-
-					break;
-
-				case 'h' or 'H':
-
-					while (count >= 2)
-					{
-						builder.Append("{hour.integer(2)}");
-						count -= 2;
-					}
-
-					while (count >= 1)
-					{
-						builder.Append("{hour.integer(1)}");
-						count -= 1;
-					}
-
-					break;
-
-				case 'm':
-
-					while (count >= 2)
-					{
-						builder.Append("{minute.integer(2)}");
-						count -= 2;
-					}
-
-					while (count >= 1)
-					{
-						builder.Append("{minute.integer(1)}");
-						count -= 1;
-					}
-
-					break;
-
-				case 's':
-
-					while (count >= 2)
-					{
-						builder.Append("{second.integer(2)}");
-						count -= 2;
-					}
-
-					while (count >= 1)
-					{
-						builder.Append("{second.integer(1)}");
-						count -= 1;
-					}
-
-					break;
-
-				case 'z':
-					while (count >= 3)
-					{
-						builder.Append("{timezone.full}");
-						count -= 3;
-					}
-
-					while (count >= 2)
-					{
-						builder.Append("{timezone.abbreviated(2)}");
-						count -= 2;
-					}
-
-					while (count >= 1)
-					{
-						builder.Append("{timezone.abbreviated(1)}");
-						count -= 1;
-					}
-
-					break;
-
-				default:
-					builder.Append(lastChar, count);
-					break;
-			}
-		}
-
-		string ConstructPattern(string str)
-		{
-			var builder = new StringBuilder();
-			char lastChar = str[0];
-			int count = 1;
-			for (int i = 1; i < str.Length; i++)
-			{
-				if (lastChar != str[i])
-				{
-					AddToBuilder(builder, lastChar, count);
-
-					lastChar = str[i];
-					count = 1;
-				}
-				else
-				{
-					count++;
-				}
-			}
-
-			AddToBuilder(builder, lastChar, count);
-			return builder.ToString();
-		}
-	}
-
 }
diff --git a/src/Uno.UWP/Globalization/DateTimeFormatting/DateTimePatternParser/PatternNodes.cs b/src/Uno.UWP/Globalization/DateTimeFormatting/DateTimePatternParser/PatternNodes.cs
index a2c3cf8d6557..146eea3e6a11 100644
--- a/src/Uno.UWP/Globalization/DateTimeFormatting/DateTimePatternParser/PatternNodes.cs
+++ b/src/Uno.UWP/Globalization/DateTimeFormatting/DateTimePatternParser/PatternNodes.cs
@@ -38,19 +38,19 @@ public PatternRootNode(
 	public PatternLiteralTextNode? OptionalSuffixLiteralText { get; }
 	public PatternRootNode? OptionalSuffixPattern { get; }
 
-	internal string Format(DateTimeOffset dateTime, CultureInfo culture, bool isTwentyFourHours)
+	internal string Format(DateTimeOffset dateTime, CultureInfo culture)
 	{
 		var builder = new StringBuilder();
-		Format(builder, dateTime, culture, isTwentyFourHours);
+		Format(builder, dateTime, culture);
 		return builder.ToString();
 	}
 
-	internal void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture, bool isTwentyFourHours)
+	internal void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture)
 	{
-		OptionalPrefixLiteralText?.Format(builder, dateTime, culture, isTwentyFourHours);
-		DateTimeNode.Format(builder, dateTime, culture, isTwentyFourHours);
-		OptionalSuffixLiteralText?.Format(builder, dateTime, culture, isTwentyFourHours);
-		OptionalSuffixPattern?.Format(builder, dateTime, culture, isTwentyFourHours);
+		OptionalPrefixLiteralText?.Format(builder, dateTime, culture);
+		DateTimeNode.Format(builder, dateTime, culture);
+		OptionalSuffixLiteralText?.Format(builder, dateTime, culture);
+		OptionalSuffixPattern?.Format(builder, dateTime, culture);
 	}
 }
 
@@ -65,7 +65,7 @@ public PatternLiteralTextNode(string text)
 
 	public string Text { get; }
 
-	internal void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture, bool isTwentyFourHours)
+	internal void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture)
 		=> builder.Append(Text);
 }
 
@@ -73,7 +73,7 @@ internal void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo
 //                        <period> | <hour> | <minute> | <second> | <timezone>
 internal abstract class PatternDateTimeNode
 {
-	internal abstract void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture, bool isTwentyFourHours);
+	internal abstract void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture);
 }
 
 // <era> ::= "{era.abbreviated" [<ideal-length>] "}"
@@ -87,7 +87,7 @@ public PatternEraNode(int? 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)
+	internal override void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture)
 	{
 		// C# can't represent negative dates (i.e, before christ).
 		// So, looks like Era will always be "AD" (Anno Domini).
@@ -114,7 +114,7 @@ public PatternYearNode(YearKind kind, int? idealLength)
 	public YearKind Kind { get; }
 	public int? IdealLength { get; }
 
-	internal override void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture, bool isTwentyFourHours)
+	internal override void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture)
 	{
 		if (Kind == YearKind.Full)
 		{
@@ -170,42 +170,28 @@ public PatternMonthNode(MonthKind kind, int? idealLength = null)
 	// Always null for full and solo.full
 	public int? IdealLength { get; }
 
-	internal override void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture, bool isTwentyFourHours)
+	internal override void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture)
 	{
+		// TODO
 		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);
-			}
+
 		}
 	}
 }
@@ -235,23 +221,24 @@ public PatternDayOfWeekNode(DayOfWeekKind kind, int? idealLength = null)
 	// Always null for full and solo.full
 	public int? IdealLength { get; }
 
-	internal override void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture, bool isTwentyFourHours)
+	internal override void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture)
 	{
+		// TODO
 		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));
+
 		}
 	}
 }
@@ -266,7 +253,7 @@ public PatternDayNode(int? idealLength)
 
 	public int? IdealLength { get; }
 
-	internal override void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture, bool isTwentyFourHours)
+	internal override void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture)
 	{
 		if (IdealLength.HasValue)
 		{
@@ -289,13 +276,8 @@ public PatternPeriodNode(int? idealLength)
 
 	public int? IdealLength { get; }
 
-	internal override void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture, bool isTwentyFourHours)
+	internal override void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture)
 	{
-		if (isTwentyFourHours)
-		{
-			return;
-		}
-
 		string period = dateTime.ToString("tt", culture);
 		if (IdealLength.HasValue && IdealLength.Value < period.Length)
 		{
@@ -318,21 +300,15 @@ public PatternHourNode(int? idealLength)
 
 	public int? IdealLength { get; }
 
-	internal override void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture, bool isTwentyFourHours)
+	internal override void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture)
 	{
-		int hour = dateTime.Hour;
-		if (!isTwentyFourHours && hour > 12)
-		{
-			hour = hour - 12;
-		}
-
 		if (IdealLength.HasValue)
 		{
-			builder.Append(hour.ToString(new string('0', IdealLength.Value), culture));
+			builder.Append(dateTime.Hour.ToString(new string('0', IdealLength.Value), culture));
 		}
 		else
 		{
-			builder.Append(hour);
+			builder.Append(dateTime.Hour);
 		}
 	}
 }
@@ -347,7 +323,7 @@ public PatternMinuteNode(int? idealLength)
 
 	public int? IdealLength { get; }
 
-	internal override void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture, bool isTwentyFourHours)
+	internal override void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture)
 	{
 		if (IdealLength.HasValue)
 		{
@@ -370,7 +346,7 @@ public PatternSecondNode(int? idealLength)
 
 	public int? IdealLength { get; }
 
-	internal override void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture, bool isTwentyFourHours)
+	internal override void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture)
 	{
 		if (IdealLength.HasValue)
 		{
@@ -404,7 +380,7 @@ public PatternTimeZoneNode(TimeZoneKind kind, int? idealLength = null)
 	// Always null for full
 	public int? IdealLength { get; }
 
-	internal override void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture, bool isTwentyFourHours)
+	internal override void Format(StringBuilder builder, DateTimeOffset dateTime, CultureInfo culture)
 	{
 		// Important: dateTime parameter shouldn't be used here.
 		// WinUI uses the local time zone info.
diff --git a/src/Uno.UWP/Globalization/DateTimeFormatting/DateTimePatternParser/PatternParser.cs b/src/Uno.UWP/Globalization/DateTimeFormatting/DateTimePatternParser/PatternParser.cs
index f5c33414fbcc..eb3fc4167be7 100644
--- a/src/Uno.UWP/Globalization/DateTimeFormatting/DateTimePatternParser/PatternParser.cs
+++ b/src/Uno.UWP/Globalization/DateTimeFormatting/DateTimePatternParser/PatternParser.cs
@@ -76,11 +76,6 @@ public PatternRootNode Parse()
 	//                        <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;
@@ -425,7 +420,7 @@ private void ExpectCharacterAndAdvance(char c)
 	{
 		if (_pattern[_index] != '(' ||
 			_index + 2 >= _pattern.Length ||
-			_pattern[_index + 2] != ')')
+			_pattern[_index + 2] != '(')
 		{
 			return null;
 		}
diff --git a/src/Uno.UWP/Globalization/DateTimeFormatting/DateTimeTemplateParser/TemplateNodes.cs b/src/Uno.UWP/Globalization/DateTimeFormatting/DateTimeTemplateParser/TemplateNodes.cs
index 2a020273afb5..760860a3671b 100644
--- a/src/Uno.UWP/Globalization/DateTimeFormatting/DateTimeTemplateParser/TemplateNodes.cs
+++ b/src/Uno.UWP/Globalization/DateTimeFormatting/DateTimeTemplateParser/TemplateNodes.cs
@@ -1,40 +1,11 @@
 #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> |
@@ -65,11 +36,6 @@ public TemplateRootNode(TemplateNode first, TemplateNode? second = null)
 	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>
@@ -100,12 +66,6 @@ public TemplateMonthDayNode(TemplateDateNode left, TemplateDateNode 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> |
@@ -126,13 +86,6 @@ public TemplateRelativeLongDateNode(TemplateDateNode left, TemplateDateNode midd
 	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> |
@@ -147,12 +100,6 @@ public TemplateMonthYearNode(TemplateNode left, TemplateNode right)
 
 	public TemplateNode Left { get; }
 	public TemplateNode Right { get; }
-
-	internal override void Traverse(DateTimeTemplateInfo state)
-	{
-		Left.Traverse(state);
-		Right.Traverse(state);
-	}
 }
 
 // <shortdate> ::= "shortdate" |
@@ -176,20 +123,6 @@ public TemplateShortDateNode(TemplateDateNode? left, TemplateDateNode? middle, T
 	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" |
@@ -233,21 +166,6 @@ public TemplateLongDateNode(TemplateDateNode? first, TemplateDateNode? second, T
 	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> | 
@@ -266,12 +184,6 @@ public TemplateTimeNode(TemplateNode first, TemplateNode? second = null)
 	public TemplateNode First { get; }
 
 	public TemplateNode? Second { get; }
-
-	internal override void Traverse(DateTimeTemplateInfo state)
-	{
-		First.Traverse(state);
-		Second?.Traverse(state);
-	}
 }
 
 // <shorttime> ::= "shorttime" |
@@ -297,20 +209,6 @@ public TemplateShortTimeNode(TemplateNode? first, TemplateNode? second, Template
 	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" |
@@ -360,21 +258,6 @@ public TemplateLongTimeNode(TemplateNode? first, TemplateNode? second, TemplateN
 	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);
-		}
-	}
 }
 
 
@@ -398,17 +281,6 @@ private TemplateYearNode(YearKind 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"
@@ -433,18 +305,6 @@ private TemplateMonthNode(MonthKind 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"
@@ -455,11 +315,6 @@ private TemplateDayNode()
 	}
 
 	public static TemplateDayNode Instance { get; } = new();
-
-	internal override void Traverse(DateTimeTemplateInfo state)
-	{
-		state.IncludeDay = DayFormat.Default;
-	}
 }
 
 // <dayofweek> ::= "dayofweek" | "dayofweek.full" | "dayofweek.abbreviated"
@@ -482,17 +337,6 @@ private TemplateDayOfWeekNode(DayOfWeekKind 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"
@@ -503,11 +347,6 @@ private TemplateHourNode()
 	}
 
 	public static TemplateHourNode Instance { get; } = new();
-
-	internal override void Traverse(DateTimeTemplateInfo state)
-	{
-		state.IncludeHour = HourFormat.Default;
-	}
 }
 
 // <minute> ::= "minute"
@@ -518,11 +357,6 @@ private TemplateMinuteNode()
 	}
 
 	public static TemplateMinuteNode Instance { get; } = new();
-
-	internal override void Traverse(DateTimeTemplateInfo state)
-	{
-		state.IncludeMinute = MinuteFormat.Default;
-	}
 }
 
 // <second> ::= "second"
@@ -533,11 +367,6 @@ private TemplateSecondNode()
 	}
 
 	public static TemplateSecondNode Instance { get; } = new();
-
-	internal override void Traverse(DateTimeTemplateInfo state)
-	{
-		state.IncludeSecond = SecondFormat.Default;
-	}
 }
 
 // <timezone> ::= "timezone" | "timezone.full" | "timezone.abbreviated"
@@ -560,15 +389,4 @@ private TemplateTimeZoneNode(TimeZoneKind 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
index 1f8fd7184ebf..eef71a14dd92 100644
--- a/src/Uno.UWP/Globalization/DateTimeFormatting/DateTimeTemplateParser/TemplateParser.cs
+++ b/src/Uno.UWP/Globalization/DateTimeFormatting/DateTimeTemplateParser/TemplateParser.cs
@@ -13,7 +13,29 @@ internal sealed class TemplateParser
 
 	public bool Completed => _index >= _template.Length;
 
-	public DateTimeTemplateInfo Info { get; } = new();
+	public YearFormat IncludeYear { get; private set; }
+
+	public MonthFormat IncludeMonth { get; private set; }
+
+	public DayFormat IncludeDay { get; private set; }
+
+	public DayOfWeekFormat IncludeDayOfWeek { get; private set; }
+
+	public HourFormat IncludeHour { get; private set; }
+
+	public MinuteFormat IncludeMinute { get; private set; }
+
+	public SecondFormat IncludeSecond { get; private set; }
+
+	public TimeZoneFormat IncludeTimeZone { get; private set; }
+
+	public bool IsLongTime { get; private set; }
+
+	public bool IsShortTime { get; private set; }
+
+	public bool IsLongDate { get; private set; }
+
+	public bool IsShortDate { get; private set; }
 
 	public TemplateParser(string template)
 	{
@@ -27,10 +49,212 @@ private TemplateRootNode EnsureCompleted(TemplateRootNode root)
 			throw new ArgumentException($"Failed to parse '{_template}'. Couldn't consume all characters. Stopped at index '{_index}'.");
 		}
 
-		root.Traverse(Info);
+		Traverse(root);
 		return root;
 	}
 
+	private void Traverse(TemplateNode? node)
+	{
+		if (node is null)
+		{
+			return;
+		}
+
+		// TODO: Move all the parser state that's altered by Traverse to own class.
+		// And then introduce an abstract Traverse that takes an instance of the state class.
+		// This will avoid these ugly type checks.
+		if (node is TemplateRootNode root)
+			Traverse(root);
+		else if (node is TemplateMonthDayNode monthDay)
+			Traverse(monthDay);
+		else if (node is TemplateRelativeLongDateNode relativeLongDate)
+			Traverse(relativeLongDate);
+		else if (node is TemplateMonthYearNode monthYear)
+			Traverse(monthYear);
+		else if (node is TemplateShortDateNode shortDate)
+			Traverse(shortDate);
+		else if (node is TemplateLongDateNode longDate)
+			Traverse(longDate);
+		else if (node is TemplateTimeNode time)
+			Traverse(time);
+		else if (node is TemplateShortTimeNode shortTime)
+			Traverse(shortTime);
+		else if (node is TemplateLongTimeNode longTime)
+			Traverse(longTime);
+		else if (node is TemplateYearNode year)
+			Traverse(year);
+		else if (node is TemplateMonthNode month)
+			Traverse(month);
+		else if (node is TemplateDayNode day)
+			Traverse(day);
+		else if (node is TemplateDayOfWeekNode dayOfWeek)
+			Traverse(dayOfWeek);
+		else if (node is TemplateHourNode hour)
+			Traverse(hour);
+		else if (node is TemplateMinuteNode minute)
+			Traverse(minute);
+		else if (node is TemplateSecondNode second)
+			Traverse(second);
+		else if (node is TemplateTimeZoneNode timeZone)
+			Traverse(timeZone);
+		else
+			throw new InvalidOperationException();
+	}
+
+	private void Traverse(TemplateRootNode root)
+	{
+		Traverse(root.First);
+		Traverse(root.Second);
+	}
+
+	private void Traverse(TemplateMonthDayNode monthDay)
+	{
+		Traverse(monthDay.Left);
+		Traverse(monthDay.Right);
+	}
+
+	private void Traverse(TemplateRelativeLongDateNode relativeLongDate)
+	{
+		Traverse(relativeLongDate.Left);
+		Traverse(relativeLongDate.Middle);
+		Traverse(relativeLongDate.Right);
+	}
+
+	private void Traverse(TemplateMonthYearNode monthYear)
+	{
+		Traverse(monthYear.Left);
+		Traverse(monthYear.Right);
+	}
+
+	private void Traverse(TemplateShortDateNode shortDate)
+	{
+		if (ReferenceEquals(shortDate, TemplateShortDateNode.DefaultShortDateInstance))
+		{
+			IsShortDate = true;
+		}
+		else
+		{
+			Traverse(shortDate.Left);
+			Traverse(shortDate.Middle);
+			Traverse(shortDate.Right);
+		}
+	}
+
+	private void Traverse(TemplateLongDateNode longDate)
+	{
+		if (ReferenceEquals(longDate, TemplateLongDateNode.DefaultLongDateInstance))
+		{
+			IsLongDate = true;
+		}
+		else
+		{
+			Traverse(longDate.First);
+			Traverse(longDate.Second);
+			Traverse(longDate.Third);
+			Traverse(longDate.Forth);
+		}
+	}
+
+	private void Traverse(TemplateTimeNode time)
+	{
+		Traverse(time.First);
+		Traverse(time.Second);
+	}
+
+	private void Traverse(TemplateShortTimeNode shortTime)
+	{
+		if (ReferenceEquals(shortTime, TemplateShortTimeNode.DefaultShortTimeInstance))
+		{
+			IsShortTime = true;
+		}
+		else
+		{
+			Traverse(shortTime.First);
+			Traverse(shortTime.Second);
+			Traverse(shortTime.Third);
+		}
+	}
+
+	private void Traverse(TemplateLongTimeNode longTime)
+	{
+		if (ReferenceEquals(longTime, TemplateLongTimeNode.DefaultLongTimeInstance))
+		{
+			IsLongTime = true;
+		}
+		else
+		{
+			Traverse(longTime.First);
+			Traverse(longTime.Second);
+			Traverse(longTime.Third);
+			Traverse(longTime.Forth);
+		}
+	}
+
+	private void Traverse(TemplateYearNode year)
+	{
+		IncludeYear = year.Kind switch
+		{
+			TemplateYearNode.YearKind.Normal => YearFormat.Default,
+			TemplateYearNode.YearKind.Full => YearFormat.Full,
+			TemplateYearNode.YearKind.Abbreviated => YearFormat.Abbreviated,
+			_ => throw new InvalidOperationException(),
+		};
+	}
+
+	private void Traverse(TemplateMonthNode month)
+	{
+		IncludeMonth = month.Kind switch
+		{
+			TemplateMonthNode.MonthKind.Normal => MonthFormat.Default,
+			TemplateMonthNode.MonthKind.Full => MonthFormat.Full,
+			TemplateMonthNode.MonthKind.Abbreviated => MonthFormat.Abbreviated,
+			TemplateMonthNode.MonthKind.Numeric => MonthFormat.Numeric,
+			_ => throw new InvalidOperationException(),
+		};
+	}
+
+	private void Traverse(TemplateDayNode day)
+	{
+		IncludeDay = DayFormat.Default;
+	}
+
+	private void Traverse(TemplateDayOfWeekNode dayOfWeek)
+	{
+		IncludeDayOfWeek = dayOfWeek.Kind switch
+		{
+			TemplateDayOfWeekNode.DayOfWeekKind.Normal => DayOfWeekFormat.Default,
+			TemplateDayOfWeekNode.DayOfWeekKind.Full => DayOfWeekFormat.Full,
+			TemplateDayOfWeekNode.DayOfWeekKind.Abbreviated => DayOfWeekFormat.Abbreviated,
+			_ => throw new InvalidOperationException(),
+		};
+	}
+
+	private void Traverse(TemplateHourNode hour)
+	{
+		IncludeHour = HourFormat.Default;
+	}
+
+	private void Traverse(TemplateMinuteNode minute)
+	{
+		IncludeMinute = MinuteFormat.Default;
+	}
+
+	private void Traverse(TemplateSecondNode second)
+	{
+		IncludeSecond = SecondFormat.Default;
+	}
+
+	private void Traverse(TemplateTimeZoneNode timeZone)
+	{
+		IncludeTimeZone = timeZone.Kind switch
+		{
+			TemplateTimeZoneNode.TimeZoneKind.Normal => TimeZoneFormat.Default,
+			TemplateTimeZoneNode.TimeZoneKind.Full => TimeZoneFormat.Full,
+			TemplateTimeZoneNode.TimeZoneKind.Abbreviated => TimeZoneFormat.Abbreviated,
+			_ => throw new InvalidOperationException(),
+		};
+	}
+
 	public TemplateRootNode Parse()
 	{
 		_ = SkipWhitespace();
@@ -292,21 +516,14 @@ private bool TryParseLongDate([NotNullWhen(true)] out TemplateLongDateNode? long
 			out longDate);
 	}
 
-	private bool TryParseShortDate([NotNullWhen(true)] out TemplateShortDateNode? shortDate)
+	private bool TryParseShortDate([NotNullWhen(true)] out TemplateShortDateNode? date)
 	{
-		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);
+			out date);
 	}
 
 	private bool TryParseYear([NotNullWhen(true)] out TemplateYearNode? year)