simple-table-core 3.8.5 → 3.8.7

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

@@ -13,6 +13,17 @@ 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;
@@ -188,6 +199,14 @@ export declare class SimpleTableVanilla {
      * No-op when animations are disabled (which already includes the
      * prefers-reduced-motion check via {@link AnimationCoordinator.isEnabled}).
      */
+    /**
+     * Walk the CURRENT (pre-change) header tree and collect every accessor that
+     * is renderable as a header cell given the current collapsed/hidden state —
+     * group headers plus the leaf columns visible under them (honoring
+     * `showWhen` and the collapsed set). Used by {@link beginAccordionAnimation}
+     * to seed the animation coordinator's re-entry guard.
+     */
+    private collectAccordionRenderableAccessors;
     private beginAccordionAnimation;
     private initializeManagers;
     mount(): void;

package/dist/cjs/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/cjs/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[];
@@ -125,6 +127,7 @@ export declare class RenderOrchestrator {
     getLastProcessedResult(): ProcessRowsResult | null;
     /** See {@link TableRenderer.getCurrentBodyLayouts}. */
     getCurrentBodyLayouts(): Map<HTMLElement, Map<string, CellPosition>>;
+    setOnRendererHostDiscard(cb: ((host: HTMLElement) => void) | undefined): void;
     invalidateCache(type?: "body" | "header" | "context" | "all"): void;
     computeEffectiveHeaders(headers: HeaderObject[], config: SimpleTableConfig, customTheme: CustomTheme, containerWidth?: number): HeaderObject[];
     /**

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

@@ -44,6 +44,13 @@ export interface BodySectionParams {
 export declare class SectionRenderer {
     private headerSections;
     private bodySections;
+    /**
+     * Callback fired before a body cell host element is permanently removed in
+     * the {@link invalidateCache} "all" path (which wipes every rendered cell).
+     * Threaded down from the table config so framework adapters can tear down
+     * renderer subtrees (React portals, etc.) before the nodes are discarded.
+     */
+    private onRendererHostDiscard?;
     private bodyCellsCache;
     private headerCellsCache;
     private contextCache;
@@ -64,6 +71,7 @@ export declare class SectionRenderer {
     private getCachedBodyCells;
     private getCachedHeaderCells;
     private getCachedContext;
+    setOnRendererHostDiscard(cb: ((host: HTMLElement) => void) | undefined): void;
     invalidateCache(type?: "body" | "header" | "context" | "all"): void;
     /**
      * Get the next colIndex after rendering a section

package/dist/cjs/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[];
@@ -99,6 +101,7 @@ export declare class TableRenderer {
     private pendingRenderCallback;
     constructor();
     private scheduleRender;
+    setOnRendererHostDiscard(cb: ((host: HTMLElement) => void) | undefined): void;
     invalidateCache(type?: "body" | "header" | "context" | "all"): void;
     /** See {@link SectionRenderer.getCurrentBodyLayouts}. */
     getCurrentBodyLayouts(): Map<HTMLElement, Map<string, CellPosition>>;

package/dist/cjs/src/managers/AnimationCoordinator.d.ts

@@ -41,6 +41,21 @@ export declare class AnimationCoordinator {
      * rather than appearing in place. Cleared at the end of {@link play}.
      */
     private incomingOrigins;
+    /**
+     * Accessors that were already renderable (visible leaf/group columns) in the
+     * pre-change layout for an in-flight accordion-horizontal toggle. Set once
+     * per collapse/expand render and consumed by the renderers' grow-from-zero
+     * gate so a column that merely re-enters the virtualization band (because the
+     * collapsed group shrank the content width and clamped scrollLeft) is NOT
+     * mistaken for a freshly-expanded column and animated from width 0.
+     *
+     * Header cells have no full pre-change conceptual layout the way body cells do
+     * (see SectionRenderer.getCurrentBodyLayouts), so `hasSnapshotEntry` alone
+     * can't tell "newly visible" apart from "scrolled back into view". This set
+     * supplies the missing pre-change visibility signal. Cleared at the end of
+     * {@link play}.
+     */
+    private accordionPreVisibleAccessors;
     private inFlight;
     /** Outgoing cells the renderer handed off; keyed per container so play() finds them. */
     private retainedCells;
@@ -82,7 +97,21 @@ export declare class AnimationCoordinator {
      * transforms it left behind, so only the latest sort animates.
      */
     private scheduledFlip;
+    /**
+     * Invoked immediately BEFORE a retained/ghost element is permanently removed
+     * from the DOM (FLIP/shrink/cancel/destroy teardown). Lets framework adapters
+     * tear down renderer subtrees (React portals, etc.) mounted into the element
+     * before it's discarded. NOT called on reuse/reparent paths
+     * ({@link claimRetainedForReuse} success), so a reclaimed ghost keeps its
+     * content.
+     */
+    private onHostDiscard?;
     constructor(opts?: AnimationCoordinatorOptions);
+    /**
+     * Register the callback fired before a ghost/retained element is permanently
+     * removed (see {@link onHostDiscard}). Additive: passing `undefined` disables it.
+     */
+    setOnHostDiscard(cb: ((host: HTMLElement) => void) | undefined): void;
     setEnabled(enabled: boolean): void;
     setDuration(duration: number): void;
     setEasing(easing: string): void;
@@ -101,6 +130,21 @@ export declare class AnimationCoordinator {
      * the corresponding cells.
      */
     setIncomingOrigins(origins: Map<string, CellPosition> | null): void;
+    /**
+     * Register the set of accessors that were renderable in the pre-change layout
+     * of an accordion-horizontal toggle. Must be set after `captureSnapshot` and
+     * before the render that creates cells. Consumed and cleared by the next
+     * {@link play}. Pass `null` (e.g. for vertical/row accordions) to disable the
+     * re-entry guard so behavior is unchanged.
+     */
+    setAccordionPreVisibleAccessors(accessors: Set<string> | null): void;
+    /**
+     * True when `accessor` was already a renderable column before the current
+     * accordion-horizontal toggle. Renderers use this to skip the grow-from-zero
+     * animation for columns that only re-entered the virtualization band rather
+     * than genuinely becoming visible from an expand.
+     */
+    wasRenderableBeforeAccordion(accessor: string): boolean;
     /**
      * Read scroller layout metrics for `container`, caching the result for the
      * remainder of the current render cycle. Subsequent calls in the same

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

@@ -72,6 +72,16 @@ export interface SimpleTableConfig {
     onPageChange?: (page: number) => void | Promise<void>;
     onRowGroupExpand?: (props: OnRowGroupExpandProps) => void | Promise<void>;
     onRowSelectionChange?: (props: RowSelectionChangeProps) => void;
+    /**
+     * Called by the renderer immediately BEFORE it permanently discards a host
+     * element that may contain async-framework renderer output (e.g. React
+     * portals): innerHTML clears on cell rebuild/edit, plain cell removal, and
+     * the animation coordinator's ghost/FLIP/shrink teardown paths. Framework
+     * adapters use this to tear down the renderer subtree mounted into `host`
+     * (or any descendant) so it isn't orphaned. Reuse/reparent paths never fire
+     * it, so a reused node keeps its renderer content.
+     */
+    onRendererHostDiscard?: (host: HTMLElement) => void;
     onSortChange?: (sort: SortColumn | null) => void;
     quickFilter?: QuickFilterConfig;
     rowButtons?: RowButton[];

package/dist/cjs/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/cjs/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/cjs/src/utils/bodyCell/eventTracking.d.ts

@@ -1,3 +1,3 @@
 export declare const addTrackedEventListener: (element: HTMLElement, event: string, handler: EventListener, options?: AddEventListenerOptions) => void;
 export declare const getRenderedCells: (container: HTMLElement) => Map<string, HTMLElement>;
-export declare const cleanupBodyCellRendering: (container?: HTMLElement) => void;
+export declare const cleanupBodyCellRendering: (container?: HTMLElement, onHostDiscard?: ((host: HTMLElement) => void) | undefined) => void;

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

@@ -104,6 +104,14 @@ export interface CellRenderContext {
     handleRowSelect?: (rowId: string, checked: boolean) => void;
     handleMouseDown: (cell: CellData) => void;
     handleMouseOver: (cell: CellData, clientX: number, clientY: number) => void;
+    /**
+     * Called immediately BEFORE the renderer permanently discards a host element
+     * (e.g. `innerHTML = ""` on cell rebuild/edit, or a plain `element.remove()`).
+     * Framework adapters use this to tear down any renderer subtree (React
+     * portal, etc.) mounted into `host` or one of its descendants. Reuse paths
+     * never call it, so a reused node keeps its content.
+     */
+    onRendererHostDiscard?: (host: HTMLElement) => void;
     cellRegistry?: Map<string, CellRegistryEntry>;
     setCollapsedRows: Dispatch<SetStateAction<Map<string, number>>>;
     setExpandedRows: Dispatch<SetStateAction<Map<string, number>>>;

package/dist/cjs/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/cjs/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/cjs/src/utils/headerWidthUtils.d.ts

@@ -95,4 +95,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/cjs/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/cjs/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/cjs/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[];