@vuu-ui/vuu-data-local 3.0.0 → 3.1.0-beta.2

package/src/array-data-source/array-data-source.js

@@ -0,0 +1,689 @@
+import { filterPredicate, parseFilter } from "@vuu-ui/vuu-filter-parser";
+import { EventEmitter, KeySet, NULL_RANGE, Range, buildColumnMap, combineFilters, filterAsQuery, getAddedItems, hasBaseFilter, hasFilter, hasGroupBy, hasSort, isConfigChanged, isGroupByChanged, logger, metadataKeys, rangeNewItems, toSchemaColumn, uuid, vanillaConfig, withConfigDefaults } from "@vuu-ui/vuu-utils";
+import { aggregateData } from "./aggregate-utils.js";
+import { buildDataToClientMap, toClientRow } from "./array-data-utils.js";
+import { collapseGroup, expandGroup, groupRows } from "./group-utils.js";
+import { binarySearch, sortComparator, sortRows } from "./sort-utils.js";
+const { debug: debug, info: info } = logger("ArrayDataSource");
+const { KEY: KEY } = metadataKeys;
+const toDataSourceRow = (indexOfKeyColumn, index)=>(data, idx)=>{
+        const key = `${data[indexOfKeyColumn]}`;
+        index?.set(key, idx);
+        return [
+            idx,
+            idx,
+            true,
+            false,
+            1,
+            0,
+            key,
+            0,
+            0,
+            false,
+            ...data
+        ];
+    };
+const buildTableSchema = (columns, keyColumn)=>{
+    const schema = {
+        columns: columns.map(toSchemaColumn),
+        key: keyColumn ?? columns[0].name,
+        table: {
+            module: "",
+            table: "Array"
+        }
+    };
+    return schema;
+};
+class ArrayDataSource extends EventEmitter {
+    clientCallback;
+    columnDescriptors;
+    dataIndices;
+    dataMap;
+    groupMap;
+    key;
+    lastRangeServed = {
+        from: 0,
+        to: 0
+    };
+    rangeChangeRowset;
+    openTreeNodes = [];
+    preserveScrollPositionAcrossConfigChange = false;
+    #columnMap;
+    _config = vanillaConfig;
+    #data;
+    #freezeTimestamp = void 0;
+    #keys = new KeySet(NULL_RANGE);
+    #links;
+    #maxRangeEnd = Number.MAX_SAFE_INTEGER;
+    #range = Range(0, 0);
+    #status = "initialising";
+    #title;
+    _menu;
+    selectedRows = new Set();
+    index = new Map();
+    tableSchema;
+    viewport;
+    processedData = void 0;
+    constructor({ aggregations, baseFilterSpec, columnDescriptors, data, dataMap, filterSpec, groupBy, keyColumn, rangeChangeRowset = "delta", sort, title, viewport }){
+        super();
+        if (!data || !columnDescriptors) throw Error("ArrayDataSource constructor called without data or without columnDescriptors");
+        this.columnDescriptors = columnDescriptors;
+        this.dataMap = dataMap;
+        this.key = keyColumn ? this.columnDescriptors.findIndex((col)=>col.name === keyColumn) : 0;
+        this.rangeChangeRowset = rangeChangeRowset;
+        this.tableSchema = buildTableSchema(columnDescriptors, keyColumn);
+        this.viewport = viewport || uuid();
+        this.#title = title;
+        const columns = columnDescriptors.map((col)=>col.name);
+        this.#columnMap = buildColumnMap(columns);
+        this.dataIndices = buildDataToClientMap(this.#columnMap, this.dataMap);
+        this.#data = data.map(toDataSourceRow(this.key, this.index));
+        this.config = {
+            ...this._config,
+            aggregations: aggregations || this._config.aggregations,
+            baseFilterSpec,
+            columns,
+            filterSpec: filterSpec || this._config.filterSpec,
+            groupBy: groupBy || this._config.groupBy,
+            sort: sort || this._config.sort
+        };
+        debug?.(`columnMap: ${JSON.stringify(this.#columnMap)}`);
+    }
+    async subscribe({ viewport = this.viewport ?? (this.viewport = uuid()), columns, aggregations, baseFilterSpec, range, sort, groupBy, filterSpec }, callback) {
+        this.clientCallback = callback;
+        this.viewport = viewport;
+        this.#status = "subscribed";
+        this.lastRangeServed = {
+            from: 0,
+            to: 0
+        };
+        if (this.tableSchema.rangeLimits) this.#maxRangeEnd = this.tableSchema.rangeLimits.maxRangeEnd;
+        let config = this._config;
+        const hasConfigProps = aggregations || columns || filterSpec || groupBy || sort;
+        if (hasConfigProps) config = {
+            ...config,
+            aggregations: aggregations || this._config.aggregations,
+            baseFilterSpec: baseFilterSpec || this._config.baseFilterSpec,
+            columns: columns || this._config.columns,
+            filterSpec: filterSpec || this._config.filterSpec,
+            groupBy: groupBy || this._config.groupBy,
+            sort: sort || this._config.sort
+        };
+        const subscribedMessage = {
+            ...config,
+            type: "subscribed",
+            clientViewportId: this.viewport,
+            range: this.#range,
+            tableSchema: this.tableSchema
+        };
+        this.clientCallback?.(subscribedMessage);
+        this.emit("subscribed", subscribedMessage);
+        if (hasConfigProps) this.config = config;
+        else {
+            this.sendSizeUpdateToClient();
+            this.emit("resize", this.processedData ? this.processedData.length : this.#data.length, this.#maxRangeEnd);
+            if (range && !this.#range.equals(range)) this.range = range;
+            else if (this.#range !== NULL_RANGE) this.sendRowsToClient();
+            if (0 !== this.range.to) {
+                const pageCount = Math.ceil(this.size / (this.range.to - this.range.from));
+                this.emit("page-count", pageCount);
+            }
+        }
+    }
+    unsubscribe() {
+        this.#status = "unsubscribed";
+        this.emit("unsubscribed", this.viewport);
+        this.removeAllListeners();
+        this.clientCallback = void 0;
+    }
+    suspend() {
+        console.log('[ArrayDataSource] suspend');
+        if ("unsubscribed" !== this.#status) {
+            info?.(`suspend #${this.viewport}, current status ${this.#status}`);
+            this.#status = "suspended";
+            this.emit("suspended", this.viewport);
+        }
+    }
+    resume(callback) {
+        const isSuspended = "suspended" === this.#status;
+        info?.(`resume #${this.viewport}, current status ${this.#status}`);
+        if (callback) this.clientCallback = callback;
+        if (isSuspended) this.#status = "subscribed";
+        this.emit("resumed", this.viewport);
+        if (this.selectedRows.size > 0) if (this.selectedRows.has("*")) this.emit("row-selection", this.size);
+        else this.emit("row-selection", this.selectedRows.size);
+        this.sendRowsToClient(true);
+    }
+    disable() {
+        this.emit("disabled", this.viewport);
+    }
+    enable() {
+        this.emit("enabled", this.viewport);
+    }
+    select(selectRequest) {
+        switch(selectRequest.type){
+            case "SELECT_ROW":
+                {
+                    const { preserveExistingSelection, rowKey } = selectRequest;
+                    if (!preserveExistingSelection) this.selectedRows.clear();
+                    this.selectedRows.add(rowKey);
+                    break;
+                }
+            case "DESELECT_ROW":
+                {
+                    const { preserveExistingSelection, rowKey } = selectRequest;
+                    if (preserveExistingSelection) if (this.selectedRows.has("*")) {
+                        this.selectedRows.clear();
+                        for (const key of this.index.keys())if (key !== rowKey) this.selectedRows.add(key);
+                    } else this.selectedRows.delete(rowKey);
+                    else this.selectedRows.clear();
+                    break;
+                }
+            case "SELECT_ROW_RANGE":
+                {
+                    const { preserveExistingSelection, fromRowKey, toRowKey } = selectRequest;
+                    if (!preserveExistingSelection) this.selectedRows.clear();
+                    const fromIdx = this.index.get(fromRowKey);
+                    const toIdx = this.index.get(toRowKey);
+                    if ("number" == typeof fromIdx && "number" == typeof toIdx) for(let i = fromIdx; i <= toIdx; i++){
+                        const { [KEY]: rowKey } = this.#data[i];
+                        this.selectedRows.add(rowKey);
+                    }
+                    break;
+                }
+            case "SELECT_ALL":
+                this.selectedRows.clear();
+                this.selectedRows.add("*");
+                break;
+            case "DESELECT_ALL":
+                this.selectedRows.clear();
+                break;
+        }
+        this.setRange(this.#range, true);
+        this.emit("row-selection", "SELECT_ALL" === selectRequest.type ? this.size : this.selectedRows.size);
+    }
+    getRowKey(keyOrIndex) {
+        if ("string" == typeof keyOrIndex) return keyOrIndex;
+        const row = this.getRowAtIndex(keyOrIndex);
+        if (void 0 === row) throw Error(`row not found at index ${keyOrIndex}`);
+        return row?.[KEY];
+    }
+    openTreeNode(keyOrIndex) {
+        const key = this.getRowKey(keyOrIndex);
+        this.openTreeNodes.push(key);
+        this.processedData = expandGroup(this.openTreeNodes, this.#data, this._config.groupBy, this.#columnMap, this.groupMap, this.processedData);
+        this.setRange(this.#range.reset, true);
+    }
+    closeTreeNode(keyOrIndex) {
+        const key = this.getRowKey(keyOrIndex);
+        this.openTreeNodes = this.openTreeNodes.filter((value)=>value !== key);
+        if (this.processedData) {
+            this.processedData = collapseGroup(key, this.processedData);
+            this.setRange(this.#range.reset, true);
+        }
+    }
+    get pageSize() {
+        return this.#range.to - this.#range.from;
+    }
+    get links() {
+        return this.#links;
+    }
+    set links(links) {
+        this.#links = links;
+        if (links) this._clientCallback?.({
+            clientViewportId: this.viewport,
+            type: "vuu-links",
+            links
+        });
+    }
+    get menu() {
+        return this._menu;
+    }
+    get status() {
+        return this.#status;
+    }
+    get data() {
+        return this.#data;
+    }
+    get currentData() {
+        return this.processedData ?? this.#data;
+    }
+    get table() {
+        return this.tableSchema.table;
+    }
+    get columns() {
+        return this._config.columns;
+    }
+    set columns(columns) {}
+    get config() {
+        return this._config;
+    }
+    set config(config) {
+        const originalConfig = this._config;
+        const configChanges = this.applyConfig(config);
+        if (configChanges) {
+            if (config) {
+                const newConfig = config?.filterSpec?.filter && config?.filterSpec.filterStruct === void 0 ? {
+                    ...config,
+                    filterSpec: {
+                        filter: config.filterSpec.filter,
+                        filterStruct: parseFilter(config.filterSpec.filter)
+                    }
+                } : config;
+                this._config = withConfigDefaults(newConfig);
+                let processedData;
+                if (hasFilter(config) || hasBaseFilter(config)) {
+                    const fn = this.getFilterPredicate();
+                    processedData = this.#data.filter(fn);
+                }
+                if (configChanges.columnsChanged) this.processNewColumns(originalConfig.columns, config.columns);
+                if (hasSort(config)) processedData = sortRows(processedData ?? this.#data, config.sort, this.#columnMap);
+                if (this.openTreeNodes.length > 0 && isGroupByChanged(originalConfig, config)) {
+                    if (0 === this._config.groupBy.length) this.openTreeNodes.length = 0;
+                }
+                if (hasGroupBy(config)) {
+                    const [groupedData, groupMap] = groupRows(processedData ?? this.#data, config.groupBy, this.#columnMap);
+                    this.groupMap = groupMap;
+                    processedData = groupedData;
+                    if (this.openTreeNodes.length > 0) processedData = expandGroup(this.openTreeNodes, this.#data, this._config.groupBy, this.#columnMap, this.groupMap, processedData);
+                }
+                if (processedData) this.processedData = this.indexProcessedData(processedData);
+                else this.processedData = void 0;
+            }
+            if (configChanges.filterChanged || configChanges.baseFilterChanged || configChanges.groupByChanged) requestAnimationFrame(()=>{
+                this.emit("resize", this.size);
+            });
+            if ("subscribed" === this.#status) requestAnimationFrame(()=>{
+                this.sendSizeUpdateToClient();
+                if (this.preserveScrollPositionAcrossConfigChange) this.preserveScrollPositionAcrossConfigChange = false;
+                else this.setRange(this.#range.reset, true);
+                this.emit("config", this._config, this.range, void 0, configChanges);
+            });
+        }
+    }
+    processNewColumns(originalColumns, columns) {
+        const addedColumns = getAddedItems(originalColumns, columns);
+        addedColumns.length;
+        this.#columnMap = buildColumnMap(columns);
+        this.dataIndices = buildDataToClientMap(this.#columnMap, this.dataMap);
+    }
+    indexProcessedData(data) {
+        return data?.map((row, i)=>{
+            const dolly = row.slice();
+            dolly[0] = i;
+            dolly[1] = i;
+            return dolly;
+        });
+    }
+    getFilterPredicate() {
+        const { filterSpec: { filterStruct } } = combineFilters(this._config);
+        if (filterStruct) return filterPredicate(this.#columnMap, filterStruct);
+        throw Error("filter must include filterStruct");
+    }
+    applyConfig(config, preserveExistingConfigAttributes = false) {
+        const { noChanges, ...otherChanges } = isConfigChanged(this._config, config);
+        if (true !== noChanges) {
+            if (config) {
+                const newConfig = config?.filterSpec?.filter && config?.filterSpec.filterStruct === void 0 ? {
+                    ...config,
+                    filterSpec: {
+                        filter: config.filterSpec.filter,
+                        filterStruct: parseFilter(config.filterSpec.filter)
+                    }
+                } : config;
+                if (preserveExistingConfigAttributes) this._config = {
+                    ...this._config,
+                    ...config
+                };
+                else this._config = withConfigDefaults(newConfig);
+                return otherChanges;
+            }
+        }
+    }
+    get columnMap() {
+        return this.#columnMap;
+    }
+    get selectedRowsCount() {
+        return this.selectedRows.size;
+    }
+    get size() {
+        return this.processedData?.length ?? this.#data.length;
+    }
+    get maxRangeEnd() {
+        return this.#maxRangeEnd;
+    }
+    get range() {
+        return this.#range;
+    }
+    set range(range) {
+        this.setRange(range);
+    }
+    delete(row) {
+        console.log(`delete row ${row.join(",")}`);
+    }
+    insert = (row)=>{
+        const dataSourceRow = toDataSourceRow(this.key, this.index)(row, this.size);
+        this.#data.push(dataSourceRow);
+        const { from, to } = this.#range;
+        const [rowIdx] = dataSourceRow;
+        const isSorted = hasSort(this.config);
+        const isFiltered = hasFilter(this.config) || hasBaseFilter(this.config);
+        if (isSorted && isFiltered) {
+            const meetsFilterCriteria = this.getFilterPredicate();
+            if (meetsFilterCriteria(dataSourceRow)) this.insertIntoSortedData(dataSourceRow);
+        } else if (isSorted) this.insertIntoSortedData(dataSourceRow);
+        else if (isFiltered) {
+            const meetsFilterCriteria = this.getFilterPredicate();
+            if (meetsFilterCriteria(dataSourceRow)) {
+                this.processedData?.push(dataSourceRow);
+                this.sendSizeUpdateToClient();
+                if (rowIdx >= from && rowIdx < to) this.sendRowsToClient();
+                this.emit("resize", this.#data.length);
+            }
+        } else {
+            this.sendSizeUpdateToClient();
+            if (rowIdx >= from && rowIdx < to) this.sendRowsToClient();
+            this.emit("resize", this.size);
+        }
+    };
+    insertIntoSortedData(row) {
+        const indexedSortDefs = this.config.sort.sortDefs.map(({ column, sortType })=>[
+                this.columnMap[column],
+                sortType
+            ]);
+        if (this.processedData) {
+            const comparator = sortComparator(indexedSortDefs);
+            const insertPos = binarySearch(this.processedData, row, comparator);
+            this.sendSizeUpdateToClient();
+            if (-1 === insertPos) {
+                this.processedData?.unshift(row);
+                if (this.processedData) this.processedData = this.indexProcessedData(this.processedData);
+                if (insertPos <= this.#range.to) this.sendRowsToClient(true);
+                if (this.processedData) this.emit("resize", this.processedData.length);
+            } else if (this.processedData) this.emit("resize", this.processedData.length);
+        }
+    }
+    validateDataValue(columnName, value) {
+        const columnDescriptor = this.columnDescriptors.find((col)=>col.name === columnName);
+        if (columnDescriptor) switch(columnDescriptor.serverDataType){
+            case "int":
+                if ("number" == typeof value) {
+                    if (Math.floor(value) !== value) throw Error(`${columnName} is int but value = ${value}`);
+                } else if ("string" == typeof value) {
+                    const numericValue = parseFloat(value);
+                    if (Math.floor(numericValue) !== numericValue) throw Error(`${columnName} is ${value} is not a valid integer`);
+                }
+                break;
+            default:
+        }
+        else throw Error(`Unknown column ${columnName}`);
+    }
+    updateDataItem = (keyValue, columnName, value)=>{
+        this.validateDataValue(columnName, value);
+        const colIndex = this.#columnMap[columnName];
+        const dataColIndex = this.dataMap?.[columnName];
+        const dataIndex = this.indexOfRowWithKey(keyValue);
+        if (-1 !== dataIndex && void 0 !== dataColIndex) {
+            const dataSourceRow = this.#data[dataIndex];
+            dataSourceRow[colIndex] = value;
+            const { from, to } = this.#range;
+            const [rowIdx] = dataSourceRow;
+            if (rowIdx >= from && rowIdx < to) this.sendRowsToClient(false, dataSourceRow);
+        }
+    };
+    getRowByKey(key) {
+        const data = this.processedData ?? this.#data;
+        return data.find((row)=>row[KEY] === key);
+    }
+    getRowAtIndex(rowIndex) {
+        return (this.processedData ?? this.#data)[rowIndex];
+    }
+    indexOfRowWithKey = (key)=>this.#data.findIndex((row)=>row[KEY] === key);
+    update = (row, columnName)=>{
+        const keyValue = row[this.key];
+        const dataColIndex = this.dataMap?.[columnName];
+        return this.updateDataItem(keyValue, columnName, row[dataColIndex]);
+    };
+    updateRow = (row, _columnName)=>{
+        const keyValue = row[this.key];
+        const dataIndex = this.#data.findIndex((row)=>row[KEY] === keyValue);
+        if (-1 !== dataIndex) {
+            const dataSourceRow = toDataSourceRow(this.key)(row, dataIndex);
+            this.#data[dataIndex] = dataSourceRow;
+            const { from, to } = this.#range;
+            const isFiltered = hasFilter(this.config) || hasBaseFilter(this.config);
+            const isSorted = hasSort(this.config);
+            if (isFiltered) {
+                const meetsFilterCriteria = this.getFilterPredicate();
+                if (meetsFilterCriteria(dataSourceRow) && this.processedData) {
+                    const dataIndex = this.processedData.findIndex((row)=>row[KEY] === keyValue);
+                    if (-1 !== dataIndex) {
+                        const existingRow = this.processedData[dataIndex];
+                        const newFilteredRow = existingRow.slice(0, 10).concat(dataSourceRow.slice(10));
+                        this.processedData[dataIndex] = newFilteredRow;
+                        if (dataIndex >= from && dataIndex < to) this.sendRowsToClient(false, newFilteredRow);
+                    }
+                } else if (this.processedData) {
+                    const dataIndex = this.processedData.findIndex((row)=>row[KEY] === keyValue);
+                    if (-1 !== dataIndex) console.log('dataRow no longer in filter set');
+                }
+            } else if (isSorted) {
+                if (this.processedData) {
+                    const dataIndex = this.processedData.findIndex((row)=>row[KEY] === keyValue);
+                    if (-1 !== dataIndex) {
+                        const existingRow = this.processedData[dataIndex];
+                        const newSortedRow = existingRow.slice(0, 10).concat(dataSourceRow.slice(10));
+                        this.processedData[dataIndex] = newSortedRow;
+                        if (dataIndex >= from && dataIndex < to) this.sendRowsToClient(false, newSortedRow);
+                    }
+                }
+            } else if (dataIndex >= from && dataIndex < to) this.sendRowsToClient(false, dataSourceRow);
+        }
+    };
+    handleDeleteFromTable = async (key)=>{
+        const dataIndex = this.#data.findIndex((row)=>row[KEY] === key);
+        if (-1 === dataIndex) return "row not found";
+        let doomedIndex;
+        if (this.processedData) {
+            for(let i = 0; i < this.processedData.length; i++)if (this.processedData[i][KEY] === key) doomedIndex = i;
+            else if (void 0 !== doomedIndex) this.processedData[i][0] -= 1;
+            if (void 0 !== doomedIndex) this.processedData.splice(doomedIndex, 1);
+        }
+        this.#data.splice(dataIndex, 1);
+        for(let i = dataIndex; i < this.#data.length; i++)this.#data[i][0] -= 1;
+        this.sendSizeUpdateToClient();
+        const { from, to } = this.#range;
+        const deletedIndex = doomedIndex ?? dataIndex;
+        if (deletedIndex >= from && deletedIndex < to) {
+            this.#keys.reset(this.rangeWithBufferWithinMaxRangeEnd);
+            this.sendRowsToClient(true);
+        }
+        this.emit("resize", this.size);
+        return true;
+    };
+    setRange(range, forceFullRefresh = false) {
+        this.constrainRangeToMaxRangeEnd(range);
+        if (range.from !== this.#range.from || range.to !== this.#range.to) {
+            const currentPageCount = Math.ceil(this.size / (this.#range.to - this.#range.from));
+            const newPageCount = Math.ceil(this.size / (range.to - range.from));
+            this.#range = range;
+            const keysResequenced = this.#keys.reset(this.rangeWithBufferWithinMaxRangeEnd);
+            this.sendRowsToClient(forceFullRefresh || keysResequenced);
+            requestAnimationFrame(()=>{
+                if (newPageCount !== currentPageCount) this.emit("page-count", newPageCount);
+                this.emit("range", range);
+            });
+        } else if (forceFullRefresh) this.sendRowsToClient(forceFullRefresh);
+    }
+    constrainRangeToMaxRangeEnd(range) {
+        if (this.#maxRangeEnd === Number.MAX_SAFE_INTEGER) return;
+        const pageSize = Math.max(0, range.to - range.from);
+        if (range.from >= this.#maxRangeEnd) {
+            range.from = Math.max(0, this.#maxRangeEnd - pageSize);
+            range.to = this.#maxRangeEnd;
+        } else if (range.to > this.#maxRangeEnd) range.to = this.#maxRangeEnd;
+    }
+    get rangeWithBufferWithinMaxRangeEnd() {
+        const withBuffer = this.#range.withBuffer;
+        return this.#maxRangeEnd === Number.MAX_SAFE_INTEGER ? withBuffer : {
+            from: withBuffer.from,
+            to: Math.min(withBuffer.to, this.#maxRangeEnd)
+        };
+    }
+    sendSizeUpdateToClient() {
+        this.clientCallback?.({
+            clientViewportId: this.viewport,
+            mode: "size-only",
+            type: "viewport-update",
+            size: this.processedData ? this.processedData.length : this.#data.length
+        });
+    }
+    sendRowsToClient(forceFullRefresh = false, row) {
+        if (row) this.clientCallback?.({
+            clientViewportId: this.viewport,
+            mode: "update",
+            rows: [
+                toClientRow(row, this.#keys, this.selectedRows, this.dataIndices)
+            ],
+            type: "viewport-update"
+        });
+        else {
+            const rowRange = "delta" !== this.rangeChangeRowset || forceFullRefresh ? this.rangeWithBufferWithinMaxRangeEnd : rangeNewItems(this.lastRangeServed, this.rangeWithBufferWithinMaxRangeEnd);
+            const data = this.processedData ?? this.#data;
+            const rowsWithinViewport = data.slice(rowRange.from, rowRange.to).map((row)=>toClientRow(row, this.#keys, this.selectedRows, this.dataIndices));
+            this.clientCallback?.({
+                clientViewportId: this.viewport,
+                mode: "batch",
+                range: this.#range,
+                rows: rowsWithinViewport,
+                size: data.length,
+                type: "viewport-update"
+            });
+            this.lastRangeServed = {
+                from: this.#range.from,
+                to: Math.min(this.#range.to, this.#range.from + rowsWithinViewport.length)
+            };
+        }
+    }
+    get aggregations() {
+        return this._config.aggregations;
+    }
+    set aggregations(aggregations) {
+        this._config = {
+            ...this._config,
+            aggregations
+        };
+        const targetData = this.processedData ?? this.#data;
+        const leafData = this.#data;
+        aggregateData(aggregations, targetData, this._config.groupBy, leafData, this.#columnMap, this.groupMap);
+        this.setRange(this.#range.reset, true);
+        this.emit("config", this._config, this.range);
+    }
+    get sort() {
+        return this._config.sort;
+    }
+    set sort(sort) {
+        debug?.(`sort ${JSON.stringify(sort)}`);
+        this.config = {
+            ...this._config,
+            sort
+        };
+    }
+    get baseFilter() {
+        return this._config.baseFilterSpec;
+    }
+    set baseFilter(baseFilter) {
+        debug?.(`baseFilter ${JSON.stringify(baseFilter)}`);
+        this.config = {
+            ...this._config,
+            baseFilterSpec: baseFilter
+        };
+    }
+    get filter() {
+        return this._config.filterSpec;
+    }
+    set filter(filter) {
+        debug?.(`filter ${JSON.stringify(filter)}`);
+        this.config = {
+            ...this._config,
+            filterSpec: filter
+        };
+    }
+    setFilter(filter) {
+        const dataSourceFilter = {
+            filter: filterAsQuery(filter),
+            filterStruct: filter
+        };
+        this.filter = dataSourceFilter;
+    }
+    clearFilter() {
+        this.filter = {
+            filter: ""
+        };
+    }
+    get groupBy() {
+        return this._config.groupBy;
+    }
+    set groupBy(groupBy) {
+        this.config = {
+            ...this._config,
+            groupBy
+        };
+    }
+    get title() {
+        return this.#title ?? `${this.table.module} ${this.table.table}`;
+    }
+    set title(title) {
+        this.#title = title;
+        this.emit("title-changed", this.viewport, title);
+    }
+    get _clientCallback() {
+        return this.clientCallback;
+    }
+    createLink({ parentVpId, link: { fromColumn, toColumn } }) {
+        console.log("create link", {
+            parentVpId,
+            fromColumn,
+            toColumn
+        });
+    }
+    removeLink() {
+        console.log("remove link");
+    }
+    async remoteProcedureCall() {
+        return Promise.reject();
+    }
+    async menuRpcCall(rpcRequest) {
+        console.log({
+            rpcRequest
+        });
+        return new Promise(()=>{});
+    }
+    freeze() {
+        if (this.isFrozen) throw Error("[BaseDataSource] cannot freeze, dataSource is already frozen");
+        this.#freezeTimestamp = Date.now();
+        this.emit("freeze", true, this.#freezeTimestamp);
+        this.preserveScrollPositionAcrossConfigChange = true;
+        this.baseFilter = {
+            filter: `vuuCreatedTimestamp < ${this.#freezeTimestamp}`
+        };
+    }
+    unfreeze() {
+        if (this.isFrozen) {
+            const freezeTimestamp = this.#freezeTimestamp;
+            this.#freezeTimestamp = void 0;
+            this.emit("freeze", false, freezeTimestamp);
+            this.preserveScrollPositionAcrossConfigChange = true;
+            this.baseFilter = {
+                filter: ""
+            };
+        } else throw Error("[BaseDataSource] cannot freeze, dataSource is already frozen");
+    }
+    get freezeTimestamp() {
+        return this.#freezeTimestamp;
+    }
+    get isFrozen() {
+        return "number" == typeof this.#freezeTimestamp;
+    }
+}
+export { ArrayDataSource };