simple-table-core 4.0.1 → 4.0.2

package/dist/{src/utils → utils}/nestedGridRowRenderer.d.ts

@@ -1,50 +1,50 @@
-/**
- * Vanilla equivalent of React NestedGridRow: renders a full-width row that contains
- * a nested SimpleTable when a row has nestedTable config (expandable + nestedTable headers).
- */
-import type TableRow from "../types/TableRow";
-import type { CustomTheme } from "../types/CustomTheme";
-import type { SimpleTableConfig } from "../types/SimpleTableConfig";
-import { type HeightOffsets } from "./infiniteScrollUtils";
-/**
- * Minimal surface of a table instance this renderer drives. Declared
- * structurally so this module never has to statically import the concrete
- * `SimpleTableVanilla` class — that import would close a cycle
- * (SimpleTableVanilla → RenderOrchestrator → TableRenderer → SectionRenderer →
- * nestedGridRowRenderer → SimpleTableVanilla). The class is injected at render
- * time via {@link NestedTableFactory} instead.
- */
-export interface NestedTableInstance {
-    mount: () => void;
-    destroy: () => void;
-}
-/** Factory injected by the host table to instantiate a nested table. */
-export type NestedTableFactory = (container: HTMLElement, config: SimpleTableConfig) => NestedTableInstance;
-export interface NestedGridRowRenderContext {
-    rowHeight: number;
-    heightOffsets: HeightOffsets | undefined;
-    customTheme: CustomTheme;
-    theme?: string;
-    rowGrouping?: (string | number)[];
-    depth: number;
-    loadingStateRenderer?: SimpleTableConfig["loadingStateRenderer"];
-    errorStateRenderer?: SimpleTableConfig["errorStateRenderer"];
-    emptyStateRenderer?: SimpleTableConfig["emptyStateRenderer"];
-    icons?: SimpleTableConfig["icons"];
-    /** Injected constructor for nested tables (breaks the import cycle). */
-    createNestedTable?: NestedTableFactory;
-}
-/**
- * Creates a nested grid row element: a div with class "st-row st-nested-grid-row"
- * that contains a nested SimpleTableVanilla instance.
- * Returns the row element and a cleanup function to destroy the nested table.
- */
-export declare function createNestedGridRow(tableRow: TableRow, context: NestedGridRowRenderContext): {
-    element: HTMLElement;
-    cleanup: () => void;
-};
-/**
- * Creates a spacer row for pinned sections: same position/height as a nested grid row
- * but no inner table (keeps scroll height in sync).
- */
-export declare function createNestedGridSpacer(tableRow: TableRow, context: Pick<NestedGridRowRenderContext, "rowHeight" | "heightOffsets" | "customTheme">): HTMLElement;
+/**
+ * Vanilla equivalent of React NestedGridRow: renders a full-width row that contains
+ * a nested SimpleTable when a row has nestedTable config (expandable + nestedTable headers).
+ */
+import type TableRow from "../types/TableRow";
+import type { CustomTheme } from "../types/CustomTheme";
+import type { SimpleTableConfig } from "../types/SimpleTableConfig";
+import { type HeightOffsets } from "./infiniteScrollUtils";
+/**
+ * Minimal surface of a table instance this renderer drives. Declared
+ * structurally so this module never has to statically import the concrete
+ * `SimpleTableVanilla` class — that import would close a cycle
+ * (SimpleTableVanilla → RenderOrchestrator → TableRenderer → SectionRenderer →
+ * nestedGridRowRenderer → SimpleTableVanilla). The class is injected at render
+ * time via {@link NestedTableFactory} instead.
+ */
+export interface NestedTableInstance {
+    mount: () => void;
+    destroy: () => void;
+}
+/** Factory injected by the host table to instantiate a nested table. */
+export type NestedTableFactory = (container: HTMLElement, config: SimpleTableConfig) => NestedTableInstance;
+export interface NestedGridRowRenderContext {
+    rowHeight: number;
+    heightOffsets: HeightOffsets | undefined;
+    customTheme: CustomTheme;
+    theme?: string;
+    rowGrouping?: (string | number)[];
+    depth: number;
+    loadingStateRenderer?: SimpleTableConfig["loadingStateRenderer"];
+    errorStateRenderer?: SimpleTableConfig["errorStateRenderer"];
+    emptyStateRenderer?: SimpleTableConfig["emptyStateRenderer"];
+    icons?: SimpleTableConfig["icons"];
+    /** Injected constructor for nested tables (breaks the import cycle). */
+    createNestedTable?: NestedTableFactory;
+}
+/**
+ * Creates a nested grid row element: a div with class "st-row st-nested-grid-row"
+ * that contains a nested SimpleTableVanilla instance.
+ * Returns the row element and a cleanup function to destroy the nested table.
+ */
+export declare function createNestedGridRow(tableRow: TableRow, context: NestedGridRowRenderContext): {
+    element: HTMLElement;
+    cleanup: () => void;
+};
+/**
+ * Creates a spacer row for pinned sections: same position/height as a nested grid row
+ * but no inner table (keeps scroll height in sync).
+ */
+export declare function createNestedGridSpacer(tableRow: TableRow, context: Pick<NestedGridRowRenderContext, "rowHeight" | "heightOffsets" | "customTheme">): HTMLElement;

