Cleanups

javiercn · javiercn · commit bc59fb1b0719 · 2025-07-08T18:20:39.000+02:00
diff --git a/src/StaticWebAssetsSdk/Tasks/ApplyCompressionNegotiation.cs b/src/StaticWebAssetsSdk/Tasks/ApplyCompressionNegotiation.cs
@@ -20,10 +20,10 @@ public class ApplyCompressionNegotiation : Task
     [Output]
     public ITaskItem[] UpdatedEndpoints { get; set; }
 
-    private readonly List<StaticWebAssetEndpointSelector> _selectorsList = new();
-    private readonly List<StaticWebAssetEndpointResponseHeader> _headersList = new();
-    private readonly List<StaticWebAssetEndpointResponseHeader> _tempHeadersList = new();
-    private readonly List<StaticWebAssetEndpointProperty> _propertiesList = new();
+    private readonly List<StaticWebAssetEndpointSelector> _selectorsList = [];
+    private readonly List<StaticWebAssetEndpointResponseHeader> _headersList = [];
+    private readonly List<StaticWebAssetEndpointResponseHeader> _tempHeadersList = [];
+    private readonly List<StaticWebAssetEndpointProperty> _propertiesList = [];
     private const int ExpectedCompressionHeadersCount = 2;
 
     public override bool Execute()
@@ -36,7 +36,9 @@ public override bool Execute()
 
         var compressionHeadersByEncoding = new Dictionary<string, StaticWebAssetEndpointResponseHeader[]>(ExpectedCompressionHeadersCount);
 
-        ProcessCompressedAssets(assetsById, endpointsByAsset, updatedEndpoints, compressionHeadersByEncoding);
+        using var jsonContext = new JsonWriterContext();
+
+        ProcessCompressedAssets(assetsById, endpointsByAsset, updatedEndpoints, compressionHeadersByEncoding, jsonContext);
         AddRemainingEndpoints(endpointsByAsset, updatedEndpoints);
         UpdatedEndpoints = StaticWebAssetEndpoint.ToTaskItems(updatedEndpoints);
         return true;
@@ -46,7 +48,8 @@ private void ProcessCompressedAssets(
         Dictionary<string, StaticWebAsset> assetsById,
         IDictionary<string, List<StaticWebAssetEndpoint>> endpointsByAsset,
         HashSet<StaticWebAssetEndpoint> updatedEndpoints,
-        Dictionary<string, StaticWebAssetEndpointResponseHeader[]> compressionHeadersByEncoding)
+        Dictionary<string, StaticWebAssetEndpointResponseHeader[]> compressionHeadersByEncoding,
+        JsonWriterContext jsonContext)
     {
         foreach (var compressedAsset in assetsById.Values)
         {
@@ -74,8 +77,7 @@ private void ProcessCompressedAssets(
                     StaticWebAssetEndpointResponseHeader.PopulateFromMetadataValue(compressedEndpoint.ResponseHeadersString, _headersList);
                     var currentCompressionHeaders = GetOrCreateCompressionHeaders(compressionHeadersByEncoding, compressedAsset);
                     _headersList.AddRange(currentCompressionHeaders);
-                    using var headerContext = new JsonWriterContext();
-                    var headersString = StaticWebAssetEndpointResponseHeader.ToMetadataValue(_headersList, headerContext);
+                    var headersString = StaticWebAssetEndpointResponseHeader.ToMetadataValue(_headersList, jsonContext);
                     compressedEndpoint.SetResponseHeadersString(headersString);
                 }
 
@@ -91,14 +93,30 @@ private void ProcessCompressedAssets(
                         continue;
                     }
 
-                    var endpointCopy = CreateUpdatedEndpoint(compressedAsset, quality, compressedEndpoint, compressedHeaders, relatedEndpointCandidate);
+                    var endpointCopy = CreateUpdatedEndpoint(compressedAsset, quality, compressedEndpoint, compressedHeaders, relatedEndpointCandidate, jsonContext);
                     updatedEndpoints.Add(endpointCopy);
+                    // Since we are going to remove the endpoints from the associated item group and the route is
+                    // the ItemSpec, we want to add the original as well so that it gets re-added.
+                    // The endpoint pointing to the uncompressed asset doesn't have a Content-Encoding selector and
+                    // will use the default "identity" encoding during content negotiation.
                     updatedEndpoints.Add(relatedEndpointCandidate);
                 }
             }
         }
     }
 
+    // Before we return the updated endpoints we need to capture any other endpoint whose asset is not associated
+    // with the compressed asset. This is because we are going to remove the endpoints from the associated item group
+    // and the route is the ItemSpec, so it will cause those endpoints to be removed.
+    // For example, we have css/app.css and Link/css/app.css where Link=css/app.css and the first asset is a build asset
+    // and the second asset is a publish asset.
+    // If we are processing build assets, we'll mistakenly remove the endpoints associated with the publish asset.
+
+    // Iterate over the endpoints and find those endpoints whose route is in the set of updated endpoints but whose asset
+    // is not, and add them to the updated endpoints.
+
+    // Reuse the map we created at the beginning.
+    // Remove all the endpoints that were updated to avoid adding them again.
     private void AddRemainingEndpoints(
         IDictionary<string, List<StaticWebAssetEndpoint>> endpointsByAsset,
         HashSet<StaticWebAssetEndpoint> updatedEndpoints)
