@verdant-web/store 2.7.6 → 2.7.7-next.0

package/dist/cjs/sync/WebSocketSync.d.ts

@@ -1,41 +1,41 @@
-import { ClientMessage, EventSubscriber } from '@verdant-web/common';
-import { Metadata } from '../metadata/Metadata.js';
-import { PresenceManager } from './PresenceManager.js';
-import { ServerSyncEndpointProvider } from './ServerSyncEndpointProvider.js';
-import { SyncTransport, SyncTransportEvents } from './Sync.js';
-export declare class WebSocketSync extends EventSubscriber<SyncTransportEvents> implements SyncTransport {
-    private meta;
-    readonly presence: PresenceManager;
-    private socket;
-    private connectQueue;
-    private syncQueue;
-    private endpointProvider;
-    private _status;
-    private synced;
-    private hasStartedSync;
-    readonly mode = "realtime";
-    private log;
-    private heartbeat;
-    private reconnectScheduler;
-    constructor({ endpointProvider, meta, presence, log, }: {
-        endpointProvider: ServerSyncEndpointProvider;
-        meta: Metadata;
-        presence: PresenceManager;
-        log?: (...args: any[]) => any;
-    });
-    private onOpen;
-    private onOnlineChange;
-    private onMessage;
-    private onError;
-    private onClose;
-    private initializeSocket;
-    private sendHeartbeat;
-    reconnect: () => void;
-    private canSkipSyncWait;
-    send: (message: ClientMessage) => void;
-    dispose: () => void;
-    start: () => void;
-    stop: () => void;
-    get isConnected(): boolean;
-    get status(): "active" | "paused";
-}
+import { ClientMessage, EventSubscriber } from '@verdant-web/common';
+import { Metadata } from '../metadata/Metadata.js';
+import { PresenceManager } from './PresenceManager.js';
+import { ServerSyncEndpointProvider } from './ServerSyncEndpointProvider.js';
+import { SyncTransport, SyncTransportEvents } from './Sync.js';
+export declare class WebSocketSync extends EventSubscriber<SyncTransportEvents> implements SyncTransport {
+    private meta;
+    readonly presence: PresenceManager;
+    private socket;
+    private connectQueue;
+    private syncQueue;
+    private endpointProvider;
+    private _status;
+    private synced;
+    private hasStartedSync;
+    readonly mode = "realtime";
+    private log;
+    private heartbeat;
+    private reconnectScheduler;
+    constructor({ endpointProvider, meta, presence, log, }: {
+        endpointProvider: ServerSyncEndpointProvider;
+        meta: Metadata;
+        presence: PresenceManager;
+        log?: (...args: any[]) => any;
+    });
+    private onOpen;
+    private onOnlineChange;
+    private onMessage;
+    private onError;
+    private onClose;
+    private initializeSocket;
+    private sendHeartbeat;
+    reconnect: () => void;
+    private canSkipSyncWait;
+    send: (message: ClientMessage) => void;
+    dispose: () => void;
+    start: () => void;
+    stop: () => void;
+    get isConnected(): boolean;
+    get status(): "active" | "paused";
+}

package/dist/cjs/sync/WebSocketSync.js