package/dist/utils/normalizeConfig.d.ts

@@ -0,0 +1,62 @@
+import type HeaderObject from "../types/HeaderObject";
+import type { SimpleTableConfig } from "../types/SimpleTableConfig";
+/** Preferred column-def aliases accepted on column objects (normalized to `is*` fields). */
+export type ColumnDefAliases = {
+    /** @deprecated Prefer `editable` */
+    isEditable?: boolean;
+    editable?: boolean;
+    /** @deprecated Prefer `sortable` */
+    isSortable?: boolean;
+    sortable?: boolean;
+    /** @deprecated Prefer `essential` */
+    isEssential?: boolean;
+    essential?: boolean;
+};
+/**
+ * Consumer-facing config input: accepts preferred prop names alongside legacy
+ * names. {@link normalizeConfig} / {@link normalizeConfigPatch} collapse aliases
+ * into the canonical {@link SimpleTableConfig} shape used internally.
+ */
+export type SimpleTableConfigInput = Omit<SimpleTableConfig, "defaultHeaders" | "editColumns" | "editColumnsInitOpen" | "shouldPaginate" | "onGridReady" | "useHoverRowBackground" | "useOddColumnBackground" | "useOddEvenRowBackground"> & {
+    /** Preferred column definitions prop. */
+    columns?: HeaderObject[];
+    /** @deprecated Prefer `columns` */
+    defaultHeaders?: HeaderObject[];
+    /** Preferred flag for the column editor / visibility UI. */
+    enableColumnEditor?: boolean;
+    /** @deprecated Prefer `enableColumnEditor` */
+    editColumns?: boolean;
+    enableColumnEditorInitOpen?: boolean;
+    /** @deprecated Prefer `enableColumnEditorInitOpen` */
+    editColumnsInitOpen?: boolean;
+    /** Preferred pagination flag. */
+    enablePagination?: boolean;
+    /** @deprecated Prefer `enablePagination` */
+    shouldPaginate?: boolean;
+    /** Preferred ready callback. */
+    onTableReady?: () => void;
+    /** @deprecated Prefer `onTableReady` */
+    onGridReady?: () => void;
+    hoverRowBackground?: boolean;
+    /** @deprecated Prefer `hoverRowBackground` */
+    useHoverRowBackground?: boolean;
+    oddColumnBackground?: boolean;
+    /** @deprecated Prefer `oddColumnBackground` */
+    useOddColumnBackground?: boolean;
+    oddEvenRowBackground?: boolean;
+    /** @deprecated Prefer `oddEvenRowBackground` */
+    useOddEvenRowBackground?: boolean;
+};
+/** Normalize a single column def: preferred bare adjectives win over `is*` aliases. */
+export declare function normalizeColumnDef(header: HeaderObject): HeaderObject;
+export declare function normalizeColumnDefs(headers: HeaderObject[]): HeaderObject[];
+/**
+ * Collapse consumer aliases into the canonical config shape.
+ * Requires `columns` or `defaultHeaders`.
+ */
+export declare function normalizeConfig(input: SimpleTableConfigInput): SimpleTableConfig;
+/**
+ * Normalize a partial update patch. Maps preferred alias keys onto canonical
+ * keys so `update({ columns })` / `update({ enablePagination })` work.
+ */
+export declare function normalizeConfigPatch(patch: Partial<SimpleTableConfigInput>): Partial<SimpleTableConfig>;

