simple-table-core 3.8.7 → 3.8.9

package/dist/cjs/src/core/SimpleTableVanilla.d.ts

@@ -29,6 +29,16 @@ export declare class SimpleTableVanilla {
     private autoSizeAccessors;
     /** Accessors awaiting a content-fit measurement on the next render. */
     private pendingAutoSize;
+    /**
+     * Natural (unexpanded) pixel width per leaf column, overriding the declared
+     * width: the measured content width for `width: "auto"` columns and the
+     * width the user explicitly set via drag-resize / double-click auto-fit.
+     * With autoExpandColumns these feed the shrink floors used during column
+     * resize — neighbors give up surplus (expanded) space but are never
+     * squeezed below their natural width; past that point the section
+     * overflows into horizontal scroll.
+     */
+    private naturalWidths;
     /** Guard against re-entrancy while the auto-size pass re-renders. */
     private isAutoSizing;
     private currentPage;
@@ -279,6 +289,17 @@ export declare class SimpleTableVanilla {
      * every auto column's width.
      */
     private getAutoSizeRows;
+    /**
+     * Shrink floors for auto-expand column resize, keyed by accessor. Each
+     * visible leaf's floor is its natural width — a user-set / content-measured
+     * override when present, else the pixel width declared in the column
+     * definitions — raised to at least its `minWidth` (or the global minimum).
+     * Flexible declarations (fr / % / unmeasured "auto") have no pixel natural,
+     * so they floor at `minWidth` alone.
+     */
+    private getShrinkFloors;
+    /** Record user-set / measured widths as the columns' new natural widths. */
+    private recordNaturalWidths;
     /** Immutably write measured pixel widths into the leaf headers. */
     private applyMeasuredWidths;
     /**
@@ -287,6 +308,11 @@ export declare class SimpleTableVanilla {
      * measurement reads the just-rendered (provisional-width) DOM and the
      * corrective render happens in the same synchronous task, so there is no
      * visible width snap.
+     *
+     * With autoExpandColumns, the measured width becomes the column's natural
+     * width: the expand-only auto-scale pass in the corrective render stretches
+     * columns to fill surplus container space, or leaves them at natural width
+     * (horizontal scroll) when they don't fit.
      */
     private maybeAutoSizeColumns;
     /**

package/dist/cjs/src/core/rendering/RenderOrchestrator.d.ts

@@ -64,6 +64,10 @@ export interface RenderContext {
         current: HTMLDivElement | null;
     };
     onRender: () => void;
+    /** Natural-width shrink floors (accessor -> px) for auto-expand column resize. */
+    getShrinkFloors?: () => Map<string, number>;
+    /** Persist user-set widths (drag / double-click auto-fit) as natural widths. */
+    onAutoExpandNaturalWidths?: (widths: Map<string, number>) => void;
     pinnedLeftHeaderRef: {
         current: HTMLDivElement | null;
     };

package/dist/cjs/src/core/rendering/TableRenderer.d.ts

@@ -59,6 +59,10 @@ export interface TableRendererDeps {
         current: HTMLDivElement | null;
     };
     onRender: () => void;
+    /** Natural-width shrink floors (accessor -> px) for auto-expand column resize. */
+    getShrinkFloors?: () => Map<string, number>;
+    /** Persist user-set widths (drag / double-click auto-fit) as natural widths. */
+    onAutoExpandNaturalWidths?: (widths: Map<string, number>) => void;
     pinnedLeftHeaderRef: {
         current: HTMLDivElement | null;
     };

package/dist/cjs/src/types/HandleResizeStartProps.d.ts

@@ -12,10 +12,14 @@ export type HandleResizeStartProps = {
     headers: HeaderObject[];
     mainBodyRef: RefObject<HTMLDivElement>;
     onColumnWidthChange?: (headers: HeaderObject[]) => void;
+    /** Persist the dragged column(s)' final widths as their natural widths (autoExpandColumns). */
+    onAutoExpandNaturalWidths?: (widths: Map<string, number>) => void;
     pinnedLeftRef: RefObject<HTMLDivElement>;
     pinnedRightRef: RefObject<HTMLDivElement>;
     reverse: boolean;
     setHeaders: (headers: HeaderObject[] | ((prev: HeaderObject[]) => HeaderObject[])) => void;
     setIsResizing: (isResizing: boolean | ((prev: boolean) => boolean)) => void;
+    /** Natural-width shrink floors (accessor -> px) for compensating neighbors (autoExpandColumns). */
+    shrinkFloors?: Map<string, number>;
     startWidth: number;
 };

package/dist/cjs/src/types/HeaderObject.d.ts

@@ -121,7 +121,11 @@ type HeaderObject = {
     showWhen?: ShowWhen;
     /**
      * Column width. A number or px/fr/% string sets a fixed/proportional width.
-     * The special value `"auto"` sizes the column to fit its content (see `autoSizeMode`).
+     * The special value `"auto"` sizes the column to fit its content (see
+     * `autoSizeMode`). With `autoExpandColumns`, the fixed/measured width acts
+     * as the column's natural width: it can stretch to help fill surplus
+     * container space but is never squeezed narrower (the table scrolls
+     * horizontally instead).
      */
     width: number | string;
     maxWidth?: number | string;

package/dist/cjs/src/types/SimpleTableConfig.d.ts

@@ -22,6 +22,13 @@ import { AnimationsConfig } from "./AnimationsConfig";
 import type { FooterPosition } from "./FooterPosition";
 export interface SimpleTableConfig {
     animations?: AnimationsConfig;
+    /**
+     * Expand-only fill: when the columns' natural widths (declared px, or
+     * content-measured for `width: "auto"`) leave surplus container space,
+     * columns stretch proportionally to fill it (respecting `maxWidth`).
+     * Columns are never squeezed below their natural width — when they don't
+     * fit, the table scrolls horizontally instead.
+     */
     autoExpandColumns?: boolean;
     canExpandRowGroup?: (row: Row) => boolean;
     cellUpdateFlash?: boolean;

package/dist/cjs/src/utils/headerCell/resizing.d.ts

@@ -1,3 +1,3 @@
 import HeaderObject from "../../types/HeaderObject";
 import { HeaderRenderContext } from "./types";
-export declare const createResizeHandle: (header: HeaderObject, context: HeaderRenderContext, isLastMainAutoExpandColumn: boolean) => HTMLElement | null;
+export declare const createResizeHandle: (header: HeaderObject, context: HeaderRenderContext) => HTMLElement | null;

package/dist/cjs/src/utils/headerCell/styling.d.ts

@@ -1,7 +1,7 @@
 import { AbsoluteCell, HeaderRenderContext } from "./types";
-export declare const calculateHeaderCellClasses: (cell: AbsoluteCell, context: HeaderRenderContext, isLastMainAutoExpandColumn: boolean) => string;
-export declare const createHeaderCellElement: (cell: AbsoluteCell, context: HeaderRenderContext, isLastMainAutoExpandColumn: boolean) => HTMLElement;
+export declare const calculateHeaderCellClasses: (cell: AbsoluteCell, context: HeaderRenderContext) => string;
+export declare const createHeaderCellElement: (cell: AbsoluteCell, context: HeaderRenderContext) => HTMLElement;
 export declare const getLastHeaderIndex: (absoluteCells: AbsoluteCell[]) => number;
 /** Replace sort/filter/collapse icons on an existing header cell, preserving label/drag handlers. */
 export declare const refreshHeaderCellIcons: (cellElement: HTMLElement, header: AbsoluteCell["header"], context: HeaderRenderContext, colIndex: number) => void;
-export declare const updateHeaderCellElement: (cellElement: HTMLElement, cell: AbsoluteCell, context: HeaderRenderContext, isLastMainAutoExpandColumn: boolean) => void;
+export declare const updateHeaderCellElement: (cellElement: HTMLElement, cell: AbsoluteCell, context: HeaderRenderContext) => void;

package/dist/cjs/src/utils/headerCell/types.d.ts

@@ -38,6 +38,10 @@ export interface HeaderRenderContext {
     filters: TableFilterState;
     forceUpdate: () => void;
     getCollapsedHeaders?: () => Set<Accessor>; /** Get current collapsed headers (avoids stale closure in toggle handler). */
+    /** Natural-width shrink floors (accessor -> px) for auto-expand column resize. */
+    getShrinkFloors?: () => Map<string, number>;
+    /** Persist user-set widths (drag / double-click auto-fit) as natural widths. */
+    onAutoExpandNaturalWidths?: (widths: Map<string, number>) => void;
     handleApplyFilter: (filter: FilterCondition) => void;
     handleClearFilter: (accessor: Accessor) => void;
     handleSelectAll?: (checked: boolean) => void;

package/dist/cjs/src/utils/headerWidthUtils.d.ts

@@ -62,11 +62,6 @@ export declare const getHeaderMinWidth: (header: HeaderObject) => number;
  * Get all visible leaf headers from an array of headers
  */
 export declare const getAllVisibleLeafHeaders: (headers: HeaderObject[], collapsedHeaders?: Set<Accessor>) => HeaderObject[];
-/**
- * Convert pixel-based widths to proportional fr units
- * This is used when autoExpandColumns is enabled
- */
-export declare const convertPixelWidthsToFr: (headers: HeaderObject[], collapsedHeaders?: Set<Accessor>) => HeaderObject[];
 /**
  * Calculate the optimal width for a column by measuring both header and cell content
  * This is used for auto-sizing columns to fit their content (like Excel/Google Sheets)

package/dist/cjs/src/utils/resizeUtils/autoExpandResize.d.ts

@@ -1,10 +1,17 @@
 import type HeaderObject from "../../types/HeaderObject";
 import type { Pinned } from "../../types/Pinned";
 /**
- * Handle resize with autoExpandColumns enabled
- * Columns to the right (or left for right-pinned) shrink proportionally
+ * 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, startWidth, }: {
+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;
@@ -17,5 +24,9 @@ export declare const handleResizeWithAutoExpand: ({ childrenToResize, collapsedH
     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;

package/dist/cjs/src/utils/resizeUtils/compensation.d.ts

@@ -3,9 +3,15 @@ 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, }: {
+export declare const distributeCompensationProportionally: ({ columnsToShrink, totalCompensation, initialWidthsMap, shrinkFloors, }: {
     columnsToShrink: HeaderObject[];
     totalCompensation: number;
     initialWidthsMap: Map<string, number>;
+    shrinkFloors?: Map<string, number> | undefined;
 }) => void;

package/dist/cjs/src/utils/resizeUtils/index.d.ts

@@ -4,7 +4,7 @@ import type { HandleResizeStartProps } from "../../types/HandleResizeStartProps"
 /**
  * Handler for when resize dragging starts
  */
-export declare const handleResizeStart: ({ autoExpandColumns, collapsedHeaders, containerWidth, event, header, headers, mainBodyRef, onColumnWidthChange, reverse, setHeaders, setIsResizing, startWidth, }: HandleResizeStartProps) => void;
+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;
@@ -13,10 +13,14 @@ export type ApplyColumnAutoFitWithAutoExpandParams = {
     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, }: ApplyColumnAutoFitWithAutoExpandParams) => void;
+export declare const applyColumnAutoFitWithAutoExpand: ({ header, headers, collapsedHeaders, containerWidth, mainBodyRef, reverse, headerCellElement, getTargetLeafWidth, onAutoExpandNaturalWidths, shrinkFloors, }: ApplyColumnAutoFitWithAutoExpandParams) => void;

package/dist/cjs/stories/tests/08-ColumnWidthTests.stories.d.ts

@@ -45,7 +45,9 @@ export declare const AutoExpandColumnsBasic: {
         canvasElement: any;
     }) => Promise<void>;
 };
-export declare const AutoExpandColumnsIgnoresMinWidth: {
+/** Expand-only: when declared widths exceed the container, columns keep their
+ *  declared (natural) widths and the table scrolls horizontally — no squeeze. */
+export declare const AutoExpandColumnsNeverSqueezesBelowDeclaredWidth: {
     render: () => HTMLDivElement & {
         _table?: import("../../src/index").SimpleTableVanilla | undefined;
     };
@@ -53,7 +55,9 @@ export declare const AutoExpandColumnsIgnoresMinWidth: {
         canvasElement: any;
     }) => Promise<void>;
 };
-export declare const AutoExpandColumnsIgnoresMaxWidth: {
+/** Expansion respects maxWidth: capped columns stop at their cap and the
+ *  remaining surplus is redistributed to uncapped columns. */
+export declare const AutoExpandColumnsRespectsMaxWidthOnExpand: {
     render: () => HTMLDivElement & {
         _table?: import("../../src/index").SimpleTableVanilla | undefined;
     };

package/dist/cjs/stories/tests/39-AutoExpandColumnsTests.stories.d.ts

@@ -309,9 +309,10 @@ export declare const AutoExpandShrinkColumnToMinWidth: {
         canvasElement: HTMLElement;
     }) => Promise<void>;
 };
-/** Grow a column until all siblings hit minWidth.
- *  Growth should be clamped once there is no more shrinkable headroom. */
-export declare const AutoExpandGrowUntilSiblingsAtMin: {
+/** Grow a column far past what siblings can absorb. Siblings shrink only down
+ *  to their natural (declared) widths — never below — and the extra growth
+ *  overflows the container into horizontal scroll. */
+export declare const AutoExpandGrowPastSiblingFloorsOverflows: {
     parameters: {
         tags: string[];
     };
@@ -360,8 +361,10 @@ export declare const AutoExpandDoubleClickResizePinned: {
         canvasElement: HTMLElement;
     }) => Promise<void>;
 };
-/** Last main column under autoExpand: no resize handle; prior column still has a handle. */
-export declare const AutoExpandLastMainColumnNoResizeHandle: {
+/** The last main column keeps its resize handle under autoExpandColumns
+ *  (growth past the container is now possible via horizontal overflow).
+ *  Dragging it reclaims the left neighbor's expanded surplus first. */
+export declare const AutoExpandLastMainColumnHasResizeHandle: {
     parameters: {
         tags: string[];
     };

package/dist/cjs/stories/tests/49-AutoWidthAutoExpandTests.stories.d.ts

@@ -0,0 +1,151 @@
+/**
+ * AUTO WIDTH + AUTO EXPAND COLUMNS TESTS
+ *
+ * Combined coverage for `width: "auto"` columns under `autoExpandColumns`
+ * (the expand-only model):
+ * - surplus: content-measured natural widths stretched proportionally to fill
+ * - deficit: natural widths kept, horizontal scroll, never squeezed
+ * - container resize crossing the fit threshold both ways (no compounding)
+ * - drag-resize into horizontal overflow and back out of it
+ * - neighbor shrink floors at the measured (natural) width during drags
+ * - maxWidth caps during expansion with surplus redistribution
+ * - pinned + auto + autoExpand layout
+ * - data updates and pagination page changes re-measuring auto columns
+ * - double-click auto-fit under the expand-or-scroll model
+ */
+import { SimpleTableVanilla } from "../../src/index";
+import type { Meta } from "@storybook/html";
+declare const meta: Meta;
+export default meta;
+/** Surplus: auto column is content-measured, then all columns stretch
+ *  proportionally to fill the container. No horizontal scroll. */
+export declare const AutoWidthSurplusStretchesToFill: {
+    parameters: {
+        tags: string[];
+    };
+    render: () => HTMLDivElement & {
+        _table?: SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
+/** Deficit: the measured auto column plus fixed columns exceed the container.
+ *  Nothing is squeezed — natural widths are kept and the table scrolls. */
+export declare const AutoWidthDeficitScrollsNoSqueeze: {
+    parameters: {
+        tags: string[];
+    };
+    render: () => HTMLDivElement & {
+        _table?: SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
+/** Container resize across the fit threshold in both directions: shrink below
+ *  the natural total (scroll, naturals kept), then grow back (re-expand).
+ *  Widths must return to the original expanded values — no compounding. */
+export declare const AutoWidthContainerResizeNoCompounding: {
+    parameters: {
+        tags: string[];
+    };
+    render: () => HTMLDivElement & {
+        _table?: SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
+/** Drag a column into overflow (past the neighbors' natural floors), then drag
+ *  it back: the freed space first swallows the overflow, then refills the
+ *  neighbors, ending exactly full again. */
+export declare const AutoExpandDragIntoOverflowAndBack: {
+    parameters: {
+        tags: string[];
+    };
+    render: () => HTMLDivElement & {
+        _table?: SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
+/** During a drag, a `width: "auto"` neighbor gives up only its expanded
+ *  surplus: it shrinks down to its measured content width and no further. */
+export declare const AutoWidthNeighborFloorsAtMeasuredWidth: {
+    parameters: {
+        tags: string[];
+    };
+    render: () => HTMLDivElement & {
+        _table?: SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
+/** During expansion, capped columns (including a measured auto column with
+ *  maxWidth) stop at their cap; the surplus flows to the uncapped column. */
+export declare const AutoWidthMaxWidthCapsExpansion: {
+    parameters: {
+        tags: string[];
+    };
+    render: () => HTMLDivElement & {
+        _table?: SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
+/** A pinned-left auto column keeps its compact measured width (pinned sections
+ *  don't stretch); the main section expands to fill the remaining space. */
+export declare const AutoWidthPinnedAutoColumn: {
+    parameters: {
+        tags: string[];
+    };
+    render: () => HTMLDivElement & {
+        _table?: SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
+/** A data update that grows the auto column's content past the container
+ *  crosses from "expanded fill" into "natural widths + scroll". */
+export declare const AutoWidthDataUpdateGrowsPastThreshold: {
+    parameters: {
+        tags: string[];
+    };
+    render: () => HTMLDivElement & {
+        _table?: SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
+/** Pagination: each page re-measures the auto column against its own rows —
+ *  a compact page fills the container, a long-content page overflows. */
+export declare const AutoWidthPaginationRemeasuresPerPage: {
+    parameters: {
+        tags: string[];
+    };
+    render: () => HTMLDivElement & {
+        _table?: SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
+/** Double-click auto-fit sets the column to its content width (its new natural
+ *  width); the freed surplus flows to the neighbor and the table stays full. */
+export declare const AutoWidthDoubleClickAutoFit: {
+    parameters: {
+        tags: string[];
+    };
+    render: () => HTMLDivElement & {
+        _table?: SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};