simple-table-core 3.8.0 → 3.8.2

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

@@ -225,6 +225,13 @@ export declare class SimpleTableVanilla {
     private isAutoSizeLeaf;
     private computeAutoSizeAccessors;
     private getAutoSizeStyleRoot;
+    /**
+     * Rows that content-fit ("auto") measurement should sample. With client-side
+     * pagination only the current page is rendered, so fit columns to the page's
+     * rows rather than the entire dataset — otherwise off-page values inflate
+     * every auto column's width.
+     */
+    private getAutoSizeRows;
     /** Immutably write measured pixel widths into the leaf headers. */
     private applyMeasuredWidths;
     /**

package/dist/src/hooks/contentHeight.d.ts

@@ -17,7 +17,7 @@ export interface ContentHeightConfig {
 /**
  * Converts a height value (string or number) to pixels
  */
-export declare const convertHeightToPixels: (heightValue: string | number) => number;
+export declare const convertHeightToPixels: (heightValue: string | number, container?: Element | null) => number;
 /**
  * Calculates the content height for the table.
  * This is a pure function alternative to the useContentHeight hook.

package/dist/src/managers/AutoScaleManager.d.ts

@@ -1,4 +1,4 @@
-import HeaderObject from "../types/HeaderObject";
+import HeaderObject, { Accessor } from "../types/HeaderObject";
 interface AutoScaleConfig {
     autoExpandColumns: boolean;
     containerWidth: number;
@@ -8,6 +8,13 @@ interface AutoScaleConfig {
         current: HTMLDivElement | null;
     };
     isResizing?: boolean;
+    /**
+     * Currently collapsed header accessors. Auto-scale must only account for the
+     * leaf columns that are actually visible for the current collapsed state —
+     * otherwise it sums the widths of hidden child columns and under-expands,
+     * leaving empty space on the right.
+     */
+    collapsedHeaders?: Set<Accessor>;
 }
 type HeaderUpdateCallback = (headers: HeaderObject[]) => void;
 export declare const applyAutoScaleToHeaders: (headers: HeaderObject[], options: AutoScaleConfig) => HeaderObject[];

package/dist/stories/tests/12-CellSelectionTests.stories.d.ts

@@ -131,6 +131,21 @@ export declare const CopySelectionWithoutHeaders: {
         canvasElement: HTMLElement;
     }) => Promise<void>;
 };