package/dist/{cjs/src/utils → utils}/pinnedColumnUtils.d.ts

@@ -1,29 +1,29 @@
-import HeaderObject, { Accessor } from "../types/HeaderObject";
-import { PinnedSectionsState } from "../types/PinnedSectionsState";
-import { PanelSection } from "../types/PanelSection";
-export type { PinnedSectionsState, PanelSection };
-/** Root-level columns only, preserving order within each pin group. */
-export declare function partitionRootHeadersByPin(headers: HeaderObject[]): {
-    pinnedLeft: HeaderObject[];
-    unpinned: HeaderObject[];
-    pinnedRight: HeaderObject[];
-};
-export declare function isHeaderEssential(header: HeaderObject, essentialAccessors: ReadonlySet<string>): boolean;
-/** Accessors for every header with `isEssential` in the tree (including nested). */
-export declare function collectEssentialAccessors(headers: HeaderObject[]): Set<string>;
-/** Within one sibling list: all essential columns must form a left prefix. */
-export declare function hasEssentialPrefixOrder(siblings: HeaderObject[], essentialAccessors: ReadonlySet<string>): boolean;
-/** Root array mixes pin sections; validate each pin group separately, then recurse into children. */
-export declare function validateFullHeaderTreeEssentialOrder(headers: HeaderObject[], essentialAccessors: ReadonlySet<string>): boolean;
-export declare function getPinnedSectionsState(headers: HeaderObject[]): PinnedSectionsState;
-/**
- * Rebuilds root `headers` order and `pinned` flags from section accessor lists.
- * Clamps essential columns to the left within each section. Returns null if accessors don't match roots.
- */
-export declare function rebuildHeadersFromPinnedState(headers: HeaderObject[], state: PinnedSectionsState, essentialAccessors: ReadonlySet<string>): HeaderObject[] | null;
-/**
- * Move a root column to another pin section.
- * Appends within left/right targets. For `main`, left-pinned columns are inserted at the
- * start of main; right-pinned (and other) columns are inserted at the end of main.
- */
-export declare function moveRootColumnPinSide(headers: HeaderObject[], accessor: Accessor, target: Exclude<PanelSection, "main"> | "main", essentialAccessors: ReadonlySet<string>): HeaderObject[] | null;
+import HeaderObject, { Accessor } from "../types/HeaderObject";
+import { PinnedSectionsState } from "../types/PinnedSectionsState";
+import { PanelSection } from "../types/PanelSection";
+export type { PinnedSectionsState, PanelSection };
+/** Root-level columns only, preserving order within each pin group. */
+export declare function partitionRootHeadersByPin(headers: HeaderObject[]): {
+    pinnedLeft: HeaderObject[];
+    unpinned: HeaderObject[];
+    pinnedRight: HeaderObject[];
+};
+export declare function isHeaderEssential(header: HeaderObject, essentialAccessors: ReadonlySet<string>): boolean;
+/** Accessors for every header with `isEssential` in the tree (including nested). */
+export declare function collectEssentialAccessors(headers: HeaderObject[]): Set<string>;
+/** Within one sibling list: all essential columns must form a left prefix. */
+export declare function hasEssentialPrefixOrder(siblings: HeaderObject[], essentialAccessors: ReadonlySet<string>): boolean;
+/** Root array mixes pin sections; validate each pin group separately, then recurse into children. */
+export declare function validateFullHeaderTreeEssentialOrder(headers: HeaderObject[], essentialAccessors: ReadonlySet<string>): boolean;
+export declare function getPinnedSectionsState(headers: HeaderObject[]): PinnedSectionsState;
+/**
+ * Rebuilds root `headers` order and `pinned` flags from section accessor lists.
+ * Clamps essential columns to the left within each section. Returns null if accessors don't match roots.
+ */
+export declare function rebuildHeadersFromPinnedState(headers: HeaderObject[], state: PinnedSectionsState, essentialAccessors: ReadonlySet<string>): HeaderObject[] | null;
+/**
+ * Move a root column to another pin section.
+ * Appends within left/right targets. For `main`, left-pinned columns are inserted at the
+ * start of main; right-pinned (and other) columns are inserted at the end of main.
+ */
+export declare function moveRootColumnPinSide(headers: HeaderObject[], accessor: Accessor, target: Exclude<PanelSection, "main"> | "main", essentialAccessors: ReadonlySet<string>): HeaderObject[] | null;

