@happyvertical/smrt-ui 0.42.3 → 0.42.5

package/dist/components/data/DataTableIdentity.d.ts

@@ -0,0 +1,21 @@
+import { type DataTableRowId } from './DataTableController.js';
+/** A stable row identity accessor. It must not depend on display position. */
+export type DataTableRowKey<T> = keyof T | ((row: T) => DataTableRowId);
+export interface DataTableResolvedRow<T> {
+    row: T;
+    /** Index in the `data` array supplied to DataTable before local transforms. */
+    sourceIndex: number;
+    /** Canonical key used by Svelte, selection, and expansion. */
+    rowId: DataTableRowId;
+}
+export interface ResolveDataTableRowsOptions {
+    /** Durable table features may not use the historical source-index fallback. */
+    requireStableIdentity?: boolean;
+}
+/**
+ * Resolve the renderer's source rows once and fail closed for missing or
+ * duplicate durable identities. The index fallback only exists for
+ * presentational local tables that have no durable row state.
+ */
+export declare function resolveDataTableRows<T>(rows: readonly T[], rowKey: DataTableRowKey<T> | undefined, options?: ResolveDataTableRowsOptions): DataTableResolvedRow<T>[];
+//# sourceMappingURL=DataTableIdentity.d.ts.map

package/dist/components/data/DataTableIdentity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataTableIdentity.d.ts","sourceRoot":"","sources":["../../../src/components/data/DataTableIdentity.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EAEpB,MAAM,0BAA0B,CAAC;AAElC,8EAA8E;AAC9E,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC,KAAK,cAAc,CAAC,CAAC;AAExE,MAAM,WAAW,oBAAoB,CAAC,CAAC;IACrC,GAAG,EAAE,CAAC,CAAC;IACP,+EAA+E;IAC/E,WAAW,EAAE,MAAM,CAAC;IACpB,8DAA8D;IAC9D,KAAK,EAAE,cAAc,CAAC;CACvB;AAED,MAAM,WAAW,2BAA2B;IAC1C,+EAA+E;IAC/E,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC;AAQD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EACpC,IAAI,EAAE,SAAS,CAAC,EAAE,EAClB,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG,SAAS,EACtC,OAAO,GAAE,2BAAgC,GACxC,oBAAoB,CAAC,CAAC,CAAC,EAAE,CAqB3B"}

package/dist/components/data/DataTableIdentity.js

@@ -0,0 +1,28 @@
+import { assertDataTableRowId, dataTableRowIdKey, } from './DataTableController.js';
+function readRowKey(row, rowKey) {
+    return typeof rowKey === 'function'
+        ? rowKey(row)
+        : row[rowKey];
+}
+/**
+ * Resolve the renderer's source rows once and fail closed for missing or
+ * duplicate durable identities. The index fallback only exists for
+ * presentational local tables that have no durable row state.
+ */
+export function resolveDataTableRows(rows, rowKey, options = {}) {
+    if (options.requireStableIdentity && !rowKey) {
+        throw new TypeError('DataTable rowKey is required for selectable, expandable, manual, or agent-addressable tables');
+    }
+    const seen = new Set();
+    return rows.map((row, sourceIndex) => {
+        const rowId = rowKey
+            ? assertDataTableRowId(readRowKey(row, rowKey))
+            : sourceIndex;
+        const key = dataTableRowIdKey(rowId);
+        if (seen.has(key)) {
+            throw new TypeError(`DataTable rowKey must resolve to unique row ids; duplicate ${key}`);
+        }
+        seen.add(key);
+        return { row, sourceIndex, rowId };
+    });
+}

package/dist/components/data/DataTableLayout.d.ts

