@verdant-web/store 2.0.1 → 2.0.2

package/dist/cjs/sync/PresenceManager.js

@@ -1,108 +1,108 @@
-"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;
-    }
-    constructor({ initialPresence, updateBatchTimeout = 200, defaultProfile, }) {
-        super();
-        this._peers = {};
-        this._self = { profile: {} };
-        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._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.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.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);
-                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],
-            });
-        };
-        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;
+    }
+    constructor({ initialPresence, updateBatchTimeout = 200, defaultProfile, }) {
+        super();
+        this._peers = {};
+        this._self = { profile: {} };
+        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._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.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.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);
+                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],
+            });
+        };
+        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";
+}

package/dist/cjs/sync/PushPullSync.js

@@ -1,142 +1,142 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PushPullSync = void 0;
-const common_1 = require("@verdant-web/common");
-const Heartbeat_js_1 = require("./Heartbeat.js");
-class PushPullSync extends common_1.EventSubscriber {
-    constructor({ endpointProvider, meta, presence, interval = 15 * 1000, log = () => { }, }) {
-        super();
-        this.mode = 'pull';
-        this._isConnected = false;
-        this._status = 'paused';
-        this._hasSynced = false;
-        this.setInterval = (interval) => {
-            this.heartbeat.setInterval(interval);
-        };
-        this.sendRequest = async (messages) => {
-            this.log('Sending sync request', messages);
-            try {
-                const { http: host, token } = await this.endpointProvider.getEndpoints();
-                const response = await fetch(host, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        Authorization: `Bearer ${token}`,
-                    },
-                    body: JSON.stringify({
-                        messages,
-                    }),
-                    credentials: 'include',
-                });
-                if (response.ok) {
-                    this.heartbeat.keepAlive();
-                    const json = (await response.json());
-                    for (const message of json.messages) {
-                        this.handleServerMessage(message);
-                    }
-                    if (!this._isConnected) {
-                        this._isConnected = true;
-                        this.emit('onlineChange', true);
-                    }
-                }
-                else {
-                    this.log('Sync request failed', response.status, await response.text());
-                    if (this._isConnected) {
-                        this._isConnected = false;
-                        this.emit('onlineChange', false);
-                    }
-                    // only keep trying if the error was not 4xx
-                    if (response.status >= 500) {
-                        this.heartbeat.keepAlive();
-                    }
-                }
-            }
-            catch (error) {
-                if (this._isConnected) {
-                    this._isConnected = false;
-                    this.emit('onlineChange', false);
-                }
-                this.log(error);
-                this.heartbeat.keepAlive();
-            }
-        };
-        this.handleServerMessage = async (message) => {
-            if (message.type === 'sync-resp') {
-                if (message.ackThisNonce) {
-                    // we need to ack the nonce to confirm that we received the sync-resp
-                    this.log('Sending sync ack', message.ackThisNonce);
-                    this.sendRequest([
-                        await this.meta.messageCreator.createAck(message.ackThisNonce),
-                    ]);
-                }
-                // but we can go ahead and preemptively allow ops to be sent
-                this._hasSynced = true;
-            }
-            this.emit('message', message);
-        };
-        this.send = (message) => {
-            // only certain messages are sent for pull-based sync.
-            switch (message.type) {
-                case 'presence-update':
-                case 'sync':
-                case 'heartbeat':
-                    return this.sendRequest([message]);
-                case 'op':
-                    if (this._hasSynced) {
-                        return this.sendRequest([message]);
-                    }
-                    break;
-            }
-        };
-        this.dispose = () => { };
-        // on a heartbeat, do a sync
-        this.onHeartbeat = async () => {
-            // for HTTP sync we send presence first, so that the sync-resp message
-            // will include the client's own presence info and fill in missing profile
-            // data on the first request. otherwise it would have to wait for the second.
-            this.sendRequest([
-                await this.meta.messageCreator.createPresenceUpdate(this.presence.self.presence),
-                await this.meta.messageCreator.createSyncStep1(),
-            ]);
-        };
-        // if the server fails to respond in a certain amount of time, we assume
-        // the connection is lost and go offline.
-        this.onHeartbeatMissed = async () => {
-            this.emit('onlineChange', false);
-            this.log('Missed heartbeat');
-            this._isConnected = false;
-        };
-        this.log = log;
-        this.meta = meta;
-        this.presence = presence;
-        this.endpointProvider = endpointProvider;
-        this.heartbeat = new Heartbeat_js_1.Heartbeat({
-            interval,
-        });
-        this.heartbeat.subscribe('beat', this.onHeartbeat);
-        this.heartbeat.subscribe('missed', this.onHeartbeatMissed);
-    }
-    get interval() {
-        return this.heartbeat.interval;
-    }
-    start() {
-        if (this.status === 'active') {
-            return;
-        }
-        this.heartbeat.start(true);
-        this._status = 'active';
-    }
-    stop() {
-        this.heartbeat.stop();
-        this._status = 'paused';
-    }
-    reconnect() { }
-    get isConnected() {
-        return this._isConnected;
-    }
-    get status() {
-        return this._status;
-    }
-}
-exports.PushPullSync = PushPullSync;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PushPullSync = void 0;
+const common_1 = require("@verdant-web/common");
+const Heartbeat_js_1 = require("./Heartbeat.js");
+class PushPullSync extends common_1.EventSubscriber {
+    constructor({ endpointProvider, meta, presence, interval = 15 * 1000, log = () => { }, }) {
+        super();
+        this.mode = 'pull';
+        this._isConnected = false;
+        this._status = 'paused';
+        this._hasSynced = false;
+        this.setInterval = (interval) => {
+            this.heartbeat.setInterval(interval);
+        };
+        this.sendRequest = async (messages) => {
+            this.log('Sending sync request', messages);
+            try {
+                const { http: host, token } = await this.endpointProvider.getEndpoints();
+                const response = await fetch(host, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: `Bearer ${token}`,
+                    },
+                    body: JSON.stringify({
+                        messages,
+                    }),
+                    credentials: 'include',
+                });
+                if (response.ok) {
+                    this.heartbeat.keepAlive();
+                    const json = (await response.json());
+                    for (const message of json.messages) {
+                        this.handleServerMessage(message);
+                    }
+                    if (!this._isConnected) {
+                        this._isConnected = true;
+                        this.emit('onlineChange', true);
+                    }
+                }
+                else {
+                    this.log('Sync request failed', response.status, await response.text());
+                    if (this._isConnected) {
+                        this._isConnected = false;
+                        this.emit('onlineChange', false);
+                    }
+                    // only keep trying if the error was not 4xx
+                    if (response.status >= 500) {
+                        this.heartbeat.keepAlive();
+                    }
+                }
+            }
+            catch (error) {
+                if (this._isConnected) {
+                    this._isConnected = false;
+                    this.emit('onlineChange', false);
+                }
+                this.log(error);
+                this.heartbeat.keepAlive();
+            }
+        };
+        this.handleServerMessage = async (message) => {
+            if (message.type === 'sync-resp') {
+                if (message.ackThisNonce) {
+                    // we need to ack the nonce to confirm that we received the sync-resp
+                    this.log('Sending sync ack', message.ackThisNonce);
+                    this.sendRequest([
+                        await this.meta.messageCreator.createAck(message.ackThisNonce),
+                    ]);
+                }
+                // but we can go ahead and preemptively allow ops to be sent
+                this._hasSynced = true;
+            }
+            this.emit('message', message);
+        };
+        this.send = (message) => {
+            // only certain messages are sent for pull-based sync.
+            switch (message.type) {
+                case 'presence-update':
+                case 'sync':
+                case 'heartbeat':
+                    return this.sendRequest([message]);
+                case 'op':
+                    if (this._hasSynced) {
+                        return this.sendRequest([message]);
+                    }
+                    break;
+            }
+        };
+        this.dispose = () => { };
+        // on a heartbeat, do a sync
+        this.onHeartbeat = async () => {
+            // for HTTP sync we send presence first, so that the sync-resp message
+            // will include the client's own presence info and fill in missing profile
+            // data on the first request. otherwise it would have to wait for the second.
+            this.sendRequest([
+                await this.meta.messageCreator.createPresenceUpdate(this.presence.self.presence),
+                await this.meta.messageCreator.createSyncStep1(),
+            ]);
+        };
+        // if the server fails to respond in a certain amount of time, we assume
+        // the connection is lost and go offline.
+        this.onHeartbeatMissed = async () => {
+            this.emit('onlineChange', false);
+            this.log('Missed heartbeat');
+            this._isConnected = false;
+        };
+        this.log = log;
+        this.meta = meta;
+        this.presence = presence;
+        this.endpointProvider = endpointProvider;
+        this.heartbeat = new Heartbeat_js_1.Heartbeat({
+            interval,
+        });
+        this.heartbeat.subscribe('beat', this.onHeartbeat);
+        this.heartbeat.subscribe('missed', this.onHeartbeatMissed);
+    }
+    get interval() {
+        return this.heartbeat.interval;
+    }
+    start() {
+        if (this.status === 'active') {
+            return;
+        }
+        this.heartbeat.start(true);
+        this._status = 'active';
+    }
+    stop() {
+        this.heartbeat.stop();
+        this._status = 'paused';
+    }
+    reconnect() { }
+    get isConnected() {
+        return this._isConnected;
+    }
+    get status() {
+        return this._status;
+    }
+}
+exports.PushPullSync = PushPullSync;
 //# sourceMappingURL=PushPullSync.js.map

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