+/**
+ * Regression: with `selectableCells` enabled, the cell mousedown handler used to
+ * `preventDefault()` and start a cell selection even when the press landed on an
+ * <a> rendered inside the cell. That cancelled the link's native default (href
+ * navigation) and forced a body re-render that swallowed the pending click.
+ * A link inside a cell must stay clickable and must not trigger cell selection.
+ */
+export declare const LinkInsideCellStaysClickable: {
+    render: () => HTMLDivElement & {
+        _table?: import("../../src/index").SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
 export declare const ShiftArrowExtendsSelection: {
     render: () => HTMLDivElement & {
         _table?: import("../../src/index").SimpleTableVanilla | undefined;

package/dist/stories/tests/15-ColumnVisibilityTests.stories.d.ts

@@ -109,6 +109,14 @@ export declare const ExcludeFromRenderNotInColumnEditor: {
         canvasElement: HTMLElement;
     }) => Promise<void>;
 };
+export declare const ExcludeFromRenderDoesNotInflateRowWidth: {
+    render: () => HTMLDivElement & {
+        _table?: import("../../src/index").SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
 export declare const ColumnEditorCustomText: {
     render: () => HTMLDivElement & {
         _table?: import("../../src/index").SimpleTableVanilla | undefined;

package/dist/stories/tests/22-LoadingStateTests.stories.d.ts

@@ -3,11 +3,12 @@
  * Tests for isLoading prop - skeleton loaders in cells when data is loading.
  */
 import type { Meta } from "@storybook/html";
+import { SimpleTableVanilla } from "../../src/index";
 declare const meta: Meta;
 export default meta;
 export declare const LoadingStateShowsSkeletons: {
     render: () => HTMLDivElement & {
-        _table?: import("../../src/index").SimpleTableVanilla | undefined;
+        _table?: SimpleTableVanilla | undefined;
     };
     play: ({ canvasElement }: {
         canvasElement: HTMLElement;
@@ -15,7 +16,7 @@ export declare const LoadingStateShowsSkeletons: {
 };
 export declare const NotLoadingShowsData: {
     render: () => HTMLDivElement & {
-        _table?: import("../../src/index").SimpleTableVanilla | undefined;
+        _table?: SimpleTableVanilla | undefined;
     };
     play: ({ canvasElement }: {
         canvasElement: HTMLElement;
@@ -23,7 +24,30 @@ export declare const NotLoadingShowsData: {
 };
 export declare const LoadingStateWithEmptyRows: {
     render: () => HTMLDivElement & {
-        _table?: import("../../src/index").SimpleTableVanilla | undefined;
+        _table?: SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
+/**
+ * Repro for the stale-cell bug. Body cells are keyed by `${rowId}-${accessor}`,
+ * where `rowId` comes from `getRowId`. When `getRowId` derives the id from row
+ * data, a row that is still loading has no id yet, so `getRowId` returns
+ * `undefined` (→ "undefined"). While `isLoading` is true the core renders a
+ * batch of skeleton rows that ALL collapse to the same cell id
+ * (`undefined-<accessor>`); only the last one is tracked in the rendered-cell
+ * registry, so the rest are orphaned in the DOM. Once the data resolves and
+ * `getRowId` returns a real id, the registry-driven cleanup removes only the
+ * tracked cell, leaving the orphaned skeleton cells underneath the real data
+ * cell indefinitely.
+ *
+ * After a single row resolves, the body should hold exactly one cell per
+ * column and no leftover loading skeletons.
+ */
+export declare const LoadingToLoadedRemovesStaleCells: {
+    render: () => HTMLDivElement & {
+        _table?: SimpleTableVanilla | undefined;
     };
     play: ({ canvasElement }: {
         canvasElement: HTMLElement;

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

@@ -80,6 +80,16 @@ export declare const AutoExpandGroupedExpandCollapse: {
         canvasElement: HTMLElement;
     }) => Promise<void>;
 };
+export declare const AutoExpandCollapsibleColumnsFillContainer: {
+    tags: string[];
+    parameters: {
+        tags: string[];
+    };
+    render: () => HTMLElement;
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
 export declare const AutoExpandWithNestedGrouping: {
     parameters: {
         tags: string[];

package/dist/stories/tests/40-MaxHeightScrollTests.stories.d.ts

@@ -26,3 +26,12 @@ export declare const MaxHeightNoScrollWhenContentFits: {
         canvasElement: any;
     }) => Promise<void>;
 };
+export declare const MaxHeightCalcScrolls: {
+    tags: string[];
+    render: () => HTMLDivElement & {
+        _table?: import("../../src/index").SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: any;
+    }) => Promise<void>;
+};

package/dist/stories/tests/47-DeferredHeadersTests.stories.d.ts

@@ -0,0 +1,23 @@
+/**
+ * DEFERRED HEADERS TESTS
+ * Regression tests for populating `defaultHeaders` after mount (the table
+ * mounts with an empty header array, then `update({ defaultHeaders })` supplies
+ * the real columns — e.g. from an async fetch / useEffect).
+ *
+ * The header band must become visible once the columns arrive. Previously the
+ * DimensionManager kept maxHeaderDepth/calculatedHeaderHeight at 0 (computed
+ * from the empty mount-time headers), so the header row rendered at 0px height
+ * even though the body and the header cells existed.
+ */
+import type { Meta } from "@storybook/html";
+import { SimpleTableVanilla } from "../../src/index";
+declare const meta: Meta;
+export default meta;
+export declare const PopulateHeadersAfterMount: {
+    render: () => HTMLDivElement & {
+        _table?: SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "simple-table-core",
-  "version": "3.8.0",
+  "version": "3.8.2",
   "main": "dist/cjs/index.js",
   "module": "dist/index.es.js",
   "types": "dist/src/index.d.ts",