@@ -0,0 +1,37 @@
+import type { DataTableColumnPinning, DataTableViewState } from './DataTableController.js';
+import type { DataTableColumn } from './types.js';
+export interface DataTableResolvedColumn<T> {
+    column: DataTableColumn<T>;
+    pin?: DataTableColumnPinning['position'];
+    /** A persisted pixel width supersedes the column's presentational default. */
+    width?: number;
+    /** CSS-safe width used for a sticky offset when one is available. */
+    offsetWidth: string;
+    stickyOffset?: string;
+}
+export interface DataTableHeaderGroupCell {
+    kind: 'group';
+    key: string;
+    label: string;
+    colspan: number;
+    rowspan: number;
+    pin?: DataTableColumnPinning['position'];
+    stickyOffset?: string;
+}
+export interface DataTableHeaderLeafCell<T> {
+    kind: 'leaf';
+    column: DataTableResolvedColumn<T>;
+    rowspan: number;
+}
+export type DataTableHeaderCell<T> = DataTableHeaderGroupCell | DataTableHeaderLeafCell<T>;
+export interface DataTableLayout<T> {
+    columns: DataTableResolvedColumn<T>[];
+    headerRows: DataTableHeaderCell<T>[][];
+}
+/**
+ * Resolve a DOM-safe table layout from canonical controller state. Pinning is
+ * a partition of the configured order so the visual and assistive orders stay
+ * aligned. Header groups are then rebuilt from the final visible leaf order.
+ */
+export declare function resolveDataTableLayout<T>(columns: readonly DataTableColumn<T>[], state: Pick<DataTableViewState, 'columnOrder' | 'columnVisibility' | 'columnWidths' | 'columnPinning'>, measuredWidths?: Readonly<Record<string, number>>): DataTableLayout<T>;
+//# sourceMappingURL=DataTableLayout.d.ts.map

package/dist/components/data/DataTableLayout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataTableLayout.d.ts","sourceRoot":"","sources":["../../../src/components/data/DataTableLayout.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,sBAAsB,EACtB,kBAAkB,EACnB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,eAAe,EAA8B,MAAM,YAAY,CAAC;AAE9E,MAAM,WAAW,uBAAuB,CAAC,CAAC;IACxC,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC;IAC3B,GAAG,CAAC,EAAE,sBAAsB,CAAC,UAAU,CAAC,CAAC;IACzC,8EAA8E;IAC9E,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,qEAAqE;IACrE,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,OAAO,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,sBAAsB,CAAC,UAAU,CAAC,CAAC;IACzC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,uBAAuB,CAAC,CAAC;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,uBAAuB,CAAC,CAAC,CAAC,CAAC;IACnC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAC7B,wBAAwB,GACxB,uBAAuB,CAAC,CAAC,CAAC,CAAC;AAE/B,MAAM,WAAW,eAAe,CAAC,CAAC;IAChC,OAAO,EAAE,uBAAuB,CAAC,CAAC,CAAC,EAAE,CAAC;IACtC,UAAU,EAAE,mBAAmB,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;CACxC;AA4GD;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,EACtC,OAAO,EAAE,SAAS,eAAe,CAAC,CAAC,CAAC,EAAE,EACtC,KAAK,EAAE,IAAI,CACT,kBAAkB,EAClB,aAAa,GAAG,kBAAkB,GAAG,cAAc,GAAG,eAAe,CACtE,EACD,cAAc,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAM,GACpD,eAAe,CAAC,CAAC,CAAC,CA2DpB"}

package/dist/components/data/DataTableLayout.js