@@ -1,27 +1,27 @@
-import { ReplicaType } from '@verdant-web/common';
-export interface ServerSyncEndpointProviderConfig {
-    /**
-     * The location of the endpoint used to retrieve an
-     * authorization token for the client.
-     */
-    authEndpoint?: string;
-    /**
-     * A custom fetch function to retrieve authorization
-     * data.
-     */
-    fetchAuth?: () => Promise<{
-        accessToken: string;
-    }>;
-}
-export declare class ServerSyncEndpointProvider {
-    private config;
-    private cached;
-    type: ReplicaType;
-    constructor(config: ServerSyncEndpointProviderConfig);
-    getEndpoints: () => Promise<{
-        http: string;
-        websocket: string;
-        files: string;
-        token: string;
-    }>;
-}
+import { ReplicaType } from '@verdant-web/common';
+export interface ServerSyncEndpointProviderConfig {
+    /**
+     * The location of the endpoint used to retrieve an
+     * authorization token for the client.
+     */
+    authEndpoint?: string;
+    /**
+     * A custom fetch function to retrieve authorization
+     * data.
+     */
+    fetchAuth?: () => Promise<{
+        accessToken: string;
+    }>;
+}
+export declare class ServerSyncEndpointProvider {
+    private config;
+    private cached;
+    type: ReplicaType;
+    constructor(config: ServerSyncEndpointProviderConfig);
+    getEndpoints: () => Promise<{
+        http: string;
+        websocket: string;
+        files: string;
+        token: string;
+    }>;
+}