CSS engine: sync CSS Grid properties and factory registrations

The grid property set from PeachPDF v0.9.6 (upstream 4319393 and the follow-up
grid work in fb7a769, 12ec795, 253de51): grid-template-columns/-rows/-areas,
the grid-column/-row/-area placement shorthands, grid-auto-flow/-columns/-rows,
the `grid` and `grid-template` mega-shorthands, and justify-items/-self plus
the place-items/-content/-self shorthands.

grid-template-columns/-rows carry a parsed GridTemplate through the cascade via
CssProperty<T>, rather than only their authored text.

The `grid` and `grid-template` shorthands are registered through
AddLogicalShorthand so the serializer will not try to reconstruct them from
their longhands - their multi-slash and areas grammar is not worth rebuilding
and doing so could change existing output.

Parse-and-cascade only: HTML-Renderer has no grid layout engine, so
`display: grid` still lays out as a block and these declarations are ignored at
the box boundary. Wiring them up needs a layout engine and is a separate piece
of work.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: 2 people

Source/HtmlRenderer/Core/CssEngine/Factories/PropertyFactory.cs

@@ -366,6 +366,47 @@ private PropertyFactory()
             _fontsBuilder.Add(PropertyNames.Src, () => new SrcProperty());
             _fontsBuilder.Add(PropertyNames.UnicodeRange, () => new UnicodeRangeProperty());
 
+            // CSS Grid Layout Level 1/2. The engine parses and validates the full grid property set;
+            // the renderer has no grid layout engine yet, so these cascade and are then ignored at the
+            // box boundary.
+            AddLonghand(PropertyNames.GridTemplateColumns, () => new GridTemplateColumnsProperty());
+            AddLonghand(PropertyNames.GridTemplateRows, () => new GridTemplateRowsProperty());
+            AddLonghand(PropertyNames.GridTemplateAreas, () => new GridTemplateAreasProperty());
+            AddLonghand(PropertyNames.GridColumnStart, () => new GridColumnStartProperty());
+            AddLonghand(PropertyNames.GridColumnEnd, () => new GridColumnEndProperty());
+            AddLonghand(PropertyNames.GridRowStart, () => new GridRowStartProperty());
+            AddLonghand(PropertyNames.GridRowEnd, () => new GridRowEndProperty());
+
+            AddShorthand(PropertyNames.GridColumn, () => new GridColumnProperty(),
+                PropertyNames.GridColumnStart, PropertyNames.GridColumnEnd);
+            AddShorthand(PropertyNames.GridRow, () => new GridRowProperty(),
+                PropertyNames.GridRowStart, PropertyNames.GridRowEnd);
+            AddShorthand(PropertyNames.GridArea, () => new GridAreaProperty(),
+                PropertyNames.GridRowStart, PropertyNames.GridColumnStart,
+                PropertyNames.GridRowEnd, PropertyNames.GridColumnEnd);
+
+            AddLonghand(PropertyNames.GridAutoFlow, () => new GridAutoFlowProperty());
+            AddLonghand(PropertyNames.GridAutoColumns, () => new GridAutoColumnsProperty());
+            AddLonghand(PropertyNames.GridAutoRows, () => new GridAutoRowsProperty());
+
+            // The grid mega-shorthands parse/expand like any other, but are excluded from serialization
+            // reconstruction (via _logicalShorthands) - reconstructing a `grid`/`grid-template` from its
+            // longhands is not worth the complexity and could change existing output.
+            AddLogicalShorthand(PropertyNames.GridTemplate, () => new GridTemplateProperty(),
+                PropertyNames.GridTemplateRows, PropertyNames.GridTemplateColumns, PropertyNames.GridTemplateAreas);
+            AddLogicalShorthand(PropertyNames.Grid, () => new GridProperty(),
+                PropertyNames.GridTemplateRows, PropertyNames.GridTemplateColumns, PropertyNames.GridTemplateAreas,
+                PropertyNames.GridAutoFlow, PropertyNames.GridAutoRows, PropertyNames.GridAutoColumns);
+
+            AddLonghand(PropertyNames.JustifyItems, () => new JustifyItemsProperty());
+            AddLonghand(PropertyNames.JustifySelf, () => new JustifySelfProperty());
+            AddShorthand(PropertyNames.PlaceItems, () => new PlaceItemsProperty(),
+                PropertyNames.AlignItems, PropertyNames.JustifyItems);
+            AddShorthand(PropertyNames.PlaceContent, () => new PlaceContentProperty(),
+                PropertyNames.AlignContent, PropertyNames.JustifyContent);
+            AddShorthand(PropertyNames.PlaceSelf, () => new PlaceSelfProperty(),
+                PropertyNames.AlignSelf, PropertyNames.JustifySelf);
+
             // CSS Logical Properties and Values Level 1. Layout here is always LTR / horizontal-tb,
             // so each logical property is registered to produce/export the existing physical
             // longhands (block-start = top, block-end = bottom, inline-start = left,