@@ -0,0 +1,135 @@
+function compareOrder(left, right, order) {
+    const leftOrder = order.get(left.id) ?? Number.MAX_SAFE_INTEGER;
+    const rightOrder = order.get(right.id) ?? Number.MAX_SAFE_INTEGER;
+    return leftOrder === rightOrder ? 0 : leftOrder - rightOrder;
+}
+function headerPath(column) {
+    const path = column.headerPath ?? [];
+    for (const segment of path) {
+        if (!segment ||
+            typeof segment.id !== 'string' ||
+            segment.id.length === 0 ||
+            typeof segment.label !== 'string' ||
+            segment.label.length === 0) {
+            throw new TypeError(`DataTable headerPath entries for ${column.id} require non-empty id and label`);
+        }
+    }
+    return path;
+}
+function offsetWidth(column, width, measuredWidth) {
+    if (measuredWidth !== undefined && measuredWidth > 0) {
+        return `${measuredWidth}px`;
+    }
+    if (width !== undefined)
+        return `${width}px`;
+    return column.width ?? column.minWidth ?? '0px';
+}
+function resolveHeaderRows(columns) {
+    const paths = columns.map(({ column }) => headerPath(column));
+    const groupDepth = Math.max(0, ...paths.map((path) => path.length));
+    if (groupDepth === 0) {
+        return [columns.map((column) => ({ kind: 'leaf', column, rowspan: 1 }))];
+    }
+    const rows = Array.from({ length: groupDepth + 1 }, () => []);
+    for (let level = 0; level <= groupDepth; level += 1) {
+        let index = 0;
+        while (index < columns.length) {
+            const path = paths[index];
+            if (path.length < level) {
+                index += 1;
+                continue;
+            }
+            if (path.length === level) {
+                rows[level].push({
+                    kind: 'leaf',
+                    column: columns[index],
+                    rowspan: groupDepth - level + 1,
+                });
+                index += 1;
+                continue;
+            }
+            const segment = path[level];
+            let end = index + 1;
+            while (end < columns.length &&
+                paths[end][level]?.id === segment.id &&
+                paths[end][level]?.label === segment.label) {
+                end += 1;
+            }
+            rows[level].push({
+                kind: 'group',
+                key: `${level}:${index}:${segment.id}`,
+                label: segment.label,
+                colspan: end - index,
+                rowspan: 1,
+                ...resolveGroupPin(columns.slice(index, end)),
+            });
+            index = end;
+        }
+    }
+    return rows;
+}
+function resolveGroupPin(columns) {
+    const pin = columns[0]?.pin;
+    if (!pin || !columns.every((column) => column.pin === pin))
+        return {};
+    const edge = pin === 'start' ? columns[0] : columns.at(-1);
+    return { pin, stickyOffset: edge?.stickyOffset };
+}
+/**
+ * Resolve a DOM-safe table layout from canonical controller state. Pinning is
+ * a partition of the configured order so the visual and assistive orders stay
+ * aligned. Header groups are then rebuilt from the final visible leaf order.
+ */
+export function resolveDataTableLayout(columns, state, measuredWidths = {}) {
+    const order = new Map(state.columnOrder.map((id, index) => [id, index]));
+    const visibility = new Map(state.columnVisibility.map((entry) => [entry.columnId, entry.visible]));
+    const widths = new Map(state.columnWidths.map((entry) => [entry.columnId, entry.width]));
+    const pinning = new Map(state.columnPinning.map((entry) => [entry.columnId, entry.position]));
+    const ordered = columns
+        .filter((column) => !column.hidden && visibility.get(column.id) !== false)
+        .slice()
+        .sort((left, right) => compareOrder(left, right, order));
+    const partitions = {
+        start: ordered.filter((column) => pinning.get(column.id) === 'start'),
+        center: ordered.filter((column) => !pinning.has(column.id)),
+        end: ordered.filter((column) => pinning.get(column.id) === 'end'),
+    };
+    const resolved = [];
+    let startOffset = '0px';
+    for (const column of partitions.start) {
+        const width = widths.get(column.id);
+        const offset = offsetWidth(column, width, measuredWidths[column.id]);
+        resolved.push({
+            column,
+            pin: 'start',
+            width,
+            offsetWidth: offset,
+            stickyOffset: startOffset,
+        });
+        startOffset = `calc(${startOffset} + ${offset})`;
+    }
+    for (const column of partitions.center) {
+        const width = widths.get(column.id);
+        resolved.push({
+            column,
+            width,
+            offsetWidth: offsetWidth(column, width, measuredWidths[column.id]),
+        });
+    }
+    let endOffset = '0px';
+    const endColumns = [];
+    for (const column of partitions.end.slice().reverse()) {
+        const width = widths.get(column.id);
+        const offset = offsetWidth(column, width, measuredWidths[column.id]);
+        endColumns.unshift({
+            column,
+            pin: 'end',
+            width,
+            offsetWidth: offset,
+            stickyOffset: endOffset,
+        });
+        endOffset = `calc(${endOffset} + ${offset})`;
+    }
+    resolved.push(...endColumns);
+    return { columns: resolved, headerRows: resolveHeaderRows(resolved) };
+}

