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

package/dist/cjs/sync/Sync.js

@@ -1,271 +1,271 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServerSync = exports.NoSync = void 0;
-const common_1 = require("@verdant-web/common");
-const PresenceManager_js_1 = require("./PresenceManager.js");
-const FileSync_js_1 = require("./FileSync.js");
-const PushPullSync_js_1 = require("./PushPullSync.js");
-const ServerSyncEndpointProvider_js_1 = require("./ServerSyncEndpointProvider.js");
-const WebSocketSync_js_1 = require("./WebSocketSync.js");
-class NoSync extends common_1.EventSubscriber {
-    constructor() {
-        super(...arguments);
-        this.mode = 'pull';
-        this.dispose = () => { };
-        this.isConnected = false;
-        this.status = 'paused';
-        this.pullInterval = 0;
-        this.presence = new PresenceManager_js_1.PresenceManager({
-            initialPresence: {},
-            defaultProfile: {},
-        });
-        this.uploadFile = async () => {
-            return {
-                success: false,
-                retry: false,
-            };
-        };
-        this.getFile = async () => {
-            return {
-                success: false,
-                retry: false,
-            };
-        };
-    }
-    send() { }
-    start() { }
-    stop() { }
-    reconnect() { }
-    setMode() { }
-    setPullInterval() { }
-}
-exports.NoSync = NoSync;
-class ServerSync extends common_1.EventSubscriber {
-    constructor({ authEndpoint, fetchAuth, initialPresence, automaticTransportSelection = true, autoStart, initialTransport, pullInterval, presenceUpdateBatchTimeout, defaultProfile, useBroadcastChannel, }, { meta, log, onData, }) {
-        super();
-        this.broadcastChannel = null;
-        this._activelySyncing = false;
-        this.handleBroadcastChannelMessage = (event) => {
-            if (event.data.type === 'sync') {
-                this.handleMessage(event.data.message);
-            }
-        };
-        this.handleMessage = async (message) => {
-            var _a;
-            // TODO: move this into metadata
-            if (message.type === 'op-re' || message.type === 'sync-resp') {
-                for (const op of message.operations) {
-                    this.meta.time.update(op.timestamp);
-                }
-            }
-            this.log('sync message', JSON.stringify(message, null, 2));
-            switch (message.type) {
-                case 'op-re':
-                    await this.onData({
-                        operations: message.operations,
-                        baselines: message.baselines,
-                    });
-                    if (message.globalAckTimestamp) {
-                        await this.meta.setGlobalAck(message.globalAckTimestamp);
-                    }
-                    break;
-                case 'global-ack':
-                    await this.meta.setGlobalAck(message.timestamp);
-                    break;
-                case 'sync-resp':
-                    this._activelySyncing = true;
-                    this.emit('syncingChange', true);
-                    await this.onData({
-                        operations: message.operations,
-                        baselines: message.baselines,
-                        reset: message.overwriteLocalData,
-                    });
-                    if (message.globalAckTimestamp) {
-                        await this.meta.setGlobalAck(message.globalAckTimestamp);
-                    }
-                    await this.meta.updateLastSynced(message.ackedTimestamp);
-                    this._activelySyncing = false;
-                    this.emit('syncingChange', false);
-                    break;
-                case 'need-since':
-                    this.activeSync.send(await this.meta.messageCreator.createSyncStep1(message.since));
-                    break;
-                case 'server-ack':
-                    await this.meta.updateLastSynced(message.timestamp);
-            }
-            (_a = this.broadcastChannel) === null || _a === void 0 ? void 0 : _a.postMessage({
-                type: 'sync',
-                message,
-            });
-            // update presence if necessary
-            this.presence[PresenceManager_js_1.HANDLE_MESSAGE](await this.meta.localReplica.get(), message);
-        };
-        this.handleOnlineChange = (online) => {
-            this.emit('onlineChange', online);
-        };
-        this.handlePresenceUpdate = async (presence) => {
-            this.send(await this.meta.messageCreator.createPresenceUpdate(presence));
-        };
-        this.setMode = (transport) => {
-            if (transport === 'realtime' && !this.canDoRealtime) {
-                throw new Error(`Cannot switch to realtime mode, because the current auth token does not allow it`);
-            }
-            let newSync;
-            if (transport === 'realtime') {
-                newSync = this.webSocketSync;
-            }
-            else {
-                newSync = this.pushPullSync;
-            }
-            if (newSync === this.activeSync)
-                return;
-            this.log('switching to', transport, 'mode');
-            // transfer state to new sync
-            if (this.activeSync.status === 'active') {
-                newSync.start();
-            }
-            this.activeSync.stop();
-            this.activeSync = newSync;
-        };
-        this.setPullInterval = (interval) => {
-            this.pushPullSync.setInterval(interval);
-        };
-        this.send = (message) => {
-            if (this.activeSync.status === 'active') {
-                return this.activeSync.send(message);
-            }
-        };
-        this.uploadFile = async (info) => {
-            if (this.activeSync.status === 'active') {
-                return this.fileSync.uploadFile(info);
-            }
-            else {
-                return {
-                    success: false,
-                    retry: false,
-                };
-            }
-        };
-        this.getFile = async (id) => {
-            // TODO: should this error? or just try anyway?
-            if (this.activeSync.status === 'active') {
-                return this.fileSync.getFile(id);
-            }
-            else {
-                throw new Error('Offline, cannot retrieve remote file details');
-            }
-        };
-        this.start = () => {
-            return this.activeSync.start();
-        };
-        this.stop = () => {
-            return this.activeSync.stop();
-        };
-        this.dispose = () => {
-            this.webSocketSync.dispose();
-            this.pushPullSync.dispose();
-        };
-        this.reconnect = () => {
-            return this.activeSync.reconnect();
-        };
-        this.meta = meta;
-        this.onData = onData;
-        this.log = log || (() => { });
-        this.presence = new PresenceManager_js_1.PresenceManager({
-            initialPresence,
-            defaultProfile,
-            updateBatchTimeout: presenceUpdateBatchTimeout,
-        });
-        this.endpointProvider = new ServerSyncEndpointProvider_js_1.ServerSyncEndpointProvider({
-            authEndpoint,
-            fetchAuth,
-        });
-        this.webSocketSync = new WebSocketSync_js_1.WebSocketSync({
-            endpointProvider: this.endpointProvider,
-            meta,
-            presence: this.presence,
-            log: this.log,
-        });
-        this.pushPullSync = new PushPullSync_js_1.PushPullSync({
-            endpointProvider: this.endpointProvider,
-            meta,
-            presence: this.presence,
-            log: this.log,
-            interval: pullInterval,
-        });
-        this.fileSync = new FileSync_js_1.FileSync({
-            endpointProvider: this.endpointProvider,
-            log: this.log,
-        });
-        if (useBroadcastChannel && 'BroadcastChannel' in window) {
-            this.broadcastChannel = new BroadcastChannel('verdant');
-            this.broadcastChannel.addEventListener('message', this.handleBroadcastChannelMessage);
-        }
-        if (initialTransport === 'realtime') {
-            this.activeSync = this.webSocketSync;
-        }
-        else {
-            this.activeSync = this.pushPullSync;
-        }
-        this.presence.subscribe('update', this.handlePresenceUpdate);
-        this.meta.subscribe('message', this.send);
-        this.webSocketSync.subscribe('message', this.handleMessage);
-        this.webSocketSync.subscribe('onlineChange', this.handleOnlineChange);
-        this.pushPullSync.subscribe('message', this.handleMessage);
-        this.pushPullSync.subscribe('onlineChange', this.handleOnlineChange);
-        if (automaticTransportSelection && this.canDoRealtime) {
-            // automatically shift between transport modes depending
-            // on whether any peers are present
-            const decideIfUpgrade = () => {
-                if (switchoverTimeout) {
-                    clearTimeout(switchoverTimeout);
-                }
-                const hasPeers = Object.keys(this.presence.peers).length > 0;
-                const shouldUpgrade = hasPeers ||
-                    (automaticTransportSelection !== 'peers-only' &&
-                        this.presence.selfReplicaIds.size > 1);
-                if (shouldUpgrade && this.mode === 'pull') {
-                    this.setMode('realtime');
-                }
-                else if (!shouldUpgrade && this.mode === 'realtime') {
-                    // wait 1 second then switch to pull mode if still empty
-                    switchoverTimeout = setTimeout(() => {
-                        if (Object.keys(this.presence.peers).length === 0) {
-                            this.setMode('pull');
-                        }
-                    }, 1000);
-                }
-            };
-            let switchoverTimeout;
-            this.presence.subscribe('peersChanged', decideIfUpgrade);
-            if (automaticTransportSelection !== 'peers-only') {
-                this.presence.subscribe('selfChanged', decideIfUpgrade);
-            }
-        }
-        if (autoStart) {
-            this.start();
-        }
-    }
-    get canDoRealtime() {
-        return (this.endpointProvider.type === common_1.ReplicaType.Realtime ||
-            this.endpointProvider.type === common_1.ReplicaType.PassiveRealtime ||
-            this.endpointProvider.type === common_1.ReplicaType.ReadOnlyRealtime);
-    }
-    get syncing() {
-        return this._activelySyncing;
-    }
-    get pullInterval() {
-        return this.pushPullSync.interval;
-    }
-    get isConnected() {
-        return this.activeSync.isConnected;
-    }
-    get status() {
-        return this.activeSync.status;
-    }
-    get mode() {
-        return this.activeSync.mode;
-    }
-}
-exports.ServerSync = ServerSync;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerSync = exports.NoSync = void 0;
+const common_1 = require("@verdant-web/common");
+const PresenceManager_js_1 = require("./PresenceManager.js");
+const FileSync_js_1 = require("./FileSync.js");
+const PushPullSync_js_1 = require("./PushPullSync.js");
+const ServerSyncEndpointProvider_js_1 = require("./ServerSyncEndpointProvider.js");
+const WebSocketSync_js_1 = require("./WebSocketSync.js");
+class NoSync extends common_1.EventSubscriber {
+    constructor() {
+        super(...arguments);
+        this.mode = 'pull';
+        this.dispose = () => { };
+        this.isConnected = false;
+        this.status = 'paused';
+        this.pullInterval = 0;
+        this.presence = new PresenceManager_js_1.PresenceManager({
+            initialPresence: {},
+            defaultProfile: {},
+        });
+        this.uploadFile = async () => {
+            return {
+                success: false,
+                retry: false,
+            };
+        };
+        this.getFile = async () => {
+            return {
+                success: false,
+                retry: false,
+            };
+        };
+    }
+    send() { }
+    start() { }
+    stop() { }
+    reconnect() { }
+    setMode() { }
+    setPullInterval() { }
+}
+exports.NoSync = NoSync;
+class ServerSync extends common_1.EventSubscriber {
+    constructor({ authEndpoint, fetchAuth, initialPresence, automaticTransportSelection = true, autoStart, initialTransport, pullInterval, presenceUpdateBatchTimeout, defaultProfile, useBroadcastChannel, }, { meta, log, onData, }) {
+        super();
+        this.broadcastChannel = null;
+        this._activelySyncing = false;
+        this.handleBroadcastChannelMessage = (event) => {
+            if (event.data.type === 'sync') {
+                this.handleMessage(event.data.message);
+            }
+        };
+        this.handleMessage = async (message) => {
+            var _a;
+            // TODO: move this into metadata
+            if (message.type === 'op-re' || message.type === 'sync-resp') {
+                for (const op of message.operations) {
+                    this.meta.time.update(op.timestamp);
+                }
+            }
+            this.log('sync message', JSON.stringify(message, null, 2));
+            switch (message.type) {
+                case 'op-re':
+                    await this.onData({
+                        operations: message.operations,
+                        baselines: message.baselines,
+                    });
+                    if (message.globalAckTimestamp) {
+                        await this.meta.setGlobalAck(message.globalAckTimestamp);
+                    }
+                    break;
+                case 'global-ack':
+                    await this.meta.setGlobalAck(message.timestamp);
+                    break;
+                case 'sync-resp':
+                    this._activelySyncing = true;
+                    this.emit('syncingChange', true);
+                    await this.onData({
+                        operations: message.operations,
+                        baselines: message.baselines,
+                        reset: message.overwriteLocalData,
+                    });
+                    if (message.globalAckTimestamp) {
+                        await this.meta.setGlobalAck(message.globalAckTimestamp);
+                    }
+                    await this.meta.updateLastSynced(message.ackedTimestamp);
+                    this._activelySyncing = false;
+                    this.emit('syncingChange', false);
+                    break;
+                case 'need-since':
+                    this.activeSync.send(await this.meta.messageCreator.createSyncStep1(message.since));
+                    break;
+                case 'server-ack':
+                    await this.meta.updateLastSynced(message.timestamp);
+            }
+            (_a = this.broadcastChannel) === null || _a === void 0 ? void 0 : _a.postMessage({
+                type: 'sync',
+                message,
+            });
+            // update presence if necessary
+            this.presence[PresenceManager_js_1.HANDLE_MESSAGE](await this.meta.localReplica.get(), message);
+        };
+        this.handleOnlineChange = (online) => {
+            this.emit('onlineChange', online);
+        };
+        this.handlePresenceUpdate = async (presence) => {
+            this.send(await this.meta.messageCreator.createPresenceUpdate(presence));
+        };
+        this.setMode = (transport) => {
+            if (transport === 'realtime' && !this.canDoRealtime) {
+                throw new Error(`Cannot switch to realtime mode, because the current auth token does not allow it`);
+            }
+            let newSync;
+            if (transport === 'realtime') {
+                newSync = this.webSocketSync;
+            }
+            else {
+                newSync = this.pushPullSync;
+            }
+            if (newSync === this.activeSync)
+                return;
+            this.log('switching to', transport, 'mode');
+            // transfer state to new sync
+            if (this.activeSync.status === 'active') {
+                newSync.start();
+            }
+            this.activeSync.stop();
+            this.activeSync = newSync;
+        };
+        this.setPullInterval = (interval) => {
+            this.pushPullSync.setInterval(interval);
+        };
+        this.send = (message) => {
+            if (this.activeSync.status === 'active') {
+                return this.activeSync.send(message);
+            }
+        };
+        this.uploadFile = async (info) => {
+            if (this.activeSync.status === 'active') {
+                return this.fileSync.uploadFile(info);
+            }
+            else {
+                return {
+                    success: false,
+                    retry: false,
+                };
+            }
+        };
+        this.getFile = async (id) => {
+            // TODO: should this error? or just try anyway?
+            if (this.activeSync.status === 'active') {
+                return this.fileSync.getFile(id);
+            }
+            else {
+                throw new Error('Offline, cannot retrieve remote file details');
+            }
+        };
+        this.start = () => {
+            return this.activeSync.start();
+        };
+        this.stop = () => {
+            return this.activeSync.stop();
+        };
+        this.dispose = () => {
+            this.webSocketSync.dispose();
+            this.pushPullSync.dispose();
+        };
+        this.reconnect = () => {
+            return this.activeSync.reconnect();
+        };
+        this.meta = meta;
+        this.onData = onData;
+        this.log = log || (() => { });
+        this.presence = new PresenceManager_js_1.PresenceManager({
+            initialPresence,
+            defaultProfile,
+            updateBatchTimeout: presenceUpdateBatchTimeout,
+        });
+        this.endpointProvider = new ServerSyncEndpointProvider_js_1.ServerSyncEndpointProvider({
+            authEndpoint,
+            fetchAuth,
+        });
+        this.webSocketSync = new WebSocketSync_js_1.WebSocketSync({
+            endpointProvider: this.endpointProvider,
+            meta,
+            presence: this.presence,
+            log: this.log,
+        });
+        this.pushPullSync = new PushPullSync_js_1.PushPullSync({
+            endpointProvider: this.endpointProvider,
+            meta,
+            presence: this.presence,
+            log: this.log,
+            interval: pullInterval,
+        });
+        this.fileSync = new FileSync_js_1.FileSync({
+            endpointProvider: this.endpointProvider,
+            log: this.log,
+        });
+        if (useBroadcastChannel && 'BroadcastChannel' in window) {
+            this.broadcastChannel = new BroadcastChannel('verdant');
+            this.broadcastChannel.addEventListener('message', this.handleBroadcastChannelMessage);
+        }
+        if (initialTransport === 'realtime') {
+            this.activeSync = this.webSocketSync;
+        }
+        else {
+            this.activeSync = this.pushPullSync;
+        }
+        this.presence.subscribe('update', this.handlePresenceUpdate);
+        this.meta.subscribe('message', this.send);
+        this.webSocketSync.subscribe('message', this.handleMessage);
+        this.webSocketSync.subscribe('onlineChange', this.handleOnlineChange);
+        this.pushPullSync.subscribe('message', this.handleMessage);
+        this.pushPullSync.subscribe('onlineChange', this.handleOnlineChange);
+        if (automaticTransportSelection && this.canDoRealtime) {
+            // automatically shift between transport modes depending
+            // on whether any peers are present
+            const decideIfUpgrade = () => {
+                if (switchoverTimeout) {
+                    clearTimeout(switchoverTimeout);
+                }
+                const hasPeers = Object.keys(this.presence.peers).length > 0;
+                const shouldUpgrade = hasPeers ||
+                    (automaticTransportSelection !== 'peers-only' &&
+                        this.presence.selfReplicaIds.size > 1);
+                if (shouldUpgrade && this.mode === 'pull') {
+                    this.setMode('realtime');
+                }
+                else if (!shouldUpgrade && this.mode === 'realtime') {
+                    // wait 1 second then switch to pull mode if still empty
+                    switchoverTimeout = setTimeout(() => {
+                        if (Object.keys(this.presence.peers).length === 0) {
+                            this.setMode('pull');
+                        }
+                    }, 1000);
+                }
+            };
+            let switchoverTimeout;
+            this.presence.subscribe('peersChanged', decideIfUpgrade);
+            if (automaticTransportSelection !== 'peers-only') {
+                this.presence.subscribe('selfChanged', decideIfUpgrade);
+            }
+        }
+        if (autoStart) {
+            this.start();
+        }
+    }
+    get canDoRealtime() {
+        return (this.endpointProvider.type === common_1.ReplicaType.Realtime ||
+            this.endpointProvider.type === common_1.ReplicaType.PassiveRealtime ||
+            this.endpointProvider.type === common_1.ReplicaType.ReadOnlyRealtime);
+    }
+    get syncing() {
+        return this._activelySyncing;
+    }
+    get pullInterval() {
+        return this.pushPullSync.interval;
+    }
+    get isConnected() {
+        return this.activeSync.isConnected;
+    }
+    get status() {
+        return this.activeSync.status;
+    }
+    get mode() {
+        return this.activeSync.mode;
+    }
+}
+exports.ServerSync = ServerSync;
 //# sourceMappingURL=Sync.js.map

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";
+}