@vuu-ui/vuu-data-remote 3.3.10 → 4.0.0-alpha.1

package/package.json

@@ -1,8 +1,9 @@
 {
-  "version": "3.3.10",
+  "version": "4.0.0-alpha.1",
   "main": "./src/index.js",
   "author": "heswell",
   "license": "Apache-2.0",
+  "type": "module",
   "scripts": {
     "build": "node ../../scripts/run-build-worker.mjs && node ../../scripts/run-build-rslib.ts",
     "build:dev": "node ../../scripts/run-build-worker.mjs &&  node ../../scripts/run-build.mjs -- --dev",
@@ -11,14 +12,15 @@
     "type-defs": "node ../../scripts/build-type-defs.mjs"
   },
   "devDependencies": {
-    "@vuu-ui/vuu-data-types": "3.3.10",
-    "@vuu-ui/vuu-table-types": "3.3.10",
-    "@vuu-ui/vuu-filter-types": "3.3.10",
-    "@vuu-ui/vuu-protocol-types": "3.3.10"
+    "@vuu-ui/vuu-data-types": "4.0.0-alpha.1",
+    "@vuu-ui/vuu-table-types": "4.0.0-alpha.1",
+    "@vuu-ui/vuu-filter-types": "4.0.0-alpha.1",
+    "@vuu-ui/vuu-protocol-types": "4.0.0-alpha.1"
   },
   "dependencies": {
-    "@vuu-ui/vuu-filter-parser": "3.3.10",
-    "@vuu-ui/vuu-utils": "3.3.10"
+    "@vuu-ui/vuu-data-editing": "4.0.0-alpha.1",
+    "@vuu-ui/vuu-filter-parser": "4.0.0-alpha.1",
+    "@vuu-ui/vuu-utils": "4.0.0-alpha.1"
   },
   "files": [
     "README.md",
@@ -33,6 +35,5 @@
   },
   "module": "./src/index.js",
   "name": "@vuu-ui/vuu-data-remote",
-  "type": "module",
   "types": "types/index.d.ts"
 }

package/src/ConnectionManager.js

@@ -2,20 +2,55 @@ import { DeferredPromise, EventEmitter, isConnectionQualityMetrics, isRequestRes
 import { isWebSocketConnectionStatus } from "./WebSocketConnection.js";
 import { DedicatedWorker } from "./DedicatedWorker.js";
 import { shouldMessageBeRoutedToDataSource } from "./data-source.js";
-class ConnectionManager extends EventEmitter {
-    static #instance;
+const DEFAULT_CONNECTION_ID = "portal";
+class ConnectionChannel {
+    onConnectionStatus;
+    onConnectionMetrics;
     #connectionStatus = "closed";
     #deferredServerAPI = new DeferredPromise();
     #pendingRequests = new Map();
     #viewports = new Map();
     #worker;
-    constructor(){
-        super();
+    #serverAPI;
+    constructor(onConnectionStatus, onConnectionMetrics){
+        this.onConnectionStatus = onConnectionStatus;
+        this.onConnectionMetrics = onConnectionMetrics;
         this.#worker = new DedicatedWorker(this.handleMessageFromWorker);
-    }
-    static get instance() {
-        if (!ConnectionManager.#instance) ConnectionManager.#instance = new ConnectionManager();
-        return ConnectionManager.#instance;
+        this.#serverAPI = {
+            subscribe: (message, callback)=>{
+                if (this.#viewports.get(message.viewport)) throw Error("ConnectionManager attempting to subscribe with an existing viewport id");
+                this.#viewports.set(message.viewport, {
+                    status: "subscribing",
+                    request: message,
+                    postMessageToClientDataSource: callback
+                });
+                this.#worker.send({
+                    type: "subscribe",
+                    ...message
+                });
+            },
+            unsubscribe: (viewport)=>{
+                this.#worker.send({
+                    type: "unsubscribe",
+                    viewport
+                });
+            },
+            send: (message)=>{
+                this.#worker.send(message);
+            },
+            destroy: (viewportId)=>{
+                if (viewportId && this.#viewports.has(viewportId)) this.#viewports.delete(viewportId);
+            },
+            rpcCall: async (message)=>this.asyncRequest(message),
+            select: async (selectRequest)=>this.asyncRequest(selectRequest),
+            getTableList: async ()=>this.asyncRequest({
+                    type: "GET_TABLE_LIST"
+                }),
+            getTableSchema: async (table)=>this.asyncRequest({
+                    type: "GET_TABLE_META",
+                    table
+                })
+        };
     }
     get connectionStatus() {
         return this.#connectionStatus;
@@ -23,28 +58,45 @@ class ConnectionManager extends EventEmitter {
     get connected() {
         return "connected" === this.#connectionStatus || "reconnected" === this.#connectionStatus;
     }
+    get serverAPI() {
+        return this.#deferredServerAPI.promise;
+    }
     async connect(options, throwOnRejected = false) {
         try {
             const result = await this.#worker.connect(options);
-            if ("connected" === result) this.#deferredServerAPI.resolve(this.connectedServerAPI);
+            if ("connected" === result.status || "reconnected" === result.status) this.#deferredServerAPI.resolve(this.#serverAPI);
             return result;
         } catch (err) {
-            if (!throwOnRejected) return "connection-failed";
-            throw err;
+            if (throwOnRejected) throw err;
+            return {
+                status: "rejected"
+            };
         }
     }
     disableActiveSubscriptions() {
-        console.log("[ConnectionManager] disableActiveSubscriptions");
         this.#worker.send({
             type: "disable-all-active"
         });
     }
     enableActiveSubscriptions() {
-        console.log("[ConnectionManager] enableActiveSubscriptions");
         this.#worker.send({
             type: "enable-all-active"
         });
     }