package/dist/components/data/DataTablePerformance.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Published, testable scale guidance for the DataTable pipeline.
+ *
+ * These are interaction thresholds, not hard data limits. Use the benchmark
+ * fixture before raising them for a new renderer, browser target, or cell shape.
+ */
+export declare const DATA_TABLE_SCALE_THRESHOLDS: {
+    readonly localRender: {
+        readonly maxRows: 250;
+        readonly maxCells: 5000;
+        readonly recommendation: "Use normal semantic rendering for ordinary, bounded result sets.";
+    };
+    readonly clientTransforms: {
+        readonly maxRows: 1000;
+        readonly maxCells: 20000;
+        readonly recommendation: "Use manual filtering, sorting, or paging once a client transform exceeds this budget.";
+    };
+    readonly manualPaging: {
+        readonly recommendedPageSize: 100;
+        readonly maxRenderedRows: 250;
+        readonly recommendation: "Keep remote pages bounded and pass totalRows only for a known server total.";
+    };
+    readonly virtualization: {
+        readonly minRows: 250;
+        readonly recommendation: "Use fixed-height virtualization for continuous browsing above the local render budget; preserve stable rowKey values and retain remote paging for unbounded data.";
+    };
+};
+export type DataTableScaleStrategy = 'local' | 'manual-paging' | 'virtualization';
+/** Returns the recommended rendering strategy for a known row and column count. */
+export declare function recommendDataTableScaleStrategy(rowCount: number, columnCount: number): DataTableScaleStrategy;
+//# sourceMappingURL=DataTablePerformance.d.ts.map

package/dist/components/data/DataTablePerformance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataTablePerformance.d.ts","sourceRoot":"","sources":["../../../src/components/data/DataTablePerformance.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;CAwB9B,CAAC;AAEX,MAAM,MAAM,sBAAsB,GAC9B,OAAO,GACP,eAAe,GACf,gBAAgB,CAAC;AAErB,mFAAmF;AACnF,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,GAClB,sBAAsB,CAwBxB"}

package/dist/components/data/DataTablePerformance.js

@@ -0,0 +1,46 @@
+/**
+ * Published, testable scale guidance for the DataTable pipeline.
+ *
+ * These are interaction thresholds, not hard data limits. Use the benchmark
+ * fixture before raising them for a new renderer, browser target, or cell shape.
+ */
+export const DATA_TABLE_SCALE_THRESHOLDS = {
+    localRender: {
+        maxRows: 250,
+        maxCells: 5_000,
+        recommendation: 'Use normal semantic rendering for ordinary, bounded result sets.',
+    },
+    clientTransforms: {
+        maxRows: 1_000,
+        maxCells: 20_000,
+        recommendation: 'Use manual filtering, sorting, or paging once a client transform exceeds this budget.',
+    },
+    manualPaging: {
+        recommendedPageSize: 100,
+        maxRenderedRows: 250,
+        recommendation: 'Keep remote pages bounded and pass totalRows only for a known server total.',
+    },
+    virtualization: {
+        minRows: 250,
+        recommendation: 'Use fixed-height virtualization for continuous browsing above the local render budget; preserve stable rowKey values and retain remote paging for unbounded data.',
+    },
+};
+/** Returns the recommended rendering strategy for a known row and column count. */
+export function recommendDataTableScaleStrategy(rowCount, columnCount) {
+    if (!Number.isInteger(rowCount) ||
+        !Number.isInteger(columnCount) ||
+        rowCount < 0 ||
+        columnCount < 0) {
+        throw new TypeError('DataTable scale counts must be non-negative integers');
+    }
+    const cells = rowCount * columnCount;
+    if (rowCount <= DATA_TABLE_SCALE_THRESHOLDS.localRender.maxRows &&
+        cells <= DATA_TABLE_SCALE_THRESHOLDS.localRender.maxCells) {
+        return 'local';
+    }
+    if (rowCount > DATA_TABLE_SCALE_THRESHOLDS.clientTransforms.maxRows ||
+        cells > DATA_TABLE_SCALE_THRESHOLDS.clientTransforms.maxCells) {
+        return 'manual-paging';
+    }
+    return 'virtualization';
+}

