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

package/dist/esm/sync/{WebsocketSync.js → WebSocketSync.js}

@@ -1,187 +1,187 @@
-import { EventSubscriber, } from '@verdant-web/common';
-import { Backoff, BackoffScheduler } from '../BackoffScheduler.js';
-import { Heartbeat } from './Heartbeat.js';
-export class WebSocketSync extends 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();
-        this.reconnectScheduler = new BackoffScheduler(new 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;
-    }
-}
+import { EventSubscriber, } from '@verdant-web/common';
+import { Backoff, BackoffScheduler } from '../BackoffScheduler.js';
+import { Heartbeat } from './Heartbeat.js';
+export class WebSocketSync extends 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();
+        this.reconnectScheduler = new BackoffScheduler(new 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;
+    }
+}
 //# sourceMappingURL=WebSocketSync.js.map

package/dist/esm/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/esm/types.js

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=types.js.map

package/dist/esm/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/esm/utils/Disposable.js

@@ -1,15 +1,15 @@
-export 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);
-        };
-    }
-}
+export 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);
+        };
+    }
+}
 //# sourceMappingURL=Disposable.js.map

package/dist/esm/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/esm/utils/Resolvable.js

@@ -1,19 +1,19 @@
-export 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);
-    }
-}
+export 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);
+    }
+}
 //# sourceMappingURL=Resolvable.js.map

package/dist/esm/vanilla.d.ts

@@ -1 +1 @@
-export {};
+export {};

package/dist/esm/vanilla.js

@@ -1,3 +1,3 @@
-import * as everything from './index.js';
-window.Verdant = everything;
+import * as everything from './index.js';
+window.Verdant = everything;
 //# sourceMappingURL=vanilla.js.map