package/dist/{cjs/src/utils → utils}/pivot/pivotRows.d.ts

@@ -1,16 +1,16 @@
-import type HeaderObject from "../../types/HeaderObject";
-import type { Accessor } from "../../types/HeaderObject";
-import type Row from "../../types/Row";
-import type { PivotConfig, PivotResult } from "../../types/PivotTypes";
-export type PivotRowsProps = {
-    rows: Row[];
-    pivot: PivotConfig;
-    /** Field catalog (`defaultHeaders`) for labels, types, widths, formatters. */
-    fieldHeaders: HeaderObject[];
-};
-export declare const buildPivotAccessor: (colKey: string, valueAccessor: Accessor) => string;
-export declare const buildPivotRowTotalAccessor: (valueAccessor: Accessor) => string;
-/**
- * Pure transform: flat source rows + pivot config → pivoted rows and generated headers.
- */
-export declare const pivotRows: ({ rows, pivot, fieldHeaders }: PivotRowsProps) => PivotResult;
+import type HeaderObject from "../../types/HeaderObject";
+import type { Accessor } from "../../types/HeaderObject";
+import type Row from "../../types/Row";
+import type { PivotConfig, PivotResult } from "../../types/PivotTypes";
+export type PivotRowsProps = {
+    rows: Row[];
+    pivot: PivotConfig;
+    /** Field catalog (`defaultHeaders`) for labels, types, widths, formatters. */
+    fieldHeaders: HeaderObject[];
+};
+export declare const buildPivotAccessor: (colKey: string, valueAccessor: Accessor) => string;
+export declare const buildPivotRowTotalAccessor: (valueAccessor: Accessor) => string;
+/**
+ * Pure transform: flat source rows + pivot config → pivoted rows and generated headers.
+ */
+export declare const pivotRows: ({ rows, pivot, fieldHeaders }: PivotRowsProps) => PivotResult;

package/dist/{src/utils → utils}/propSyncEqual.d.ts