package/dist/components/data/DataTableVirtualization.d.ts

@@ -0,0 +1,71 @@
+import type { DataTableRowId } from './DataTableController.js';
+/**
+ * Fixed-height virtualization configuration for the DataTable body.
+ *
+ * Header groups and summary rows remain normal table sections and are not
+ * included in the virtual row count. Body rows must have a fixed height.
+ */
+export interface DataTableVirtualizationOptions {
+    /** The measured, fixed height of each data row in CSS pixels. */
+    rowHeight: number;
+    /**
+     * The visible height of the scrolling data viewport in CSS pixels. The
+     * component adds measured caption and header height around this body region.
+     */
+    viewportHeight: number;
+    /** Extra rows rendered before and after the visible range. Defaults to 3. */
+    overscan?: number;
+    /** Controlled scroll position, used to restore a table after remounting. */
+    scrollTop?: number;
+    /**
+     * Receives the current virtual scroll position. When a footer is present,
+     * its measured height extends the range so it remains reachable.
+     */
+    onScrollTopChange?: (scrollTop: number) => void;
+    /**
+     * A stable row id that must remain visible. Use this with
+     * `onFocusedRowIdChange` to restore keyboard focus after a data refresh.
+     */
+    focusedRowId?: DataTableRowId | null;
+    /** Receives the stable id of a row when focus enters that row. */
+    onFocusedRowIdChange?: (rowId: DataTableRowId) => void;
+}
+export type DataTableVirtualizationReason = 'disabled' | 'variable-row-height';
+export interface DataTableVirtualizationContext {
+    options?: DataTableVirtualizationOptions;
+    rowCount: number;
+    scrollTop: number;
+    /** Expansion and body group rows produce variable heights and disable the window. */
+    hasVariableRowHeight?: boolean;
+    /** Structural header rows, including grouped headers. Excluded from the window. */
+    headerRowCount?: number;
+    /** Structural summary rows. Excluded from the window. */
+    summaryRowCount?: number;
+}
+export interface DataTableVirtualWindow {
+    enabled: boolean;
+    reason?: DataTableVirtualizationReason;
+    startIndex: number;
+    endIndex: number;
+    topSpacerHeight: number;
+    bottomSpacerHeight: number;
+    totalBodyHeight: number;
+    headerRowCount: number;
+    summaryRowCount: number;
+}
+/**
+ * Returns the maximum scroll position for a virtual body and an optional
+ * measured summary footer. Header and caption height are outside this range.
+ */
+export declare function maximumDataTableVirtualScrollTop(rowCount: number, options: Pick<DataTableVirtualizationOptions, 'rowHeight' | 'viewportHeight'>, footerHeight?: number): number;
+/**
+ * Resolves the renderable data-row window without using source order as an
+ * identity. The caller retains the rows and slices by the returned indexes.
+ */
+export declare function resolveDataTableVirtualWindow(context: DataTableVirtualizationContext): DataTableVirtualWindow;
+/**
+ * Returns the smallest fixed-height scroll position that reveals a stable row
+ * index, clamped to the body extent. Callers resolve the index from `rowKey`.
+ */
+export declare function scrollTopForDataTableRow(rowIndex: number, rowCount: number, options: Pick<DataTableVirtualizationOptions, 'rowHeight' | 'viewportHeight'>, currentScrollTop?: number): number;
+//# sourceMappingURL=DataTableVirtualization.d.ts.map

