add gaps in intrinsic space distribution and some performance improvements

intergalacticspacehighway · intergalacticspacehighway · commit 846cf284ce9a · 2025-11-18T22:46:15.000+05:30
diff --git a/yoga/algorithm/grid/TrackSizing.h b/yoga/algorithm/grid/TrackSizing.h
@@ -9,10 +9,11 @@
 #include <yoga/algorithm/grid/GridLayout.h>
 #include <yoga/numeric/Comparison.h>
 #include <yoga/style/StyleSizeLength.h>
-#include <set>
+#include <unordered_set>
 
 namespace facebook::yoga {
 
+// Used in distributeSpaceToTracksBaseSize and distributeSpaceToTracksGrowthLimit
 enum SpaceDistributionPhase {
   AccommodateMinimumContribution,
   AccommodateMaxContentContribution,
@@ -145,11 +146,10 @@ struct TrackSizing {
       if (includesFlexibleTrack(spannedTracks)) {
         continue;
       }
-      int32_t span = dimension == Dimension::Width ? (item.columnEnd - item.columnStart) : (item.rowEnd - item.rowStart);
+      size_t span = dimension == Dimension::Width ? (item.columnEnd - item.columnStart) : (item.rowEnd - item.rowStart);
       itemsGroupedByIncreasingSpan[span].push_back({item, spannedTracks});
     }
 
-    // auto sizingMode = dimension == Dimension::Width ? widthSizingMode : heightSizingMode;
     auto containerSize = dimension == Dimension::Width ? containerInnerWidth : containerInnerHeight;
     auto sizingMode = dimension == Dimension::Width ? widthSizingMode : heightSizingMode;
     
@@ -181,10 +181,10 @@ struct TrackSizing {
         }
 
         // 2. For content-based minimums
-        // Unimplemented
-        
+        // TODO: Implement when we support min-content
+
         // 3. For max-content minimums        
-        // Unimplemented
+        // TODO: Implement when we support max-content
         
         // 4. If at this point any track’s growth limit is now less than its base size, increase its growth limit to match its base size.
         for (auto& track: spannedTracks) {
@@ -233,12 +233,12 @@ struct TrackSizing {
         auto minimumContribution = sizingMode == SizingMode::MaxContent ? getLimitedMinimumContentContribution(item, dimension) : getMinimumContribution(item, dimension);
         distributeSpaceToFlexibleTracks(dimension, intrinsicMinimumSizingFunctionTracks, spannedTracks, minimumContribution, SpaceDistributionPhase::AccommodateMinimumContribution);
       }
-      // 2, 3, 4, 5, 6 Unimplemented
+      // 2, 3, 4, 5, 6 does not seem to be needed since max-sizing function is flexible kind and we do not support min-content, max-content yet
     }
   };
 
   // https://www.w3.org/TR/css-grid-1/#extra-space
-  // Handles for distributing space to track's base size
+  // Distribute space to tracks' where affected size is base size
   void distributeSpaceToTracksBaseSize(
     Dimension dimension, 
     std::vector<GridTrackSize*>& affectedTracks, 
@@ -257,12 +257,18 @@ struct TrackSizing {
 
     // 2.1 Find the space to distribute
     float totalSpannedTracksSize = 0.0f;
-    for (auto& track: spannedTracks) {
-      totalSpannedTracksSize += track->baseSize;
+    auto gap = node->style().computeGapForDimension(dimension, containerSize);
+    for (size_t i = 0; i < spannedTracks.size(); i++) {
+      totalSpannedTracksSize += spannedTracks[i]->baseSize;
+      // gaps are treated as tracks of fixed size. Item can span over gaps.
+      if (i < spannedTracks.size() - 1) {
+        totalSpannedTracksSize += gap;
+      }
     }
     float spaceToDistribute = std::max(0.0f, sizeContribution - totalSpannedTracksSize);
-    std::set<GridTrackSize*> frozenTracks;
-    
+    std::unordered_set<GridTrackSize*> frozenTracks;
+    frozenTracks.reserve(affectedTracks.size());
+
     // 2.2. Distribute space up to limits
     while (frozenTracks.size() < affectedTracks.size() && spaceToDistribute > 0.0f && !yoga::inexactEquals(spaceToDistribute, 0.0f)) {
       auto unfrozenTrackCount = affectedTracks.size() - frozenTracks.size();
@@ -289,7 +295,7 @@ struct TrackSizing {
     }
 
     // 2.3. Distribute space to non-affected tracks:
-    // Currently, browsers do not implement this step.
+    // Currently, browsers do not implement this step. So we avoid it to match with browsers
     // https://github.com/w3c/csswg-drafts/issues/3648
   
     // 2.4. Distribute space beyond limits
@@ -316,14 +322,10 @@ struct TrackSizing {
         }
       }
 
-      frozenTracks.clear();
-      while (spaceToDistribute > 0.0f && !yoga::inexactEquals(spaceToDistribute, 0.0f) && tracksToGrowBeyondLimits.size() > 0) {
-        auto unfrozenTrackCount = tracksToGrowBeyondLimits.size() - frozenTracks.size();
+      auto unfrozenTrackCount = tracksToGrowBeyondLimits.size();
+      while (spaceToDistribute > 0.0f && !yoga::inexactEquals(spaceToDistribute, 0.0f) && unfrozenTrackCount > 0) {
         auto distributionPerTrack = spaceToDistribute / unfrozenTrackCount;
         for (auto& track: tracksToGrowBeyondLimits) {
-          if (frozenTracks.contains(track)) {
-            continue;
-          }
           itemIncurredIncrease[track] += distributionPerTrack;
           spaceToDistribute -= distributionPerTrack;
         }
@@ -343,6 +345,8 @@ struct TrackSizing {
     }
   }
 
+  // https://www.w3.org/TR/css-grid-1/#extra-space
+  // Distribute space to tracks' where affected size is growth limit
   void distributeSpaceToTracksGrowthLimit(
     Dimension dimension, 
     std::vector<GridTrackSize*>& affectedTracks, 
@@ -361,23 +365,25 @@ struct TrackSizing {
 
     // 2.1 Find the space to distribute
     float totalSpannedTracksSize = 0.0f;
-    for (auto& track: spannedTracks) {
-      totalSpannedTracksSize += track->growthLimit == INFINITY ? track->baseSize : track->growthLimit;
+    auto gap = node->style().computeGapForDimension(dimension, containerSize);
+    for (size_t i = 0; i < spannedTracks.size(); i++) {
+      totalSpannedTracksSize += spannedTracks[i]->growthLimit == INFINITY ? spannedTracks[i]->baseSize : spannedTracks[i]->growthLimit;
+      if (i < spannedTracks.size() - 1) {
+        // gaps are treated as tracks of fixed size. Item can span over gaps.
+        totalSpannedTracksSize += gap;
+      }
     }
     float spaceToDistribute = std::max(0.0f, sizeContribution - totalSpannedTracksSize);
-    std::set<GridTrackSize*> frozenTracks;
-
-    // Freeze tracks that are not infinitely growable before distribution
-    // Per spec: "If the affected size was a growth limit and the track is not marked infinitely growable,
-    // then each item-incurred increase will be zero."
+    std::unordered_set<GridTrackSize*> frozenTracks;
+    frozenTracks.reserve(affectedTracks.size());
 
     // 2.2. Distribute space up to limits
     while (frozenTracks.size() < affectedTracks.size() && spaceToDistribute > 0.0f && !yoga::inexactEquals(spaceToDistribute, 0.0f)) {
       auto unfrozenTrackCount = affectedTracks.size() - frozenTracks.size();
       auto distributionPerTrack = spaceToDistribute / unfrozenTrackCount;
 
       for (auto& track: affectedTracks) {
-        if (frozenTracks.find(track) != frozenTracks.end()) {
+        if (frozenTracks.contains(track)) {
           continue;
         }
         auto limit = INFINITY;
@@ -417,15 +423,11 @@ struct TrackSizing {
             tracksToGrowBeyondLimits.push_back(track);
           }
         }
-        frozenTracks.clear();
+
         while (spaceToDistribute > 0.0f && !yoga::inexactEquals(spaceToDistribute, 0.0f) && tracksToGrowBeyondLimits.size() > 0) {
-          // TODO: handle fit-content check here
           auto unfrozenTrackCount = tracksToGrowBeyondLimits.size() - frozenTracks.size();
           auto distributionPerTrack = spaceToDistribute / unfrozenTrackCount;
           for (auto& track: tracksToGrowBeyondLimits) {
-            if (frozenTracks.find(track) != frozenTracks.end()) {
-              continue;
-            }
             itemIncurredIncrease[track] += distributionPerTrack;
             spaceToDistribute -= distributionPerTrack;
           }
@@ -449,17 +451,25 @@ struct TrackSizing {
       }
     }
   }
-
+  // https://www.w3.org/TR/css-grid-1/#extra-space
+  // We keep affected size as base size because growth limit distribution step does not apply to flexible max sizing functions.
+  // Also there is no use of limit here since growth limit is INFINITY for flexible tracks
   void distributeSpaceToFlexibleTracks(
     Dimension dimension, 
     std::vector<GridTrackSize*>& affectedTracks, 
     const std::vector<GridTrackSize*>& spannedTracks, 
     float sizeContribution, 
     SpaceDistributionPhase sizeContributionPhase
   ) {
+    auto containerSize = dimension == Dimension::Width ? containerInnerWidth : containerInnerHeight;
     float totalSpannedTracksSize = 0.0f;
-    for (auto& track: spannedTracks) {
-      totalSpannedTracksSize += track->baseSize;
+    auto gap = node->style().computeGapForDimension(dimension, containerSize);
+    for (size_t i = 0; i < spannedTracks.size(); i++) {
+      totalSpannedTracksSize += spannedTracks[i]->baseSize;
+      if (i < spannedTracks.size() - 1) {
+        // gaps are treated as tracks of fixed size. Item can span over gaps.
+        totalSpannedTracksSize += gap;
+      }
     }
 
     float sumOfFlexFactors = 0.0f;
@@ -513,10 +523,11 @@ struct TrackSizing {
         freeSpace = INFINITY;
       }
       
-      // If the free space is positive, distribute it equally to the base sizes of all tracks, 
+      // If the free space is positive, distribute it equally to the base sizes of all tracks,
       // freezing tracks as they reach their growth limits (and continuing to grow the unfrozen tracks as needed).
       if (freeSpace > 0.0f && !yoga::inexactEquals(freeSpace, 0.0f)) {
-        std::set<GridTrackSize*> frozenTracks;
+        std::unordered_set<GridTrackSize*> frozenTracks;
+        frozenTracks.reserve(tracks.size());
         auto extraSpace = freeSpace;
         
         while (frozenTracks.size() < tracks.size() && extraSpace > 0.0f && !yoga::inexactEquals(extraSpace, 0.0f)) {
@@ -595,8 +606,8 @@ struct TrackSizing {
       trackPointers.push_back(&track);
     }
 
-    std::function<float(const std::vector<GridTrackSize*>&, float, std::set<GridTrackSize*>)> findFrSize;
-    findFrSize = [&](const std::vector<GridTrackSize*>& tracks, float spaceToFill, std::set<GridTrackSize*> inflexibleTracks) -> float {
+    std::function<float(const std::vector<GridTrackSize*>&, float, std::unordered_set<GridTrackSize*>)> findFrSize;
+    findFrSize = [&](const std::vector<GridTrackSize*>& tracks, float spaceToFill, std::unordered_set<GridTrackSize*> inflexibleTracks) -> float {
       auto leftoverSpace = spaceToFill;
       auto flexFactorSum = 0.0f;
       std::vector<GridTrackSize*> flexibleTracks;
@@ -625,7 +636,7 @@ struct TrackSizing {
       // Let the hypothetical fr size be the leftover space divided by the flex factor sum.
       auto hypotheticalFrSize = leftoverSpace / flexFactorSum;
       // If the product of the hypothetical fr size and a flexible track's flex factor is less than the track's base size
-      std::set<GridTrackSize*> _inflexibleTracks;
+      std::unordered_set<GridTrackSize*> _inflexibleTracks;
       for (auto& track : flexibleTracks) {
         if (track->maxSizingFunction.isStretch() && track->maxSizingFunction.value().isDefined()) {
           float flexFactor = track->maxSizingFunction.value().unwrap();
@@ -662,7 +673,7 @@ struct TrackSizing {
     // Otherwise, if the free space is a definite length:
     // The used flex fraction is the result of finding the size of an fr using all of the grid tracks and a space to fill of the available grid space.
     else if (freeSpace != YGUndefined) {
-      usedFlexFraction = findFrSize(trackPointers, containerSize, std::set<GridTrackSize*>());
+      usedFlexFraction = findFrSize(trackPointers, containerSize, std::unordered_set<GridTrackSize*>());
     } 
     // Otherwise, if the free space is an indefinite length:
     // The used flex fraction is the maximum of:
@@ -689,7 +700,7 @@ struct TrackSizing {
             spannedTrackPointers.push_back(track);
           }
           auto itemMaxContentContribution = getMaxContentContribution(item, dimension);
-          usedFlexFraction = std::max(usedFlexFraction, findFrSize(spannedTrackPointers, itemMaxContentContribution, std::set<GridTrackSize*>()));
+          usedFlexFraction = std::max(usedFlexFraction, findFrSize(spannedTrackPointers, itemMaxContentContribution, std::unordered_set<GridTrackSize*>()));
         }
       }
 
@@ -729,7 +740,7 @@ struct TrackSizing {
     if (yoga::isDefined(minContainerSize)) {
       if (newTotalSize < minContainerSize) {
         // Redo with min constraint
-        usedFlexFraction = findFrSize(trackPointers, minContainerSize, std::set<GridTrackSize*>());
+        usedFlexFraction = findFrSize(trackPointers, minContainerSize, std::unordered_set<GridTrackSize*>());
       }
     }
      
@@ -747,7 +758,7 @@ struct TrackSizing {
     if (yoga::isDefined(maxContainerSize)) {
       if (newTotalSize > maxContainerSize) {
         // Redo with max constraint
-        usedFlexFraction = findFrSize(trackPointers, maxContainerSize, std::set<GridTrackSize*>());
+        usedFlexFraction = findFrSize(trackPointers, maxContainerSize, std::unordered_set<GridTrackSize*>());
       }
     }
     
