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

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

@@ -1,43 +1,43 @@
-import { ServerMessage, EventSubscriber } from '@verdant-web/common';
-import type { UserInfo } from '../index.js';
-import { LocalReplicaInfo } from '../metadata/LocalReplicaStore.js';
-export declare const HANDLE_MESSAGE: unique symbol;
-export declare class PresenceManager<Profile = any, Presence = any> extends EventSubscriber<{
-    peerChanged: (userId: string, presence: UserInfo<Profile, Presence>) => void;
-    selfChanged: (presence: UserInfo<Profile, Presence>) => void;
-    peersChanged: (peers: Record<string, any>) => void;
-    peerLeft: (userId: string, lastPresence: UserInfo<Profile, Presence>) => void;
-    update: (presence: Partial<Presence>) => void;
-}> {
-    private _peers;
-    private _self;
-    private _selfReplicaIds;
-    private _peerIds;
-    private _updateBatcher;
-    private _updateBatch;
-    get self(): UserInfo<Profile, Presence>;
-    get peers(): Record<string, UserInfo<Profile, Presence>>;
-    get peerIds(): string[];
-    get everyone(): {
-        [x: string]: UserInfo<Profile, Presence>;
-    };
-    get selfReplicaIds(): Set<string>;
-    constructor({ initialPresence, updateBatchTimeout, defaultProfile, }: {
-        initialPresence: Presence;
-        defaultProfile: Profile;
-        updateBatchTimeout?: number;
-    });
-    /**
-     * Decides if an update is for the local user or not. Even if it's a different replica
-     * than the local one.
-     *
-     * If the replicaId matches, we use that first - we may not know the local replica's User ID yet,
-     * e.g. on the first presence update.
-     *
-     * Otherwise, match the user ID to our local copy.
-     */
-    private isSelf;
-    [HANDLE_MESSAGE]: (localReplicaInfo: LocalReplicaInfo, message: ServerMessage) => Promise<void>;
-    update: (presence: Partial<Presence>) => Promise<void>;
-    flushPresenceUpdates: (presenceUpdates: Partial<Presence>[]) => void;
-}
+import { ServerMessage, EventSubscriber } from '@verdant-web/common';
+import type { UserInfo } from '../index.js';
+import { LocalReplicaInfo } from '../metadata/LocalReplicaStore.js';
+export declare const HANDLE_MESSAGE: unique symbol;
+export declare class PresenceManager<Profile = any, Presence = any> extends EventSubscriber<{
+    peerChanged: (userId: string, presence: UserInfo<Profile, Presence>) => void;
+    selfChanged: (presence: UserInfo<Profile, Presence>) => void;
+    peersChanged: (peers: Record<string, any>) => void;
+    peerLeft: (userId: string, lastPresence: UserInfo<Profile, Presence>) => void;
+    update: (presence: Partial<Presence>) => void;
+}> {
+    private _peers;
+    private _self;
+    private _selfReplicaIds;
+    private _peerIds;
+    private _updateBatcher;
+    private _updateBatch;
+    get self(): UserInfo<Profile, Presence>;
+    get peers(): Record<string, UserInfo<Profile, Presence>>;
+    get peerIds(): string[];
+    get everyone(): {
+        [x: string]: UserInfo<Profile, Presence>;
+    };
+    get selfReplicaIds(): Set<string>;
+    constructor({ initialPresence, updateBatchTimeout, defaultProfile, }: {
+        initialPresence: Presence;
+        defaultProfile: Profile;
+        updateBatchTimeout?: number;
+    });
+    /**
+     * Decides if an update is for the local user or not. Even if it's a different replica
+     * than the local one.
+     *
+     * If the replicaId matches, we use that first - we may not know the local replica's User ID yet,
+     * e.g. on the first presence update.
+     *
+     * Otherwise, match the user ID to our local copy.
+     */
+    private isSelf;
+    [HANDLE_MESSAGE]: (localReplicaInfo: LocalReplicaInfo, message: ServerMessage) => Promise<void>;
+    update: (presence: Partial<Presence>) => Promise<void>;
+    flushPresenceUpdates: (presenceUpdates: Partial<Presence>[]) => void;
+}

package/dist/cjs/sync/PresenceManager.js