Source/HtmlRenderer/Core/CssEngine/StyleProperties/Grid/GridAreaProperty.cs

@@ -0,0 +1,19 @@
+namespace TheArtOfDev.HtmlRenderer.Core.CssEngine
+{
+    /// <summary>
+    /// The <c>grid-area</c> shorthand (CSS Grid §8.3.1): <c>&lt;grid-line&gt; [ / &lt;grid-line&gt; ]{0,3}</c>,
+    /// expanding to <c>grid-row-start</c> / <c>grid-column-start</c> / <c>grid-row-end</c> /
+    /// <c>grid-column-end</c>. The single named-area form is out of v1 scope.
+    /// </summary>
+    internal sealed class GridAreaProperty : ShorthandProperty
+    {
+        private static readonly IValueConverter StyleConverter = Converters.GridAreaConverter.OrGlobalValue();
+
+        internal GridAreaProperty()
+            : base(PropertyNames.GridArea)
+        {
+        }
+
+        internal override IValueConverter Converter => StyleConverter;
+    }
+}

Source/HtmlRenderer/Core/CssEngine/StyleProperties/Grid/GridAutoColumnsProperty.cs

@@ -0,0 +1,15 @@
+namespace TheArtOfDev.HtmlRenderer.Core.CssEngine
+{
+    /// <summary>The <c>grid-auto-columns</c> property (CSS Grid §7.6): the size of implicitly-created columns.</summary>
+    internal sealed class GridAutoColumnsProperty : Property
+    {
+        private static readonly IValueConverter StyleConverter = new GridAutoTracksValueConverter().OrDefault();
+
+        internal GridAutoColumnsProperty()
+            : base(PropertyNames.GridAutoColumns)
+        {
+        }
+
+        internal override IValueConverter Converter => StyleConverter;
+    }
+}

Source/HtmlRenderer/Core/CssEngine/StyleProperties/Grid/GridAutoFlowProperty.cs

@@ -0,0 +1,15 @@
+namespace TheArtOfDev.HtmlRenderer.Core.CssEngine
+{
+    /// <summary>The <c>grid-auto-flow</c> property (CSS Grid §7.7): the auto-placement direction and packing.</summary>
+    internal sealed class GridAutoFlowProperty : Property
+    {
+        private static readonly IValueConverter StyleConverter = new GridAutoFlowValueConverter().OrDefault();
+
+        internal GridAutoFlowProperty()
+            : base(PropertyNames.GridAutoFlow)
+        {
+        }
+
+        internal override IValueConverter Converter => StyleConverter;
+    }
+}

Source/HtmlRenderer/Core/CssEngine/StyleProperties/Grid/GridAutoRowsProperty.cs

@@ -0,0 +1,15 @@
+namespace TheArtOfDev.HtmlRenderer.Core.CssEngine
+{
+    /// <summary>The <c>grid-auto-rows</c> property (CSS Grid §7.6): the size of implicitly-created rows.</summary>
+    internal sealed class GridAutoRowsProperty : Property
+    {
+        private static readonly IValueConverter StyleConverter = new GridAutoTracksValueConverter().OrDefault();
+
+        internal GridAutoRowsProperty()
+            : base(PropertyNames.GridAutoRows)
+        {
+        }
+
+        internal override IValueConverter Converter => StyleConverter;
+    }
+}

Source/HtmlRenderer/Core/CssEngine/StyleProperties/Grid/GridColumnEndProperty.cs

