taffy-js 0.2.9 → 0.2.11

package/pkg/taffy_wasm.js

@@ -512,6 +512,41 @@ export const FlexWrap = Object.freeze({
     WrapReverse: 2, "2": "WrapReverse",
 });
 
+/**
+ * Grid auto flow enumeration
+ *
+ * Controls whether grid items are placed row-wise or column-wise, and whether
+ * the sparse or dense packing algorithm is used.
+ *
+ * @example
+ * ```typescript
+ * import { GridAutoFlow } from 'taffy-js';
+ *
+ * style.gridAutoFlow = GridAutoFlow.Row;       // Fill rows first
+ * style.gridAutoFlow = GridAutoFlow.Column;    // Fill columns first
+ * style.gridAutoFlow = GridAutoFlow.RowDense;  // Fill rows, pack densely
+ * ```
+ * @enum {0 | 1 | 2 | 3}
+ */
+export const GridAutoFlow = Object.freeze({
+    /**
+     * Items are placed by filling each row in turn, adding new rows as necessary
+     */
+    Row: 0, "0": "Row",
+    /**
+     * Items are placed by filling each column in turn, adding new columns as necessary
+     */
+    Column: 1, "1": "Column",
+    /**
+     * Combines `Row` with the dense packing algorithm
+     */
+    RowDense: 2, "2": "RowDense",
+    /**
+     * Combines `Column` with the dense packing algorithm
+     */
+    ColumnDense: 3, "3": "ColumnDense",
+});
+
 /**
  * Main axis alignment enumeration
  *
@@ -864,17 +899,17 @@ export const Overflow = Object.freeze({
      */
     Visible: 0, "0": "Visible",
     /**
-     * Content is clipped at the container boundary
+     * Content is clipped at the container boundary, but unlike Hidden, this forbids all scrolling
      */
-    Hidden: 1, "1": "Hidden",
+    Clip: 1, "1": "Clip",
     /**
-     * Always display scrollbars for scrollable content
+     * Content is clipped at the container boundary
      */
-    Scroll: 2, "2": "Scroll",
+    Hidden: 2, "2": "Hidden",
     /**
-     * Display scrollbars only when content overflows (internally maps to Scroll)
+     * Always display scrollbars for scrollable content
      */