package/dist/components/data/DataTableVirtualization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataTableVirtualization.d.ts","sourceRoot":"","sources":["../../../src/components/data/DataTableVirtualization.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE/D;;;;;GAKG;AACH,MAAM,WAAW,8BAA8B;IAC7C,iEAAiE;IACjE,SAAS,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4EAA4E;IAC5E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IAChD;;;OAGG;IACH,YAAY,CAAC,EAAE,cAAc,GAAG,IAAI,CAAC;IACrC,kEAAkE;IAClE,oBAAoB,CAAC,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC;CACxD;AAED,MAAM,MAAM,6BAA6B,GAAG,UAAU,GAAG,qBAAqB,CAAC;AAE/E,MAAM,WAAW,8BAA8B;IAC7C,OAAO,CAAC,EAAE,8BAA8B,CAAC;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,qFAAqF;IACrF,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,mFAAmF;IACnF,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,yDAAyD;IACzD,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,6BAA6B,CAAC;IACvC,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;CACzB;AAkCD;;;GAGG;AACH,wBAAgB,gCAAgC,CAC9C,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,IAAI,CAAC,8BAA8B,EAAE,WAAW,GAAG,gBAAgB,CAAC,EAC7E,YAAY,SAAI,GACf,MAAM,CAaR;AAqBD;;;GAGG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,8BAA8B,GACtC,sBAAsB,CAyDxB;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,IAAI,CAAC,8BAA8B,EAAE,WAAW,GAAG,gBAAgB,CAAC,EAC7E,gBAAgB,SAAI,GACnB,MAAM,CA0BR"}

package/dist/components/data/DataTableVirtualization.js