@@ -1,60 +1,60 @@
-/**
- * Shared prop-sync helpers for framework adapters.
- * Used to skip no-op `defaultHeaders` / `rows` updates when consumers rebuild
- * column configs or shallow-clone rows every render.
- */
-import type { GetRowIdParams } from "../types/GetRowId";
-/** Minimal header shape for structural comparison (renderers ignored). */
-export type HeaderStructureLike = {
-    accessor: string | number | symbol;
-    width?: number | string;
-    minWidth?: number | string;
-    maxWidth?: number | string;
-    label?: string;
-    type?: string;
-    pinned?: string | boolean | null;
-    hide?: boolean;
-    isSortable?: boolean;
-    filterable?: boolean;
-    align?: string;
-    collapsible?: boolean;
-    collapseDefault?: boolean;
-    showWhen?: string;
-    isEditable?: boolean;
-    isEssential?: boolean;
-    disableReorder?: boolean;
-    expandable?: boolean;
-    excludeFromRender?: boolean;
-    autoSizeMode?: string;
-    tooltip?: string;
-    quickFilterable?: boolean;
-    filterOperators?: ReadonlyArray<string>;
-    children?: ReadonlyArray<HeaderStructureLike>;
-};
-/**
- * True when two header trees describe the same columns (accessors, widths,
- * flags, nesting). Ignores renderer identity.
- */
-export declare function headersStructurallyEqual(a: ReadonlyArray<HeaderStructureLike> | undefined, b: ReadonlyArray<HeaderStructureLike> | undefined): boolean;
-/** Collect every accessor in a header tree (for renderer-cache pruning). */
-export declare function collectHeaderAccessors(headers: ReadonlyArray<HeaderStructureLike>, into?: Set<string>): Set<string>;
-/**
- * Shallow equality of a single row object (own enumerable keys, `===` values).
- * Identical references are equal. In-place mutation on a shared object is
- * invisible — callers must pass new object identities when data changes.
- */
-export declare function shallowEqualRow(a: object, b: object): boolean;
-/** Compatible with `GetRowId`; return may be nullish for sync helpers. */
-export type GetRowIdLike = (params: GetRowIdParams) => string | number | null | undefined;
-/**
- * Above this length, skip per-field shallow compares when row object identity
- * differs. Same-array-ref and same-row-object cases stay O(1) / O(n) pointer
- * checks. Protects huge client datasets from O(n × fields) scans.
- */
-export declare const SHALLOW_ROW_COMPARE_MAX = 50000;
-/**
- * True when `next` is a no-op relative to `prev` for table sync:
- * same length, matching `getRowId` sequence (when provided), and each row
- * either the same object or shallow-equal (for modest list sizes).
- */
-export declare function rowsShallowUnchanged(prev: ReadonlyArray<object> | undefined, next: ReadonlyArray<object> | undefined, getRowId?: GetRowIdLike): boolean;
+/**
+ * Shared prop-sync helpers for framework adapters.
+ * Used to skip no-op `defaultHeaders` / `rows` updates when consumers rebuild
+ * column configs or shallow-clone rows every render.
+ */
+import type { GetRowIdParams } from "../types/GetRowId";
+/** Minimal header shape for structural comparison (renderers ignored). */
+export type HeaderStructureLike = {
+    accessor: string | number | symbol;
+    width?: number | string;
+    minWidth?: number | string;
+    maxWidth?: number | string;
+    label?: string;
+    type?: string;
+    pinned?: string | boolean | null;
+    hide?: boolean;
+    isSortable?: boolean;
+    filterable?: boolean;
+    align?: string;
+    collapsible?: boolean;
+    collapseDefault?: boolean;
+    showWhen?: string;
+    isEditable?: boolean;
+    isEssential?: boolean;
+    disableReorder?: boolean;
+    expandable?: boolean;
+    excludeFromRender?: boolean;
+    autoSizeMode?: string;
+    tooltip?: string;
+    quickFilterable?: boolean;
+    filterOperators?: ReadonlyArray<string>;
+    children?: ReadonlyArray<HeaderStructureLike>;
+};
+/**
+ * True when two header trees describe the same columns (accessors, widths,
+ * flags, nesting). Ignores renderer identity.
+ */
+export declare function headersStructurallyEqual(a: ReadonlyArray<HeaderStructureLike> | undefined, b: ReadonlyArray<HeaderStructureLike> | undefined): boolean;
+/** Collect every accessor in a header tree (for renderer-cache pruning). */
+export declare function collectHeaderAccessors(headers: ReadonlyArray<HeaderStructureLike>, into?: Set<string>): Set<string>;
+/**
+ * Shallow equality of a single row object (own enumerable keys, `===` values).
+ * Identical references are equal. In-place mutation on a shared object is
+ * invisible — callers must pass new object identities when data changes.
+ */
+export declare function shallowEqualRow(a: object, b: object): boolean;
+/** Compatible with `GetRowId`; return may be nullish for sync helpers. */
+export type GetRowIdLike = (params: GetRowIdParams) => string | number | null | undefined;
+/**
+ * Above this length, skip per-field shallow compares when row object identity
+ * differs. Same-array-ref and same-row-object cases stay O(1) / O(n) pointer
+ * checks. Protects huge client datasets from O(n × fields) scans.
+ */
+export declare const SHALLOW_ROW_COMPARE_MAX = 50000;
+/**
+ * True when `next` is a no-op relative to `prev` for table sync:
+ * same length, matching `getRowId` sequence (when provided), and each row
+ * either the same object or shallow-equal (for modest list sizes).
+ */
+export declare function rowsShallowUnchanged(prev: ReadonlyArray<object> | undefined, next: ReadonlyArray<object> | undefined, getRowId?: GetRowIdLike): boolean;

package/dist/{cjs/src/utils → utils}/quickFilterUtils.d.ts

