@vuu-ui/vuu-data-remote 2.1.19-beta.2 → 2.1.19-beta.3

package/src/server-proxy/viewport.js

@@ -1,591 +0,0 @@
-import { KeySet, RangeMonitor, getFullRange, logger } from "@vuu-ui/vuu-utils";
-import { getFirstAndLastRows } from "../message-utils.js";
-import { ArrayBackedMovingWindow } from "./array-backed-moving-window.js";
-import * as __rspack_external__messages_js_85065717 from "./messages.js";
-const { debug: debug, debugEnabled: debugEnabled, error: error, info: info, infoEnabled: infoEnabled, warn: warn } = logger("Viewport");
-const isLeafUpdate = ({ rowKey, updateType })=>"U" === updateType && !rowKey.startsWith("$root");
-const NO_DATA_UPDATE = [
-    void 0,
-    void 0
-];
-const NO_UPDATE_STATUS = {
-    count: 0,
-    mode: void 0,
-    size: 0,
-    ts: 0
-};
-class Viewport {
-    #status = "";
-    aggregations;
-    batchMode = false;
-    bufferSize;
-    #clientRange;
-    columns;
-    dataWindow;
-    filter;
-    groupBy;
-    sort;
-    hasUpdates = false;
-    pendingUpdates = [];
-    keys;
-    pendingLinkedParent;
-    pendingOperations = new Map();
-    pendingRangeRequests = [];
-    postMessageToClient;
-    rowCountChanged = false;
-    lastUpdateStatus = NO_UPDATE_STATUS;
-    updateThrottleTimer = void 0;
-    rangeMonitor = new RangeMonitor("ViewPort");
-    clientViewportId;
-    disabled = false;
-    disabledActive = false;
-    frozen = false;
-    isTree = false;
-    links;
-    linkedParent;
-    serverViewportId;
-    suspended = false;
-    suspendTimer = null;
-    table;
-    title;
-    constructor({ aggregations, bufferSize = 50, columns, filterSpec: filter, groupBy = [], table, range, sort, title, viewport, visualLink }, postMessageToClient){
-        this.aggregations = aggregations;
-        this.bufferSize = bufferSize;
-        this.#clientRange = range;
-        this.clientViewportId = viewport;
-        this.columns = columns;
-        this.filter = filter;
-        this.groupBy = groupBy;
-        this.keys = new KeySet(range);
-        this.pendingLinkedParent = visualLink;
-        this.table = table;
-        this.sort = sort;
-        this.title = title;
-        infoEnabled && info?.(`${table.table} #${viewport},  bufferSize=${bufferSize}`);
-        this.dataWindow = new ArrayBackedMovingWindow(this.#clientRange, range, this.bufferSize);
-        this.postMessageToClient = postMessageToClient;
-    }
-    setLastSizeOnlyUpdateSize = (size)=>{
-        this.lastUpdateStatus.size = size;
-    };
-    setLastUpdate = (mode)=>{
-        const { ts: lastTS, mode: lastMode } = this.lastUpdateStatus;
-        let elapsedTime = 0;
-        if (lastMode === mode) {
-            const ts = Date.now();
-            this.lastUpdateStatus.count += 1;
-            this.lastUpdateStatus.ts = ts;
-            elapsedTime = 0 === lastTS ? 0 : ts - lastTS;
-        } else {
-            this.lastUpdateStatus.count = 1;
-            this.lastUpdateStatus.ts = 0;
-            elapsedTime = 0;
-        }
-        this.lastUpdateStatus.mode = mode;
-        return elapsedTime;
-    };
-    get hasUpdatesToProcess() {
-        if (this.suspended) return false;
-        return this.rowCountChanged || this.hasUpdates;
-    }
-    get size() {
-        return this.dataWindow.rowCount ?? 0;
-    }
-    get clientRange() {
-        return this.#clientRange;
-    }
-    get status() {
-        return this.#status;
-    }
-    set status(status) {
-        this.#status = status;
-    }
-    subscribe() {
-        const { filter } = this.filter;
-        this.status = "subscribed" === this.#status ? "resubscribing" : "subscribing";
-        return {
-            type: __rspack_external__messages_js_85065717.CREATE_VP,
-            table: this.table,
-            range: getFullRange(this.#clientRange, this.bufferSize),
-            aggregations: this.aggregations,
-            columns: this.columns,
-            sort: this.sort,
-            groupBy: this.groupBy,
-            filterSpec: {
-                filter
-            }
-        };
-    }
-    handleSubscribed({ viewPortId, aggregations, columns, filterSpec: filter, range, sort, groupBy, table }, baseTableSchema) {
-        this.serverViewportId = viewPortId;
-        this.status = "subscribed";
-        this.aggregations = aggregations;
-        this.columns = columns;
-        this.groupBy = groupBy;
-        this.isTree = groupBy && groupBy.length > 0;
-        this.dataWindow.setRange(range.from, range.to);
-        const tableSchema = table === baseTableSchema.table.table ? baseTableSchema : {
-            ...baseTableSchema,
-            table: {
-                ...baseTableSchema.table,
-                session: table
-            }
-        };
-        return {
-            aggregations,
-            type: "subscribed",
-            clientViewportId: this.clientViewportId,
-            columns,
-            filterSpec: filter,
-            groupBy,
-            range,
-            sort,
-            tableSchema
-        };
-    }
-    awaitOperation(requestId, msg) {
-        this.pendingOperations.set(requestId, msg);
-    }
-    completeOperation(requestId, ...params) {
-        const { clientViewportId, pendingOperations } = this;
-        const pendingOperation = pendingOperations.get(requestId);
-        if (!pendingOperation) return void error(`no matching operation found to complete for requestId ${requestId}`);
-        const { type } = pendingOperation;
-        info?.(`completeOperation ${type}`);
-        pendingOperations.delete(requestId);
-        if ("CHANGE_VP_RANGE" === type) {
-            const [from, to] = params;
-            infoEnabled && info(`completeOperation CHANGE_VP_RANGE
-        window setRange (${from}:${to}) ${this.pendingRangeRequests.length} range requests pending`);
-            this.dataWindow?.setRange(from, to);
-            for(let i = this.pendingRangeRequests.length - 1; i >= 0; i--){
-                const pendingRangeRequest = this.pendingRangeRequests[i];
-                if (pendingRangeRequest.requestId === requestId) {
-                    pendingRangeRequest.acked = true;
-                    break;
-                }
-                warn?.("range requests sent faster than they are being ACKed");
-            }
-        } else if ("config" === type) {
-            const { aggregations, columns, filterSpec: filter, groupBy, sort } = pendingOperation.data;
-            this.aggregations = aggregations;
-            this.columns = columns;
-            this.filter = filter;
-            this.groupBy = groupBy;
-            this.sort = sort;
-            if (groupBy.length > 0) this.isTree = true;
-            else if (this.isTree) this.isTree = false;
-            debug?.(`config change confirmed, isTree : ${this.isTree}`);
-            return {
-                clientViewportId,
-                type,
-                config: pendingOperation.data
-            };
-        } else if ("selection" === type) ;
-        else if ("disable" === type) {
-            this.suspended = false;
-            this.disabled = true;
-            this.disabledActive = pendingOperation.disableActive;
-            return {
-                type: "disabled",
-                clientViewportId
-            };
-        } else if ("enable" === type) {
-            this.disabled = false;
-            this.disabledActive = false;
-            return {
-                type: "enabled",
-                clientViewportId
-            };
-        } else if ("freeze" === type) {
-            this.frozen = true;
-            return {
-                type: "frozen",
-                clientViewportId
-            };
-        } else if ("unfreeze" === type) {
-            this.frozen = false;
-            return {
-                type: "unfrozen",
-                clientViewportId
-            };
-        } else if ("CREATE_VISUAL_LINK" === type) {
-            const [colName, parentViewportId, parentColName] = params;
-            this.linkedParent = {
-                colName,
-                parentViewportId,
-                parentColName
-            };
-            this.pendingLinkedParent = void 0;
-            return {
-                requestId,
-                type: "vuu-link-created",
-                clientViewportId,
-                colName,
-                parentViewportId,
-                parentColName
-            };
-        } else if ("REMOVE_VISUAL_LINK" === type) {
-            this.linkedParent = void 0;
-            return {
-                requestId,
-                type: "vuu-link-removed",
-                clientViewportId
-            };
-        }
-    }
-    rangeRequest(requestId, range) {
-        if (debugEnabled) this.rangeMonitor.set(range);
-        infoEnabled && info(`(bufferSize ${this.bufferSize}) rangeRequest (${range.from}:${range.to}) current: window client (${this.dataWindow.clientRange.from}:${this.dataWindow.clientRange.to}), full (${this.dataWindow.range.from}:${this.dataWindow.range.to}) `);
-        const type = "CHANGE_VP_RANGE";
-        if (!this.dataWindow) return [
-            null
-        ];
-        {
-            const [serverDataRequired, clientRows] = this.dataWindow.setClientRange(range.from, range.to);
-            infoEnabled && info(`updated: dataWindow clientRange (${this.dataWindow.clientRange.from}:${this.dataWindow.clientRange.to}), fullRange (${this.dataWindow.range.from}:${this.dataWindow.range.to}) serverDataRequired ${serverDataRequired ? "Y" : "N"} ${clientRows.length} rows returned from local buffer`);
-            let debounceRequest;
-            const maxRange = this.dataWindow.rowCount || void 0;
-            const serverRequest = serverDataRequired && !this.rangeRequestAlreadyPending(range) ? {
-                type,
-                viewPortId: this.serverViewportId,
-                ...getFullRange(range, this.bufferSize, maxRange)
-            } : null;
-            if (serverRequest) {
-                infoEnabled && info(`create CHANGE_VP_RANGE: (${serverRequest.from} - ${serverRequest.to})`);
-                debugEnabled && debug?.(`create CHANGE_VP_RANGE: [${serverRequest.from} - ${serverRequest.to}]`);
-                this.awaitOperation(requestId, {
-                    type
-                });
-                const pendingRequest = this.pendingRangeRequests.at(-1);
-                if (pendingRequest) if (pendingRequest.acked) console.warn("Range Request before previous request is filled");
-                else {
-                    const { from, to } = pendingRequest;
-                    if (this.dataWindow.outOfRange(from, to)) debounceRequest = {
-                        clientViewportId: this.clientViewportId,
-                        type: "debounce-begin"
-                    };
-                    else warn?.("Range Request before previous request is acked");
-                }
-                this.pendingRangeRequests.push({
-                    ...serverRequest,
-                    requestId
-                });
-            } else if (clientRows.length > 0) this.batchMode = false;
-            this.keys.reset(this.dataWindow.clientRange);
-            const toClient = this.isTree ? toClientRowTree : toClientRow;
-            if (clientRows.length) return [
-                serverRequest,
-                clientRows.map((row)=>toClient(row, this.keys))
-            ];
-            if (debounceRequest) return [
-                serverRequest,
-                void 0,
-                debounceRequest
-            ];
-            return [
-                serverRequest
-            ];
-        }
-    }
-    setLinks(links) {
-        this.links = links.filter((link)=>link.parentVpId !== this.serverViewportId);
-        return [
-            {
-                type: "vuu-links",
-                links: this.links,
-                clientViewportId: this.clientViewportId
-            },
-            this.pendingLinkedParent
-        ];
-    }
-    setMenu(menu) {
-        return {
-            type: "vuu-menu",
-            menu,
-            clientViewportId: this.clientViewportId
-        };
-    }
-    openTreeNode(requestId, message) {
-        const treeKey = void 0 === message.index ? message.key : this.getKeyForRowAtIndex(message.index);
-        infoEnabled && info(`treeKey ${treeKey}`);
-        return {
-            type: __rspack_external__messages_js_85065717.OPEN_TREE_NODE,
-            vpId: this.serverViewportId,
-            treeKey
-        };
-    }
-    closeTreeNode(requestId, message) {
-        const treeKey = void 0 === message.index ? message.key : this.getKeyForRowAtIndex(message.index);
-        return {
-            type: __rspack_external__messages_js_85065717.CLOSE_TREE_NODE,
-            vpId: this.serverViewportId,
-            treeKey
-        };
-    }
-    createLink(requestId, vuuCreateVisualLink) {
-        const message = {
-            ...vuuCreateVisualLink,
-            childVpId: this.serverViewportId
-        };
-        this.awaitOperation(requestId, message);
-        return message;
-    }
-    removeLink(requestId) {
-        const message = {
-            type: "REMOVE_VISUAL_LINK",
-            childVpId: this.serverViewportId
-        };
-        this.awaitOperation(requestId, message);
-        return message;
-    }
-    suspend() {
-        this.suspended = true;
-        this.pendingUpdates.length = 0;
-        info?.("suspend");
-    }
-    resume() {
-        this.suspended = false;
-        if (debugEnabled) debug?.(`resume: ${this.currentData()}`);
-        return [
-            this.size,
-            this.currentData()
-        ];
-    }
-    currentData() {
-        const out = [];
-        if (this.dataWindow) {
-            const records = this.dataWindow.getData();
-            const { keys } = this;
-            const toClient = this.isTree ? toClientRowTree : toClientRow;
-            for (const row of records)if (row) out.push(toClient(row, keys));
-        }
-        return out;
-    }
-    enable(requestId) {
-        this.awaitOperation(requestId, {
-            type: "enable"
-        });
-        info?.(`enable: ${this.serverViewportId}`);
-        return {
-            type: __rspack_external__messages_js_85065717.ENABLE_VP,
-            viewPortId: this.serverViewportId
-        };
-    }
-    disable(requestId, disableActive = false) {
-        this.awaitOperation(requestId, {
-            type: "disable",
-            disableActive
-        });
-        info?.(`disable: ${this.serverViewportId}`);
-        return {
-            type: __rspack_external__messages_js_85065717.DISABLE_VP,
-            viewPortId: this.serverViewportId
-        };
-    }
-    freeze(requestId) {
-        this.awaitOperation(requestId, {
-            type: "freeze"
-        });
-        info?.(`freeze: ${this.serverViewportId}`);
-        return {
-            type: "FREEZE_VP",
-            viewPortId: this.serverViewportId
-        };
-    }
-    unfreeze(requestId) {
-        this.awaitOperation(requestId, {
-            type: "unfreeze"
-        });
-        info?.(`unfreeze: ${this.serverViewportId}`);
-        this.frozen = false;
-        return {
-            type: "UNFREEZE_VP",
-            viewPortId: this.serverViewportId
-        };
-    }
-    setConfig(requestId, config) {
-        this.awaitOperation(requestId, {
-            type: "config",
-            data: config
-        });
-        const { filterSpec: filter, ...remainingConfig } = config;
-        debugEnabled ? debug?.(`setConfig ${JSON.stringify(config)}`) : info?.("setConfig");
-        if (!this.isTree && config.groupBy.length > 0) this.dataWindow?.clear();
-        return this.createRequest({
-            ...remainingConfig,
-            filterSpec: "string" == typeof filter?.filter ? {
-                filter: filter.filter
-            } : {
-                filter: ""
-            }
-        }, true);
-    }
-    selectRequest(request) {
-        info?.(`selectRequest: ${request.type}`);
-        if (this.serverViewportId) return {
-            ...request,
-            vpId: this.serverViewportId
-        };
-        throw Error(`[Viewport] cannot process ${request.type} before serverViewportId has been set`);
-    }
-    removePendingRangeRequest(firstIndex, lastIndex) {
-        for(let i = this.pendingRangeRequests.length - 1; i >= 0; i--){
-            const { from, to } = this.pendingRangeRequests[i];
-            let isLast = true;
-            if (firstIndex >= from && firstIndex < to || lastIndex > from && lastIndex < to) {
-                if (!isLast) console.warn("removePendingRangeRequest TABLE_ROWS are not for latest request");
-                this.pendingRangeRequests.splice(i, 1);
-                break;
-            }
-            isLast = false;
-        }
-    }
-    rangeRequestAlreadyPending = (range)=>{
-        const { bufferSize } = this;
-        const bufferThreshold = 0.25 * bufferSize;
-        let { from: stillPendingFrom } = range;
-        for (const { from, to } of this.pendingRangeRequests)if (stillPendingFrom >= from && stillPendingFrom < to) if (range.to + bufferThreshold <= to) return true;
-        else stillPendingFrom = to;
-        return false;
-    };
-    clearCache() {
-        this.dataWindow.setRowCount(0);
-        this.postMessageToClient({
-            clientViewportId: this.clientViewportId,
-            type: "viewport-clear"
-        });
-    }
-    updateRows(rows) {
-        const [firstRow, lastRow] = getFirstAndLastRows(rows);
-        if (firstRow && lastRow) this.removePendingRangeRequest(firstRow.rowIndex, lastRow.rowIndex);
-        if (1 === rows.length) {
-            if (0 === firstRow.vpSize && this.disabled) return void debug?.(`ignore a SIZE=0 message on disabled viewport (${rows.length} rows)`);
-        }
-        for (const row of rows)if (this.isTree && isLeafUpdate(row)) continue;
-        else {
-            if ("SIZE" === row.updateType || this.dataWindow?.rowCount !== row.vpSize) {
-                this.dataWindow?.setRowCount(row.vpSize);
-                this.rowCountChanged = true;
-            }
-            if ("U" === row.updateType) {
-                if (this.dataWindow?.setAtIndex(row)) {
-                    if (true !== this.suspended) {
-                        this.hasUpdates = true;
-                        if (!this.batchMode) this.pendingUpdates.push(row);
-                    }
-                }
-            }
-        }
-    }
-    getKeyForRowAtIndex(rowIndex) {
-        const row = this.dataWindow.getAtIndex(rowIndex);
-        return row?.rowKey;
-    }
-    getClientRows() {
-        let out;
-        let mode = "size-only";
-        if (!this.hasUpdates && !this.rowCountChanged) return NO_DATA_UPDATE;
-        if (this.hasUpdates) {
-            const { keys } = this;
-            const toClient = this.isTree ? toClientRowTree : toClientRow;
-            if (this.updateThrottleTimer) {
-                self.clearTimeout(this.updateThrottleTimer);
-                this.updateThrottleTimer = void 0;
-            }
-            if (this.pendingUpdates.length > 0) {
-                out = [];
-                mode = "update";
-                for (const row of this.pendingUpdates)out.push(toClient(row, keys));
-            }
-            this.pendingUpdates.length = 0;
-            this.hasUpdates = false;
-        }
-        if (this.throttleMessage(mode)) return NO_DATA_UPDATE;
-        return [
-            out,
-            mode
-        ];
-    }
-    sendThrottledSizeMessage = ()=>{
-        this.updateThrottleTimer = void 0;
-        this.lastUpdateStatus.count = 3;
-        this.postMessageToClient({
-            clientViewportId: this.clientViewportId,
-            mode: "size-only",
-            size: this.lastUpdateStatus.size,
-            type: "viewport-update"
-        });
-    };
-    shouldThrottleMessage = (mode)=>{
-        const elapsedTime = this.setLastUpdate(mode);
-        return "size-only" === mode && elapsedTime > 0 && elapsedTime < 500 && this.lastUpdateStatus.count > 3;
-    };
-    throttleMessage = (mode)=>{
-        if (this.shouldThrottleMessage(mode)) {
-            info?.("[Viewport] throttling updates setTimeout to 300");
-            this.setLastSizeOnlyUpdateSize(this.dataWindow.rowCount);
-            if (void 0 === this.updateThrottleTimer) this.updateThrottleTimer = setTimeout(this.sendThrottledSizeMessage, 100);
-            return true;
-        }
-        if (void 0 !== this.updateThrottleTimer) {
-            clearTimeout(this.updateThrottleTimer);
-            this.updateThrottleTimer = void 0;
-        }
-        return false;
-    };
-    getNewRowCount = ()=>{
-        if (this.rowCountChanged && this.dataWindow) {
-            this.rowCountChanged = false;
-            return this.dataWindow.rowCount;
-        }
-    };
-    createRequest(params, overWrite = false) {
-        if (overWrite) return {
-            type: "CHANGE_VP",
-            viewPortId: this.serverViewportId,
-            ...params
-        };
-        return {
-            type: "CHANGE_VP",
-            viewPortId: this.serverViewportId,
-            aggregations: this.aggregations,
-            columns: this.columns,
-            sort: this.sort,
-            groupBy: this.groupBy,
-            filterSpec: {
-                filter: this.filter.filter
-            },
-            ...params
-        };
-    }
-}
-const isNew = false;
-const toClientRow = ({ rowIndex, rowKey, sel: isSelected, data, ts }, keys)=>[
-        rowIndex,
-        keys.keyFor(rowIndex),
-        true,
-        false,
-        0,
-        0,
-        rowKey,
-        isSelected,
-        ts,
-        isNew
-    ].concat(data);
-const toClientRowTree = ({ rowIndex, rowKey, sel: isSelected, data, ts }, keys)=>{
-    const [depth, isExpanded, , isLeaf, , count, ...rest] = data;
-    return [
-        rowIndex,
-        keys.keyFor(rowIndex),
-        isLeaf,
-        isExpanded,
-        depth,
-        count,
-        rowKey,
-        isSelected,
-        ts,
-        isNew
-    ].concat(rest);
-};
-export { NO_DATA_UPDATE, Viewport };

package/src/worker.js

@@ -1,65 +0,0 @@
-import { isConnectionQualityMetrics, logger } from "@vuu-ui/vuu-utils";
-import { ServerProxy } from "./server-proxy/server-proxy.js";
-import { WebSocketConnection } from "./WebSocketConnection.js";
-let serverProxy;
-let webSocketConnection;
-const { info: info, infoEnabled: infoEnabled } = logger("worker");
-const sendMessageToClient = (message)=>{
-    postMessage(message);
-};
-async function connectToServer(url, protocols, token) {
-    if (void 0 === webSocketConnection && void 0 === serverProxy) {
-        webSocketConnection = new WebSocketConnection({
-            callback: (msg)=>{
-                if (isConnectionQualityMetrics(msg)) postMessage({
-                    type: "connection-metrics",
-                    messages: msg
-                });
-                else serverProxy.handleMessageFromServer(msg);
-            },
-            protocols,
-            url
-        });
-        webSocketConnection.on("connection-status", postMessage);
-        serverProxy = new ServerProxy(webSocketConnection, sendMessageToClient);
-    }
-    await webSocketConnection.openWebSocket();
-    return serverProxy.login(token);
-}
-const handleMessageFromClient = async ({ data: message })=>{
-    switch(message.type){
-        case "connect":
-            try {
-                const sessionId = await connectToServer(message.url, message.protocol, message.token);
-                postMessage({
-                    type: "connected",
-                    sessionId
-                });
-            } catch (err) {
-                postMessage({
-                    type: "connection-failed",
-                    reason: String(err)
-                });
-            }
-            break;
-        case "disconnect":
-            serverProxy.disconnect();
-            webSocketConnection?.close();
-            break;
-        case "subscribe":
-            infoEnabled && info(`===> ${JSON.stringify(message)}`);
-            serverProxy.subscribe(message);
-            break;
-        case "unsubscribe":
-            infoEnabled && info(`===> ${JSON.stringify(message)}`);
-            serverProxy.unsubscribe(message.viewport);
-            break;
-        default:
-            infoEnabled && info(`===> ${JSON.stringify(message)}`);
-            serverProxy.handleMessageFromClient(message);
-    }
-};
-self.addEventListener("message", handleMessageFromClient);
-postMessage({
-    type: "ready"
-});