@@ -1,191 +1,191 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebSocketSync = void 0;
-const common_1 = require("@verdant-web/common");
-const BackoffScheduler_js_1 = require("../BackoffScheduler.js");
-const Heartbeat_js_1 = require("./Heartbeat.js");
-class WebSocketSync extends common_1.EventSubscriber {
-    constructor({ endpointProvider, meta, presence, log, }) {
-        super();
-        this.socket = null;
-        // messages awaiting websocket connection to send
-        this.connectQueue = [];
-        // messages awaiting sync response to send
-        this.syncQueue = [];
-        this._status = 'paused';
-        this.synced = false;
-        this.hasStartedSync = false;
-        this.mode = 'realtime';
-        this.log = (...args) => { };
-        this.heartbeat = new Heartbeat_js_1.Heartbeat();
-        this.reconnectScheduler = new BackoffScheduler_js_1.BackoffScheduler(new BackoffScheduler_js_1.Backoff(60 * 1000, 1.5));
-        this.onOpen = () => {
-            if (!this.socket) {
-                throw new Error('Invalid sync state: online but socket is null');
-            }
-            this.synced = false;
-            if (this.connectQueue.length) {
-                for (const msg of this.connectQueue) {
-                    this.log('Sending queued message', JSON.stringify(msg, null, 2));
-                    this.socket.send(JSON.stringify(msg));
-                }
-                this.connectQueue = [];
-            }
-            this.log('Sync connected');
-            this.onOnlineChange(true);
-            this.reconnectScheduler.reset();
-        };
-        this.onOnlineChange = async (online) => {
-            this.log('Socket online change', online);
-            if (!online) {
-                this.hasStartedSync = false;
-                this.synced = false;
-                this.heartbeat.stop();
-            }
-            else {
-                this.log('Starting sync');
-                this.hasStartedSync = true;
-                this.synced = false;
-                this.send(await this.meta.messageCreator.createPresenceUpdate(this.presence.self.presence));
-                this.send(await this.meta.messageCreator.createSyncStep1());
-                this.heartbeat.start();
-            }
-            this.emit('onlineChange', online);
-        };
-        this.onMessage = async (event) => {
-            const message = JSON.parse(event.data);
-            switch (message.type) {
-                case 'sync-resp':
-                    if (message.ackThisNonce) {
-                        // we need to send the ack to confirm we got the response
-                        this.send(await this.meta.messageCreator.createAck(message.ackThisNonce));
-                    }
-                    this.hasStartedSync = true;
-                    this.synced = true;
-                    if (this.syncQueue.length) {
-                        for (const msg of this.syncQueue) {
-                            this.send(msg);
-                        }
-                        this.syncQueue = [];
-                    }
-                case 'need-since':
-                case 'presence-changed':
-                case 'presence-offline':
-                    this.emit('message', message);
-                    break;
-                case 'op-re':
-                    if (!this.hasStartedSync) {
-                        this.log(`Skipping op-re message because sync hasn't started yet`, message);
-                        break;
-                    }
-                    this.emit('message', message);
-                    break;
-                case 'heartbeat-response':
-                    this.heartbeat.keepAlive();
-                    this.emit('message', message);
-                    break;
-                default:
-                    if (this.synced) {
-                        this.emit('message', message);
-                    }
-                    break;
-            }
-        };
-        this.onError = (event) => {
-            this.log(event);
-            this.reconnectScheduler.next();
-            this.log(`Attempting reconnect to websocket sync`);
-        };
-        this.onClose = (event) => {
-            this.log('Sync disconnected');
-            this.onOnlineChange(false);
-            this.onError(event);
-        };
-        this.initializeSocket = async () => {
-            const endpoint = await this.endpointProvider.getEndpoints();
-            // abusing protocols to pass the auth token
-            this.socket = new WebSocket(endpoint.websocket, ['Bearer', endpoint.token]);
-            this.socket.addEventListener('message', this.onMessage);
-            this.socket.addEventListener('open', this.onOpen);
-            this.socket.addEventListener('error', this.onError);
-            this.socket.addEventListener('close', this.onClose);
-            return this.socket;
-        };
-        this.sendHeartbeat = async () => {
-            this.send(await this.meta.messageCreator.createHeartbeat());
-        };
-        this.reconnect = () => {
-            this.stop();
-            this.start();
-        };
-        this.canSkipSyncWait = (message) => {
-            return (message.type === 'sync' ||
-                message.type === 'presence-update' ||
-                message.type === 'sync-ack' ||
-                message.type === 'heartbeat');
-        };
-        this.send = (message) => {
-            var _a, _b;
-            if (this.status !== 'active')
-                return;
-            // wait until a sync has started before doing anything other than sync.
-            // new "op" messages can arrive before sync has started, so we need to wait
-            if (!this.hasStartedSync && !this.canSkipSyncWait(message)) {
-                return;
-            }
-            if (this.canSkipSyncWait(message)) {
-                if (((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN) {
-                    this.log('Sending message', JSON.stringify(message, null, 2));
-                    this.socket.send(JSON.stringify(message));
-                }
-                else {
-                    this.log('Enqueueing message until socket is open', JSON.stringify(message, null, 2));
-                    this.connectQueue.push(message);
-                }
-            }
-            else if (this.synced) {
-                if (((_b = this.socket) === null || _b === void 0 ? void 0 : _b.readyState) === WebSocket.OPEN) {
-                    this.log('Sending message', JSON.stringify(message, null, 2));
-                    this.socket.send(JSON.stringify(message));
-                }
-            }
-            else if (this.hasStartedSync) {
-                this.log('Enqueueing message until synced', JSON.stringify(message, null, 2));
-                this.syncQueue.push(message);
-            }
-        };
-        this.dispose = () => {
-            var _a, _b, _c;
-            (_a = this.socket) === null || _a === void 0 ? void 0 : _a.removeEventListener('message', this.onMessage);
-            (_b = this.socket) === null || _b === void 0 ? void 0 : _b.removeEventListener('close', this.onClose);
-            (_c = this.socket) === null || _c === void 0 ? void 0 : _c.close();
-        };
-        this.start = () => {
-            if (this.socket) {
-                return;
-            }
-            this.initializeSocket();
-            this._status = 'active';
-        };
-        this.stop = () => {
-            this.dispose();
-            this.socket = null;
-            this._status = 'paused';
-        };
-        this.log = log || this.log;
-        this.endpointProvider = endpointProvider;
-        this.meta = meta;
-        this.presence = presence;
-        this.reconnectScheduler.subscribe('trigger', this.initializeSocket);
-        this.heartbeat.subscribe('beat', this.sendHeartbeat);
-    }
-    get isConnected() {
-        var _a;
-        return ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN;
-    }
-    get status() {
-        return this._status;
-    }
-}
-exports.WebSocketSync = WebSocketSync;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketSync = void 0;
+const common_1 = require("@verdant-web/common");
+const BackoffScheduler_js_1 = require("../BackoffScheduler.js");
+const Heartbeat_js_1 = require("./Heartbeat.js");
+class WebSocketSync extends common_1.EventSubscriber {
+    constructor({ endpointProvider, meta, presence, log, }) {
+        super();
+        this.socket = null;
+        // messages awaiting websocket connection to send
+        this.connectQueue = [];
+        // messages awaiting sync response to send
+        this.syncQueue = [];
+        this._status = 'paused';
+        this.synced = false;
+        this.hasStartedSync = false;
+        this.mode = 'realtime';
+        this.log = (...args) => { };
+        this.heartbeat = new Heartbeat_js_1.Heartbeat();
+        this.reconnectScheduler = new BackoffScheduler_js_1.BackoffScheduler(new BackoffScheduler_js_1.Backoff(60 * 1000, 1.5));
+        this.onOpen = () => {
+            if (!this.socket) {
+                throw new Error('Invalid sync state: online but socket is null');
+            }
+            this.synced = false;
+            if (this.connectQueue.length) {
+                for (const msg of this.connectQueue) {
+                    this.log('Sending queued message', JSON.stringify(msg, null, 2));
+                    this.socket.send(JSON.stringify(msg));
+                }
+                this.connectQueue = [];
+            }
+            this.log('Sync connected');
+            this.onOnlineChange(true);
+            this.reconnectScheduler.reset();
+        };
+        this.onOnlineChange = async (online) => {
+            this.log('Socket online change', online);
+            if (!online) {
+                this.hasStartedSync = false;
+                this.synced = false;
+                this.heartbeat.stop();
+            }
+            else {
+                this.log('Starting sync');
+                this.hasStartedSync = true;
+                this.synced = false;
+                this.send(await this.meta.messageCreator.createPresenceUpdate(this.presence.self.presence));
+                this.send(await this.meta.messageCreator.createSyncStep1());
+                this.heartbeat.start();
+            }
+            this.emit('onlineChange', online);
+        };
+        this.onMessage = async (event) => {
+            const message = JSON.parse(event.data);
+            switch (message.type) {
+                case 'sync-resp':
+                    if (message.ackThisNonce) {
+                        // we need to send the ack to confirm we got the response
+                        this.send(await this.meta.messageCreator.createAck(message.ackThisNonce));
+                    }
+                    this.hasStartedSync = true;
+                    this.synced = true;
+                    if (this.syncQueue.length) {
+                        for (const msg of this.syncQueue) {
+                            this.send(msg);
+                        }
+                        this.syncQueue = [];
+                    }
+                case 'need-since':
+                case 'presence-changed':
+                case 'presence-offline':
+                    this.emit('message', message);
+                    break;
+                case 'op-re':
+                    if (!this.hasStartedSync) {
+                        this.log(`Skipping op-re message because sync hasn't started yet`, message);
+                        break;
+                    }
+                    this.emit('message', message);
+                    break;
+                case 'heartbeat-response':
+                    this.heartbeat.keepAlive();
+                    this.emit('message', message);
+                    break;
+                default:
+                    if (this.synced) {
+                        this.emit('message', message);
+                    }
+                    break;
+            }
+        };
+        this.onError = (event) => {
+            this.log(event);
+            this.reconnectScheduler.next();
+            this.log(`Attempting reconnect to websocket sync`);
+        };
+        this.onClose = (event) => {
+            this.log('Sync disconnected');
+            this.onOnlineChange(false);
+            this.onError(event);
+        };
+        this.initializeSocket = async () => {
+            const endpoint = await this.endpointProvider.getEndpoints();
+            // abusing protocols to pass the auth token
+            this.socket = new WebSocket(endpoint.websocket, ['Bearer', endpoint.token]);
+            this.socket.addEventListener('message', this.onMessage);
+            this.socket.addEventListener('open', this.onOpen);
+            this.socket.addEventListener('error', this.onError);
+            this.socket.addEventListener('close', this.onClose);
+            return this.socket;
+        };
+        this.sendHeartbeat = async () => {
+            this.send(await this.meta.messageCreator.createHeartbeat());
+        };
+        this.reconnect = () => {
+            this.stop();
+            this.start();
+        };
+        this.canSkipSyncWait = (message) => {
+            return (message.type === 'sync' ||
+                message.type === 'presence-update' ||
+                message.type === 'sync-ack' ||
+                message.type === 'heartbeat');
+        };
+        this.send = (message) => {
+            var _a, _b;
+            if (this.status !== 'active')
+                return;
+            // wait until a sync has started before doing anything other than sync.
+            // new "op" messages can arrive before sync has started, so we need to wait
+            if (!this.hasStartedSync && !this.canSkipSyncWait(message)) {
+                return;
+            }
+            if (this.canSkipSyncWait(message)) {
+                if (((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN) {
+                    this.log('Sending message', JSON.stringify(message, null, 2));
+                    this.socket.send(JSON.stringify(message));
+                }
+                else {
+                    this.log('Enqueueing message until socket is open', JSON.stringify(message, null, 2));
+                    this.connectQueue.push(message);
+                }
+            }
+            else if (this.synced) {
+                if (((_b = this.socket) === null || _b === void 0 ? void 0 : _b.readyState) === WebSocket.OPEN) {
+                    this.log('Sending message', JSON.stringify(message, null, 2));
+                    this.socket.send(JSON.stringify(message));
+                }
+            }
+            else if (this.hasStartedSync) {
+                this.log('Enqueueing message until synced', JSON.stringify(message, null, 2));
+                this.syncQueue.push(message);
+            }
+        };
+        this.dispose = () => {
+            var _a, _b, _c;
+            (_a = this.socket) === null || _a === void 0 ? void 0 : _a.removeEventListener('message', this.onMessage);
+            (_b = this.socket) === null || _b === void 0 ? void 0 : _b.removeEventListener('close', this.onClose);
+            (_c = this.socket) === null || _c === void 0 ? void 0 : _c.close();
+        };
+        this.start = () => {
+            if (this.socket) {
+                return;
+            }
+            this.initializeSocket();
+            this._status = 'active';
+        };
+        this.stop = () => {
+            this.dispose();
+            this.socket = null;
+            this._status = 'paused';
+        };
+        this.log = log || this.log;
+        this.endpointProvider = endpointProvider;
+        this.meta = meta;
+        this.presence = presence;
+        this.reconnectScheduler.subscribe('trigger', this.initializeSocket);
+        this.heartbeat.subscribe('beat', this.sendHeartbeat);
+    }
+    get isConnected() {
+        var _a;
+        return ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN;
+    }
+    get status() {
+        return this._status;
+    }
+}
+exports.WebSocketSync = WebSocketSync;
 //# sourceMappingURL=WebSocketSync.js.map

package/dist/cjs/types.d.ts

@@ -1,12 +1,12 @@
-import { Operation } from '@verdant-web/common';
-export type LogFunction = (...args: any[]) => void;
-/**
- * Operations moving through the client system are
- * tagged with whether or not they are stored in
- * the database (confirmed) or only in memory,
- * which might mean they are lost if the client
- * crashes.
- */
-export interface TaggedOperation extends Operation {
-    confirmed?: boolean;
-}
+import { Operation } from '@verdant-web/common';
+export type LogFunction = (...args: any[]) => void;
+/**
+ * Operations moving through the client system are
+ * tagged with whether or not they are stored in
+ * the database (confirmed) or only in memory,
+ * which might mean they are lost if the client
+ * crashes.
+ */
+export interface TaggedOperation extends Operation {
+    confirmed?: boolean;
+}

package/dist/cjs/types.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=types.js.map

package/dist/cjs/utils/Disposable.d.ts

@@ -1,6 +1,6 @@
-export declare class Disposable {
-    private _disposes;
-    protected disposed: boolean;
-    dispose: () => void;
-    protected addDispose: (dispose: () => void) => void;
-}
+export declare class Disposable {
+    private _disposes;
+    protected disposed: boolean;
+    dispose: () => void;
+    protected addDispose: (dispose: () => void) => void;
+}

package/dist/cjs/utils/Disposable.js

@@ -1,19 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Disposable = void 0;
-class Disposable {
-    constructor() {
-        this._disposes = [];
-        this.disposed = false;
-        this.dispose = () => {
-            this.disposed = true;
-            this._disposes.forEach((dispose) => dispose());
-            this._disposes = [];
-        };
-        this.addDispose = (dispose) => {
-            this._disposes.push(dispose);
-        };
-    }
-}
-exports.Disposable = Disposable;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Disposable = void 0;
+class Disposable {
+    constructor() {
+        this._disposes = [];
+        this.disposed = false;
+        this.dispose = () => {
+            this.disposed = true;
+            this._disposes.forEach((dispose) => dispose());
+            this._disposes = [];
+        };
+        this.addDispose = (dispose) => {
+            this._disposes.push(dispose);
+        };
+    }
+}
+exports.Disposable = Disposable;
 //# sourceMappingURL=Disposable.js.map

package/dist/cjs/utils/Resolvable.d.ts

@@ -1,8 +1,8 @@
-export declare class Resolvable<T> {
-    readonly promise: Promise<T>;
-    private _resolve;
-    private _reject;
-    constructor();
-    resolve(value: T): void;
-    reject(reason?: any): void;
-}
+export declare class Resolvable<T> {
+    readonly promise: Promise<T>;
+    private _resolve;
+    private _reject;
+    constructor();
+    resolve(value: T): void;
+    reject(reason?: any): void;
+}

package/dist/cjs/utils/Resolvable.js

@@ -1,23 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Resolvable = void 0;
-class Resolvable {
-    constructor() {
-        let resolve;
-        let reject;
-        this.promise = new Promise((res, rej) => {
-            resolve = res;
-            reject = rej;
-        });
-        this._resolve = resolve;
-        this._reject = reject;
-    }
-    resolve(value) {
-        this._resolve(value);
-    }
-    reject(reason) {
-        this._reject(reason);
-    }
-}
-exports.Resolvable = Resolvable;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Resolvable = void 0;
+class Resolvable {
+    constructor() {
+        let resolve;
+        let reject;
+        this.promise = new Promise((res, rej) => {
+            resolve = res;
+            reject = rej;
+        });
+        this._resolve = resolve;
+        this._reject = reject;
+    }
+    resolve(value) {
+        this._resolve(value);
+    }
+    reject(reason) {
+        this._reject(reason);
+    }
+}
+exports.Resolvable = Resolvable;
 //# sourceMappingURL=Resolvable.js.map

package/dist/cjs/v2/AckInfoStore.d.ts

@@ -0,0 +1,10 @@
+import { IDBService } from './IDBService.js';
+declare type AckInfo = {
+    type: 'ack';
+    globalAckTimestamp: string | null;
+};
+export declare class AckInfoStore extends IDBService {
+    getAckInfo: () => Promise<AckInfo>;
+    setGlobalAck: (ack: string) => Promise<void>;
+}
+export {};

package/dist/cjs/v2/AckInfoStore.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AckInfoStore = void 0;
+const IDBService_js_1 = require("./IDBService.js");
+class AckInfoStore extends IDBService_js_1.IDBService {
+    constructor() {
+        super(...arguments);
+        this.getAckInfo = async () => {
+            const result = await this.run('info', (store) => store.get('ack'));
+            if (result) {
+                return result;
+            }
+            else {
+                return {
+                    globalAckTimestamp: null,
+                    type: 'ack',
+                };
+            }
+        };
+        this.setGlobalAck = async (ack) => {
+            await this.run('info', (store) => store.put({ type: 'ack', globalAckTimestamp: ack }), 'readwrite');
+        };
+    }
+}
+exports.AckInfoStore = AckInfoStore;
+//# sourceMappingURL=AckInfoStore.js.map

package/dist/cjs/v2/AckInfoStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AckInfoStore.js","sourceRoot":"","sources":["../../../src/v2/AckInfoStore.ts"],"names":[],"mappings":";;;AAAA,mDAA6C;AAS7C,MAAa,YAAa,SAAQ,0BAAU;IAA5C;;QACC,eAAU,GAAG,KAAK,IAAsB,EAAE;YACzC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,GAAG,CAAU,MAAM,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;YAC5E,IAAI,MAAM,EAAE;gBACX,OAAO,MAAM,CAAC;aACd;iBAAM;gBACN,OAAO;oBACN,kBAAkB,EAAE,IAAI;oBACxB,IAAI,EAAE,KAAK;iBACX,CAAC;aACF;QACF,CAAC,CAAC;QAEF,iBAAY,GAAG,KAAK,EAAE,GAAW,EAAE,EAAE;YACpC,MAAM,IAAI,CAAC,GAAG,CACb,MAAM,EACN,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,kBAAkB,EAAE,GAAG,EAAE,CAAC,EAC9D,WAAW,CACX,CAAC;QACH,CAAC,CAAC;IACH,CAAC;CAAA;AApBD,oCAoBC"}