@@ -1,14 +1,14 @@
-import { SmartFilterToken } from "../types/QuickFilterTypes";
-/**
- * Parses a smart filter query into tokens
- * Supports:
- * - Multi-word: "john engineer" → matches rows containing both "john" AND "engineer"
- * - Phrase: "john doe" → matches exact phrase
- * - Negation: -inactive → excludes rows containing "inactive"
- * - Column-specific: name:john → searches only in name column
- */
-export declare const parseSmartFilter: (query: string) => SmartFilterToken[];
-/**
- * Checks if a value matches a simple filter (case-insensitive contains)
- */
-export declare const matchesSimpleFilter: (value: string, filterText: string, caseSensitive: boolean) => boolean;
+import { SmartFilterToken } from "../types/QuickFilterTypes";
+/**
+ * Parses a smart filter query into tokens
+ * Supports:
+ * - Multi-word: "john engineer" → matches rows containing both "john" AND "engineer"
+ * - Phrase: "john doe" → matches exact phrase
+ * - Negation: -inactive → excludes rows containing "inactive"
+ * - Column-specific: name:john → searches only in name column
+ */
+export declare const parseSmartFilter: (query: string) => SmartFilterToken[];
+/**
+ * Checks if a value matches a simple filter (case-insensitive contains)
+ */
+export declare const matchesSimpleFilter: (value: string, filterText: string, caseSensitive: boolean) => boolean;

package/dist/{src/utils → utils}/resizeUtils/autoExpandResize.d.ts

@@ -1,32 +1,32 @@
-import type HeaderObject from "../../types/HeaderObject";
-import type { Pinned } from "../../types/Pinned";
-/**
- * Handle resize with autoExpandColumns enabled.
- *
- * Neighbors compensate a growing column only down to their shrink floor (their
- * natural width — declared, content-measured, or user-set). Once all
- * neighbors are at their floor, the main section keeps growing past the
- * container width and overflows into horizontal scroll instead of blocking
- * the drag. Pinned sections cannot scroll their own content, so their growth
- * stays capped by the neighbors' available surplus (plus the pinned-width
- * policy cap).
- */
-export declare const handleResizeWithAutoExpand: ({ childrenToResize, collapsedHeaders, containerWidth, delta, headers, initialWidthsMap, isParentResize, resizedHeader, reverse, rootPinned, sectionHeaders, sectionWidth, sectionViewportWidth, shrinkFloors, startWidth, }: {
-    childrenToResize?: HeaderObject[] | undefined;
-    collapsedHeaders?: Set<string> | undefined;
-    containerWidth: number;
-    delta: number;
-    headers: HeaderObject[];
-    initialWidthsMap: Map<string, number>;
-    isParentResize?: boolean | undefined;
-    resizedHeader: HeaderObject;
-    reverse: boolean;
-    rootPinned: Pinned | undefined;
-    sectionHeaders: HeaderObject[];
-    sectionWidth: number;
-    /** Visible viewport width of the section (main: container minus pinned). 0 when unknown. */
-    sectionViewportWidth?: number | undefined;
-    /** Accessor -> natural width; the shrink floor for compensating neighbors. */
-    shrinkFloors?: Map<string, number> | undefined;
-    startWidth: number;
-}) => void;
+import type HeaderObject from "../../types/HeaderObject";
+import type { Pinned } from "../../types/Pinned";
+/**
+ * Handle resize with autoExpandColumns enabled.
+ *
+ * Neighbors compensate a growing column only down to their shrink floor (their
+ * natural width — declared, content-measured, or user-set). Once all
+ * neighbors are at their floor, the main section keeps growing past the
+ * container width and overflows into horizontal scroll instead of blocking
+ * the drag. Pinned sections cannot scroll their own content, so their growth
+ * stays capped by the neighbors' available surplus (plus the pinned-width
+ * policy cap).
+ */
+export declare const handleResizeWithAutoExpand: ({ childrenToResize, collapsedHeaders, containerWidth, delta, headers, initialWidthsMap, isParentResize, resizedHeader, reverse, rootPinned, sectionHeaders, sectionWidth, sectionViewportWidth, shrinkFloors, startWidth, }: {
+    childrenToResize?: HeaderObject[];
+    collapsedHeaders?: Set<string>;
+    containerWidth: number;
+    delta: number;
+    headers: HeaderObject[];
+    initialWidthsMap: Map<string, number>;
+    isParentResize?: boolean;
+    resizedHeader: HeaderObject;
+    reverse: boolean;
+    rootPinned: Pinned | undefined;
+    sectionHeaders: HeaderObject[];
+    sectionWidth: number;
+    /** Visible viewport width of the section (main: container minus pinned). 0 when unknown. */
+    sectionViewportWidth?: number;
+    /** Accessor -> natural width; the shrink floor for compensating neighbors. */
+    shrinkFloors?: Map<string, number>;
+    startWidth: number;
+}) => void;

