simple-table-core 4.0.2 → 4.0.4

package/dist/types/ColumnEditorRowRendererProps.d.ts

@@ -10,7 +10,7 @@ export interface ColumnEditorRowRendererComponents {
     /** Default pin column (outline / filled); omit when building a fully custom row */
     pinIcon?: IconElement;
 }
-/** Pin / unpin actions for column editor rows (also use for lock/tooltip UX via HeaderObject.isEssential). */
+/** Pin / unpin actions for column editor rows (also use for lock/tooltip UX via HeaderObject.essential). */
 export interface ColumnEditorPinControl {
     pinnedSide: "left" | "right" | null;
     canPinLeft: boolean;
@@ -26,8 +26,8 @@ interface ColumnEditorRowRendererProps {
     components: ColumnEditorRowRendererComponents;
     /** Which panel section this row is rendered in */
     panelSection?: PanelSection;
-    /** Resolved from HeaderObject.isEssential / essentialAccessors */
-    isEssential?: boolean;
+    /** Resolved from HeaderObject.essential / essentialAccessors */
+    essential?: boolean;
     /** False when visibility cannot be toggled (essential columns) */
     canToggleVisibility?: boolean;
     /** Mirrors `columnEditorConfig.allowColumnPinning` (default true) */

package/dist/types/HeaderObject.d.ts

@@ -97,29 +97,17 @@ type HeaderObject = {
     filterOperators?: FilterOperator[];
     headerRenderer?: HeaderRenderer;
     hide?: boolean;
-    /**
-     * Whether cells in this column are editable.
-     * @deprecated Prefer {@link editable}
-     */
-    isEditable?: boolean;
-    /** Whether cells in this column are editable. Preferred over `isEditable`. */
+    /** Whether cells in this column are editable. */
     editable?: boolean;
     excludeFromRender?: boolean;
     excludeFromCsv?: boolean;
     isSelectionColumn?: boolean;
     /**
-     * When true, column stays visible, cannot be unpinned from a pinned side, cannot reorder above non-essentials in its section.
-     * @deprecated Prefer {@link essential}
+     * When true, column stays visible, cannot be unpinned from a pinned side, and
+     * cannot reorder above non-essentials in its section.
      */
-    isEssential?: boolean;
-    /** When true, column stays visible and cannot be unpinned / reordered above non-essentials. Preferred over `isEssential`. */
     essential?: boolean;
-    /**
-     * Whether this column is sortable.
-     * @deprecated Prefer {@link sortable}
-     */
-    isSortable?: boolean;
-    /** Whether this column is sortable. Preferred over `isSortable`. */
+    /** Whether this column is sortable. */
     sortable?: boolean;
     label: string;
     minWidth?: number | string;

package/dist/types/SimpleTableConfig.d.ts

@@ -66,6 +66,12 @@ export interface SimpleTableConfig {
     externalFilterHandling?: boolean;
     externalSortHandling?: boolean;
     footerRenderer?: (props: FooterRendererProps) => HTMLElement | string | null;
+    /**
+     * @see SimpleTableProps.footerRenderKey
+     * Included in the custom-footer reuse key so external footer state can bust
+     * the scroll-safe cache without replacing the `footerRenderer` function.
+     */
+    footerRenderKey?: string | number;
     /** Placement of the pagination footer. Default `"bottom"`. */
     footerPosition?: FooterPosition;
     headerDropdown?: VanillaHeaderDropdown;

package/dist/types/SimpleTableProps.d.ts

@@ -88,6 +88,15 @@ export interface SimpleTableProps {
     externalFilterHandling?: boolean;
     externalSortHandling?: boolean;
     footerRenderer?: (props: FooterRendererProps) => HTMLElement | string | null;
+    /**
+     * Cache key for a custom `footerRenderer`. Include any external state the
+     * footer reads (e.g. a loading flag) so the footer re-renders when that
+     * state changes even if page/row-count inputs are unchanged.
+     *
+     * Scroll-driven re-renders still reuse the previous footer DOM when this key
+     * (and pagination inputs) are stable — that avoids scroll-snap regressions.
+     */
+    footerRenderKey?: string | number;
     footerPosition?: FooterPosition;
     headerDropdown?: HeaderDropdown;
     height?: string | number;

package/dist/utils/cellUtils.d.ts

@@ -1,6 +1,7 @@
 import HeaderObject, { Accessor } from "../types/HeaderObject";
 import { Pinned } from "../types/Pinned";
 import { RowId } from "../types/RowId";
+export { isHeaderExcludedFromLayout } from "./headerLayoutUtils";
 export declare const getCellId: ({ accessor, rowId }: {
     accessor: Accessor;
     rowId: RowId;

package/dist/utils/collapseUtils.d.ts

@@ -19,9 +19,10 @@ export declare const getAllChildHeaders: (header: HeaderObject) => HeaderObject[
 export declare const hasCollapsibleChildren: (header: HeaderObject) => boolean;
 /**
  * Number of visible leaf (bottom-level) columns a header spans, for
- * `aria-colspan` on grouped/nested header cells. Leaf headers that are hidden
- * (`hide`) or suppressed by their parent's collapsed state are excluded so the
- * announced span matches the columns actually rendered. Leaf headers return 1.
+ * `aria-colspan` on grouped/nested header cells. Leaf headers excluded from
+ * layout (`hide` / `excludeFromRender`) or suppressed by their parent's
+ * collapsed state are omitted so the announced span matches the columns
+ * actually rendered. Leaf headers return 1.
  */
 export declare const getHeaderColspan: (header: HeaderObject, rootHeaders: HeaderObject[], collapsedHeaders: Set<Accessor>) => number;
 /**

package/dist/utils/headerLayoutUtils.d.ts

@@ -0,0 +1,9 @@
+import type HeaderObject from "../types/HeaderObject";
+/**
+ * True when a column must not participate in table layout: cells, widths,
+ * positions, colspan, pinned-section math, etc.
+ *
+ * Covers both user-hidden columns (`hide`) and export-only columns
+ * (`excludeFromRender`). Prefer this over checking either flag alone.
+ */
+export declare const isHeaderExcludedFromLayout: (header: Pick<HeaderObject, "hide" | "excludeFromRender">) => boolean;

package/dist/utils/normalizeConfig.d.ts

@@ -1,21 +1,12 @@
 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.
+ *
+ * Column flags (`sortable` / `editable` / `essential`) have no legacy aliases —
+ * they are stored and returned as those names only.
  */
 export type SimpleTableConfigInput = Omit<SimpleTableConfig, "defaultHeaders" | "editColumns" | "editColumnsInitOpen" | "shouldPaginate" | "onGridReady" | "useHoverRowBackground" | "useOddColumnBackground" | "useOddEvenRowBackground"> & {
     /** Preferred column definitions prop. */
@@ -47,7 +38,7 @@ export type SimpleTableConfigInput = Omit<SimpleTableConfig, "defaultHeaders" |
     /** @deprecated Prefer `oddEvenRowBackground` */
     useOddEvenRowBackground?: boolean;
 };
-/** Normalize a single column def: preferred bare adjectives win over `is*` aliases. */
+/** Pass-through for column trees (kept for call-site stability / future transforms). */
 export declare function normalizeColumnDef(header: HeaderObject): HeaderObject;
 export declare function normalizeColumnDefs(headers: HeaderObject[]): HeaderObject[];
 /**

package/dist/utils/pinnedColumnUtils.d.ts

@@ -9,7 +9,7 @@ export declare function partitionRootHeadersByPin(headers: HeaderObject[]): {
     pinnedRight: HeaderObject[];
 };
 export declare function isHeaderEssential(header: HeaderObject, essentialAccessors: ReadonlySet<string>): boolean;
-/** Accessors for every header with `isEssential` in the tree (including nested). */
+/** Accessors for every header with `essential` 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;

package/dist/utils/propSyncEqual.d.ts

@@ -14,14 +14,14 @@ export type HeaderStructureLike = {
     type?: string;
     pinned?: string | boolean | null;
     hide?: boolean;
-    isSortable?: boolean;
+    sortable?: boolean;
     filterable?: boolean;
     align?: string;
     collapsible?: boolean;
     collapseDefault?: boolean;
     showWhen?: string;
-    isEditable?: boolean;
-    isEssential?: boolean;
+    editable?: boolean;
+    essential?: boolean;
     disableReorder?: boolean;
     expandable?: boolean;
     excludeFromRender?: boolean;

package/package.json

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