+    async disconnect() {
+        try {
+            this.#worker.send({
+                type: "disconnect"
+            });
+            this.#deferredServerAPI = new DeferredPromise();
+            return "disconnected";
+        } catch  {
+            return "rejected";
+        }
+    }
+    destroy() {
+        this.#worker.terminate();
+    }
     handleMessageFromWorker = (message)=>{
         if (shouldMessageBeRoutedToDataSource(message)) {
             const viewport = this.#viewports.get(message.clientViewportId);
@@ -52,8 +104,8 @@ class ConnectionManager extends EventEmitter {
             else console.error(`[ConnectionManager] ${message.type} message received, viewport not found`);
         } else if (isWebSocketConnectionStatus(message)) {
             this.#connectionStatus = message;
-            this.emit("connection-status", message);
-        } else if (isConnectionQualityMetrics(message)) this.emit("connection-metrics", message);
+            this.onConnectionStatus(message);
+        } else if (isConnectionQualityMetrics(message)) this.onConnectionMetrics(message);
         else if (isRequestResponse(message)) {
             const { requestId } = message;
             if (this.#pendingRequests.has(requestId)) {
@@ -64,71 +116,112 @@ class ConnectionManager extends EventEmitter {
             } else console.warn("%cConnectionManager Unexpected message from the worker", "color:red;font-weight:bold;");
         }
     };
-    get serverAPI() {
-        return this.#deferredServerAPI.promise;
-    }
-    connectedServerAPI = {
-        subscribe: (message, callback)=>{
-            if (this.#viewports.get(message.viewport)) throw Error("ConnectionManager attempting to subscribe with an existing viewport id");
-            this.#viewports.set(message.viewport, {
-                status: "subscribing",
-                request: message,
-                postMessageToClientDataSource: callback
-            });
-            this.#worker.send({
-                type: "subscribe",
-                ...message
-            });
-        },
-        unsubscribe: (viewport)=>{
-            this.#worker.send({
-                type: "unsubscribe",
-                viewport
-            });
-        },
-        send: (message)=>{
-            this.#worker.send(message);
-        },
-        destroy: (viewportId)=>{
-            if (viewportId && this.#viewports.has(viewportId)) this.#viewports.delete(viewportId);
-        },
-        rpcCall: async (message)=>this.asyncRequest(message),
-        select: async (selectRequest)=>this.asyncRequest(selectRequest),
-        getTableList: async ()=>this.asyncRequest({
-                type: "GET_TABLE_LIST"
-            }),
-        getTableSchema: async (table)=>this.asyncRequest({
-                type: "GET_TABLE_META",
-                table
-            })
-    };
     asyncRequest = (msg)=>{
         const requestId = uuid();
         this.#worker.send({
             requestId,
             ...msg
         });
