Migrate to Uno.Sdk

.github/workflows/build.yml

@@ -112,14 +112,22 @@ jobs:
         with:
           global-json-file: tooling/global.json
 
+      # Run from ./tooling so global.json scopes the install to the pinned SDK feature
+      # band; otherwise the workloads land on the runner's newer preinstalled SDK.
+      - name: Install .NET workloads
+        working-directory: tooling
+        run: dotnet workload install wasm-tools
+
       - name: .NET Info (if diagnostics)
         if: ${{ env.ENABLE_DIAGNOSTICS == 'true' }}
         run: dotnet --info
 
       - name: Copy props files to root
         shell: pwsh
         working-directory: ./
-        run: copy ./tooling/.github/workflows/config/* ./
+        run: |
+          copy ./tooling/.github/workflows/config/* ./
+          copy ./tooling/global.json ./
 
       - name: Add msbuild to PATH
         uses: microsoft/setup-msbuild@v2
@@ -149,6 +157,14 @@ jobs:
           # WinUI 3 not supported on uwp
           - winui: 3
             multitarget: uwp
+        include:
+          # The Uno.Sdk head replaces the classic Wasm head on WinUI 3, so it rides on the
+          # existing wasm/winui3 job as a flag rather than a fake entry in the multitarget axis.
+          # GenerateSingleSampleHeads.ps1 derives the same thing itself (wasm + WinUI 3); this flag
+          # only drives which CI steps run below (workloads, build command), not the script's own behavior.
+          - winui: 3
+            multitarget: wasm
+            unoSdkHead: true
 
     env:
       HEADS_DIRECTORY: tooling/ProjectHeads
@@ -178,6 +194,13 @@ jobs:
         with:
           global-json-file: tooling/global.json
 
+      # Run from ./tooling so global.json scopes the install to the pinned SDK feature
+      # band; otherwise the workloads land on the runner's newer preinstalled SDK.
+      - name: Install .NET workloads
+        if: ${{ matrix.multitarget == 'wasm' }}
+        working-directory: tooling
+        run: dotnet workload install wasm-tools ${{ matrix.unoSdkHead && 'android ios maui' || '' }}
+
       - name: .NET Info (if diagnostics)
         if: ${{ env.ENABLE_DIAGNOSTICS == 'true' }}
         run: dotnet --info
@@ -187,6 +210,7 @@ jobs:
         working-directory: ./
         run: |
           copy ./tooling/.github/workflows/config/* ./
+          copy ./tooling/global.json ./
           mkdir ./.config
           copy ./tooling/.config/dotnet-tools.json ./.config/dotnet-tools.json
           mkdir ./components
@@ -214,8 +238,17 @@ jobs:
 
       - name: Add project heads to ${{ env.TEST_PROJECT_NAME }}
         working-directory: ./${{ env.TEST_PROJECT_DIRECTORY }}
-        run: ${{ github.workspace }}/${{ env.HEADS_DIRECTORY }}/GenerateSingleSampleHeads.ps1 -MultiTargets ${{ matrix.multitarget }} -winui ${{ matrix.winui }} -componentPath "${{ github.workspace }}/${{ env.TEST_PROJECT_DIRECTORY }}"${{ env.ENABLE_DIAGNOSTICS == 'true' && ' -UseDiagnostics' || '' }}
-
+        run: >-
+          ${{ github.workspace }}/${{ env.HEADS_DIRECTORY }}/GenerateSingleSampleHeads.ps1
+          -MultiTargets ${{ matrix.multitarget }}
+          -winui ${{ matrix.winui }}
+          -componentPath "${{ github.workspace }}/${{ env.TEST_PROJECT_DIRECTORY }}"
+          ${{ env.ENABLE_DIAGNOSTICS == 'true' && ' -UseDiagnostics' || '' }}
+
+      # The generated solution already contains only the head(s) for the requested MultiTarget(s)
+      # (GenerateSingleSolution.ps1 swaps in the Uno.Sdk head instead of the classic Wasm one for
+      # WinUI 3 + wasm), so one MSBuild invocation covers the Uno.Sdk head too - msbuild.exe builds
+      # it fine, verified locally against dotnet build with identical results.
       - name: MSBuild
         working-directory: ./${{ env.TEST_PROJECT_DIRECTORY }}
         run: msbuild.exe ${{ env.TEST_PROJECT_NAME }}.sln /restore /nowarn:MSB4011 -p:Configuration=Release /m ${{ env.ENABLE_DIAGNOSTICS == 'true' && '/bl' || '' }} /v:${{ env.MSBUILD_VERBOSITY }}
@@ -246,10 +279,11 @@ jobs:
           name: new-experiment-logs-${{ matrix.multitarget }}-winui${{ matrix.winui }}
           path: ./**/*.*log
 
