@affino/datagrid-worker 0.1.1

package/dist/workerOwnedRowModel.js

@@ -0,0 +1,893 @@
+import { DATAGRID_WORKER_ROW_MODEL_PAYLOAD_SCHEMA_VERSION, DATAGRID_WORKER_ROW_MODEL_PROTOCOL_VERSION, createDataGridWorkerRowModelCommandMessage, isDataGridWorkerRowModelUpdateMessage, } from "./workerOwnedRowModelProtocol.js";
+function createDefaultSnapshot() {
+    return {
+        kind: "client",
+        rowCount: 0,
+        loading: false,
+        error: null,
+        viewportRange: { start: 0, end: 0 },
+        pagination: {
+            enabled: false,
+            pageSize: 0,
+            currentPage: 0,
+            pageCount: 0,
+            totalRowCount: 0,
+            startIndex: 0,
+            endIndex: 0,
+        },
+        sortModel: [],
+        filterModel: null,
+        groupBy: null,
+        pivotModel: null,
+        pivotColumns: [],
+        groupExpansion: {
+            expandedByDefault: false,
+            toggledGroupKeys: [],
+        },
+    };
+}
+function cloneRowNode(row) {
+    return {
+        ...row,
+        groupMeta: row.groupMeta
+            ? {
+                ...row.groupMeta,
+                aggregates: row.groupMeta.aggregates
+                    ? { ...row.groupMeta.aggregates }
+                    : undefined,
+            }
+            : undefined,
+        state: { ...row.state },
+    };
+}
+function cloneSnapshot(snapshot) {
+    var _a;
+    return {
+        ...snapshot,
+        viewportRange: {
+            start: snapshot.viewportRange.start,
+            end: snapshot.viewportRange.end,
+        },
+        pagination: {
+            ...snapshot.pagination,
+        },
+        sortModel: snapshot.sortModel.map(sort => ({ ...sort })),
+        filterModel: snapshot.filterModel
+            ? {
+                columnFilters: { ...snapshot.filterModel.columnFilters },
+                advancedFilters: { ...snapshot.filterModel.advancedFilters },
+                advancedExpression: (_a = snapshot.filterModel.advancedExpression) !== null && _a !== void 0 ? _a : null,
+            }
+            : null,
+        groupBy: snapshot.groupBy
+            ? {
+                fields: [...snapshot.groupBy.fields],
+                expandedByDefault: snapshot.groupBy.expandedByDefault,
+            }
+            : null,
+        pivotModel: snapshot.pivotModel
+            ? {
+                rows: [...snapshot.pivotModel.rows],
+                columns: [...snapshot.pivotModel.columns],
+                values: snapshot.pivotModel.values.map(value => ({ ...value })),
+                ...(snapshot.pivotModel.rowSubtotals ? { rowSubtotals: true } : {}),
+                ...(snapshot.pivotModel.columnSubtotals ? { columnSubtotals: true } : {}),
+                ...(snapshot.pivotModel.columnGrandTotal ? { columnGrandTotal: true } : {}),
+                ...(snapshot.pivotModel.columnSubtotalPosition
+                    ? { columnSubtotalPosition: snapshot.pivotModel.columnSubtotalPosition }
+                    : {}),
+                ...(snapshot.pivotModel.columnGrandTotalPosition
+                    ? { columnGrandTotalPosition: snapshot.pivotModel.columnGrandTotalPosition }
+                    : {}),
+                ...(snapshot.pivotModel.grandTotal ? { grandTotal: true } : {}),
+            }
+            : null,
+        pivotColumns: snapshot.pivotColumns
+            ? snapshot.pivotColumns.map(column => ({
+                ...column,
+                columnPath: column.columnPath.map(segment => ({ ...segment })),
+            }))
+            : [],
+        groupExpansion: {
+            expandedByDefault: snapshot.groupExpansion.expandedByDefault,
+            toggledGroupKeys: [...snapshot.groupExpansion.toggledGroupKeys],
+        },
+    };
+}
+function cloneAggregationModel(model) {
+    if (!model) {
+        return null;
+    }
+    return {
+        columns: model.columns.map(column => ({
+            ...column,
+        })),
+        ...(model.basis ? { basis: model.basis } : {}),
+    };
+}
+function cloneFormulaExecutionPlan(plan) {
+    if (!plan) {
+        return null;
+    }
+    return {
+        order: [...plan.order],
+        levels: plan.levels.map(level => [...level]),
+        nodes: plan.nodes.map(node => ({
+            name: node.name,
+            field: node.field,
+            level: node.level,
+            fieldDeps: [...node.fieldDeps],
+            computedDeps: [...node.computedDeps],
+            dependents: [...node.dependents],
+        })),
+    };
+}
+function cloneFormulaComputeStageDiagnostics(diagnostics) {
+    if (!diagnostics) {
+        return null;
+    }
+    return {
+        strategy: diagnostics.strategy,
+        rowsTouched: diagnostics.rowsTouched,
+        changedRows: diagnostics.changedRows,
+        fieldsTouched: [...diagnostics.fieldsTouched],
+        evaluations: diagnostics.evaluations,
+        skippedByObjectIs: diagnostics.skippedByObjectIs,
+        dirtyRows: diagnostics.dirtyRows,
+        dirtyNodes: [...diagnostics.dirtyNodes],
+    };
+}
+export function createDataGridWorkerOwnedRowModel(options) {
+    var _a;
+    const MAX_WINDOW_CACHE_SIZE = 8;
+    const INITIAL_SYNC_PREFETCH_MAX_ROWS = 25;
+    const PATCH_BURST_IMMEDIATE_FLUSH_THRESHOLD = 1024;
+    const viewportCoalescingStrategy = (_a = options.viewportCoalescingStrategy) !== null && _a !== void 0 ? _a : "split";
+    let disposed = false;
+    let nextRequestId = 1;
+    let lastAppliedRequestId = 0;
+    let initialWindowPrefetchResolved = false;
+    let loadingViewport = false;
+    let pendingViewportRequestId = 0;
+    let pendingViewportRange = null;
+    let requestedViewportRange = null;
+    let dispatchCount = 0;
+    let updatesReceived = 0;
+    let updatesApplied = 0;
+    let updatesDroppedStale = 0;
+    let updatesDroppedInitialAfterApplied = 0;
+    let commandsCoalesced = 0;
+    let patchCommandsCoalesced = 0;
+    let patchUpdatesReceived = 0;
+    let patchUpdatesDispatched = 0;
+    let patchUpdatesMergedAway = 0;
+    let immediateFlushCount = 0;
+    let queuePeak = 0;
+    let lastPayloadSchemaVersion = null;
+    let payloadSchemaMismatches = 0;
+    let loadingSetCount = 0;
+    let loadingClearCount = 0;
+    let snapshot = options.initialSnapshot
+        ? cloneSnapshot(options.initialSnapshot)
+        : createDefaultSnapshot();
+    let aggregationModel = null;
+    let formulaFields = [];
+    let formulaExecutionPlan = null;
+    let formulaComputeStageDiagnostics = null;
+    let visibleRange = {
+        start: snapshot.viewportRange.start,
+        end: snapshot.viewportRange.end,
+    };
+    let visibleRows = [];
+    const visibleWindowCache = new Map();
+    const visibleWindowCacheOrder = [];
+    const queuedCommands = [];
+    const queuedCommandIndexByKey = new Map();
+    let flushScheduled = false;
+    const listeners = new Set();
+    const rangeKey = (range) => `${range.start}:${range.end}`;
+    const parseRangeKey = (key) => {
+        const [startRaw, endRaw] = key.split(":");
+        const start = Number.parseInt(startRaw !== null && startRaw !== void 0 ? startRaw : "", 10);
+        const end = Number.parseInt(endRaw !== null && endRaw !== void 0 ? endRaw : "", 10);
+        if (!Number.isFinite(start) || !Number.isFinite(end)) {
+            return null;
+        }
+        return {
+            start,
+            end,
+        };
+    };
+    const rangeContains = (container, target) => {
+        if (!container) {
+            return false;
+        }
+        return container.start <= target.start && container.end >= target.end;
+    };
+    const isSameRange = (left, right) => {
+        return Boolean(left) && left.start === right.start && left.end === right.end;
+    };
+    const normalizeRequestedRange = (range) => {
+        if (range.start <= range.end) {
+            return range;
+        }
+        return {
+            start: range.end,
+            end: range.start,
+        };
+    };
+    const normalizeDispatchViewportRange = (range) => {
+        const normalized = normalizeRequestedRange(range);
+        const requestedSize = Math.max(1, normalized.end - normalized.start + 1);
+        const prefetchPad = Math.max(24, Math.min(96, Math.ceil(requestedSize * 0.75)));
+        const rowCount = Math.max(0, snapshot.rowCount);
+        const expandedStart = Math.max(0, normalized.start - prefetchPad);
+        const expandedEndRaw = normalized.end + prefetchPad;
+        const expandedEnd = rowCount > 0 ? Math.min(rowCount - 1, expandedEndRaw) : expandedEndRaw;
+        return {
+            start: expandedStart,
+            end: Math.max(expandedStart, expandedEnd),
+        };
+    };
+    const isRangeCoveredByVisibleWindow = (range) => {
+        if (visibleRows.length <= 0) {
+            return false;
+        }
+        return rangeContains(visibleRange, range);
+    };
+    const clampRangeToRowCount = (range, rowCount) => {
+        const normalized = normalizeRequestedRange(range);
+        if (rowCount <= 0) {
+            return { start: 0, end: 0 };
+        }
+        const start = Math.max(0, Math.min(rowCount - 1, normalized.start));
+        const end = Math.max(start, Math.min(rowCount - 1, normalized.end));
+        return { start, end };
+    };
+    const buildPublicSnapshot = () => {
+        const nextSnapshot = cloneSnapshot(snapshot);
+        if (loadingViewport) {
+            nextSnapshot.loading = true;
+        }
+        return nextSnapshot;
+    };
+    const emit = () => {
+        if (listeners.size === 0) {
+            return;
+        }
+        const nextSnapshot = buildPublicSnapshot();
+        for (const listener of listeners) {
+            listener(nextSnapshot);
+        }
+    };
+    const mergePatchRowOptions = (left, right) => {
+        var _a;
+        if (!left && !right) {
+            return undefined;
+        }
+        const merged = {};
+        if ((left === null || left === void 0 ? void 0 : left.recomputeSort) === true || (right === null || right === void 0 ? void 0 : right.recomputeSort) === true) {
+            merged.recomputeSort = true;
+        }
+        if ((left === null || left === void 0 ? void 0 : left.recomputeFilter) === true || (right === null || right === void 0 ? void 0 : right.recomputeFilter) === true) {
+            merged.recomputeFilter = true;
+        }
+        if ((left === null || left === void 0 ? void 0 : left.recomputeGroup) === true || (right === null || right === void 0 ? void 0 : right.recomputeGroup) === true) {
+            merged.recomputeGroup = true;
+        }
+        if (right && "emit" in right && right.emit !== undefined) {
+            merged.emit = right.emit;
+        }
+        if (right && "signal" in right) {
+            merged.signal = (_a = right.signal) !== null && _a !== void 0 ? _a : null;
+        }
+        return Object.keys(merged).length > 0 ? merged : undefined;
+    };
+    const mergePatchRowUpdates = (left, right) => {
+        if (left.length === 0) {
+            return right;
+        }
+        if (right.length === 0) {
+            return left;
+        }
+        const mergedByRowId = new Map();
+        const order = [];
+        const addUpdates = (updates) => {
+            var _a;
+            for (const update of updates) {
+                if (!mergedByRowId.has(update.rowId)) {
+                    order.push(update.rowId);
+                    mergedByRowId.set(update.rowId, update.data);
+                    continue;
+                }
+                const previous = (_a = mergedByRowId.get(update.rowId)) !== null && _a !== void 0 ? _a : {};
+                mergedByRowId.set(update.rowId, { ...previous, ...update.data });
+            }
+        };
+        addUpdates(left);
+        addUpdates(right);
+        return order.map((rowId) => {
+            var _a;
+            return ({
+                rowId,
+                data: (_a = mergedByRowId.get(rowId)) !== null && _a !== void 0 ? _a : {},
+            });
+        });
+    };
+    const mergeCommandPayload = (left, right) => {
+        if (left.type === "patch-rows" && right.type === "patch-rows") {
+            const mergedOptions = mergePatchRowOptions(left.options, right.options);
+            const mergedUpdates = mergePatchRowUpdates(left.updates, right.updates);
+            return {
+                type: "patch-rows",
+                updates: mergedUpdates,
+                ...(mergedOptions ? { options: mergedOptions } : {}),
+            };
+        }
+        return right;
+    };
+    const getCoalesceKey = (payload) => {
+        var _a;
+        switch (payload.type) {
+            case "set-rows":
+                return payload.type;
+            case "patch-rows":
+                return payload.type;
+            case "set-viewport-range":
+                if (viewportCoalescingStrategy === "simple") {
+                    return "set-viewport-range";
+                }
+                return `set-viewport-range:${(_a = payload.coalesceScope) !== null && _a !== void 0 ? _a : "user"}`;
+            case "set-pagination":
+            case "set-page-size":
+            case "set-current-page":
+            case "set-sort-model":
+            case "set-filter-model":
+            case "set-sort-and-filter-model":
+            case "set-group-by":
+            case "set-pivot-model":
+            case "set-aggregation-model":
+            case "set-group-expansion":
+            case "register-formula-field":
+            case "refresh":
+                return payload.type;
+            default:
+                return null;
+        }
+    };
+    const cloneForTransport = (value, context) => {
+        if (typeof structuredClone === "function") {
+            try {
+                return structuredClone(value);
+            }
+            catch {
+                // Fallback below for reactive proxies and other non-structured values.
+            }
+        }
+        try {
+            return JSON.parse(JSON.stringify(value));
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            throw new Error(`[AffinoDataGrid worker] Unable to serialize ${context}: ${reason}`);
+        }
+    };
+    const ensureAggregationModelSerializable = (model) => {
+        if (!model) {
+            return;
+        }
+        for (const column of model.columns) {
+            if (typeof column.createState === "function"
+                || typeof column.add === "function"
+                || typeof column.remove === "function"
+                || typeof column.finalize === "function"
+                || typeof column.coerce === "function") {
+                throw new Error("[AffinoDataGrid worker] aggregationModel with function callbacks is not supported in worker-owned mode.");
+            }
+        }
+    };
+    const validateCommandPayload = (payload) => {
+        if (payload.type === "set-aggregation-model") {
+            ensureAggregationModelSerializable(payload.aggregationModel);
+        }
+    };
+    const isDataCloneError = (error) => {
+        return Boolean(error
+            && typeof error === "object"
+            && "name" in error
+            && error.name === "DataCloneError");
+    };
+    const pushWindowCache = (range, rows) => {
+        const key = rangeKey(range);
+        if (visibleWindowCache.has(key)) {
+            const existingIndex = visibleWindowCacheOrder.indexOf(key);
+            if (existingIndex >= 0) {
+                visibleWindowCacheOrder.splice(existingIndex, 1);
+            }
+        }
+        visibleWindowCache.set(key, rows.map(cloneRowNode));
+        visibleWindowCacheOrder.push(key);
+        while (visibleWindowCacheOrder.length > MAX_WINDOW_CACHE_SIZE) {
+            const oldestKey = visibleWindowCacheOrder.shift();
+            if (!oldestKey) {
+                break;
+            }
+            visibleWindowCache.delete(oldestKey);
+        }
+    };
+    const markViewportLoading = (range, requestId) => {
+        pendingViewportRequestId = Math.max(pendingViewportRequestId, requestId);
+        pendingViewportRange = { start: range.start, end: range.end };
+        if (loadingViewport) {
+            return;
+        }
+        loadingViewport = true;
+        loadingSetCount += 1;
+        emit();
+    };
+    const flushQueuedCommands = () => {
+        if (disposed || queuedCommands.length === 0) {
+            return;
+        }
+        const commands = queuedCommands.splice(0, queuedCommands.length);
+        queuedCommandIndexByKey.clear();
+        for (const command of commands) {
+            try {
+                let message = createDataGridWorkerRowModelCommandMessage(command.requestId, command.payload, options.channel);
+                if (command.payload.type === "patch-rows") {
+                    patchUpdatesDispatched += command.payload.updates.length;
+                }
+                dispatchCount += 1;
+                try {
+                    options.target.postMessage(message);
+                }
+                catch (error) {
+                    if (!isDataCloneError(error)) {
+                        throw error;
+                    }
+                    message = createDataGridWorkerRowModelCommandMessage(command.requestId, cloneForTransport(command.payload, `command '${command.payload.type}'`), options.channel);
+                    options.target.postMessage(message);
+                }
+                if (command.payload.type === "set-viewport-range") {
+                    markViewportLoading(command.payload.range, command.requestId);
+                }
+            }
+            catch (error) {
+                loadingViewport = false;
+                pendingViewportRequestId = 0;
+                pendingViewportRange = null;
+                const reason = error instanceof Error ? error.message : String(error);
+                snapshot = {
+                    ...snapshot,
+                    error: new Error(`[AffinoDataGrid worker] dispatch failed: ${reason}`),
+                };
+                emit();
+            }
+        }
+    };
+    const flushNow = () => {
+        immediateFlushCount += 1;
+        flushScheduled = false;
+        flushQueuedCommands();
+    };
+    const scheduleFlush = () => {
+        if (flushScheduled || disposed) {
+            return;
+        }
+        flushScheduled = true;
+        queueMicrotask(() => {
+            flushScheduled = false;
+            flushQueuedCommands();
+        });
+    };
+    const dispatchCommand = (payload) => {
+        if (disposed) {
+            return 0;
+        }
+        validateCommandPayload(payload);
+        if (payload.type === "patch-rows") {
+            patchUpdatesReceived += payload.updates.length;
+        }
+        const requestId = nextRequestId++;
+        const coalesceKey = getCoalesceKey(payload);
+        if (coalesceKey) {
+            const existingIndex = queuedCommandIndexByKey.get(coalesceKey);
+            if (typeof existingIndex === "number" && queuedCommands[existingIndex]) {
+                const existingCommand = queuedCommands[existingIndex];
+                const mergedPayload = mergeCommandPayload(existingCommand.payload, payload);
+                commandsCoalesced += 1;
+                if (existingCommand.payload.type === "patch-rows"
+                    && payload.type === "patch-rows"
+                    && mergedPayload.type === "patch-rows") {
+                    patchCommandsCoalesced += 1;
+                    const mergedAway = (existingCommand.payload.updates.length
+                        + payload.updates.length
+                        - mergedPayload.updates.length);
+                    if (mergedAway > 0) {
+                        patchUpdatesMergedAway += mergedAway;
+                    }
+                }
+                queuedCommands[existingIndex] = {
+                    requestId,
+                    payload: mergedPayload,
+                    coalesceKey,
+                };
+                if (mergedPayload.type === "patch-rows"
+                    && mergedPayload.updates.length >= PATCH_BURST_IMMEDIATE_FLUSH_THRESHOLD) {
+                    flushNow();
+                    return requestId;
+                }
+                scheduleFlush();
+                return requestId;
+            }
+        }
+        const command = {
+            requestId,
+            payload,
+            coalesceKey,
+        };
+        queuedCommands.push(command);
+        if (coalesceKey) {
+            queuedCommandIndexByKey.set(coalesceKey, queuedCommands.length - 1);
+        }
+        if (queuedCommands.length > queuePeak) {
+            queuePeak = queuedCommands.length;
+        }
+        if (payload.type === "patch-rows"
+            && payload.updates.length >= PATCH_BURST_IMMEDIATE_FLUSH_THRESHOLD) {
+            flushNow();
+            return requestId;
+        }
+        scheduleFlush();
+        return requestId;
+    };
+    const dispatchViewportRange = (range, coalesceScope) => {
+        const normalizedRequestedRange = normalizeRequestedRange(range);
+        const syncRequestedViewportSnapshot = () => {
+            if (coalesceScope !== "user" || isSameRange(snapshot.viewportRange, normalizedRequestedRange)) {
+                return;
+            }
+            snapshot = {
+                ...snapshot,
+                viewportRange: { ...normalizedRequestedRange },
+            };
+            emit();
+        };
+        if (coalesceScope === "user") {
+            requestedViewportRange = { ...normalizedRequestedRange };
+        }
+        if (isRangeCoveredByVisibleWindow(normalizedRequestedRange)
+            || rangeContains(pendingViewportRange, normalizedRequestedRange)) {
+            syncRequestedViewportSnapshot();
+            return 0;
+        }
+        const dispatchRange = normalizeDispatchViewportRange(normalizedRequestedRange);
+        if (isRangeCoveredByVisibleWindow(dispatchRange)
+            || rangeContains(pendingViewportRange, dispatchRange)) {
+            syncRequestedViewportSnapshot();
+            return 0;
+        }
+        const normalizedScope = viewportCoalescingStrategy === "simple"
+            ? "user"
+            : coalesceScope;
+        const requestId = dispatchCommand({
+            type: "set-viewport-range",
+            range: dispatchRange,
+            coalesceScope: normalizedScope,
+        });
+        if (requestId > 0) {
+            markViewportLoading(dispatchRange, requestId);
+        }
+        return requestId;
+    };
+    const onMessage = (event) => {
+        if (disposed) {
+            return;
+        }
+        if (!isDataGridWorkerRowModelUpdateMessage(event.data, options.channel)) {
+            return;
+        }
+        updatesReceived += 1;
+        const requestId = event.data.requestId;
+        if (requestId === 0 && lastAppliedRequestId > 0) {
+            updatesDroppedInitialAfterApplied += 1;
+            return;
+        }
+        if (requestId > 0 && requestId < lastAppliedRequestId) {
+            updatesDroppedStale += 1;
+            return;
+        }
+        if (requestId > 0) {
+            lastAppliedRequestId = requestId;
+        }
+        const update = event.data.payload;
+        const payloadSchemaVersion = typeof update.schemaVersion === "number"
+            ? update.schemaVersion
+            : 1;
+        lastPayloadSchemaVersion = payloadSchemaVersion;
+        if (payloadSchemaVersion !== DATAGRID_WORKER_ROW_MODEL_PAYLOAD_SCHEMA_VERSION) {
+            payloadSchemaMismatches += 1;
+        }
+        snapshot = update.snapshot;
+        if (requestedViewportRange) {
+            snapshot = {
+                ...snapshot,
+                viewportRange: clampRangeToRowCount(requestedViewportRange, snapshot.rowCount),
+            };
+        }
+        aggregationModel = cloneAggregationModel(update.aggregationModel);
+        formulaFields = Array.isArray(update.formulaFields)
+            ? update.formulaFields.map(field => ({
+                name: field.name,
+                field: field.field,
+                formula: field.formula,
+                deps: [...field.deps],
+                contextKeys: [...field.contextKeys],
+            }))
+            : [];
+        formulaExecutionPlan = cloneFormulaExecutionPlan(update.formulaExecutionPlan);
+        formulaComputeStageDiagnostics = cloneFormulaComputeStageDiagnostics(update.formulaComputeStageDiagnostics);
+        visibleRange = {
+            start: update.visibleRange.start,
+            end: update.visibleRange.end,
+        };
+        visibleRows = update.visibleRows;
+        pushWindowCache(visibleRange, visibleRows);
+        if (!initialWindowPrefetchResolved && requestId === 0) {
+            const totalRows = snapshot.rowCount;
+            if (totalRows > 0 && totalRows <= INITIAL_SYNC_PREFETCH_MAX_ROWS) {
+                const prefetchedRange = {
+                    start: 0,
+                    end: totalRows - 1,
+                };
+                const expectedCount = prefetchedRange.end - prefetchedRange.start + 1;
+                const hasFullInitialWindow = visibleRange.start === prefetchedRange.start
+                    && visibleRange.end === prefetchedRange.end
+                    && visibleRows.length >= expectedCount;
+                if (!hasFullInitialWindow && !isSameRange(pendingViewportRange, prefetchedRange)) {
+                    dispatchViewportRange(prefetchedRange, "prefetch");
+                }
+            }
+            initialWindowPrefetchResolved = true;
+        }
+        const matchesPendingRange = isSameRange(pendingViewportRange, visibleRange);
+        if (loadingViewport && (requestId >= pendingViewportRequestId || matchesPendingRange)) {
+            loadingViewport = false;
+            pendingViewportRequestId = 0;
+            pendingViewportRange = null;
+            loadingClearCount += 1;
+        }
+        updatesApplied += 1;
+        emit();
+    };
+    options.source.addEventListener("message", onMessage);
+    if (options.requestInitialSync !== false) {
+        dispatchCommand({ type: "sync" });
+    }
+    const readVisibleRowByIndex = (index) => {
+        if (index < visibleRange.start || index > visibleRange.end) {
+            return undefined;
+        }
+        return visibleRows[index - visibleRange.start];
+    };
+    const readCachedRowByIndex = (index) => {
+        const visibleRow = readVisibleRowByIndex(index);
+        if (visibleRow) {
+            return cloneRowNode(visibleRow);
+        }
+        for (let orderIndex = visibleWindowCacheOrder.length - 1; orderIndex >= 0; orderIndex -= 1) {
+            const key = visibleWindowCacheOrder[orderIndex];
+            if (!key) {
+                continue;
+            }
+            const range = parseRangeKey(key);
+            if (!range || index < range.start || index > range.end) {
+                continue;
+            }
+            const cachedRows = visibleWindowCache.get(key);
+            const cachedRow = cachedRows === null || cachedRows === void 0 ? void 0 : cachedRows[index - range.start];
+            if (cachedRow) {
+                return cloneRowNode(cachedRow);
+            }
+        }
+        return undefined;
+    };
+    return {
+        kind: "client",
+        getSnapshot() {
+            return buildPublicSnapshot();
+        },
+        getRowCount() {
+            return snapshot.rowCount;
+        },
+        getRow(index) {
+            const row = readVisibleRowByIndex(index);
+            if (row) {
+                return cloneRowNode(row);
+            }
+            const requestedRange = { start: index, end: index };
+            if (!isSameRange(pendingViewportRange, requestedRange)) {
+                dispatchViewportRange(requestedRange, "user");
+            }
+            return undefined;
+        },
+        getRowsInRange(range) {
+            if (range.start !== visibleRange.start || range.end !== visibleRange.end) {
+                if (!isSameRange(pendingViewportRange, range)) {
+                    dispatchViewportRange(range, "user");
+                }
+            }
+            const key = rangeKey(range);
+            const cachedRows = visibleWindowCache.get(key);
+            if (cachedRows) {
+                return [...cachedRows];
+            }
+            const rows = [];
+            for (let index = range.start; index <= range.end; index += 1) {
+                const row = readCachedRowByIndex(index);
+                if (row) {
+                    rows.push(row);
+                }
+            }
+            return rows;
+        },
+        setViewportRange(range) {
+            dispatchViewportRange(range, "user");
+        },
+        setPagination(pagination) {
+            dispatchCommand({ type: "set-pagination", pagination });
+        },
+        setPageSize(pageSize) {
+            dispatchCommand({ type: "set-page-size", pageSize });
+        },
+        setCurrentPage(page) {
+            dispatchCommand({ type: "set-current-page", page });
+        },
+        setSortModel(sortModel) {
+            dispatchCommand({ type: "set-sort-model", sortModel: sortModel.map(sort => ({ ...sort })) });
+        },
+        setFilterModel(filterModel) {
+            dispatchCommand({ type: "set-filter-model", filterModel });
+        },
+        setSortAndFilterModel(input) {
+            dispatchCommand({
+                type: "set-sort-and-filter-model",
+                input: {
+                    sortModel: input.sortModel.map(sort => ({ ...sort })),
+                    filterModel: input.filterModel,
+                },
+            });
+        },
+        setGroupBy(groupBy) {
+            dispatchCommand({ type: "set-group-by", groupBy });
+        },
+        setPivotModel(pivotModel) {
+            dispatchCommand({ type: "set-pivot-model", pivotModel });
+        },
+        getPivotModel() {
+            if (!snapshot.pivotModel) {
+                return null;
+            }
+            return {
+                rows: [...snapshot.pivotModel.rows],
+                columns: [...snapshot.pivotModel.columns],
+                values: snapshot.pivotModel.values.map(value => ({ ...value })),
+                ...(snapshot.pivotModel.rowSubtotals ? { rowSubtotals: true } : {}),
+                ...(snapshot.pivotModel.columnSubtotals ? { columnSubtotals: true } : {}),
+                ...(snapshot.pivotModel.columnGrandTotal ? { columnGrandTotal: true } : {}),
+                ...(snapshot.pivotModel.columnSubtotalPosition
+                    ? { columnSubtotalPosition: snapshot.pivotModel.columnSubtotalPosition }
+                    : {}),
+                ...(snapshot.pivotModel.columnGrandTotalPosition
+                    ? { columnGrandTotalPosition: snapshot.pivotModel.columnGrandTotalPosition }
+                    : {}),
+                ...(snapshot.pivotModel.grandTotal ? { grandTotal: true } : {}),
+            };
+        },
+        setAggregationModel(nextAggregationModel) {
+            const nextModel = cloneAggregationModel(nextAggregationModel);
+            aggregationModel = nextModel;
+            dispatchCommand({ type: "set-aggregation-model", aggregationModel: nextModel });
+        },
+        getAggregationModel() {
+            return cloneAggregationModel(aggregationModel);
+        },
+        setGroupExpansion(expansion) {
+            dispatchCommand({ type: "set-group-expansion", expansion });
+        },
+        toggleGroup(groupKey) {
+            dispatchCommand({ type: "toggle-group", groupKey });
+        },
+        expandGroup(groupKey) {
+            dispatchCommand({ type: "expand-group", groupKey });
+        },
+        collapseGroup(groupKey) {
+            dispatchCommand({ type: "collapse-group", groupKey });
+        },
+        expandAllGroups() {
+            dispatchCommand({ type: "expand-all-groups" });
+        },
+        collapseAllGroups() {
+            dispatchCommand({ type: "collapse-all-groups" });
+        },
+        refresh(reason) {
+            dispatchCommand({ type: "refresh", reason });
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        setRows(rows) {
+            dispatchCommand({ type: "set-rows", rows });
+        },
+        patchRows(updates, options) {
+            dispatchCommand({ type: "patch-rows", updates, options });
+        },
+        registerFormulaField(definition) {
+            dispatchCommand({ type: "register-formula-field", definition });
+        },
+        getFormulaFields() {
+            return formulaFields.map(field => ({
+                name: field.name,
+                field: field.field,
+                formula: field.formula,
+                deps: [...field.deps],
+                contextKeys: [...field.contextKeys],
+            }));
+        },
+        getFormulaExecutionPlan() {
+            return cloneFormulaExecutionPlan(formulaExecutionPlan);
+        },
+        getFormulaComputeStageDiagnostics() {
+            return cloneFormulaComputeStageDiagnostics(formulaComputeStageDiagnostics);
+        },
+        getComputeDiagnostics() {
+            return {
+                configuredMode: "worker",
+                effectiveMode: "worker",
+                transportKind: "custom",
+                dispatchCount,
+                fallbackCount: 0,
+            };
+        },
+        getWorkerProtocolDiagnostics() {
+            return {
+                updatesReceived,
+                updatesApplied,
+                updatesDroppedStale,
+                updatesDroppedInitialAfterApplied,
+                commandsCoalesced,
+                patchCommandsCoalesced,
+                patchUpdatesReceived,
+                patchUpdatesDispatched,
+                patchUpdatesMergedAway,
+                immediateFlushCount,
+                queuePeak,
+                protocolVersion: DATAGRID_WORKER_ROW_MODEL_PROTOCOL_VERSION,
+                expectedPayloadSchemaVersion: DATAGRID_WORKER_ROW_MODEL_PAYLOAD_SCHEMA_VERSION,
+                lastPayloadSchemaVersion,
+                payloadSchemaMismatches,
+                loadingSetCount,
+                loadingClearCount,
+            };
+        },
+        dispose() {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+            options.source.removeEventListener("message", onMessage);
+            listeners.clear();
+            visibleRows = [];
+            visibleWindowCache.clear();
+            visibleWindowCacheOrder.length = 0;
+            queuedCommands.length = 0;
+            queuedCommandIndexByKey.clear();
+            formulaFields = [];
+            formulaExecutionPlan = null;
+            formulaComputeStageDiagnostics = null;
+        },
+    };
+}