@@ -1,120 +1,120 @@
-"use strict";
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PresenceManager = exports.HANDLE_MESSAGE = void 0;
-const common_1 = require("@verdant-web/common");
-exports.HANDLE_MESSAGE = Symbol('handleMessage');
-class PresenceManager extends common_1.EventSubscriber {
-    get self() {
-        return this._self;
-    }
-    get peers() {
-        return this._peers;
-    }
-    get peerIds() {
-        return this._peerIds;
-    }
-    get everyone() {
-        const everyone = Object.assign({}, this._peers);
-        everyone[this.self.id] = this.self;
-        return everyone;
-    }
-    get selfReplicaIds() {
-        return this._selfReplicaIds;
-    }
-    constructor({ initialPresence, updateBatchTimeout = 200, defaultProfile, }) {
-        super();
-        this._peers = {};
-        this._self = { profile: {} };
-        // keep track of own replica IDs - applications may care if we're "alone" but with multiple devices.
-        this._selfReplicaIds = new Set();
-        this._peerIds = new Array();
-        /**
-         * Decides if an update is for the local user or not. Even if it's a different replica
-         * than the local one.
-         *
-         * If the replicaId matches, we use that first - we may not know the local replica's User ID yet,
-         * e.g. on the first presence update.
-         *
-         * Otherwise, match the user ID to our local copy.
-         */
-        this.isSelf = (localReplicaInfo, userInfo) => {
-            return (localReplicaInfo.id === userInfo.replicaId ||
-                this._selfReplicaIds.has(userInfo.replicaId) ||
-                this._self.id === userInfo.id);
-        };
-        this[_a] = async (localReplicaInfo, message) => {
-            let peersChanged = false;
-            const peerIdsSet = new Set(this.peerIds);
-            if (message.type === 'presence-changed') {
-                if (this.isSelf(localReplicaInfo, message.userInfo)) {
-                    this._self = message.userInfo;
-                    this._selfReplicaIds.add(message.userInfo.replicaId);
-                    this.emit('selfChanged', message.userInfo);
-                }
-                else {
-                    peerIdsSet.add(message.userInfo.id);
-                    this._peers[message.userInfo.id] = message.userInfo;
-                    peersChanged = true;
-                    this.emit('peerChanged', message.userInfo.id, message.userInfo);
-                }
-            }
-            else if (message.type === 'sync-resp') {
-                // reset to provided presence data, which includes all peers.
-                this._peers = {};
-                peerIdsSet.clear();
-                for (const [id, userInfo] of Object.entries(message.peerPresence)) {
-                    if (this.isSelf(localReplicaInfo, userInfo)) {
-                        this._self = userInfo;
-                        this._selfReplicaIds.add(userInfo.replicaId);
-                        this.emit('selfChanged', userInfo);
-                    }
-                    else {
-                        peersChanged = true;
-                        peerIdsSet.add(id);
-                        this._peers[id] = userInfo;
-                        this.emit('peerChanged', id, userInfo);
-                    }
-                }
-            }
-            else if (message.type === 'presence-offline') {
-                peerIdsSet.delete(message.userId);
-                this._selfReplicaIds.delete(message.replicaId);
-                const lastPresence = this._peers[message.userId];
-                delete this._peers[message.userId];
-                peersChanged = true;
-                this.emit('peerLeft', message.userId, lastPresence);
-            }
-            if (peersChanged) {
-                this._peerIds = Array.from(peerIdsSet);
-                this.emit('peersChanged', this._peers);
-            }
-        };
-        this.update = async (presence) => {
-            this._updateBatch.update({
-                items: [presence],
-            });
-            // proactively update the local presence
-            this.self.presence = Object.assign(Object.assign({}, this.self.presence), presence);
-            this.emit('selfChanged', this.self);
-        };
-        this.flushPresenceUpdates = (presenceUpdates) => {
-            const presence = presenceUpdates.reduce((acc, update) => {
-                return Object.assign(Object.assign({}, acc), update);
-            }, this.self.presence);
-            this.emit('update', presence);
-        };
-        this.self.presence = initialPresence;
-        this.self.profile = defaultProfile;
-        this._updateBatcher = new common_1.Batcher(this.flushPresenceUpdates);
-        this._updateBatch = this._updateBatcher.add({
-            max: 25,
-            timeout: updateBatchTimeout,
-            items: [],
-            key: 'default',
-        });
-    }
-}
-exports.PresenceManager = PresenceManager;
-_a = exports.HANDLE_MESSAGE;
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PresenceManager = exports.HANDLE_MESSAGE = void 0;
+const common_1 = require("@verdant-web/common");
+exports.HANDLE_MESSAGE = Symbol('handleMessage');
+class PresenceManager extends common_1.EventSubscriber {
+    get self() {
+        return this._self;
+    }
+    get peers() {
+        return this._peers;
+    }
+    get peerIds() {
+        return this._peerIds;
+    }
+    get everyone() {
+        const everyone = Object.assign({}, this._peers);
+        everyone[this.self.id] = this.self;
+        return everyone;
+    }
+    get selfReplicaIds() {
+        return this._selfReplicaIds;
+    }
+    constructor({ initialPresence, updateBatchTimeout = 200, defaultProfile, }) {
+        super();
+        this._peers = {};
+        this._self = { profile: {} };
+        // keep track of own replica IDs - applications may care if we're "alone" but with multiple devices.
+        this._selfReplicaIds = new Set();
+        this._peerIds = new Array();
+        /**
+         * Decides if an update is for the local user or not. Even if it's a different replica
+         * than the local one.
+         *
+         * If the replicaId matches, we use that first - we may not know the local replica's User ID yet,
+         * e.g. on the first presence update.
+         *
+         * Otherwise, match the user ID to our local copy.
+         */
+        this.isSelf = (localReplicaInfo, userInfo) => {
+            return (localReplicaInfo.id === userInfo.replicaId ||
+                this._selfReplicaIds.has(userInfo.replicaId) ||
+                this._self.id === userInfo.id);
+        };
+        this[_a] = async (localReplicaInfo, message) => {
+            let peersChanged = false;
+            const peerIdsSet = new Set(this.peerIds);
+            if (message.type === 'presence-changed') {
+                if (this.isSelf(localReplicaInfo, message.userInfo)) {
+                    this._self = message.userInfo;
+                    this._selfReplicaIds.add(message.userInfo.replicaId);
+                    this.emit('selfChanged', message.userInfo);
+                }
+                else {
+                    peerIdsSet.add(message.userInfo.id);
+                    this._peers[message.userInfo.id] = message.userInfo;
+                    peersChanged = true;
+                    this.emit('peerChanged', message.userInfo.id, message.userInfo);
+                }
+            }
+            else if (message.type === 'sync-resp') {
+                // reset to provided presence data, which includes all peers.
+                this._peers = {};
+                peerIdsSet.clear();
+                for (const [id, userInfo] of Object.entries(message.peerPresence)) {
+                    if (this.isSelf(localReplicaInfo, userInfo)) {
+                        this._self = userInfo;
+                        this._selfReplicaIds.add(userInfo.replicaId);
+                        this.emit('selfChanged', userInfo);
+                    }
+                    else {
+                        peersChanged = true;
+                        peerIdsSet.add(id);
+                        this._peers[id] = userInfo;
+                        this.emit('peerChanged', id, userInfo);
+                    }
+                }
+            }
+            else if (message.type === 'presence-offline') {
+                peerIdsSet.delete(message.userId);
+                this._selfReplicaIds.delete(message.replicaId);
+                const lastPresence = this._peers[message.userId];
+                delete this._peers[message.userId];
+                peersChanged = true;
+                this.emit('peerLeft', message.userId, lastPresence);
+            }
+            if (peersChanged) {
+                this._peerIds = Array.from(peerIdsSet);
+                this.emit('peersChanged', this._peers);
+            }
+        };
+        this.update = async (presence) => {
+            this._updateBatch.update({
+                items: [presence],
+            });
+            // proactively update the local presence
+            this.self.presence = Object.assign(Object.assign({}, this.self.presence), presence);
+            this.emit('selfChanged', this.self);
+        };
+        this.flushPresenceUpdates = (presenceUpdates) => {
+            const presence = presenceUpdates.reduce((acc, update) => {
+                return Object.assign(Object.assign({}, acc), update);
+            }, this.self.presence);
+            this.emit('update', presence);
+        };
+        this.self.presence = initialPresence;
+        this.self.profile = defaultProfile;
+        this._updateBatcher = new common_1.Batcher(this.flushPresenceUpdates);
+        this._updateBatch = this._updateBatcher.add({
+            max: 25,
+            timeout: updateBatchTimeout,
+            items: [],
+            key: 'default',
+        });
+    }
+}
+exports.PresenceManager = PresenceManager;
+_a = exports.HANDLE_MESSAGE;
 //# sourceMappingURL=PresenceManager.js.map

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