-    Auto: 3, "3": "Auto",
+    Scroll: 3, "3": "Scroll",
 });
 
 /**
@@ -1005,6 +1040,20 @@ export class Style {
     set margin(val) {
         wasm.style_set_margin(this.__wbg_ptr, val);
     }
+    /**
+     * Gets the text-align property
+     *
+     * Used by block layout to implement legacy text alignment behavior.
+     *
+     * @returns - The current [`TextAlign`](JsTextAlign) value
+     *
+     * @defaultValue - `TextAlign.Auto`
+     * @returns {TextAlign}
+     */
+    get textAlign() {
+        const ret = wasm.style_textAlign(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Gets the align-items property
      *
@@ -1030,6 +1079,19 @@ export class Style {
         const ret = wasm.style_flexShrink(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Gets the grid-column property
+     *
+     * Defines which column in the grid the item should start and end at.
+     * Corresponds to CSS `grid-column` shorthand.
+     *
+     * @returns - A `Line<GridPlacement>` with start and end placements
+     * @returns {Line<GridPlacement>}
+     */
+    get gridColumn() {
+        const ret = wasm.style_gridColumn(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Sets the display mode
      *
@@ -1037,7 +1099,6 @@ export class Style {
      *
      *
      * @example
-     *
      * ```typescript
      * style.display = Display.Flex;
      * ```
@@ -1072,6 +1133,36 @@ export class Style {
         const ret = wasm.style_aspectRatio(this.__wbg_ptr);
         return ret === 0x100000001 ? undefined : ret;
     }
+    /**
+     * Gets the justify-self property
+     *
+     * Overrides the parent's justify-items for this specific element in the inline axis.
+     *
+     * @returns - The current [`AlignSelf`](JsAlignSelf) value (returns `Auto` if not set)
+     * @returns {AlignSelf | undefined}
+     */
+    get justifySelf() {
+        const ret = wasm.style_justifySelf(this.__wbg_ptr);
+        return ret === 8 ? undefined : ret;
+    }
+    /**
+     * Sets the grid-row property
+     *
+     * @param val - A Line object with start and end GridPlacement values
+     *
+     * @example
+     * ```typescript
+     * style.display = Display.Grid;
+     * // CSS: grid-row: 1 / 3
+     * style.gridRow = { start: 1, end: 3 };
+     * // CSS: grid-row: 2 / span 2
+     * style.gridRow = { start: 2, end: { span: 2 } };
+     * ```
+     * @param {Line<GridPlacement>} val
+     */
+    set gridRow(val) {
+        wasm.style_set_gridRow(this.__wbg_ptr, val);
+    }
     /**
      * Sets the maximum size constraints
      *
@@ -1121,7 +1212,6 @@ export class Style {
      *
      *
      * @example
-     *
      * ```typescript
      * style.position = Position.Absolute;
      * style.inset = { left: 10, top: 10, right: "auto", bottom: "auto" };
@@ -1143,6 +1233,33 @@ export class Style {
         const ret = wasm.style_alignContent(this.__wbg_ptr);
         return ret === 9 ? undefined : ret;
     }
+    /**
+     * Gets whether this item is a table
+     *
+     * Table children are handled specially in block layout.
+     *
+     * @returns - Whether the item is treated as a table
+     *
+     * @defaultValue - `false`
+     * @returns {boolean}
+     */
+    get itemIsTable() {
+        const ret = wasm.style_itemIsTable(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Gets the justify-items property
+     *
+     * Defines the default justify-self for all children in the inline axis.
+     * This is primarily used for CSS Grid layout.
+     *
+     * @returns - The current [`AlignItems`](JsAlignItems) value, or `undefined` if not set
+     * @returns {AlignItems | undefined}
+     */
+    get justifyItems() {
+        const ret = wasm.style_justifyItems(this.__wbg_ptr);
+        return ret === 7 ? undefined : ret;
+    }
     /**
      * Sets the flex grow factor
      *
@@ -1164,7 +1281,6 @@ export class Style {
      *
      *
      * @example
-     *
      * ```typescript
      * style.flexWrap = FlexWrap.Wrap;
      * ```
@@ -1187,6 +1303,32 @@ export class Style {
         const ret = wasm.style_flexDirection(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Gets the grid-auto-flow property
+     *
+     * Controls how auto-placed items are inserted into the grid.
+     *
+     * @returns - The current [`GridAutoFlow`](JsGridAutoFlow) value
+     *
+     * @defaultValue - `GridAutoFlow.Row`
+     * @returns {GridAutoFlow}
+     */
+    get gridAutoFlow() {
+        const ret = wasm.style_gridAutoFlow(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Gets the grid-auto-rows property
+     *
+     * Defines the size of implicitly created rows.
+     *
+     * @returns - An array of track sizing functions
+     * @returns {any}
+     */
+    get gridAutoRows() {
+        const ret = wasm.style_gridAutoRows(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Sets the align-self property
      *
@@ -1229,6 +1371,20 @@ export class Style {
     set flexBasis(val) {
         wasm.style_set_flexBasis(this.__wbg_ptr, val);
     }
+    /**
+     * Sets the text-align property
+     *
+     * @param val - The new text-align value
+     *
+     * @example
+     * ```typescript
+     * style.textAlign = TextAlign.LegacyCenter;
+     * ```
+     * @param {TextAlign} val
+     */
+    set textAlign(val) {
+        wasm.style_set_textAlign(this.__wbg_ptr, val);
+    }
     /**
      * Gets the justify-content property
      *
@@ -1241,13 +1397,26 @@ export class Style {
         const ret = wasm.style_justifyContent(this.__wbg_ptr);
         return ret === 9 ? undefined : ret;
     }
+    /**
+     * Gets the scrollbar width
+     *
+     * The width of the scrollbar gutter when `overflow` is set to `Scroll`.
+     *
+     * @returns - The scrollbar width in pixels
+     *
+     * @defaultValue - `0`
+     * @returns {number}
+     */
+    get scrollbarWidth() {
+        const ret = wasm.style_scrollbarWidth(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Sets the align-items property
      *
      * @param val - The new align-items value, or `undefined` to use default
      *
      * @example
-     *
      * ```typescript
      * style.alignItems = AlignItems.Center;
      * ```
@@ -1270,6 +1439,38 @@ export class Style {
     set flexShrink(val) {
         wasm.style_set_flexShrink(this.__wbg_ptr, val);
     }
+    /**
+     * Sets the grid-column property
+     *
+     * @param val - A Line object with start and end GridPlacement values
+     *
+     * @example
+     * ```typescript
+     * style.display = Display.Grid;
+     * // CSS: grid-column: 1 / 4
+     * style.gridColumn = { start: 1, end: 4 };
+     * // CSS: grid-column: auto / span 3
+     * style.gridColumn = { start: "auto", end: { span: 3 } };
+     * ```
+     * @param {Line<GridPlacement>} val
+     */
+    set gridColumn(val) {
+        wasm.style_set_gridColumn(this.__wbg_ptr, val);
+    }
+    /**
+     * Gets whether this item is a replaced element
+     *
+     * Replaced elements have special sizing behavior (e.g., `<img>`, `<video>`).
+     *
+     * @returns - Whether the item is a replaced element
+     *
+     * @defaultValue - `false`
+     * @returns {boolean}
+     */
+    get itemIsReplaced() {
+        const ret = wasm.style_itemIsReplaced(this.__wbg_ptr);
+        return ret !== 0;
+    }
     /**
      * Sets the aspect ratio
      *
@@ -1284,6 +1485,32 @@ export class Style {
     set aspectRatio(val) {
         wasm.style_set_aspectRatio(this.__wbg_ptr, val);
     }
+    /**
+     * Sets the justify-self property
+     *
+     * @param val - The new justify-self value, or `undefined`/`Auto` to inherit from parent
+     *
+     * @example
+     * ```typescript
+     * style.justifySelf = AlignSelf.End;
+     * ```
+     * @param {AlignSelf | undefined} val
+     */
+    set justifySelf(val) {
+        wasm.style_set_justifySelf(this.__wbg_ptr, val);
+    }
+    /**
+     * Gets the grid-auto-columns property
+     *
+     * Defines the size of implicitly created columns.
+     *
+     * @returns - An array of track sizing functions
+     * @returns {any}
+     */
+    get gridAutoColumns() {
+        const ret = wasm.style_gridAutoColumns(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Sets the align-content property
      *
@@ -1298,6 +1525,43 @@ export class Style {
     set alignContent(val) {
         wasm.style_set_alignContent(this.__wbg_ptr, val);
     }
+    /**
+     * Sets whether this item is a table
+     *
+     * @param val - Whether the item should be treated as a table
+     * @param {boolean} val
+     */
+    set itemIsTable(val) {
+        wasm.style_set_itemIsTable(this.__wbg_ptr, val);
+    }
+    /**
+     * Sets the justify-items property
+     *
+     * @param val - The new justify-items value, or `undefined` to use default
+     *
+     * @example
+     * ```typescript
+     * style.display = Display.Grid;
+     * style.justifyItems = AlignItems.Center;
+     * ```
+     * @param {AlignItems | undefined} val
+     */
+    set justifyItems(val) {
+        wasm.style_set_justifyItems(this.__wbg_ptr, val);
+    }
+    /**
+     * Gets the grid-template-rows property
+     *
+     * Defines the track sizing functions (heights) of the grid rows.
+     * Returns Taffy's native serialization format.
+     *
+     * @returns - An array of `GridTrack` values
+     * @returns {GridTrack[]}
+     */
+    get gridTemplateRows() {
+        const ret = wasm.style_gridTemplateRows(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Sets the flex direction
      *
@@ -1305,7 +1569,6 @@ export class Style {
      *
      *
      * @example
-     *
      * ```typescript
      * style.flexDirection = FlexDirection.Column;
      * ```
@@ -1314,6 +1577,48 @@ export class Style {
     set flexDirection(val) {
         wasm.style_set_flexDirection(this.__wbg_ptr, val);
     }
+    /**
+     * Sets the grid-auto-flow property
+     *
+     * @param val - The new grid-auto-flow value
+     *
+     * @example
+     * ```typescript
+     * style.display = Display.Grid;
+     * style.gridAutoFlow = GridAutoFlow.Column;
+     * ```
+     * @param {GridAutoFlow} val
+     */
+    set gridAutoFlow(val) {
+        wasm.style_set_gridAutoFlow(this.__wbg_ptr, val);
+    }
+    /**
+     * Sets the grid-auto-rows property
+     *
+     * @param val - An array of track sizing functions for implicit rows
+     *
+     * @example
+     * ```typescript
+     * style.display = Display.Grid;
+     * style.gridAutoRows = [{ min: "Auto", max: "Auto" }];
+     * ```
+     * @param {any} val
+     */
+    set gridAutoRows(val) {
+        wasm.style_set_gridAutoRows(this.__wbg_ptr, val);
+    }
+    /**
+     * Gets the grid-template-areas property
+     *
+     * Defines named grid areas that can be referenced by grid items.
+     *
+     * @returns - An array of `GridArea` values
+     * @returns {GridArea[]}
+     */
+    get gridTemplateAreas() {
+        const ret = wasm.style_gridTemplateAreas(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Sets the justify-content property
      *
@@ -1328,6 +1633,159 @@ export class Style {
     set justifyContent(val) {
         wasm.style_set_justifyContent(this.__wbg_ptr, val);
     }
+    /**
+     * Sets the scrollbar width
+     *
+     * @param val - The scrollbar width in pixels
+     *
+     * @example
+     * ```typescript
+     * style.overflow = { x: Overflow.Scroll, y: Overflow.Scroll };
+     * style.scrollbarWidth = 15;
+     * ```
+     * @param {number} val
+     */
+    set scrollbarWidth(val) {
+        wasm.style_set_scrollbarWidth(this.__wbg_ptr, val);
+    }
+    /**
+     * Sets whether this item is a replaced element
+     *
+     * @param val - Whether the item should be treated as a replaced element
+     * @param {boolean} val
+     */
+    set itemIsReplaced(val) {
+        wasm.style_set_itemIsReplaced(this.__wbg_ptr, val);
+    }
+    /**
+     * Gets the grid-template-columns property
+     *
+     * Defines the track sizing functions (widths) of the grid columns.
+     *
+     * @returns - An array of `GridTrack` values
+     * @returns {GridTrack[]}
+     */
+    get gridTemplateColumns() {
+        const ret = wasm.style_gridTemplateColumns(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Sets the grid-auto-columns property
+     *
+     * @param val - An array of track sizing functions for implicit columns
+     * @param {any} val
+     */
+    set gridAutoColumns(val) {
+        wasm.style_set_gridAutoColumns(this.__wbg_ptr, val);
+    }
+    /**
+     * Sets the grid-template-rows property
+     *
+     * @param val - An array of GridTrack objects (Taffy's serde format)
+     *
+     * @example
+     * ```typescript
+     * style.display = Display.Grid;
+     * // Simple: use Taffy's serde format
+     * style.gridTemplateRows = [
+     *   { type: "Single", value: { min: { Length: 100 }, max: { Length: 100 } } },
+     *   { type: "Single", value: { min: "Auto", max: { Fr: 1.0 } } }
+     * ];
+     * ```
+     * @param {GridTrack[]} val
+     */
+    set gridTemplateRows(val) {
+        wasm.style_set_gridTemplateRows(this.__wbg_ptr, val);
+    }
+    /**
+     * Gets the grid-template-row-names property
+     *
+     * Defines the named lines between the rows.
+     *
+     * @returns - An array of arrays of line names
+     * @returns {string[][]}
+     */
+    get gridTemplateRowNames() {
+        const ret = wasm.style_gridTemplateRowNames(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Sets the grid-template-areas property
+     *
+     * @param val - An array of named grid area definitions
+     *
+     * @example
+     * ```typescript
+     * style.display = Display.Grid;
+     * style.gridTemplateAreas = [
+     *   { name: "header", row_start: 1, row_end: 2, column_start: 1, column_end: 4 },
+     *   { name: "main", row_start: 2, row_end: 4, column_start: 2, column_end: 4 }
+     * ];
+     * ```
+     * @param {GridArea[]} val
+     */
+    set gridTemplateAreas(val) {
+        wasm.style_set_gridTemplateAreas(this.__wbg_ptr, val);
+    }
+    /**
+     * Sets the grid-template-columns property
+     *
+     * @param val - An array of GridTrack objects
+     *
+     * @example
+     * ```typescript
+     * style.display = Display.Grid;
+     * style.gridTemplateColumns = [
+     *   { type: "Single", value: { min: { Length: 200 }, max: { Length: 200 } } },
+     *   { type: "Single", value: { min: "Auto", max: { Fr: 1.0 } } },
+     *   { type: "Single", value: { min: "Auto", max: { Fr: 1.0 } } }
+     * ];
+     * ```
+     * @param {GridTrack[]} val
+     */
+    set gridTemplateColumns(val) {
+        wasm.style_set_gridTemplateColumns(this.__wbg_ptr, val);
+    }
+    /**
+     * Gets the grid-template-column-names property
+     *
+     * Defines the named lines between the columns.
+     *
+     * @returns - An array of arrays of line names
+     * @returns {string[][]}
+     */
+    get gridTemplateColumnNames() {
+        const ret = wasm.style_gridTemplateColumnNames(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Sets the grid-template-row-names property
+     *
+     * @param val - An array of arrays of line names
+     *
+     * @example
+     * ```typescript
+     * style.gridTemplateRowNames = [["header-start"], ["header-end", "main-start"], ["main-end"]];
+     * ```
+     * @param {string[][]} val
+     */
+    set gridTemplateRowNames(val) {
+        wasm.style_set_gridTemplateRowNames(this.__wbg_ptr, val);
+    }
+    /**
+     * Sets the grid-template-column-names property
+     *
+     * @param val - An array of arrays of line names
+     *
+     * @example
+     * ```typescript
+     * style.gridTemplateColumnNames = [["sidebar-start"], ["sidebar-end", "main-start"], ["main-end"]];
+     * ```
+     * @param {string[][]} val
+     */
+    set gridTemplateColumnNames(val) {
+        wasm.style_set_gridTemplateColumnNames(this.__wbg_ptr, val);
+    }
     /**
      * Gets the gap
      *
@@ -1443,6 +1901,19 @@ export class Style {
     set gap(val) {
         wasm.style_set_gap(this.__wbg_ptr, val);
     }
+    /**
+     * Gets the grid-row property
+     *
+     * Defines which row in the grid the item should start and end at.
+     * Corresponds to CSS `grid-row` shorthand.
+     *
+     * @returns - A `Line<GridPlacement>` with start and end placements
+     * @returns {Line<GridPlacement>}
+     */
+    get gridRow() {
+        const ret = wasm.style_gridRow(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Gets the maximum size constraints
      *
@@ -2474,6 +2945,39 @@ export class TaffyTree {
 }
 if (Symbol.dispose) TaffyTree.prototype[Symbol.dispose] = TaffyTree.prototype.free;
 
+/**
+ * Text alignment enumeration (for block layout)
+ *
+ * Used by block layout to implement the legacy behaviour of `<center>` and
+ * `<div align="left | right | center">`.
+ *
+ * @example
+ * ```typescript
+ * import { TextAlign } from 'taffy-js';
+ *
+ * style.textAlign = TextAlign.LegacyCenter;  // Center block children
+ * ```
+ * @enum {0 | 1 | 2 | 3}
+ */
+export const TextAlign = Object.freeze({
+    /**
+     * No special legacy text align behaviour
+     */
+    Auto: 0, "0": "Auto",
+    /**
+     * Corresponds to `-webkit-left` or `-moz-left` in browsers
+     */
+    LegacyLeft: 1, "1": "LegacyLeft",
+    /**
+     * Corresponds to `-webkit-right` or `-moz-right` in browsers
+     */
+    LegacyRight: 2, "2": "LegacyRight",
+    /**
+     * Corresponds to `-webkit-center` or `-moz-center` in browsers
+     */
+    LegacyCenter: 3, "3": "LegacyCenter",
+});
+
 const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);
 
 async function __wbg_load(module, imports) {
@@ -2513,6 +3017,10 @@ function __wbg_get_imports() {
         const ret = Error(getStringFromWasm0(arg0, arg1));
         return ret;
     };
+    imports.wbg.__wbg_Number_2d1dcfcf4ec51736 = function(arg0) {
+        const ret = Number(arg0);
+        return ret;
+    };
     imports.wbg.__wbg_String_8f0eb39a4a4c2f66 = function(arg0, arg1) {
         const ret = String(arg1);
         const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -2600,6 +3108,10 @@ function __wbg_get_imports() {
         const ret = arg0.call(arg1);
         return ret;
     }, arguments) };
+    imports.wbg.__wbg_done_62ea16af4ce34b24 = function(arg0) {
+        const ret = arg0.done;
+        return ret;
+    };
     imports.wbg.__wbg_entries_83c79938054e065f = function(arg0) {
         const ret = Object.entries(arg0);
         return ret;
@@ -2677,7 +3189,7 @@ function __wbg_get_imports() {
         const ret = arg0.length;
         return ret;
     };
-    imports.wbg.__wbg_log_d1f98d69ddd6fc3e = function(arg0, arg1) {
+    imports.wbg.__wbg_log_23225a7078e26a12 = function(arg0, arg1) {
         console.log(getStringFromWasm0(arg0, arg1));
     };
     imports.wbg.__wbg_new_1ba21ce319a06297 = function() {
@@ -2696,10 +3208,18 @@ function __wbg_get_imports() {
         const ret = new Error();
         return ret;
     };
+    imports.wbg.__wbg_new_b546ae120718850e = function() {
+        const ret = new Map();
+        return ret;
+    };
     imports.wbg.__wbg_next_138a17bbf04e926c = function(arg0) {
         const ret = arg0.next;
         return ret;
     };
+    imports.wbg.__wbg_next_3cfe5c0fe2a4cc53 = function() { return handleError(function (arg0) {
+        const ret = arg0.next();
+        return ret;
+    }, arguments) };
     imports.wbg.__wbg_prototypesetcall_dfe9b766cdc1f1fd = function(arg0, arg1, arg2) {
         Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
     };
@@ -2710,6 +3230,13 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
         arg0[arg1] = arg2;
     };
+    imports.wbg.__wbg_set_7df433eea03a5c14 = function(arg0, arg1, arg2) {
+        arg0[arg1 >>> 0] = arg2;
+    };
+    imports.wbg.__wbg_set_efaaf145b9377369 = function(arg0, arg1, arg2) {
+        const ret = arg0.set(arg1, arg2);
+        return ret;
+    };
     imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
         const ret = arg1.stack;
         const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -2729,6 +3256,10 @@ function __wbg_get_imports() {
         const ret = TaffyError.__wrap(arg0);
         return ret;
     };
+    imports.wbg.__wbg_value_57b7b035e117f7ee = function(arg0) {
+        const ret = arg0.value;
+        return ret;
+    };
     imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
         // Cast intrinsic for `Ref(String) -> Externref`.
         const ret = getStringFromWasm0(arg0, arg1);