@@ -0,0 +1,100 @@
+function assertNonNegativeInteger(value, label) {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new TypeError(`DataTable virtualization ${label} must be a non-negative integer`);
+    }
+}
+function assertPositiveFinite(value, label) {
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new TypeError(`DataTable virtualization ${label} must be a positive finite number`);
+    }
+}
+function clampScrollTop(scrollTop, totalBodyHeight, viewportHeight) {
+    if (!Number.isFinite(scrollTop)) {
+        throw new TypeError('DataTable virtualization scrollTop must be a finite number');
+    }
+    return Math.min(Math.max(0, scrollTop), Math.max(0, totalBodyHeight - viewportHeight));
+}
+/**
+ * Returns the maximum scroll position for a virtual body and an optional
+ * measured summary footer. Header and caption height are outside this range.
+ */
+export function maximumDataTableVirtualScrollTop(rowCount, options, footerHeight = 0) {
+    assertNonNegativeInteger(rowCount, 'rowCount');
+    assertPositiveFinite(options.rowHeight, 'rowHeight');
+    assertPositiveFinite(options.viewportHeight, 'viewportHeight');
+    if (!Number.isFinite(footerHeight) || footerHeight < 0) {
+        throw new TypeError('DataTable virtualization footerHeight must be a non-negative finite number');
+    }
+    return Math.max(0, rowCount * options.rowHeight - options.viewportHeight + footerHeight);
+}
+function staticWindow(rowCount, reason, headerRowCount, summaryRowCount) {
+    return {
+        enabled: false,
+        reason,
+        startIndex: 0,
+        endIndex: rowCount,
+        topSpacerHeight: 0,
+        bottomSpacerHeight: 0,
+        totalBodyHeight: 0,
+        headerRowCount,
+        summaryRowCount,
+    };
+}
+/**
+ * Resolves the renderable data-row window without using source order as an
+ * identity. The caller retains the rows and slices by the returned indexes.
+ */
+export function resolveDataTableVirtualWindow(context) {
+    const { options, rowCount, scrollTop, hasVariableRowHeight = false, headerRowCount = 0, summaryRowCount = 0, } = context;
+    assertNonNegativeInteger(rowCount, 'rowCount');
+    assertNonNegativeInteger(headerRowCount, 'headerRowCount');
+    assertNonNegativeInteger(summaryRowCount, 'summaryRowCount');
+    if (!options) {
+        return staticWindow(rowCount, 'disabled', headerRowCount, summaryRowCount);
+    }
+    const overscan = options.overscan ?? 3;
+    assertPositiveFinite(options.rowHeight, 'rowHeight');
+    assertPositiveFinite(options.viewportHeight, 'viewportHeight');
+    assertNonNegativeInteger(overscan, 'overscan');
+    if (hasVariableRowHeight) {
+        return staticWindow(rowCount, 'variable-row-height', headerRowCount, summaryRowCount);
+    }
+    const totalBodyHeight = rowCount * options.rowHeight;
+    const currentScrollTop = clampScrollTop(scrollTop, totalBodyHeight, options.viewportHeight);
+    const startIndex = Math.max(0, Math.floor(currentScrollTop / options.rowHeight) - overscan);
+    const endIndex = Math.min(rowCount, Math.ceil((currentScrollTop + options.viewportHeight) / options.rowHeight) +
+        overscan);
+    return {
+        enabled: true,
+        startIndex,
+        endIndex,
+        topSpacerHeight: startIndex * options.rowHeight,
+        bottomSpacerHeight: (rowCount - endIndex) * options.rowHeight,
+        totalBodyHeight,
+        headerRowCount,
+        summaryRowCount,
+    };
+}
+/**
+ * Returns the smallest fixed-height scroll position that reveals a stable row
+ * index, clamped to the body extent. Callers resolve the index from `rowKey`.
+ */
+export function scrollTopForDataTableRow(rowIndex, rowCount, options, currentScrollTop = 0) {
+    assertNonNegativeInteger(rowIndex, 'rowIndex');
+    assertNonNegativeInteger(rowCount, 'rowCount');
+    if (rowIndex >= rowCount) {
+        throw new RangeError('DataTable virtualization rowIndex must reference a data row');
+    }
+    assertPositiveFinite(options.rowHeight, 'rowHeight');
+    assertPositiveFinite(options.viewportHeight, 'viewportHeight');
+    const totalBodyHeight = rowCount * options.rowHeight;
+    const current = clampScrollTop(currentScrollTop, totalBodyHeight, options.viewportHeight);
+    const rowTop = rowIndex * options.rowHeight;
+    const rowBottom = rowTop + options.rowHeight;
+    const next = rowTop < current
+        ? rowTop
+        : rowBottom > current + options.viewportHeight
+            ? rowBottom - options.viewportHeight
+            : current;
+    return clampScrollTop(next, totalBodyHeight, options.viewportHeight);
+}

package/dist/components/data/__benchmarks__/DataTable.bench.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=DataTable.bench.d.ts.map

package/dist/components/data/__benchmarks__/DataTable.bench.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataTable.bench.d.ts","sourceRoot":"","sources":["../../../../src/components/data/__benchmarks__/DataTable.bench.ts"],"names":[],"mappings":""}

package/dist/components/data/__benchmarks__/DataTable.bench.js

