simple-table-core 3.6.9 → 3.7.1

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

@@ -0,0 +1,37 @@
+/**
+ * ARIA row layer.
+ *
+ * The table renders cells as absolutely-positioned, virtualized, FLIP-animated
+ * elements. The ARIA `grid` pattern, however, requires the hierarchy
+ * `grid → rowgroup → row → gridcell/columnheader`; a flat list of cells under
+ * the section (rowgroup) makes validators (axe) report the cells as disallowed
+ * children of the rowgroup and as missing their required `row` parent.
+ *
+ * `aria-owns` does NOT solve this: axe (and the ARIA tree) still treat a cell
+ * as a child of its DOM parent, so the cell remains an invalid rowgroup child.
+ * The cells must therefore be real DOM descendants of a `role="row"` element.
+ *
+ * To get that hierarchy without disturbing the carefully-tuned positioning and
+ * animation machinery, the row element uses `display: contents`: it generates
+ * no box, establishes no containing block, and takes part in no layout, so its
+ * absolutely-positioned cell children are laid out exactly as if they were
+ * still direct children of the section. It is still present in the
+ * accessibility tree (axe's screen-reader visibility check only looks at
+ * `display:none` / `visibility` / `content-visibility` / `aria-hidden`, never
+ * at box size), so it provides the required `row` layer for free.
+ */
+/**
+ * Return the `role="row"` element for `rowKey` inside `container`, creating it
+ * (as a zero-box `display: contents` element) on first use. Refreshes
+ * `aria-rowindex` when it changes. New cells should be appended to the returned
+ * element so they become DOM descendants of a row.
+ */
+export declare const getOrCreateRowElement: (container: HTMLElement, rowKey: string, ariaRowIndex: number) => HTMLElement;
+/**
+ * Remove row elements that no longer contain any cells. Retained animation
+ * "ghost" cells keep their row alive until they finish and remove themselves,
+ * so we prune purely on emptiness rather than on a live-row set.
+ */
+export declare const reconcileRowElements: (container: HTMLElement) => void;
+/** Remove every row element tracked for `container`. */
+export declare const cleanupAriaRows: (container: HTMLElement) => void;

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

@@ -71,6 +71,12 @@ export interface CellRenderContext {
     useOddEvenRowBackground?: boolean;
     rowGrouping?: string[];
     headers: HeaderObject[];
+    /**
+     * Accessor of the column whose body cells identify the row and should carry
+     * `role="rowheader"` (the first non-selection leaf column). Other data cells
+     * remain `role="gridcell"`.
+     */
+    rowHeaderAccessor?: Accessor;
     rowHeight: number;
     /** Number of header rows (for aria-rowindex: position + maxHeaderDepth + 1) */
     maxHeaderDepth?: number;

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

@@ -17,6 +17,13 @@ export declare const getAllChildHeaders: (header: HeaderObject) => HeaderObject[
  * Check if a header has collapsible children
  */
 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.
+ */
+export declare const getHeaderColspan: (header: HeaderObject, rootHeaders: HeaderObject[], collapsedHeaders: Set<Accessor>) => number;
 /**
  * Get all leaf (bottom-level) headers that should be visible when a parent is collapsed
  * Uses flattenHeaders for consistent leaf detection

package/dist/cjs/stories/tests/45-AriaSemanticsTests.stories.d.ts

@@ -0,0 +1,83 @@
+/**
+ * ARIA SEMANTICS TESTS
+ *
+ * These tests assert the ARIA state/relationship semantics that a non-native
+ * (role="grid") table must apply by hand: selection state, expansion/treegrid
+ * levels, grouped-header span, row headers, nested/state rows in the hierarchy,
+ * header rowspan, and collapsible column-header expansion.
+ */
+import type { Meta } from "@storybook/html";
+declare const meta: Meta;
+export default meta;
+export declare const SelectedRowsExposeAriaSelected: {
+    render: () => HTMLDivElement & {
+        _table?: import("../../src/index").SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
+export declare const GridExposesAriaMultiselectable: {
+    render: () => HTMLDivElement & {
+        _table?: import("../../src/index").SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
+export declare const ExpandableRowsExposeAriaExpandedOnRow: {
+    render: () => HTMLDivElement & {
+        _table?: import("../../src/index").SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
+export declare const ExpandableGridExposesTreegridLevels: {
+    render: () => HTMLDivElement & {
+        _table?: import("../../src/index").SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
+export declare const GroupedHeadersExposeAriaColspan: {
+    render: () => HTMLDivElement & {
+        _table?: import("../../src/index").SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
+export declare const IdentityColumnExposesRowHeader: {
+    render: () => HTMLDivElement & {
+        _table?: import("../../src/index").SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
+export declare const NestedTableRowsAreInRowHierarchy: {
+    render: () => HTMLDivElement & {
+        _table?: import("../../src/index").SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
+export declare const LeafHeadersExposeRowSpan: {
+    render: () => HTMLDivElement & {
+        _table?: import("../../src/index").SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
+export declare const CollapsibleColumnHeaderExposesAriaExpanded: {
+    render: () => HTMLDivElement & {
+        _table?: import("../../src/index").SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};