-        return new Promise((resolve, reject)=>{
+        return new Promise((resolve)=>{
             this.#pendingRequests.set(requestId, {
-                resolve,
-                reject
+                resolve: (value)=>resolve(value)
             });
         });
     };
+}
+class ConnectionManager extends EventEmitter {
+    static #instance;
+    #connections = new Map();
+    #connectionStatusListeners = new Map();
+    constructor(){
+        super();
+    }
+    static get instance() {
+        if (!ConnectionManager.#instance) ConnectionManager.#instance = new ConnectionManager();
+        return ConnectionManager.#instance;
+    }
+    getConnection(connectionId = DEFAULT_CONNECTION_ID) {
+        const existing = this.#connections.get(connectionId);
+        if (existing) return existing;
+        const connection = new ConnectionChannel((status)=>{
+            this.#connectionStatusListeners.get(connectionId)?.forEach((listener)=>listener(status));
+            if (connectionId === DEFAULT_CONNECTION_ID) this.emit("connection-status", status);
+        }, (metrics)=>{
+            if (connectionId === DEFAULT_CONNECTION_ID) this.emit("connection-metrics", metrics);
+        });
+        this.#connections.set(connectionId, connection);
+        return connection;
+    }
+    get connectionStatus() {
+        return this.connectionStatusFor(DEFAULT_CONNECTION_ID);
+    }
+    get connected() {
+        return this.connectedFor(DEFAULT_CONNECTION_ID);
+    }
+    connectionStatusFor(connectionId) {
+        return this.getConnection(connectionId).connectionStatus;
+    }
+    connectedFor(connectionId) {
+        return this.getConnection(connectionId).connected;
+    }
+    onConnectionStatus(connectionId, listener) {
+        const listeners = this.#connectionStatusListeners.get(connectionId) ?? new Set();
+        listeners.add(listener);
+        this.#connectionStatusListeners.set(connectionId, listeners);
+        return ()=>{
+            listeners.delete(listener);
+            if (0 === listeners.size) this.#connectionStatusListeners.delete(connectionId);
+        };
+    }
+    async connect(options, throwOnRejected = false) {
+        return this.connectTo(DEFAULT_CONNECTION_ID, options, throwOnRejected);
+    }
+    async connectTo(connectionId, options, throwOnRejected = false) {
+        const result = await this.connectWithLoginResponseTo(connectionId, options, throwOnRejected);
+        return "rejected" === result.status ? "connection-failed" : result.status;
+    }
+    async connectWithLoginResponseTo(connectionId, options, throwOnRejected = false) {
+        return this.getConnection(connectionId).connect(options, throwOnRejected);
+    }
+    disableActiveSubscriptions() {
+        for (const connection of this.#connections.values())connection.disableActiveSubscriptions();
+    }
+    enableActiveSubscriptions() {
+        for (const connection of this.#connections.values())connection.enableActiveSubscriptions();
+    }
+    disableActiveSubscriptionsFor(connectionId) {
+        this.getConnection(connectionId).disableActiveSubscriptions();
+    }
+    enableActiveSubscriptionsFor(connectionId) {
+        this.getConnection(connectionId).enableActiveSubscriptions();
+    }
+    get serverAPI() {
+        return this.serverAPIFor(DEFAULT_CONNECTION_ID);
+    }
+    serverAPIFor(connectionId) {
+        return this.getConnection(connectionId).serverAPI;
+    }
     async disconnect() {
-        try {
-            this.#worker.send({
-                type: "disconnect"
-            });
-            this.#deferredServerAPI = new DeferredPromise();
-            return "disconnected";
-        } catch (err) {
-            return "rejected";
+        return this.disconnectFrom(DEFAULT_CONNECTION_ID);
+    }
+    async disconnectFrom(connectionId) {
+        return this.getConnection(connectionId).disconnect();
+    }
+    async destroyConnection(connectionId) {
+        const connection = this.#connections.get(connectionId);
+        if (connection) {
+            await connection.disconnect();
+            connection.destroy();
+            this.#connections.delete(connectionId);
         }
+        this.#connectionStatusListeners.delete(connectionId);
     }
     destroy() {
-        this.#worker.terminate();
+        for (const connection of this.#connections.values())connection.destroy();
+        this.#connections.clear();
+        this.#connectionStatusListeners.clear();
     }
 }
 var src_ConnectionManager = ConnectionManager.instance;
 export default src_ConnectionManager;
+export { DEFAULT_CONNECTION_ID };

package/src/DedicatedWorker.js

@@ -21,7 +21,10 @@ class DedicatedWorker {
             if ("ready" === message.type) {
                 window.clearTimeout(timer);
                 deferredWorker.resolve(worker);
-            } else if ("connected" === message.type) this.#deferredConnection?.resolve("connected");
+            } else if ("connected" === message.type) this.#deferredConnection?.resolve({
+                loginResponse: message.loginResponse,
+                status: "connected"
+            });
             else if ("connection-failed" === message.type) this.#deferredConnection?.reject(message.reason);
             else onMessage(message);
         };