@@ -0,0 +1,53 @@
+import { render } from '@testing-library/svelte';
+import { bench, describe } from 'vitest';
+import { createDataTablePerformanceColumns, createDataTablePerformanceRows, } from '../__fixtures__/DataTablePerformanceFixture.js';
+import DataTable from '../DataTable.svelte';
+import { createDataTableController } from '../DataTableController.js';
+const localRows = createDataTablePerformanceRows(250, 18);
+const localColumns = createDataTablePerformanceColumns(18);
+const transformRows = createDataTablePerformanceRows(1_000, 18);
+const manualPageRows = createDataTablePerformanceRows(100, 18);
+const BenchmarkDataTable = DataTable;
+describe('DataTable scale thresholds', () => {
+    bench('local render: 250 rows and 20 columns', () => {
+        const table = render(BenchmarkDataTable, {
+            props: { data: localRows, columns: localColumns, rowKey: 'id' },
+        });
+        table.unmount();
+    });
+    bench('client transforms: 1,000 rows and 20 columns', () => {
+        const controller = createDataTableController({
+            columnIds: localColumns.map((column) => column.id),
+            initialState: {
+                search: 'record 00',
+                sorting: [{ columnId: 'value0', direction: 'desc' }],
+            },
+        });
+        const table = render(BenchmarkDataTable, {
+            props: {
+                data: transformRows,
+                columns: localColumns,
+                rowKey: 'id',
+                controller,
+            },
+        });
+        table.unmount();
+    });
+    bench('manual paging: 100 supplied rows from a 100,000-row remote result', () => {
+        const controller = createDataTableController({
+            columnIds: localColumns.map((column) => column.id),
+            modes: { filtering: 'manual', sorting: 'manual', pagination: 'manual' },
+            initialState: { page: 500, pageSize: 100 },
+        });
+        const table = render(BenchmarkDataTable, {
+            props: {
+                data: manualPageRows,
+                columns: localColumns,
+                rowKey: 'id',
+                controller,
+                totalRows: 100_000,
+            },
+        });
+        table.unmount();
+    });
+});

package/dist/components/data/__fixtures__/DataTableConformanceFixture.d.ts

@@ -0,0 +1,27 @@
+import type { DataTableColumn, DataTableStructuralRow } from '../types.js';
+/**
+ * Shared, domain-neutral data used to exercise the documented DataTable
+ * contracts in component tests and the interactive workbench preview.
+ */
+export interface DataTableConformanceRow {
+    id: string;
+    account: string;
+    team: string;
+    actual: number;
+    forecast: number;
+    variance: number;
+    status: 'On track' | 'Watch';
+    action: string;
+}
+export declare const dataTableConformanceRows: DataTableConformanceRow[];
+export declare const dataTableConformanceColumns: DataTableColumn<DataTableConformanceRow>[];
+export declare const dataTableConformanceStructuralRows: DataTableStructuralRow<DataTableConformanceRow>[];
+/** The release-level scenarios that must remain represented in tests and the playground. */
+export interface DataTableConformanceScenario {
+    id: 'semantic-interaction' | 'manual-query' | 'async-lifecycle' | 'responsive-overflow' | 'report-layout' | 'scale-virtualization';
+    title: string;
+    contracts: readonly string[];
+}
+export declare const dataTableConformanceScenarios: readonly DataTableConformanceScenario[];
+export declare function createDataTableConformanceRows(rowCount: number): DataTableConformanceRow[];
+//# sourceMappingURL=DataTableConformanceFixture.d.ts.map

package/dist/components/data/__fixtures__/DataTableConformanceFixture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataTableConformanceFixture.d.ts","sourceRoot":"","sources":["../../../../src/components/data/__fixtures__/DataTableConformanceFixture.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAE3E;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC;IAC7B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,wBAAwB,EAAE,uBAAuB,EAqB7D,CAAC;AAEF,eAAO,MAAM,2BAA2B,EAAE,eAAe,CAAC,uBAAuB,CAAC,EAgD/E,CAAC;AAEJ,eAAO,MAAM,kCAAkC,EAAE,sBAAsB,CAAC,uBAAuB,CAAC,EAc7F,CAAC;AAEJ,4FAA4F;AAC5F,MAAM,WAAW,4BAA4B;IAC3C,EAAE,EACE,sBAAsB,GACtB,cAAc,GACd,iBAAiB,GACjB,qBAAqB,GACrB,eAAe,GACf,sBAAsB,CAAC;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9B;AAED,eAAO,MAAM,6BAA6B,EAAE,SAAS,4BAA4B,EA8C9E,CAAC;AAEJ,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,MAAM,GACf,uBAAuB,EAAE,CAW3B"}