package/dist/{cjs/src/utils → utils}/resizeUtils/compensation.d.ts

@@ -1,17 +1,17 @@
-import type HeaderObject from "../../types/HeaderObject";
-/**
- * Distribute compensation among columns proportionally based on available headroom
- * Used in autoExpandColumns mode
- * Positive compensation = shrink columns, Negative compensation = grow columns
- *
- * `shrinkFloors` (accessor -> px) sets each column's shrink floor — its natural
- * width (declared, content-measured, or user-set). Columns give up only their
- * surplus (expanded) space and are never squeezed below their natural width.
- * Falls back to MIN_COLUMN_WIDTH when a column has no known floor.
- */
-export declare const distributeCompensationProportionally: ({ columnsToShrink, totalCompensation, initialWidthsMap, shrinkFloors, }: {
-    columnsToShrink: HeaderObject[];
-    totalCompensation: number;
-    initialWidthsMap: Map<string, number>;
-    shrinkFloors?: Map<string, number> | undefined;
-}) => void;
+import type HeaderObject from "../../types/HeaderObject";
+/**
+ * Distribute compensation among columns proportionally based on available headroom
+ * Used in autoExpandColumns mode
+ * Positive compensation = shrink columns, Negative compensation = grow columns
+ *
+ * `shrinkFloors` (accessor -> px) sets each column's shrink floor — its natural
+ * width (declared, content-measured, or user-set). Columns give up only their
+ * surplus (expanded) space and are never squeezed below their natural width.
+ * Falls back to MIN_COLUMN_WIDTH when a column has no known floor.
+ */
+export declare const distributeCompensationProportionally: ({ columnsToShrink, totalCompensation, initialWidthsMap, shrinkFloors, }: {
+    columnsToShrink: HeaderObject[];
+    totalCompensation: number;
+    initialWidthsMap: Map<string, number>;
+    shrinkFloors?: Map<string, number>;
+}) => void;

package/dist/{src/utils → utils}/resizeUtils/domUpdates.d.ts

@@ -1,15 +1,15 @@
-import type HeaderObject from "../../types/HeaderObject";
-import type { Pinned } from "../../types/Pinned";
-/**
- * Get the pinned value from the root header (for nested headers, children inherit from parent)
- */
-export declare const getRootPinned: (header: HeaderObject, headers: HeaderObject[]) => Pinned | undefined;
-/**
- * Update column widths and positions directly in the DOM without triggering React re-renders
- * This is used during resize drag for better performance
- *
- * IMPORTANT: Positions are calculated per pinned section (left/main/right each start at 0)
- * @param collapsedHeaders - Set of collapsed header accessors; only visible children are laid out (matches findLeafHeaders / SectionRenderer).
- * @param overrideWidths - Optional map of accessor -> width to use for position calculation (e.g. after resize so DOM reflects just-set value)
- */
-export declare const updateColumnWidthsInDOM: (headers: HeaderObject[], collapsedHeaders?: Set<string>, overrideWidths?: Map<string, number>) => void;
+import type HeaderObject from "../../types/HeaderObject";
+import type { Pinned } from "../../types/Pinned";
+/**
+ * Get the pinned value from the root header (for nested headers, children inherit from parent)
+ */
+export declare const getRootPinned: (header: HeaderObject, headers: HeaderObject[]) => Pinned | undefined;
+/**
+ * Update column widths and positions directly in the DOM without triggering React re-renders
+ * This is used during resize drag for better performance
+ *
+ * IMPORTANT: Positions are calculated per pinned section (left/main/right each start at 0)
+ * @param collapsedHeaders - Set of collapsed header accessors; only visible children are laid out (matches findLeafHeaders / SectionRenderer).
+ * @param overrideWidths - Optional map of accessor -> width to use for position calculation (e.g. after resize so DOM reflects just-set value)
+ */
+export declare const updateColumnWidthsInDOM: (headers: HeaderObject[], collapsedHeaders?: Set<string>, overrideWidths?: Map<string, number>) => void;

package/dist/{cjs/src/utils → utils}/resizeUtils/index.d.ts