package/src/VuuDataSource.js

@@ -16,6 +16,7 @@ class VuuDataSource extends BaseDataSource {
     bufferSize;
     server = null;
     rangeRequest;
+    #connectionId;
     #allColumns;
     #autosubscribeColumns = [];
     #pendingVisualLink;
@@ -32,12 +33,13 @@ class VuuDataSource extends BaseDataSource {
     #tableSchema;
     isRemote = true;
     table;
-    constructor({ session, sessionTableMessageColumn, ...props }){
+    constructor({ session, connectionId = "portal", sessionTableMessageColumn, ...props }){
         super(props);
         const { bufferSize = 100, table, visualLink } = props;
         if (!table) throw Error("RemoteDataSource constructor called without table");
         this.bufferSize = bufferSize;
         this.table = table;
+        this.#connectionId = connectionId;
         this.#pendingVisualLink = visualLink;
         this.#session = session;
         this.#sessionTableMessageColumn = sessionTableMessageColumn;
@@ -49,11 +51,15 @@ class VuuDataSource extends BaseDataSource {
     }
     async subscribe(subscribeProps, callback) {
         super.subscribe(subscribeProps, callback);
-        const { viewport = this.viewport || (this.viewport = uuid()) } = subscribeProps;
+        let viewport = subscribeProps.viewport ?? this.viewport;
+        if (!viewport) {
+            viewport = uuid();
+            this.viewport = viewport;
+        }
         if ("disabled" === this.#status || "disabling" === this.#status || "enabling" === this.#status) return void this.enable(callback);
         if ("initialising" !== this.#status && "unsubscribed" !== this.#status) throw Error(`[VuuDataSource] invalid status ${this.#status} for subscribe`);
         this.#status = "subscribing";
-        this.server = await ConnectionManager.serverAPI;
+        this.server = await ConnectionManager.serverAPIFor(this.#connectionId);
         const { bufferSize } = this;
         const { columns, ...dataSourceConfig } = combineFilters(this.config);
         this.server?.subscribe({
@@ -434,6 +440,7 @@ class VuuDataSource extends BaseDataSource {
             assertExpectedSessionTable(sessionTable, effectiveOverrides?.table);
             const sessionDataSource = new VuuDataSource({
                 ...sessionDataSourceConfig(this.config, effectiveOverrides?.columns),
+                connectionId: this.#connectionId,
                 table: sessionTable,
                 viewport: sessionTable.table
             });
@@ -544,7 +551,7 @@ class VuuDataSource extends BaseDataSource {
         };
     }
     async addRow(rowData = {}) {
-        const response = await this.rpcRequest?.({
+        const response = await this.rpcRequest({
             type: "RPC_REQUEST",
             rpcName: "addRow",
             params: {

package/src/WebSocketConnection.js

@@ -81,7 +81,14 @@ class WebSocketConnection extends EventEmitter {
         const timer = setTimeout(()=>{
             throw Error(`Failed to open WebSocket connection to ${url}, timed out after ${connectionTimeout}ms`);
         }, connectionTimeout);
-        const ws = this.#ws = new WebSocket(url, protocols);
+        console.log(`create websocket ${url} ${protocols}`);
+        try {
+            this.#ws = new WebSocket(url, protocols);
+        } catch (e) {
+            console.error(e);
+            return;
+        }
+        const ws = this.#ws;
         ws.onopen = ()=>{
             this.connectionStatus = "websocket-open";
             clearTimeout(timer);

package/src/index.js

@@ -3,9 +3,5 @@ export * from "./constants.js";
 export * from "./data-source.js";
 export * from "./message-utils.js";
 export * from "./VuuDataSource.js";
-export { authenticate, getVuuAuthToken, parseVuuUserFromToken } from "./authenticate.js";
 export { default as ConnectionManager } from "./ConnectionManager.js";
-export { LostConnectionHandler, RetryOptions } from "./LostConnectionHandler.js";
-export { VuuAuthTokenIssuePolicy, VuuAuthenticator } from "./VuuAuthenticator.js";
-export { VuuAuthProvider } from "./VuuAuthProvider.js";
 export { isConnected } from "./WebSocketConnection.js";

package/src/inlined-worker.js

@@ -109,7 +109,9 @@ var EventEmitter = class {
   }
   invokeHandler(handler, args) {
     if (isArrayOfListeners(handler)) {
-      handler.slice().forEach((listener) => this.invokeHandler(listener, args));
+      handler.slice().forEach((listener) => {
+        this.invokeHandler(listener, args);
+      });
     } else {
       switch (args.length) {
         case 0:
@@ -1648,7 +1650,14 @@ var WebSocketConnection = class extends EventEmitter {
         \`Failed to open WebSocket connection to \${url}, timed out after \${connectionTimeout}ms\`
       );
     }, connectionTimeout);
-    const ws = __privateSet(this, _ws, new WebSocket(url, protocols));
+    console.log(\`create websocket \${url} \${protocols}\`);
+    try {
+      __privateSet(this, _ws, new WebSocket(url, protocols));
+    } catch (e) {
+      console.error(e);
+      return;
+    }
+    const ws = __privateGet(this, _ws);
     ws.onopen = () => {
       this.connectionStatus = "websocket-open";
       clearTimeout(timer);
@@ -2359,12 +2368,10 @@ var ServerProxy = class {
       case "LOGIN_SUCCESS":
         if (sessionId) {
           this.sessionId = sessionId;
-          (_a = this.pendingLogin) == null ? void 0 : _a.resolve(sessionId);
+          const loginResponse = { ...body, sessionId };
+          (_a = this.pendingLogin) == null ? void 0 : _a.resolve(loginResponse);
           this.pendingLogin = void 0;
-          this.postMessageToClient({
-            ...body,
-            sessionId
-          });
+          this.postMessageToClient(loginResponse);
         } else {
           throw Error("LOGIN_SUCCESS did not provide sessionId");
         }
@@ -2758,12 +2765,15 @@ var handleMessageFromClient = async ({
   switch (message.type) {
     case "connect":
       try {
-        const sessionId = await connectToServer(
+        const loginResponse = await connectToServer(
           message.url,
           message.protocol,
           message.token
         );
-        postMessage({ type: "connected", sessionId });
+        if (!loginResponse) {
+          throw Error("VUU server did not return a LOGIN_SUCCESS response");
+        }
+        postMessage({ type: "connected", loginResponse });
       } catch (err) {
         postMessage({ type: "connection-failed", reason: String(err) });
       }

package/src/server-proxy/server-proxy.js

@@ -514,12 +514,13 @@ class ServerProxy {
             case "LOGIN_SUCCESS":
                 if (sessionId) {
                     this.sessionId = sessionId;
-                    this.pendingLogin?.resolve(sessionId);
-                    this.pendingLogin = void 0;
-                    this.postMessageToClient({
+                    const loginResponse = {
                         ...body,
                         sessionId
-                    });
+                    };
+                    this.pendingLogin?.resolve(loginResponse);
+                    this.pendingLogin = void 0;
+                    this.postMessageToClient(loginResponse);
                 } else throw Error("LOGIN_SUCCESS did not provide sessionId");
                 break;
             case "REMOVE_VP_SUCCESS":

package/src/worker.js

@@ -30,10 +30,11 @@ const handleMessageFromClient = async ({ data: message })=>{
     switch(message.type){
         case "connect":
             try {
-                const sessionId = await connectToServer(message.url, message.protocol, message.token);
+                const loginResponse = await connectToServer(message.url, message.protocol, message.token);
+                if (!loginResponse) throw Error("VUU server did not return a LOGIN_SUCCESS response");
                 postMessage({
                     type: "connected",
-                    sessionId
+                    loginResponse
                 });
             } catch (err) {
                 postMessage({

package/types/ConnectionManager.d.ts

@@ -1,35 +1,63 @@
-import { ConnectOptions, DataSourceCallbackMessage, ServerAPI } from "@vuu-ui/vuu-data-types";
+import type { ConnectOptions, DataSourceCallbackMessage, ServerAPI } from "@vuu-ui/vuu-data-types";
+import type { VuuLoginSuccessResponse } from "@vuu-ui/vuu-protocol-types";
 import { EventEmitter } from "@vuu-ui/vuu-utils";
-import { ConnectionStatus, WebSocketConnectionEvents } from "./WebSocketConnection";
-import { ConnectionQualityMetrics } from "@vuu-ui/vuu-data-types";
+import type { ConnectionQualityMetrics } from "@vuu-ui/vuu-data-types";
+import type { ConnectionStatus, WebSocketConnectionEvents } from "./WebSocketConnection";
+export declare const DEFAULT_CONNECTION_ID = "portal";
 export type PostMessageToClientCallback = (msg: DataSourceCallbackMessage) => void;
 export type ConnectionEvents = WebSocketConnectionEvents & {
     "connection-metrics": (message: ConnectionQualityMetrics) => void;
 };
+export type ConnectionStatusListener = (status: ConnectionStatus) => void;
+export type VuuConnectionResult = {
+    loginResponse: VuuLoginSuccessResponse & {
+        sessionId: string;
+    };
+    status: "connected" | "reconnected";
+} | {
+    status: "rejected";
+};
+/**
+ * Process-wide registry for VUU server connections.
+ *
+ * Consumers use the exported singleton to connect, obtain a deferred
+ * `ServerAPI`, and control subscriptions. The unscoped methods operate on the
+ * legacy `portal` connection, while the `*To` and `*For` methods select an
+ * independent connection by ID. This allows remote modules to share the manager
+ * without sharing authentication, worker state, or viewport subscriptions.
+ *
+ * Connection status and metrics events are emitted for the default connection
+ * to preserve the existing application-level monitoring API.
+ */
 declare class ConnectionManager extends EventEmitter<ConnectionEvents> {
     #private;
     private constructor();
     static get instance(): ConnectionManager;
+    private getConnection;
     get connectionStatus(): ConnectionStatus;
     get connected(): boolean;
-    /**
-     * Open a connection to the VuuServer. This method opens the websocket connection
-     * and logs in. It can be called from whichever client code has access to the auth
-     * token (eg. the login page, or just a hardcoded login script in a sample).
-     * This will unblock any DataSources which may have already tried to subscribe to data,
-     * but lacked access to the auth token.
-     *
-     * @param serverUrl
-     * @param token
-     */
-    connect(options: ConnectOptions, throwOnRejected?: boolean): Promise<"connected" | "reconnected" | "rejected" | "connection-failed">;
+    connectionStatusFor(connectionId: string): ConnectionStatus;
+    connectedFor(connectionId: string): boolean;
+    onConnectionStatus(connectionId: string, listener: ConnectionStatusListener): () => void;
+    connect(options: ConnectOptions, throwOnRejected?: boolean): Promise<"connected" | "connection-failed" | "reconnected">;
+    connectTo(connectionId: string, options: ConnectOptions, throwOnRejected?: boolean): Promise<"connected" | "connection-failed" | "reconnected">;
+    connectWithLoginResponseTo(connectionId: string, options: ConnectOptions, throwOnRejected?: boolean): Promise<{
+        loginResponse: VuuLoginSuccessResponse & {
+            sessionId: string;
+        };
+        status: "connected" | "reconnected";
+    } | {
+        readonly status: "rejected";
+    }>;
     disableActiveSubscriptions(): void;
     enableActiveSubscriptions(): void;
-    private handleMessageFromWorker;
+    disableActiveSubscriptionsFor(connectionId: string): void;
+    enableActiveSubscriptionsFor(connectionId: string): void;
     get serverAPI(): Promise<ServerAPI>;
-    private connectedServerAPI;
-    private asyncRequest;
-    disconnect(): Promise<"rejected" | "disconnected">;
+    serverAPIFor(connectionId: string): Promise<ServerAPI>;
+    disconnect(): Promise<"disconnected" | "rejected">;
+    disconnectFrom(connectionId: string): Promise<"disconnected" | "rejected">;
+    destroyConnection(connectionId: string): Promise<void>;
     destroy(): void;
 }
 declare const _default: ConnectionManager;

package/types/DedicatedWorker.d.ts

@@ -1,9 +1,16 @@
-import { ConnectOptions, VuuUIMessageIn, VuuUIMessageOut, WithRequestId } from "@vuu-ui/vuu-data-types";
-import { SelectRequest, VuuCreateVisualLink, VuuRemoveVisualLink, VuuRpcMenuRequest, VuuRpcServiceRequest } from "@vuu-ui/vuu-protocol-types";
+import type { ConnectOptions, VuuUIMessageIn, VuuUIMessageOut, WithRequestId } from "@vuu-ui/vuu-data-types";
+import type { SelectRequest, VuuLoginSuccessResponse, VuuCreateVisualLink, VuuRemoveVisualLink, VuuRpcMenuRequest, VuuRpcServiceRequest } from "@vuu-ui/vuu-protocol-types";
 export declare class DedicatedWorker {
     #private;
     constructor(onMessage: (msg: VuuUIMessageIn) => void);
-    connect(options: ConnectOptions): Promise<"connected" | "reconnected" | "rejected">;
+    connect(options: ConnectOptions): Promise<{
+        loginResponse: VuuLoginSuccessResponse & {
+            sessionId: string;
+        };
+        status: "connected" | "reconnected";
+    } | {
+        status: "rejected";
+    }>;
     send(message: VuuUIMessageOut | WithRequestId<VuuCreateVisualLink | VuuRemoveVisualLink | VuuRpcServiceRequest | VuuRpcMenuRequest | SelectRequest>): Promise<void>;
     terminate(): Promise<void>;
 }

package/types/VuuDataSource.d.ts

@@ -10,7 +10,7 @@ export declare class VuuDataSource extends BaseDataSource implements DataSourceB
     rangeRequest: RangeRequest;
     readonly isRemote = true;
     table: VuuTable;
-    constructor({ session, sessionTableMessageColumn, ...props }: DataSourceConstructorProps);
+    constructor({ session, connectionId, sessionTableMessageColumn, ...props }: DataSourceConstructorProps);
     subscribe(subscribeProps: DataSourceSubscribeProps, callback: DataSourceSubscribeCallback): Promise<void>;
     handleMessageFromServer: (message: DataSourceCallbackMessage) => void;
     handleSessionMessageFromServer: (msg: DataSourceCallbackMessage) => void;
@@ -61,9 +61,9 @@ export declare class VuuDataSource extends BaseDataSource implements DataSourceB
     remoteProcedureCall<T extends VuuRpcResponse = VuuRpcResponse>(): Promise<T>;
     createSessionDataSource(copyOption: CopyOption, sessionType?: SessionType, overrides?: SessionDataSourceOverrides): Promise<VuuDataSource | undefined>;
     beginEditSession(): Promise<VuuDataSource>;
-    editCell(key: string, column: string, data: VuuRowDataItemType): Promise<RpcResultSuccess | RpcResultError>;
+    editCell(key: string, column: string, data: VuuRowDataItemType): Promise<RpcResultError | RpcResultSuccess>;
     endEditSession(saveChanges?: boolean, force?: boolean): Promise<void>;
-    rpcRequest(rpcRequest: Omit<VuuRpcServiceRequest, "context">): Promise<RpcResultSuccess | RpcResultError>;
+    rpcRequest(rpcRequest: Omit<VuuRpcServiceRequest, "context">): Promise<RpcResultError | RpcResultSuccess>;
     menuRpcCall(rpcRequest: Omit<VuuRpcMenuRequest, "vpId">): Promise<MenuRpcResponse<any> | undefined>;
     insertRow(): Promise<string>;
     deleteRow(key: string, mode?: DeleteRowMode): Promise<true | string>;