-  wasm-linux:
+  uno-linux:
     runs-on: ubuntu-latest
     env:
       HEADS_DIRECTORY: tooling/ProjectHeads
+      PROJECT_DIRECTORY: tooling/ProjectTemplate
       TEST_PROJECT_NAME: CiTestExp
 
     steps:
@@ -264,6 +298,18 @@ jobs:
         with:
           global-json-file: tooling/global.json
 
+      # iOS/maccatalyst workloads aren't installable on Linux (Uno.Sdk
+      # auto-filters those TFMs there). android + wasm-tools are both
+      # required: even a `-f net9.0-browserwasm` build restores all of the
+      # head's TargetFrameworks, so the net9.0-android TFM's workload is
+      # validated during restore.
+      # Run from ./tooling so global.json scopes the install to the pinned
+      # SDK feature band; otherwise the workloads land on the runner's newer
+      # preinstalled SDK and the 9.0.x build can't see them (NETSDK1147).
+      - name: Install .NET workloads
+        working-directory: tooling
+        run: dotnet workload install android wasm-tools
+
       - name: .NET Info (if diagnostics)
         if: ${{ env.ENABLE_DIAGNOSTICS == 'true' }}
         run: dotnet --info
@@ -273,6 +319,7 @@ jobs:
         working-directory: ./
         run: |
           copy ./tooling/.github/workflows/config/* ./
+          copy ./tooling/global.json ./
           mkdir ./.config
           copy ./tooling/.config/dotnet-tools.json ./.config/dotnet-tools.json
           mkdir ./components
@@ -291,23 +338,20 @@ jobs:
         working-directory: ./components
         run: dotnet new ctk-component -n ${{ env.TEST_PROJECT_NAME }}
 
-      - name: Generate solution
-        shell: pwsh
-        working-directory: ./
-        run: ./tooling/GenerateAllSolution.ps1${{ env.ENABLE_DIAGNOSTICS == 'true' && ' -UseDiagnostics' || '' }} -MultiTargets wasm
-
-      - name: dotnet build
+      # Build-Toolkit-Gallery.ps1 sets up TFMs/WinUI/project references and builds the Uno head
+      # directly (components are pulled in transitively as ProjectReferences), so this replaces
+      # the previous solution-gen + component prebuild + two head builds with one step - the old
+      # sequence built every component up to 3x over.
+      - name: Build Uno head (gallery)
         shell: pwsh
         working-directory: ./
-        run: ./tooling/Build-Toolkit-Components.ps1 -Release -MultiTargets wasm ${{ env.ENABLE_DIAGNOSTICS == 'true' && ' -BinlogOutput ./ -EnableBinLogs' || '' }}
-
-      # TODO: Do we want to run tests here? Can we do that on linux easily?
+        run: ./tooling/Build-Toolkit-Gallery.ps1 -Heads Uno -Release -MultiTargets wasm,linux ${{ env.ENABLE_DIAGNOSTICS == 'true' && ' -BinlogOutput ./ -EnableBinLogs' || '' }}
 
       - name: Artifact - Diagnostic Logs
         uses: actions/upload-artifact@v4
         if: ${{ (env.ENABLE_DIAGNOSTICS == 'true' || env.COREHOST_TRACE != '') && always() }}
         with:
-          name: linux-logs
+          name: uno-linux-logs
           path: ./**/*.*log
 
 

Build-Toolkit-Components.ps1