@@ -0,0 +1,18 @@
+namespace TheArtOfDev.HtmlRenderer.Core.CssEngine
+{
+    /// <summary>
+    /// The <c>grid-column-end</c> longhand (CSS Grid §8.3), one edge of a
+    /// grid item's placement. Validated by the shared <see cref="GridLineGrammar"/>.
+    /// </summary>
+    internal sealed class GridColumnEndProperty : Property
+    {
+        private static readonly IValueConverter StyleConverter = Converters.GridLineConverter.OrDefault();
+
+        internal GridColumnEndProperty()
+            : base(PropertyNames.GridColumnEnd)
+        {
+        }
+
+        internal override IValueConverter Converter => StyleConverter;
+    }
+}

Source/HtmlRenderer/Core/CssEngine/StyleProperties/Grid/GridColumnProperty.cs

@@ -0,0 +1,18 @@
+namespace TheArtOfDev.HtmlRenderer.Core.CssEngine
+{
+    /// <summary>
+    /// The <c>grid-column</c> shorthand (CSS Grid §8.3.1): <c>&lt;grid-line&gt; [ / &lt;grid-line&gt; ]?</c>,
+    /// expanding to <c>grid-column-start</c> / <c>grid-column-end</c>.
+    /// </summary>
+    internal sealed class GridColumnProperty : ShorthandProperty
+    {
+        private static readonly IValueConverter StyleConverter = Converters.GridColumnConverter.OrGlobalValue();
+
+        internal GridColumnProperty()
+            : base(PropertyNames.GridColumn)
+        {
+        }
+
+        internal override IValueConverter Converter => StyleConverter;
+    }
+}

Source/HtmlRenderer/Core/CssEngine/StyleProperties/Grid/GridColumnStartProperty.cs

@@ -0,0 +1,18 @@
+namespace TheArtOfDev.HtmlRenderer.Core.CssEngine
+{
+    /// <summary>
+    /// The <c>grid-column-start</c> longhand (CSS Grid §8.3), one edge of a
+    /// grid item's placement. Validated by the shared <see cref="GridLineGrammar"/>.
+    /// </summary>
+    internal sealed class GridColumnStartProperty : Property
+    {
+        private static readonly IValueConverter StyleConverter = Converters.GridLineConverter.OrDefault();
+
+        internal GridColumnStartProperty()
+            : base(PropertyNames.GridColumnStart)
+        {
+        }
+
+        internal override IValueConverter Converter => StyleConverter;
+    }
+}

Source/HtmlRenderer/Core/CssEngine/StyleProperties/Grid/GridProperty.cs

@@ -0,0 +1,18 @@
+namespace TheArtOfDev.HtmlRenderer.Core.CssEngine
+{
+    /// <summary>
+    /// The <c>grid</c> shorthand (CSS Grid §7.8): expands to the three <c>grid-template-*</c> longhands plus
+    /// <c>grid-auto-flow</c> / <c>grid-auto-rows</c> / <c>grid-auto-columns</c>.
+    /// </summary>
+    internal sealed class GridProperty : ShorthandProperty
+    {
+        private static readonly IValueConverter StyleConverter = Converters.GridConverter.OrGlobalValue();
+
+        internal GridProperty()
+            : base(PropertyNames.Grid)
+        {
+        }
+
+        internal override IValueConverter Converter => StyleConverter;
+    }
+}

Source/HtmlRenderer/Core/CssEngine/StyleProperties/Grid/GridRowEndProperty.cs

@@ -0,0 +1,18 @@
+namespace TheArtOfDev.HtmlRenderer.Core.CssEngine
+{
+    /// <summary>
+    /// The <c>grid-row-end</c> longhand (CSS Grid §8.3), one edge of a
+    /// grid item's placement. Validated by the shared <see cref="GridLineGrammar"/>.
+    /// </summary>
+    internal sealed class GridRowEndProperty : Property
+    {
+        private static readonly IValueConverter StyleConverter = Converters.GridLineConverter.OrDefault();
+
+        internal GridRowEndProperty()
+            : base(PropertyNames.GridRowEnd)
+        {
+        }
+
+        internal override IValueConverter Converter => StyleConverter;
+    }
+}