@@ -115,6 +133,9 @@ private void AddRemainingEndpoints(
             endpointsByAsset.Remove(endpoint.AssetFile);
         }
 
+        // We now have only endpoints that might have the same route but point to different assets
+        // and we want to include them in the updated endpoints so that we don't incorrectly remove
+        // them from the associated item group when we update the endpoints.
         var endpointsByRoute = GetEndpointsByRoute(endpointsByAsset);
         var additionalUpdatedEndpoints = new HashSet<StaticWebAssetEndpoint>(updatedEndpoints.Count, StaticWebAssetEndpoint.RouteAndAssetComparer);
         foreach (var updatedEndpoint in updatedEndpoints)
@@ -203,7 +224,8 @@ private StaticWebAssetEndpoint CreateUpdatedEndpoint(
         string quality,
         StaticWebAssetEndpoint compressedEndpoint,
         HashSet<string> compressedHeaders,
-        StaticWebAssetEndpoint relatedEndpointCandidate)
+        StaticWebAssetEndpoint relatedEndpointCandidate,
+        JsonWriterContext jsonContext)
     {
         Log.LogMessage(MessageImportance.Low, "Processing related endpoint '{0}'", relatedEndpointCandidate.Route);
         var encodingSelector = new StaticWebAssetEndpointSelector
@@ -214,28 +236,24 @@ private StaticWebAssetEndpoint CreateUpdatedEndpoint(
         };
         Log.LogMessage(MessageImportance.Low, "  Created Content-Encoding selector for compressed asset '{0}' with size '{1}' is '{2}'", encodingSelector.Value, encodingSelector.Quality, relatedEndpointCandidate.Route);
 
-        // Build selectors using reusable list to avoid array allocation
         StaticWebAssetEndpointSelector.PopulateFromMetadataValue(relatedEndpointCandidate.SelectorsString, _selectorsList);
         _selectorsList.Add(encodingSelector);
-        using var selectorContext = new JsonWriterContext();
-        var selectorsString = StaticWebAssetEndpointSelector.ToMetadataValue(_selectorsList, selectorContext);
+        var selectorsString = StaticWebAssetEndpointSelector.ToMetadataValue(_selectorsList, jsonContext);
 
         var endpointCopy = new StaticWebAssetEndpoint
         {
             AssetFile = compressedAsset.Identity,
             Route = relatedEndpointCandidate.Route,
         };
 
-        // Set selectors and properties using string methods to avoid array allocations
         endpointCopy.SetSelectorsString(selectorsString);
         endpointCopy.SetEndpointPropertiesString(relatedEndpointCandidate.EndpointPropertiesString);
 
         // Build headers using reusable list
         _headersList.Clear();
         ApplyCompressedEndpointHeaders(_headersList, compressedEndpoint, relatedEndpointCandidate.Route);
         ApplyRelatedEndpointCandidateHeaders(_headersList, relatedEndpointCandidate, compressedHeaders);
-        using var headerContext = new JsonWriterContext();
-        var headersString = StaticWebAssetEndpointResponseHeader.ToMetadataValue(_headersList, headerContext);
+        var headersString = StaticWebAssetEndpointResponseHeader.ToMetadataValue(_headersList, jsonContext);
         endpointCopy.SetResponseHeadersString(headersString);
 
         // Update the endpoint
@@ -347,9 +365,9 @@ private void ApplyCompressedEndpointHeaders(List<StaticWebAssetEndpointResponseH
 
     private void ApplyRelatedEndpointCandidateHeaders(List<StaticWebAssetEndpointResponseHeader> headers, StaticWebAssetEndpoint relatedEndpointCandidate, HashSet<string> compressedHeaders)
     {
-        StaticWebAssetEndpointResponseHeader.PopulateFromMetadataValue(relatedEndpointCandidate.ResponseHeadersString, _tempHeadersList);
+        StaticWebAssetEndpointResponseHeader.PopulateFromMetadataValue(relatedEndpointCandidate.ResponseHeadersString, _headersList);
 
-        foreach (var header in _tempHeadersList)
+        foreach (var header in _headersList)
         {
             // We need to keep the headers that are specific to the compressed asset like Content-Length,
             // Last-Modified and ETag. Any other header we should add it.
diff --git a/src/StaticWebAssetsSdk/Tasks/ComputeEndpointsForReferenceStaticWebAssets.cs b/src/StaticWebAssetsSdk/Tasks/ComputeEndpointsForReferenceStaticWebAssets.cs
@@ -25,7 +25,7 @@ public override bool Execute()
         var result = CandidateEndpoints;
 
         // Reusable list for optimized endpoint property parsing
-        var endpointPropertiesList = new List<StaticWebAssetEndpointProperty>(16);
+        var endpointPropertiesList = new List<StaticWebAssetEndpointProperty>(4);
 
         using var context = StaticWebAssetEndpointProperty.CreateWriter();
 
@@ -68,9 +68,8 @@ public override bool Execute()
                     if (propertiesModified)
                     {
                         // Serialize modified properties back using optimized method
-                        ((ITaskItem)candidateEndpoint).SetMetadata(nameof(StaticWebAssetEndpoint.EndpointProperties),
+                        candidateEndpoint.SetEndpointPropertiesString(
                             StaticWebAssetEndpointProperty.ToMetadataValue(endpointPropertiesList, context));
-                        candidateEndpoint.MarkProperiesAsModified();
                     }
 
                     Log.LogMessage(MessageImportance.Low, "Adding endpoint {0} for asset {1} with updated route {2}.", candidateEndpoint.Route, candidateEndpoint.AssetFile, candidateEndpoint.Route);
diff --git a/src/StaticWebAssetsSdk/Tasks/DefineStaticWebAssetEndpoints.cs b/src/StaticWebAssetsSdk/Tasks/DefineStaticWebAssetEndpoints.cs
@@ -40,7 +40,11 @@ public override bool Execute()
                 Log,
                 contentTypeProvider),
             static (i, loop, state) => state.Process(i, loop),
-            static worker => worker.Finally());
+            static (worker) =>
+            {
+                worker.Finally();
+                worker.Dispose();
+            });
 
         Endpoints = StaticWebAssetEndpoint.ToTaskItems(endpoints);
 
@@ -120,6 +124,8 @@ private readonly struct ParallelWorker(
         private readonly List<StaticWebAssetEndpointResponseHeader> _headersList = new(6);
         private readonly List<StaticWebAssetEndpointProperty> _propertiesList = new(10);
 
+        private readonly JsonWriterContext _serializationContext = new();
+
         private void CreateAnAddEndpoints(
             StaticWebAsset asset,
             string length,
@@ -172,10 +178,8 @@ private void CreateAnAddEndpoints(
 
                 var finalRoute = asset.IsProject() || asset.IsPackage() ? StaticWebAsset.Normalize(Path.Combine(asset.BasePath, route)) : route;
 
-                using var headerContext = new JsonWriterContext();
-                using var propertyContext = new JsonWriterContext();
-                var headersString = StaticWebAssetEndpointResponseHeader.ToMetadataValue(_headersList, headerContext);
-                var propertiesString = StaticWebAssetEndpointProperty.ToMetadataValue(_propertiesList, propertyContext);
+                var headersString = StaticWebAssetEndpointResponseHeader.ToMetadataValue(_headersList, _serializationContext);
+                var propertiesString = StaticWebAssetEndpointProperty.ToMetadataValue(_propertiesList, _serializationContext);
 
                 var endpoint = new StaticWebAssetEndpoint()
                 {
@@ -216,6 +220,11 @@ internal void Finally()
             }
         }
 
+        public void Dispose()
+        {
+            _serializationContext.Dispose();
+        }
+
         internal ParallelWorker Process(int i, ParallelLoopState _)
         {
             var asset = StaticWebAsset.FromTaskItem(CandidateAssets[i]);
diff --git a/src/StaticWebAssetsSdk/Tasks/FilterStaticWebAssetEndpoints.cs b/src/StaticWebAssetsSdk/Tasks/FilterStaticWebAssetEndpoints.cs
@@ -91,8 +91,6 @@ private bool MeetsAllCriteria(
             {
                 case "Property":
                     var meetsPropertyCriteria = criteria.ExcludeOnMatch();
-
-                    // Parse properties from string to avoid accessing endpoint.EndpointProperties array
                     var propertiesString = endpoint.EndpointPropertiesString;
                     StaticWebAssetEndpointProperty.PopulateFromMetadataValue(propertiesString, _propertiesList);
 
@@ -113,8 +111,6 @@ private bool MeetsAllCriteria(
                     break;
                 case "Selector":
                     var meetsSelectorCriteria = criteria.ExcludeOnMatch();
-
-                    // Parse selectors from string to avoid accessing endpoint.Selectors array
                     var selectorsString = endpoint.SelectorsString;
                     StaticWebAssetEndpointSelector.PopulateFromMetadataValue(selectorsString, _selectorsList);
 
@@ -135,8 +131,6 @@ private bool MeetsAllCriteria(
                     break;
                 case "Header":
                     var meetsHeaderCriteria = criteria.ExcludeOnMatch();
-
-                    // Parse headers from string to avoid accessing endpoint.ResponseHeaders array
                     var headersString = endpoint.ResponseHeadersString;
                     StaticWebAssetEndpointResponseHeader.PopulateFromMetadataValue(headersString, _headersList);
 
