Put only hard fingerprinted files into import map during publish (#47515)

maraf · web-flow · commit 5f50397976a3 · 2025-03-14T13:14:57.000Z
diff --git a/src/StaticWebAssetsSdk/Targets/Microsoft.NET.Sdk.StaticWebAssets.HtmlImportMap.targets b/src/StaticWebAssetsSdk/Targets/Microsoft.NET.Sdk.StaticWebAssets.HtmlImportMap.targets
@@ -97,7 +97,9 @@ Copyright (c) .NET Foundation. All rights reserved.
 
   <Target Name="GenerateHtmlImportMapBuildStaticWebAssets" DependsOnTargets="$(GenerateHtmlImportMapBuildStaticWebAssetsDependsOn)">
     <WriteImportMapToHtml
+      Assets="@(_EsModuleCandidate)"
       Endpoints="@(_EsModuleCandidateEndpoints)"
+      IncludeOnlyHardFingerprintedModules="false"
       HtmlFiles="@(_HtmlStaticWebAssets)"
       OutputPath="$(_BuildImportMapHtmlPath)">
       <Output TaskParameter="HtmlCandidates" ItemName="_HtmlCandidates" />
@@ -165,7 +167,9 @@ Copyright (c) .NET Foundation. All rights reserved.
 
   <Target Name="GenerateHtmlImportMapPublishStaticWebAssets" DependsOnTargets="$(GenerateHtmlImportMapPublishStaticWebAssetsDependsOn)">
     <WriteImportMapToHtml
+      Assets="@(_EsModuleCandidateForPublish)"
       Endpoints="@(_EsModuleCandidateForPublishEndpoints)"
+      IncludeOnlyHardFingerprintedModules="true"
       HtmlFiles="@(_HtmlStaticWebAssets)"
       OutputPath="$(_PublishImportMapHtmlPath)">
       <Output TaskParameter="HtmlCandidates" ItemName="_HtmlPublishCandidates" />
diff --git a/src/StaticWebAssetsSdk/Tasks/WriteImportMapToHtml.cs b/src/StaticWebAssetsSdk/Tasks/WriteImportMapToHtml.cs
@@ -13,9 +13,15 @@ namespace Microsoft.AspNetCore.StaticWebAssets.Tasks;
 
 public partial class WriteImportMapToHtml : Task
 {
+    [Required]
+    public ITaskItem[] Assets { get; set; } = [];
+
     [Required]
     public ITaskItem[] Endpoints { get; set; } = [];
 
+    [Required]
+    public bool IncludeOnlyHardFingerprintedModules { get; set; }
+
     [Required]
     public string OutputPath { get; set; } = string.Empty;
 
@@ -73,7 +79,7 @@ public override bool Execute()
                 outputContent = _assetsRegex.Replace(outputContent, e =>
                 {
                     string assetPath = e.Groups[1].Value + e.Groups[3].Value;
-                    string fingerprintedAssetPath = urlMappings.TryGetValue(assetPath, out var value) ? value.Url : assetPath;
+                    string fingerprintedAssetPath = GetFingerprintedAssetPath(urlMappings, assetPath);
                     Log.LogMessage("Replacing asset '{0}' with fingerprinted version '{1}'", assetPath, fingerprintedAssetPath);
                     return "\"" + fingerprintedAssetPath + "\"";
                 });
@@ -99,25 +105,35 @@ public override bool Execute()
         return true;
     }
 
-    internal static List<ResourceAsset> CreateResourcesFromEndpoints(IEnumerable<StaticWebAssetEndpoint> endpoints)
+    private string GetFingerprintedAssetPath(Dictionary<string, ResourceAsset> urlMappings, string assetPath)
+    {
+        if (urlMappings.TryGetValue(assetPath, out var asset) && (!IncludeOnlyHardFingerprintedModules || asset.IsHardFingerprinted))
+        {
+            return asset.Url;
+        }
+
+        return assetPath;
+    }
+
+    internal List<ResourceAsset> CreateResourcesFromEndpoints(IEnumerable<StaticWebAssetEndpoint> endpoints)
     {
         var resources = new List<ResourceAsset>();
 
         // We are converting a subset of the descriptors to resources and including a subset of the properties exposed by the
         // descriptors that are useful for the resources in the context of Blazor. Specifically, we pass in the `label` property
         // which contains the human-readable identifier for fingerprinted assets, and the integrity, which can be used to apply
         // subresource integrity to things like images, script tags, etc.
-        foreach (var descriptor in endpoints)
+        foreach (var endpoint in endpoints)
         {
             string? label = null;
             string? integrity = null;
 
             // If there's a selector this means that this is an alternative representation for a resource, so skip it.
-            if (descriptor.Selectors?.Length == 0)
+            if (endpoint.Selectors?.Length == 0)
             {
-                for (var i = 0; i < descriptor.EndpointProperties?.Length; i++)
+                for (var i = 0; i < endpoint.EndpointProperties?.Length; i++)
                 {
-                    var property = descriptor.EndpointProperties[i];
+                    var property = endpoint.EndpointProperties[i];
                     if (property.Name.Equals("label", StringComparison.OrdinalIgnoreCase))
                     {
                         label = property.Value;
@@ -128,27 +144,40 @@ internal static List<ResourceAsset> CreateResourcesFromEndpoints(IEnumerable<Sta
                     }
                 }
 
-                resources.Add(new ResourceAsset(descriptor.Route, label, integrity));
+                bool isHardFingerprinted = true;
+                var asset = Assets.FirstOrDefault(a => a.ItemSpec == endpoint.AssetFile);
+                if (asset != null)
+                {
+                    isHardFingerprinted = asset.GetMetadata("RelativePath").Contains("#[.{fingerprint}]!");
+                }
+
+                resources.Add(new ResourceAsset(endpoint.Route, label, integrity, isHardFingerprinted));
             }
         }
 
         return resources;
     }
 
-    private static ImportMap CreateImportMapFromResources(List<ResourceAsset> assets)
+    private ImportMap CreateImportMapFromResources(List<ResourceAsset> assets)
     {
         Dictionary<string, string>? imports = new();
-        Dictionary<string, Dictionary<string, string>>? scopes = new(); ;
+        Dictionary<string, Dictionary<string, string>>? scopes = new();
         Dictionary<string, string>? integrity = new();
 
         foreach (var asset in assets)
         {
+            if (IncludeOnlyHardFingerprintedModules && !asset.IsHardFingerprinted)
+            {
+                continue;
+            }
+
             if (asset.Integrity != null)
             {
                 integrity ??= [];
                 integrity[$"./{asset.Url}"] = asset.Integrity;
             }
 
+            // Only fingerprinted assets have label
             if (asset.Label != null)
             {
                 imports ??= [];
@@ -178,11 +207,12 @@ private static Dictionary<string, ResourceAsset> GroupResourcesByLabel(List<Reso
     }
 }
 
-internal sealed class ResourceAsset(string url, string? label, string? integrity)
+internal sealed class ResourceAsset(string url, string? label, string? integrity, bool isHardFingerprinted)
 {
     public string Url { get; } = url;
     public string? Label { get; set; } = label;
     public string? Integrity { get; set; } = integrity;
+    public bool IsHardFingerprinted { get; set; } = isHardFingerprinted;
 }
 
 internal class ImportMap(Dictionary<string, string> imports, Dictionary<string, Dictionary<string, string>> scopes, Dictionary<string, string> integrity)
diff --git a/test/Microsoft.NET.Sdk.Razor.Tests/StaticWebAssetsFingerprintingTest.cs b/test/Microsoft.NET.Sdk.Razor.Tests/StaticWebAssetsFingerprintingTest.cs
@@ -46,70 +46,105 @@ public void Build_FingerprintsContent_WhenEnabled()
         AssertBuildAssets(manifest1, outputPath, intermediateOutputPath);
     }
 
-    public static TheoryData<string, string, string> WriteImportMapToHtmlData => new TheoryData<string, string, string>
+    public static TheoryData<string, string, string, bool, bool> WriteImportMapToHtmlData => new TheoryData<string, string, string, bool, bool>
     {
-        { "VanillaWasm", "main.js", null },
-        { "BlazorWasmMinimal", "_framework/blazor.webassembly.js", "_framework/blazor.webassembly#[.{fingerprint}].js" }
+        { "VanillaWasm", "main.js", "main#[.{fingerprint}].js", true, true },
+        { "VanillaWasm", "main.js", null, false, false },
+        { "BlazorWasmMinimal", "_framework/blazor.webassembly.js", "_framework/blazor.webassembly#[.{fingerprint}].js", false, true }
     };
 
     [Theory]
     [MemberData(nameof(WriteImportMapToHtmlData))]
-    public void Build_WriteImportMapToHtml(string testAsset, string scriptPath, string scriptPathWithFingerprintPattern)
+    public void Build_WriteImportMapToHtml(string testAsset, string scriptPath, string scriptPathWithFingerprintPattern, bool fingerprintUserJavascriptAssets, bool expectFingerprintOnScript)
     {
         ProjectDirectory = CreateAspNetSdkTestAsset(testAsset);
         ReplaceStringInIndexHtml(ProjectDirectory, scriptPath, scriptPathWithFingerprintPattern);
+        FingerprintUserJavascriptAssets(fingerprintUserJavascriptAssets);
 
         var build = CreateBuildCommand(ProjectDirectory);
-        ExecuteCommand(build, "-p:WriteImportMapToHtml=true").Should().Pass();
+        ExecuteCommand(build, "-p:WriteImportMapToHtml=true", $"-p:FingerprintUserJavascriptAssets={fingerprintUserJavascriptAssets}").Should().Pass();
 
         var intermediateOutputPath = build.GetIntermediateDirectory(DefaultTfm, "Debug").ToString();
         var indexHtmlPath = Directory.EnumerateFiles(Path.Combine(intermediateOutputPath, "staticwebassets", "importmaphtml", "build"), "*.html").Single();
         var endpointsManifestPath = Path.Combine(intermediateOutputPath, $"staticwebassets.build.endpoints.json");
 
-        AssertImportMapInHtml(indexHtmlPath, endpointsManifestPath, scriptPath);
+        AssertImportMapInHtml(indexHtmlPath, endpointsManifestPath, scriptPath, expectFingerprintOnScript: expectFingerprintOnScript);
     }
 
     [Theory]
     [MemberData(nameof(WriteImportMapToHtmlData))]
-    public void Publish_WriteImportMapToHtml(string testAsset, string scriptPath, string scriptPathWithFingerprintPattern)
+    public void Publish_WriteImportMapToHtml(string testAsset, string scriptPath, string scriptPathWithFingerprintPattern, bool fingerprintUserJavascriptAssets, bool expectFingerprintOnScript)
     {
         ProjectDirectory = CreateAspNetSdkTestAsset(testAsset);
         ReplaceStringInIndexHtml(ProjectDirectory, scriptPath, scriptPathWithFingerprintPattern);
+        FingerprintUserJavascriptAssets(fingerprintUserJavascriptAssets);
 
         var projectName = Path.GetFileNameWithoutExtension(Directory.EnumerateFiles(ProjectDirectory.TestRoot, "*.csproj").Single());
 
         var publish = CreatePublishCommand(ProjectDirectory);
-        ExecuteCommand(publish, "-p:WriteImportMapToHtml=true").Should().Pass();
+        ExecuteCommand(publish, "-p:WriteImportMapToHtml=true", $"-p:FingerprintUserJavascriptAssets={fingerprintUserJavascriptAssets}").Should().Pass();
 
         var outputPath = publish.GetOutputDirectory(DefaultTfm, "Debug").ToString();
         var indexHtmlOutputPath = Path.Combine(outputPath, "wwwroot", "index.html");
         var endpointsManifestPath = Path.Combine(outputPath, $"{projectName}.staticwebassets.endpoints.json");
 
-        AssertImportMapInHtml(indexHtmlOutputPath, endpointsManifestPath, scriptPath);
+        AssertImportMapInHtml(indexHtmlOutputPath, endpointsManifestPath, scriptPath, expectFingerprintOnScript: expectFingerprintOnScript);
     }
 
-    private void ReplaceStringInIndexHtml(TestAsset testAsset, string scriptPath, string scriptPathWithFingerprintPattern)
+    private void FingerprintUserJavascriptAssets(bool fingerprintUserJavascriptAssets)
     {
-        if (scriptPathWithFingerprintPattern != null)
+        if (fingerprintUserJavascriptAssets)
+        {
+            ProjectDirectory.WithProjectChanges(p => 
+            {
+                if (p.Root != null)
+                {
+                    var itemGroup = new XElement("ItemGroup");
+                    var pattern = new XElement("StaticWebAssetFingerprintPattern");
+                    pattern.SetAttributeValue("Include", "Js");
+                    pattern.SetAttributeValue("Pattern", "*.js");
+                    pattern.SetAttributeValue("Expression", "#[.{fingerprint}]!");
+                    itemGroup.Add(pattern);
+                    p.Root.Add(itemGroup);
+                }
+            });
+        }
+    }
+
+    private void ReplaceStringInIndexHtml(TestAsset testAsset, string sourceValue, string targetValue)
+    {
+        if (targetValue != null)
         {
             var indexHtmlPath = Path.Combine(testAsset.TestRoot, "wwwroot", "index.html");
             var indexHtmlContent = File.ReadAllText(indexHtmlPath);
-            var newIndexHtmlContent = indexHtmlContent.Replace(scriptPath, scriptPathWithFingerprintPattern);
+            var newIndexHtmlContent = indexHtmlContent.Replace(sourceValue, targetValue);
             if (indexHtmlContent == newIndexHtmlContent)
-                throw new Exception($"Script replacement '{scriptPath}' for '{scriptPathWithFingerprintPattern}' didn't produce any change in '{indexHtmlPath}'");
+                throw new Exception($"String replacement '{sourceValue}' for '{targetValue}' didn't produce any change in '{indexHtmlPath}'");
 
             File.WriteAllText(indexHtmlPath, newIndexHtmlContent);
         }
     }
 
-    private void AssertImportMapInHtml(string indexHtmlPath, string endpointsManifestPath, string scriptPath)
+    private void AssertImportMapInHtml(string indexHtmlPath, string endpointsManifestPath, string scriptPath, bool expectFingerprintOnScript = true)
     {
         var indexHtmlContent = File.ReadAllText(indexHtmlPath);
         var endpoints = JsonSerializer.Deserialize<StaticWebAssetEndpointsManifest>(File.ReadAllText(endpointsManifestPath));
 
         var fingerprintedScriptPath = GetFingerprintedPath(scriptPath);
-        Assert.DoesNotContain($"src=\"{scriptPath}\"", indexHtmlContent);
-        Assert.Contains($"src=\"{fingerprintedScriptPath}\"", indexHtmlContent);
+        if (expectFingerprintOnScript)
+        {
+            Assert.DoesNotContain($"src=\"{scriptPath}\"", indexHtmlContent);
+            Assert.Contains($"src=\"{fingerprintedScriptPath}\"", indexHtmlContent);
+        }
+        else
+        {
+            Assert.Contains(scriptPath, indexHtmlContent);
+
+            if (scriptPath != fingerprintedScriptPath)
+            {
+                Assert.DoesNotContain(fingerprintedScriptPath, indexHtmlContent);
+            }
+        }
 
         Assert.Contains(GetFingerprintedPath("_framework/dotnet.js"), indexHtmlContent);
         Assert.Contains(GetFingerprintedPath("_framework/dotnet.native.js"), indexHtmlContent);
diff --git a/test/TestAssets/TestProjects/VanillaWasm/VanillaWasm.csproj b/test/TestAssets/TestProjects/VanillaWasm/VanillaWasm.csproj
@@ -3,7 +3,4 @@
     <TargetFramework>$(CurrentTargetFramework)</TargetFramework>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
-  <ItemGroup>
-    <StaticWebAssetFingerprintPattern Include="Js" Pattern="*.js" Expression="#[.{fingerprint}]!" />
-  </ItemGroup>
 </Project>
diff --git a/test/TestAssets/TestProjects/VanillaWasm/wwwroot/index.html b/test/TestAssets/TestProjects/VanillaWasm/wwwroot/index.html
@@ -8,7 +8,7 @@
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <script type="importmap"></script>
-  <script type="module" src="main#[.{fingerprint}].js"></script>
+  <script type="module" src="main.js"></script>
   
 </head>
 

Original file line number	Diff line number	Diff line change
`@@ -13,9 +13,15 @@ namespace Microsoft.AspNetCore.StaticWebAssets.Tasks;`
`13`	`13`
`14`	`14`	`public partial class WriteImportMapToHtml : Task`
`15`	`15`	`{`
	`16`	`+ [Required]`
	`17`	`+ public ITaskItem[] Assets { get; set; } = [];`
	`18`	`+`
`16`	`19`	`[Required]`
`17`	`20`	`public ITaskItem[] Endpoints { get; set; } = [];`
`18`	`21`
	`22`	`+ [Required]`
	`23`	`+ public bool IncludeOnlyHardFingerprintedModules { get; set; }`
	`24`	`+`
`19`	`25`	`[Required]`
`20`	`26`	`public string OutputPath { get; set; } = string.Empty;`
`21`	`27`
`@@ -73,7 +79,7 @@ public override bool Execute()`
`73`	`79`	`outputContent = _assetsRegex.Replace(outputContent, e =>`
`74`	`80`	`{`
`75`	`81`	`string assetPath = e.Groups[1].Value + e.Groups[3].Value;`
`76`		`- string fingerprintedAssetPath = urlMappings.TryGetValue(assetPath, out var value) ? value.Url : assetPath;`
	`82`	`+ string fingerprintedAssetPath = GetFingerprintedAssetPath(urlMappings, assetPath);`
`77`	`83`	`Log.LogMessage("Replacing asset '{0}' with fingerprinted version '{1}'", assetPath, fingerprintedAssetPath);`
`78`	`84`	`return "\"" + fingerprintedAssetPath + "\"";`
`79`	`85`	`});`
`@@ -99,25 +105,35 @@ public override bool Execute()`
`99`	`105`	`return true;`
`100`	`106`	`}`
`101`	`107`
`102`		`- internal static List<ResourceAsset> CreateResourcesFromEndpoints(IEnumerable<StaticWebAssetEndpoint> endpoints)`
	`108`	`+ private string GetFingerprintedAssetPath(Dictionary<string, ResourceAsset> urlMappings, string assetPath)`
	`109`	`+ {`
	`110`	`+ if (urlMappings.TryGetValue(assetPath, out var asset) && (!IncludeOnlyHardFingerprintedModules \|\| asset.IsHardFingerprinted))`
	`111`	`+ {`
	`112`	`+ return asset.Url;`
	`113`	`+ }`
	`114`	`+`
	`115`	`+ return assetPath;`
	`116`	`+ }`
	`117`	`+`
	`118`	`+ internal List<ResourceAsset> CreateResourcesFromEndpoints(IEnumerable<StaticWebAssetEndpoint> endpoints)`
`103`	`119`	`{`
`104`	`120`	`var resources = new List<ResourceAsset>();`
`105`	`121`
`106`	`122`	`// We are converting a subset of the descriptors to resources and including a subset of the properties exposed by the`
`107`	`123`	// descriptors that are useful for the resources in the context of Blazor. Specifically, we pass in the `label` property
`108`	`124`	`// which contains the human-readable identifier for fingerprinted assets, and the integrity, which can be used to apply`
`109`	`125`	`// subresource integrity to things like images, script tags, etc.`
`110`		`- foreach (var descriptor in endpoints)`
	`126`	`+ foreach (var endpoint in endpoints)`
`111`	`127`	`{`
`112`	`128`	`string? label = null;`
`113`	`129`	`string? integrity = null;`
`114`	`130`
`115`	`131`	`// If there's a selector this means that this is an alternative representation for a resource, so skip it.`
`116`		`- if (descriptor.Selectors?.Length == 0)`
	`132`	`+ if (endpoint.Selectors?.Length == 0)`
`117`	`133`	`{`
`118`		`- for (var i = 0; i < descriptor.EndpointProperties?.Length; i++)`
	`134`	`+ for (var i = 0; i < endpoint.EndpointProperties?.Length; i++)`
`119`	`135`	`{`
`120`		`- var property = descriptor.EndpointProperties[i];`
	`136`	`+ var property = endpoint.EndpointProperties[i];`
`121`	`137`	`if (property.Name.Equals("label", StringComparison.OrdinalIgnoreCase))`
`122`	`138`	`{`
`123`	`139`	`label = property.Value;`
`@@ -128,27 +144,40 @@ internal static List<ResourceAsset> CreateResourcesFromEndpoints(IEnumerable<Sta`
`128`	`144`	`}`
`129`	`145`	`}`
`130`	`146`
`131`		`- resources.Add(new ResourceAsset(descriptor.Route, label, integrity));`
	`147`	`+ bool isHardFingerprinted = true;`
	`148`	`+ var asset = Assets.FirstOrDefault(a => a.ItemSpec == endpoint.AssetFile);`
	`149`	`+ if (asset != null)`
	`150`	`+ {`
	`151`	`+ isHardFingerprinted = asset.GetMetadata("RelativePath").Contains("#[.{fingerprint}]!");`
	`152`	`+ }`
	`153`	`+`
	`154`	`+ resources.Add(new ResourceAsset(endpoint.Route, label, integrity, isHardFingerprinted));`
`132`	`155`	`}`
`133`	`156`	`}`
`134`	`157`
`135`	`158`	`return resources;`
`136`	`159`	`}`
`137`	`160`
`138`		`- private static ImportMap CreateImportMapFromResources(List<ResourceAsset> assets)`
	`161`	`+ private ImportMap CreateImportMapFromResources(List<ResourceAsset> assets)`
`139`	`162`	`{`
`140`	`163`	`Dictionary<string, string>? imports = new();`
`141`		`- Dictionary<string, Dictionary<string, string>>? scopes = new(); ;`
	`164`	`+ Dictionary<string, Dictionary<string, string>>? scopes = new();`
`142`	`165`	`Dictionary<string, string>? integrity = new();`
`143`	`166`
`144`	`167`	`foreach (var asset in assets)`
`145`	`168`	`{`
	`169`	`+ if (IncludeOnlyHardFingerprintedModules && !asset.IsHardFingerprinted)`
	`170`	`+ {`
	`171`	`+ continue;`
	`172`	`+ }`
	`173`	`+`
`146`	`174`	`if (asset.Integrity != null)`
`147`	`175`	`{`
`148`	`176`	`integrity ??= [];`
`149`	`177`	`integrity[$"./{asset.Url}"] = asset.Integrity;`
`150`	`178`	`}`
`151`	`179`
	`180`	`+ // Only fingerprinted assets have label`
`152`	`181`	`if (asset.Label != null)`
`153`	`182`	`{`
`154`	`183`	`imports ??= [];`
`@@ -178,11 +207,12 @@ private static Dictionary<string, ResourceAsset> GroupResourcesByLabel(List<Reso`
`178`	`207`	`}`
`179`	`208`	`}`
`180`	`209`
`181`		`-internal sealed class ResourceAsset(string url, string? label, string? integrity)`
	`210`	`+internal sealed class ResourceAsset(string url, string? label, string? integrity, bool isHardFingerprinted)`
`182`	`211`	`{`
`183`	`212`	`public string Url { get; } = url;`
`184`	`213`	`public string? Label { get; set; } = label;`
`185`	`214`	`public string? Integrity { get; set; } = integrity;`
	`215`	`+ public bool IsHardFingerprinted { get; set; } = isHardFingerprinted;`
`186`	`216`	`}`
`187`	`217`
`188`	`218`	`internal class ImportMap(Dictionary<string, string> imports, Dictionary<string, Dictionary<string, string>> scopes, Dictionary<string, string> integrity)`