@@ -1,26 +1,26 @@
-import type HeaderObject from "../../types/HeaderObject";
-import type { Accessor } from "../../types/HeaderObject";
-import type { HandleResizeStartProps } from "../../types/HandleResizeStartProps";
-/**
- * Handler for when resize dragging starts
- */
-export declare const handleResizeStart: ({ autoExpandColumns, collapsedHeaders, containerWidth, event, header, headers, mainBodyRef, onColumnWidthChange, onAutoExpandNaturalWidths, reverse, setHeaders, setIsResizing, shrinkFloors, startWidth, }: HandleResizeStartProps) => void;
-export type ApplyColumnAutoFitWithAutoExpandParams = {
-    collapsedHeaders: Set<Accessor>;
-    containerWidth: number;
-    getTargetLeafWidth: (leafHeader: HeaderObject) => number;
-    header: HeaderObject;
-    headerCellElement: HTMLElement | null;
-    headers: HeaderObject[];
-    mainBodyRef: HandleResizeStartProps["mainBodyRef"];
-    /** Persist the auto-fitted column(s)' widths as their natural widths. */
-    onAutoExpandNaturalWidths?: (widths: Map<string, number>) => void;
-    reverse: boolean;
-    /** Natural-width shrink floors (accessor -> px) for compensating neighbors. */
-    shrinkFloors?: Map<string, number>;
-};
-/**
- * Apply a one-shot "fit to content" width for a column while preserving autoExpand
- * compensation (same redistribution rules as dragging the resize handle).
- */
-export declare const applyColumnAutoFitWithAutoExpand: ({ header, headers, collapsedHeaders, containerWidth, mainBodyRef, reverse, headerCellElement, getTargetLeafWidth, onAutoExpandNaturalWidths, shrinkFloors, }: ApplyColumnAutoFitWithAutoExpandParams) => void;
+import type HeaderObject from "../../types/HeaderObject";
+import type { Accessor } from "../../types/HeaderObject";
+import type { HandleResizeStartProps } from "../../types/HandleResizeStartProps";
+/**
+ * Handler for when resize dragging starts
+ */
+export declare const handleResizeStart: ({ autoExpandColumns, collapsedHeaders, containerWidth, event, header, headers, mainBodyRef, onColumnWidthChange, onAutoExpandNaturalWidths, reverse, setHeaders, setIsResizing, shrinkFloors, startWidth, }: HandleResizeStartProps) => void;
+export type ApplyColumnAutoFitWithAutoExpandParams = {
+    collapsedHeaders: Set<Accessor>;
+    containerWidth: number;
+    getTargetLeafWidth: (leafHeader: HeaderObject) => number;
+    header: HeaderObject;
+    headerCellElement: HTMLElement | null;
+    headers: HeaderObject[];
+    mainBodyRef: HandleResizeStartProps["mainBodyRef"];
+    /** Persist the auto-fitted column(s)' widths as their natural widths. */
+    onAutoExpandNaturalWidths?: (widths: Map<string, number>) => void;
+    reverse: boolean;
+    /** Natural-width shrink floors (accessor -> px) for compensating neighbors. */
+    shrinkFloors?: Map<string, number>;
+};
+/**
+ * Apply a one-shot "fit to content" width for a column while preserving autoExpand
+ * compensation (same redistribution rules as dragging the resize handle).
+ */
+export declare const applyColumnAutoFitWithAutoExpand: ({ header, headers, collapsedHeaders, containerWidth, mainBodyRef, reverse, headerCellElement, getTargetLeafWidth, onAutoExpandNaturalWidths, shrinkFloors, }: ApplyColumnAutoFitWithAutoExpandParams) => void;

package/dist/{src/utils → utils}/resizeUtils/maxWidth.d.ts

@@ -1,9 +1,9 @@
-import type HeaderObject from "../../types/HeaderObject";
-/**
- * Calculate the maximum allowable width for a header based on container constraints
- */
-export declare const calculateMaxHeaderWidth: ({ header, headers, collapsedHeaders, }: {
-    header: HeaderObject;
-    headers: HeaderObject[];
-    collapsedHeaders?: Set<string> | undefined;
-}) => number;
+import type HeaderObject from "../../types/HeaderObject";
+/**
+ * Calculate the maximum allowable width for a header based on container constraints
+ */
+export declare const calculateMaxHeaderWidth: ({ header, headers, collapsedHeaders, }: {
+    header: HeaderObject;
+    headers: HeaderObject[];
+    collapsedHeaders?: Set<string>;
+}) => number;