simple-table-core 3.8.6 → 3.8.8

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

@@ -13,11 +13,32 @@ export declare class SimpleTableVanilla {
     private hoveredHeaderRef;
     private localRows;
     private headers;
+    /**
+     * Pristine deep-cloned snapshot of the column definitions as configured
+     * (constructor / update with `defaultHeaders`). `this.headers` shares object
+     * references with `config.defaultHeaders` at mount, and the column editor
+     * mutates header objects in place (e.g. `header.hide = true`) — so
+     * `config.defaultHeaders` drifts with runtime state and cannot serve as the
+     * reset target. `resetColumns()` restores from this snapshot instead, giving
+     * a well-defined default: every column visible except those explicitly
+     * configured with `hide: true` in the definitions.
+     */
+    private pristineDefaultHeaders;
     private essentialAccessors;
     /** Accessors of leaf columns that should size to content (width:"auto" or autoSizeColumns). */
     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;
@@ -268,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;
     /**
@@ -276,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/src/core/api/TableAPIImpl.d.ts

@@ -14,6 +14,8 @@ export interface TableAPIContext {
     localRows: Row[];
     effectiveHeaders: HeaderObject[];
     headers: HeaderObject[];
+    /** Pristine snapshot of the configured column definitions (see SimpleTableVanilla.pristineDefaultHeaders). */
+    getPristineDefaultHeaders: () => HeaderObject[];
     essentialAccessors: Set<string>;
     customTheme: CustomTheme;
     currentPage: number;

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

@@ -44,6 +44,8 @@ export interface RenderContext {
     getCollapsedHeaders?: () => Set<Accessor>;
     getExpandedRows: () => Map<string, number>;
     getHeaders: () => HeaderObject[];
+    /** Pristine snapshot of the configured column definitions — the reset target for the column editor's reset button. */
+    getPristineDefaultHeaders: () => HeaderObject[];
     getRowStateMap: () => Map<string | number, RowState>;
     headerRegistry: Map<string, any>;
     headers: HeaderObject[];
@@ -62,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/src/core/rendering/TableRenderer.d.ts

@@ -41,6 +41,8 @@ export interface TableRendererDeps {
     getCollapsedRows: () => Map<string, number>;
     getExpandedRows: () => Map<string, number>;
     getHeaders: () => HeaderObject[];
+    /** Pristine snapshot of the configured column definitions — the reset target for the column editor's reset button. */
+    getPristineDefaultHeaders: () => HeaderObject[];
     getRowStateMap: () => Map<string | number, any>;
     headerRegistry: Map<string, any>;
     headers: HeaderObject[];
@@ -57,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/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/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/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/src/types/TableAPI.d.ts

@@ -47,7 +47,12 @@ export type TableAPI = {
     applyColumnVisibility: (visibility: {
         [accessor: string]: boolean;
     }) => Promise<void>;
-    /** Reset columns to default order and visibility (restores defaultHeaders state). */
+    /**
+     * Reset columns to the configured definitions: default order, widths, and
+     * visibility. All columns become visible again except those explicitly
+     * defined with `hide: true` in `defaultHeaders`, regardless of any runtime
+     * visibility changes made since mount.
+     */
     resetColumns: () => void;
     setQuickFilter: (text: string) => void;
     getSelectedCells: () => Set<string>;

package/dist/src/types/Theme.d.ts

@@ -1,2 +1,2 @@
-type Theme = "light" | "dark" | "sky" | "violet" | "neutral" | "custom" | "frost" | "modern-light" | "modern-dark";
+type Theme = "light" | "dark" | "neutral" | "custom" | "modern-light" | "modern-dark";
 export default Theme;

package/dist/src/utils/charts/createBarChart.d.ts

@@ -8,6 +8,11 @@ export interface BarChartProps {
     min?: number;
     max?: number;
 }
+/**
+ * Renders a sparkline bar chart in pixel space: the viewBox always matches the
+ * actual rendered size (tracked via ResizeObserver), and bar edges are snapped
+ * to whole pixels so bars and gaps stay uniform and crisp at any column width.
+ */
 export declare const createBarChart: (options: BarChartProps) => {
     element: SVGSVGElement;
     update: (newOptions: Partial<BarChartProps>) => void;

package/dist/src/utils/charts/createLineAreaChart.d.ts

@@ -10,6 +10,14 @@ export interface LineAreaChartProps {
     min?: number;
     max?: number;
 }
+/**
+ * Renders a sparkline line/area chart in pixel space: the viewBox always
+ * matches the actual rendered size (tracked via ResizeObserver), so the stroke
+ * keeps a uniform width instead of being smeared by non-uniform scaling. The
+ * line is inset by half the stroke width so peaks and valleys aren't clipped,
+ * and the area is filled with a vertical gradient that fades toward the
+ * baseline.
+ */
 export declare const createLineAreaChart: (options: LineAreaChartProps) => {
     element: SVGSVGElement;
     update: (newOptions: Partial<LineAreaChartProps>) => void;

package/dist/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/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/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/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)
@@ -95,4 +90,10 @@ export declare const calculateHeaderContentWidth: (accessor: Accessor, options?:
     theme?: any;
     /** Scope `.st-cell-content` font/padding sampling to this table instance */
     styleRoot?: ParentNode | null;
+    /**
+     * The table's resolved sort icon. Used to reserve space on sortable columns
+     * that are not currently sorted (the icon only exists on the active sort
+     * column), so sorting later does not push the label into ellipsis.
+     */
+    sortIcon?: string | HTMLElement | SVGSVGElement;
 }) => number;

package/dist/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/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/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/stories/examples/music/MusicExample.d.ts

@@ -3,7 +3,7 @@ export declare const musicExampleDefaults: {
     columnReordering: boolean;
     columnResizing: boolean;
     selectableCells: boolean;
-    theme: "frost";
+    theme: "modern-light";
     customTheme: {
         rowHeight: number;
         headerHeight: number;

package/dist/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/stories/tests/32-ThemesTests.stories.d.ts

@@ -1,6 +1,6 @@
 /**
  * THEMES TESTS
- * Tests for SimpleTable theme prop (light, dark, sky, violet, etc.).
+ * Tests for SimpleTable theme prop (light, dark, neutral, modern-light, modern-dark).
  */
 import type { Meta } from "@storybook/html";
 declare const meta: Meta;
@@ -21,22 +21,6 @@ export declare const ThemeDark: {
         canvasElement: HTMLElement;
     }) => Promise<void>;
 };
-export declare const ThemeSky: {
-    render: () => HTMLDivElement & {
-        _table?: import("../../src/index").SimpleTableVanilla | undefined;
-    };
-    play: ({ canvasElement }: {
-        canvasElement: HTMLElement;
-    }) => Promise<void>;
-};
-export declare const ThemeViolet: {
-    render: () => HTMLDivElement & {
-        _table?: import("../../src/index").SimpleTableVanilla | undefined;
-    };
-    play: ({ canvasElement }: {
-        canvasElement: HTMLElement;
-    }) => Promise<void>;
-};
 export declare const ThemeModernLight: {
     render: () => HTMLDivElement & {
         _table?: import("../../src/index").SimpleTableVanilla | undefined;

package/dist/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/stories/tests/46-AutoSizeColumnsTests.stories.d.ts

@@ -84,6 +84,28 @@ export declare const AutoSizeMeasuresCustomRenderer: {
         canvasElement: HTMLElement;
     }) => Promise<void>;
 };
+export declare const AutoSizeMeasuresCustomHeaderRenderer: {
+    parameters: {
+        tags: string[];
+    };
+    render: () => HTMLDivElement & {
+        _table?: SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
+export declare const AutoSizeSortIconDoesNotTruncateLabel: {
+    parameters: {
+        tags: string[];
+    };
+    render: () => HTMLDivElement & {
+        _table?: SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
 export declare const AutoSizeMeasuresFormattedValue: {
     parameters: {
         tags: string[];
@@ -249,6 +271,37 @@ export declare const AutoSizeNoFlicker: {
         canvasElement: HTMLElement;
     }) => Promise<void>;
 };
+export declare const AutoSizeAsyncRendererInternalTruncation: {
+    parameters: {
+        tags: string[];
+    };
+    render: () => HTMLDivElement & {
+        _table?: SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
+export declare const AutoSizeConsistentAcrossContainerWidths: {
+    parameters: {
+        tags: string[];
+    };
+    render: () => HTMLDivElement;
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
+export declare const AutoSizeEmptyStateAsyncHeaderRenderer: {
+    parameters: {
+        tags: string[];
+    };
+    render: () => HTMLDivElement & {
+        _table?: SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
 export declare const SamplingAndOutlierHelpers: {
     parameters: {
         tags: string[];

package/dist/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>;
+};