@@ -1,36 +1,36 @@
-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 PushPullSync extends EventSubscriber<SyncTransportEvents> implements SyncTransport {
-    readonly meta: Metadata;
-    readonly presence: PresenceManager;
-    private endpointProvider;
-    private heartbeat;
-    readonly mode = "pull";
-    private log;
-    private _isConnected;
-    private _status;
-    private _hasSynced;
-    constructor({ endpointProvider, meta, presence, interval, log, }: {
-        endpointProvider: ServerSyncEndpointProvider;
-        meta: Metadata;
-        presence: PresenceManager;
-        interval?: number;
-        log?: (...args: any[]) => any;
-    });
-    setInterval: (interval: number) => void;
-    get interval(): number;
-    private sendRequest;
-    private handleServerMessage;
-    send: (message: ClientMessage) => Promise<void> | undefined;
-    start(): void;
-    stop(): void;
-    dispose: () => void;
-    reconnect(): void;
-    private onHeartbeat;
-    private onHeartbeatMissed;
-    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 PushPullSync extends EventSubscriber<SyncTransportEvents> implements SyncTransport {
+    readonly meta: Metadata;
+    readonly presence: PresenceManager;
+    private endpointProvider;
+    private heartbeat;
+    readonly mode = "pull";
+    private log;
+    private _isConnected;
+    private _status;
+    private _hasSynced;
+    constructor({ endpointProvider, meta, presence, interval, log, }: {
+        endpointProvider: ServerSyncEndpointProvider;
+        meta: Metadata;
+        presence: PresenceManager;
+        interval?: number;
+        log?: (...args: any[]) => any;
+    });
+    setInterval: (interval: number) => void;
+    get interval(): number;
+    private sendRequest;
+    private handleServerMessage;
+    send: (message: ClientMessage) => Promise<void> | undefined;
+    start(): void;
+    stop(): void;
+    dispose: () => void;
+    reconnect(): void;
+    private onHeartbeat;
+    private onHeartbeatMissed;
+    get isConnected(): boolean;
+    get status(): "active" | "paused";
+}