@happyvertical/smrt-ui 0.42.4 → 0.42.5

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"}

package/dist/components/data/__fixtures__/DataTableConformanceFixture.js

@@ -0,0 +1,141 @@
+export const dataTableConformanceRows = [
+    {
+        id: 'revenue',
+        account: 'Subscription revenue',
+        team: 'Growth',
+        actual: 182_400,
+        forecast: 176_000,
+        variance: 6_400,
+        status: 'On track',
+        action: 'Review',
+    },
+    {
+        id: 'services',
+        account: 'Professional services',
+        team: 'Delivery',
+        actual: 48_300,
+        forecast: 52_000,
+        variance: -3_700,
+        status: 'Watch',
+        action: 'Review',
+    },
+];
+export const dataTableConformanceColumns = [
+    {
+        id: 'account',
+        label: 'Account',
+        headerPath: [{ id: 'dimensions', label: 'Dimensions' }],
+        minWidth: '13rem',
+        resizable: true,
+        sortable: true,
+    },
+    {
+        id: 'team',
+        label: 'Team',
+        headerPath: [{ id: 'dimensions', label: 'Dimensions' }],
+        minWidth: '9rem',
+    },
+    {
+        id: 'actual',
+        label: 'Actual',
+        headerPath: [{ id: 'performance', label: 'Performance' }],
+        align: 'right',
+        resizable: true,
+    },
+    {
+        id: 'forecast',
+        label: 'Forecast',
+        headerPath: [{ id: 'performance', label: 'Performance' }],
+        align: 'right',
+        resizable: true,
+    },
+    {
+        id: 'variance',
+        label: 'Variance',
+        headerPath: [{ id: 'performance', label: 'Performance' }],
+        align: 'right',
+    },
+    {
+        id: 'status',
+        label: 'Status',
+        role: 'status',
+        responsive: { keepVisible: true, priority: 10 },
+    },
+    {
+        id: 'action',
+        label: 'Action',
+        role: 'action',
+        responsive: { keepVisible: true, priority: 10 },
+    },
+];
+export const dataTableConformanceStructuralRows = [
+    {
+        id: 'forecast-subtotal',
+        kind: 'subtotal',
+        label: 'Current forecast',
+        values: { actual: 230_700, forecast: 228_000, variance: 2_700 },
+    },
+    {
+        id: 'forecast-total',
+        kind: 'footer',
+        label: 'All accounts',
+        values: { actual: 230_700, forecast: 228_000, variance: 2_700 },
+    },
+];
+export const dataTableConformanceScenarios = [
+    {
+        id: 'semantic-interaction',
+        title: 'Semantic interaction',
+        contracts: ['caption', 'rowKey', 'selection', 'keyboard row actions'],
+    },
+    {
+        id: 'manual-query',
+        title: 'Manual query ownership',
+        contracts: [
+            'modes',
+            'totalRows',
+            'query revision',
+            'allMatching selection',
+        ],
+    },
+    {
+        id: 'async-lifecycle',
+        title: 'Async lifecycle',
+        contracts: ['loading', 'refreshing', 'stale', 'partial results', 'retry'],
+    },
+    {
+        id: 'responsive-overflow',
+        title: 'Responsive overflow',
+        contracts: [
+            'responsive metadata',
+            'named overflow region',
+            'keyboard scroll',
+        ],
+    },
+    {
+        id: 'report-layout',
+        title: 'Report layout',
+        contracts: ['grouped headers', 'structural rows', 'widths', 'pinning'],
+    },
+    {
+        id: 'scale-virtualization',
+        title: 'Scale and virtualization',
+        contracts: [
+            'rowKey',
+            'virtual body',
+            'stable focus',
+            'footer reachability',
+        ],
+    },
+];
+export function createDataTableConformanceRows(rowCount) {
+    return Array.from({ length: rowCount }, (_, index) => {
+        const source = dataTableConformanceRows[index % dataTableConformanceRows.length];
+        const rowNumber = index + 1;
+        return {
+            ...source,
+            id: `conformance-${rowNumber}`,
+            account: `${source.account} ${rowNumber}`,
+        };
+    });
+}

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

@@ -0,0 +1,10 @@
+import type { DataTableColumn } from '../types.js';
+export interface DataTablePerformanceRow {
+    id: string;
+    name: string;
+    group: string;
+    values: Record<string, number>;
+}
+export declare function createDataTablePerformanceRows(rowCount: number, valueColumnCount: number): DataTablePerformanceRow[];
+export declare function createDataTablePerformanceColumns(valueColumnCount: number): DataTableColumn<DataTablePerformanceRow>[];
+//# sourceMappingURL=DataTablePerformanceFixture.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DataTablePerformanceFixture.d.ts","sourceRoot":"","sources":["../../../../src/components/data/__fixtures__/DataTablePerformanceFixture.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,MAAM,WAAW,uBAAuB;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC;AAED,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,MAAM,EAChB,gBAAgB,EAAE,MAAM,GACvB,uBAAuB,EAAE,CAY3B;AAED,wBAAgB,iCAAiC,CAC/C,gBAAgB,EAAE,MAAM,GACvB,eAAe,CAAC,uBAAuB,CAAC,EAAE,CAW5C"}

package/dist/components/data/__fixtures__/DataTablePerformanceFixture.js

@@ -0,0 +1,23 @@
+export function createDataTablePerformanceRows(rowCount, valueColumnCount) {
+    return Array.from({ length: rowCount }, (_, index) => ({
+        id: `row-${index}`,
+        name: `Record ${index.toString().padStart(5, '0')}`,
+        group: `group-${index % 10}`,
+        values: Object.fromEntries(Array.from({ length: valueColumnCount }, (_, valueIndex) => [
+            `value${valueIndex}`,
+            (index * (valueIndex + 3)) % 997,
+        ])),
+    }));
+}
+export function createDataTablePerformanceColumns(valueColumnCount) {
+    return [
+        { id: 'name', label: 'Name', accessor: 'name', sortable: true },
+        { id: 'group', label: 'Group', accessor: 'group', sortable: true },
+        ...Array.from({ length: valueColumnCount }, (_, index) => ({
+            id: `value${index}`,
+            label: `Value ${index + 1}`,
+            accessor: `values.value${index}`,
+            sortable: true,
+        })),
+    ];
+}