@@ -57,11 +57,11 @@
     Date:   2/19/2024
 #>
 Param (
-    [ValidateSet('all', 'wasm', 'uwp', 'wasdk', 'wpf', 'linuxgtk', 'macos', 'ios', 'android', 'netstandard')]
+    [ValidateSet('all', 'wasm', 'uwp', 'wasdk', 'wpf', 'win32', 'linux', 'macos', 'ios', 'android', 'netstandard')]
     [Alias("mt")]
     [string[]]$MultiTargets = @('uwp', 'wasm', 'wasdk'), # default settings
-    
-    [ValidateSet('wasm', 'uwp', 'wasdk', 'wpf', 'linuxgtk', 'macos', 'ios', 'android', 'netstandard')]
+
+    [ValidateSet('wasm', 'uwp', 'wasdk', 'wpf', 'win32', 'linux', 'macos', 'ios', 'android', 'netstandard')]
     [string[]]$ExcludeMultiTargets = @(), # default settings
 
     [Alias("c")]
@@ -97,7 +97,7 @@ Param (
 
 
 if ($MultiTargets -eq 'all') {
-    $MultiTargets = @('wasm', 'uwp', 'wasdk', 'wpf', 'linuxgtk', 'macos', 'ios', 'android', 'netstandard')
+    $MultiTargets = @('wasm', 'uwp', 'wasdk', 'wpf', 'win32', 'linux', 'macos', 'ios', 'android', 'netstandard')
 }
 
 if ($null -eq $ExcludeMultiTargets)

Build-Toolkit-Gallery.ps1

@@ -9,7 +9,7 @@
     Specifies the MultiTarget TFM(s) to include for building the components. The default value is 'all'.
 
 .PARAMETER ExcludeMultiTargets
-    Specifies the MultiTarget TFM(s) to exclude for building the components. The default value excludes targets that require additional tooling or workloads to build: 'wpf', 'linuxgtk', 'macos', 'ios', and 'android'. Run uno-check to install the required workloads.
+    Specifies the MultiTarget TFM(s) to exclude for building the components. The default value excludes targets that require additional tooling or workloads to build: 'wpf', 'linux', 'macos', 'ios', and 'android'. Run uno-check to install the required workloads.
 
 .PARAMETER Heads
   The heads to include in the build. Default is 'Uwp', 'Wasdk', 'Wasm'.
@@ -46,17 +46,17 @@
   Date:   2/19/2024
 #>
 Param (
-  [ValidateSet('all', 'wasm', 'uwp', 'wasdk', 'wpf', 'linuxgtk', 'macos', 'ios', 'android', 'netstandard')]
+  [ValidateSet('all', 'wasm', 'uwp', 'wasdk', 'wpf', 'win32', 'linux', 'macos', 'ios', 'android', 'netstandard')]
   [Alias("mt")]
   [string[]]$MultiTargets = @('uwp', 'wasdk', 'wasm'), # default settings
-  
-  [ValidateSet('wasm', 'uwp', 'wasdk', 'wpf', 'linuxgtk', 'macos', 'ios', 'android', 'netstandard')]
+
+  [ValidateSet('wasm', 'uwp', 'wasdk', 'wpf', 'win32', 'linux', 'macos', 'ios', 'android', 'netstandard')]
   [string[]]$ExcludeMultiTargets = @(), # default settings
 
-  [ValidateSet('all', 'Uwp', 'Wasdk', 'Wasm', 'Tests.Uwp', 'Tests.Wasdk')]
+  [ValidateSet('all', 'Uwp', 'Wasdk', 'Wasm', 'Uno', 'Tests.Uwp', 'Tests.Wasdk')]
   [string[]]$Heads = @('Uwp', 'Wasdk', 'Wasm'),
 
-  [ValidateSet('Uwp', 'Wasdk', 'Wasm', 'Tests.Uwp', 'Tests.Wasdk')]
+  [ValidateSet('Uwp', 'Wasdk', 'Wasm', 'Uno', 'Tests.Uwp', 'Tests.Wasdk')]
   [string[]]$ExcludeHeads,
 
   [Alias("bl")]
@@ -102,7 +102,7 @@ if ($MultiTargets.Contains('uwp') -and $MultiTargets.Contains('wasdk'))
 }
 
 if ($MultiTargets -eq 'all') {
-  $MultiTargets = @('wasm', 'uwp', 'wasdk', 'wpf', 'linuxgtk', 'macos', 'ios', 'android', 'netstandard')
+  $MultiTargets = @('wasm', 'uwp', 'wasdk', 'wpf', 'win32', 'linux', 'macos', 'ios', 'android', 'netstandard')
 }
 
 if ($ExcludeMultiTargets) {
@@ -131,17 +131,31 @@ if ($Components -notcontains 'Converters') {
 & $PSScriptRoot\MultiTarget\GenerateAllProjectReferences.ps1 -MultiTarget $MultiTargets -Components $Components
 
 if ($Heads -eq 'all') {
-  $Heads = @('Uwp', 'Wasdk', 'Wasm', 'Tests.Uwp', 'Tests.Wasdk')
+  $Heads = @('Uwp', 'Wasdk', 'Wasm', 'Uno', 'Tests.Uwp', 'Tests.Wasdk')
 }
 
 function Invoke-MSBuildWithBinlog {
   param (
-    [string]$TargetHeadPath
+    [string]$TargetHeadPath,
+    [string]$TargetFramework
   )
 
   # Reset build args to default
   $msbuildArgs = @("-r", "-m", "-t:Clean,Build")
 
+  if ($TargetFramework) {
+    # dotnet build's "-f" does a scoped inner-build restore for just that TFM; plain
+    # "/p:TargetFramework=" on a multi-targeted project restores the outer project's full TFM
+    # closure first, which fails for components that don't support every TFM the head declares.
+    # msbuild.exe has no "-f" equivalent, so this only reliably supports one TFM at a time there.
+    if ($($PSVersionTable.Platform) -eq "Unix") {
+      $msbuildArgs += "-f:$TargetFramework"
+    }
+    else {
+      $msbuildArgs += "/p:TargetFramework=$TargetFramework"
+    }
+  }
+
   # Add additional properties to the msbuild arguments
   if ($AdditionalProperties) {
     foreach ($property in $AdditionalProperties.GetEnumerator()) {
@@ -153,12 +167,13 @@ function Invoke-MSBuildWithBinlog {
   if ($EnableBinLogs) {
     # Get binlog filename and output path
     $csprojFileName = [System.IO.Path]::GetFileNameWithoutExtension($TargetHeadPath)
-    $defaultBinlogFilename = "$csprojFileName.msbuild.binlog"
+    $binlogSuffix = $TargetFramework ? ".$TargetFramework" : ""
+    $defaultBinlogFilename = "$csprojFileName$binlogSuffix.msbuild.binlog"
     $finalBinlogPath = $defaultBinlogFilename;
 
     # Set default binlog output location if not provided
     if ($BinlogOutput) {
-      $finalBinlogPath = "$BinlogOutput/$defaultBinlogFilename" 
+      $finalBinlogPath = "$BinlogOutput/$defaultBinlogFilename"
     }
 
     $msbuildArgs += "/bl:$finalBinlogPath"
@@ -172,7 +187,40 @@ function Invoke-MSBuildWithBinlog {
     $msbuildArgs += "/verbosity:detailed"
   }
 
-  msbuild $msbuildArgs $TargetHeadPath
+  # On Linux there's no msbuild.exe on PATH; dotnet build is the only option there anyway.
+  if ($($PSVersionTable.Platform) -eq "Unix") {
+    dotnet build $msbuildArgs $TargetHeadPath
+  }
+  else {
+    msbuild $msbuildArgs $TargetHeadPath
+  }
+}
+
+# The Uno.Sdk head covers several MultiTargets from one multi-TFM csproj (see
+# ProjectHeads/AllComponents/Uno/CommunityToolkit.App.Uno.csproj). Building all of its enabled TFMs
+# in one invocation isn't reliable across every combination, so - matching what CI already does -
+# build it one TFM at a time via `-f`, only for the TFMs the requested $MultiTargets actually enable.
+function Get-UnoSdkHeadTargetFrameworks {
+  param (
+    [string[]]$MultiTargets
+  )
+
+  $targetFrameworks = [System.Collections.ArrayList]::new()
+
+  if (($MultiTargets | Where-Object { @('win32', 'linux', 'macos') -contains $_ }).Count -gt 0) {
+    [void]$targetFrameworks.Add('net9.0-desktop')
+  }
+  if ($MultiTargets -contains 'wasm') {
+    [void]$targetFrameworks.Add('net9.0-browserwasm')
+  }
+  if ($MultiTargets -contains 'android') {
+    [void]$targetFrameworks.Add('net9.0-android')
+  }
+  if ($MultiTargets -contains 'ios') {
+    [void]$targetFrameworks.Add('net9.0-ios')
+  }
+
+  return $targetFrameworks
 }
 
 foreach ($head in $Heads) {
@@ -182,5 +230,19 @@ foreach ($head in $Heads) {
 
   $targetHeadPath = Get-ChildItem "$PSScriptRoot/ProjectHeads/AllComponents/$head/*.csproj"
 
-  Invoke-MSBuildWithBinlog $targetHeadPath $EnableBinLogs $BinlogOutput
+  if ($head -eq 'Uno') {
+    $unoTargetFrameworks = Get-UnoSdkHeadTargetFrameworks -MultiTargets $MultiTargets
+
+    if ($unoTargetFrameworks.Count -eq 0) {
+      Write-Warning "None of the requested MultiTargets ($MultiTargets) are served by the Uno.Sdk head. Skipping."
+      continue
+    }
+
+    foreach ($targetFramework in $unoTargetFrameworks) {
+      Invoke-MSBuildWithBinlog $targetHeadPath $targetFramework
+    }
+  }
+  else {
+    Invoke-MSBuildWithBinlog $targetHeadPath
+  }
 }

CommunityToolkit.App.Shared/Renderers/Markdown/MarkdownTextBlock.cs

@@ -16,7 +16,7 @@
     #endif
 #endif
 
-#if HAS_UNO_WASM
+#if HAS_UNO_WASM && !WINUI3
 using Markdig;
 using Uno.Foundation.Interop;
 using Uno.UI.Runtime.WebAssembly;
@@ -27,7 +27,7 @@ namespace CommunityToolkit.App.Shared.Renderers;
 /// <summary>
 /// Provide an abstraction around the Toolkit MarkdownTextBlock for both UWP and WinUI 3 in the same namespace (until 8.0) as well as a polyfill for WebAssembly/WASM.
 /// </summary>
-#if HAS_UNO_WASM
+#if HAS_UNO_WASM && !WINUI3
 [HtmlElement("div")]
 public partial class MarkdownTextBlock : TextBlock
 {