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

package/dist/esm/sync/FileSync.js

@@ -1,81 +1,81 @@
-export class FileSync {
-    constructor({ endpointProvider, log, }) {
-        this.uploadFile = async (data) => {
-            const file = data.file;
-            if (!file) {
-                throw new Error('Cannot upload a non-local file');
-            }
-            // multipart upload
-            const { files: fileEndpoint, token } = await this.endpointProvider.getEndpoints();
-            const formData = new window.FormData();
-            formData.append('file', file);
-            try {
-                const response = await fetch(fileEndpoint + `/${data.id}`, {
-                    method: 'POST',
-                    body: formData,
-                    credentials: 'include',
-                    headers: {
-                        Authorization: `Bearer ${token}`,
-                    },
-                });
-                if (response.ok) {
-                    return {
-                        success: true,
-                        retry: false,
-                    };
-                }
-                else {
-                    this.log('error', 'File upload failed', response.status, await response.text());
-                    return {
-                        success: false,
-                        retry: response.status >= 500,
-                    };
-                }
-            }
-            catch (e) {
-                this.log('error', 'File upload failed', e);
-                return {
-                    success: false,
-                    retry: true,
-                };
-            }
-        };
-        this.getFile = async (id) => {
-            const { files: fileEndpoint, token } = await this.endpointProvider.getEndpoints();
-            try {
-                const response = await fetch(fileEndpoint + `/${id}`, {
-                    method: 'GET',
-                    credentials: 'include',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        Authorization: `Bearer ${token}`,
-                    },
-                });
-                if (response.ok) {
-                    const data = await response.json();
-                    return {
-                        success: true,
-                        data,
-                    };
-                }
-                else {
-                    this.log('error', 'File information fetch failed', response.status, await response.text());
-                    return {
-                        success: false,
-                        retry: response.status >= 500 || response.status === 404,
-                    };
-                }
-            }
-            catch (e) {
-                this.log('error', 'File information fetch failed', e);
-                return {
-                    success: false,
-                    retry: true,
-                };
-            }
-        };
-        this.endpointProvider = endpointProvider;
-        this.log = log;
-    }
-}
+export class FileSync {
+    constructor({ endpointProvider, log, }) {
+        this.uploadFile = async (data) => {
+            const file = data.file;
+            if (!file) {
+                throw new Error('Cannot upload a non-local file');
+            }
+            // multipart upload
+            const { files: fileEndpoint, token } = await this.endpointProvider.getEndpoints();
+            const formData = new window.FormData();
+            formData.append('file', file);
+            try {
+                const response = await fetch(fileEndpoint + `/${data.id}`, {
+                    method: 'POST',
+                    body: formData,
+                    credentials: 'include',
+                    headers: {
+                        Authorization: `Bearer ${token}`,
+                    },
+                });
+                if (response.ok) {
+                    return {
+                        success: true,
+                        retry: false,
+                    };
+                }
+                else {
+                    this.log('error', 'File upload failed', response.status, await response.text());
+                    return {
+                        success: false,
+                        retry: response.status >= 500,
+                    };
+                }
+            }
+            catch (e) {
+                this.log('error', 'File upload failed', e);
+                return {
+                    success: false,
+                    retry: true,
+                };
+            }
+        };
+        this.getFile = async (id) => {
+            const { files: fileEndpoint, token } = await this.endpointProvider.getEndpoints();
+            try {
+                const response = await fetch(fileEndpoint + `/${id}`, {
+                    method: 'GET',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: `Bearer ${token}`,
+                    },
+                });
+                if (response.ok) {
+                    const data = await response.json();
+                    return {
+                        success: true,
+                        data,
+                    };
+                }
+                else {
+                    this.log('error', 'File information fetch failed', response.status, await response.text());
+                    return {
+                        success: false,
+                        retry: response.status >= 500 || response.status === 404,
+                    };
+                }
+            }
+            catch (e) {
+                this.log('error', 'File information fetch failed', e);
+                return {
+                    success: false,
+                    retry: true,
+                };
+            }
+        };
+        this.endpointProvider = endpointProvider;
+        this.log = log;
+    }
+}
 //# sourceMappingURL=FileSync.js.map

package/dist/esm/sync/Heartbeat.d.ts

@@ -1,25 +1,25 @@
-import { EventSubscriber } from '@verdant-web/common';
-export declare class Heartbeat extends EventSubscriber<{
-    missed: () => void;
-    beat: () => void;
-}> {
-    private _interval;
-    private deadlineLength;
-    private nextBeat;
-    private deadline;
-    get interval(): number;
-    constructor({ interval, deadlineLength, restartOnTabFocus, }?: {
-        interval?: number;
-        deadlineLength?: number;
-        restartOnTabFocus?: boolean;
-    });
-    keepAlive: () => void;
-    start: (immediate?: boolean) => void;
-    stop: () => void;
-    private beat;
-    private onDeadline;
-    /**
-     * Only takes affect after the next beat
-     */
-    setInterval: (interval: number) => void;
-}
+import { EventSubscriber } from '@verdant-web/common';
+export declare class Heartbeat extends EventSubscriber<{
+    missed: () => void;
+    beat: () => void;
+}> {
+    private _interval;
+    private deadlineLength;
+    private nextBeat;
+    private deadline;
+    get interval(): number;
+    constructor({ interval, deadlineLength, restartOnTabFocus, }?: {
+        interval?: number;
+        deadlineLength?: number;
+        restartOnTabFocus?: boolean;
+    });
+    keepAlive: () => void;
+    start: (immediate?: boolean) => void;
+    stop: () => void;
+    private beat;
+    private onDeadline;
+    /**
+     * Only takes affect after the next beat
+     */
+    setInterval: (interval: number) => void;
+}

package/dist/esm/sync/Heartbeat.js

@@ -1,60 +1,60 @@
-import { EventSubscriber } from '@verdant-web/common';
-export class Heartbeat extends EventSubscriber {
-    get interval() {
-        return this._interval;
-    }
-    constructor({ interval = 15 * 1000, deadlineLength = 3 * 1000, restartOnTabFocus = true, } = {}) {
-        super();
-        this.nextBeat = null;
-        this.deadline = null;
-        this.keepAlive = () => {
-            if (this.deadline) {
-                clearTimeout(this.deadline);
-                this.deadline = null;
-                this.start();
-            }
-        };
-        this.start = (immediate = false) => {
-            this.stop();
-            if (immediate) {
-                this.beat();
-            }
-            else {
-                this.nextBeat = setTimeout(this.beat, this._interval);
-            }
-        };
-        this.stop = () => {
-            if (this.nextBeat) {
-                clearTimeout(this.nextBeat);
-            }
-            if (this.deadline) {
-                clearTimeout(this.deadline);
-            }
-        };
-        this.beat = async () => {
-            this.emit('beat');
-            this.deadline = setTimeout(this.onDeadline, this.deadlineLength);
-        };
-        this.onDeadline = () => {
-            this.deadline = null;
-            this.emit('missed');
-        };
-        /**
-         * Only takes affect after the next beat
-         */
-        this.setInterval = (interval) => {
-            this._interval = interval;
-        };
-        this._interval = interval;
-        this.deadlineLength = deadlineLength;
-        if (typeof window !== 'undefined' && restartOnTabFocus) {
-            window.addEventListener('pageshow', () => this.start(true));
-            document.addEventListener('visibilitychange', () => {
-                if (document.visibilityState === 'visible') {
-                    this.start(true);
-                }
-            });
-        }
-    }
-}
+import { EventSubscriber } from '@verdant-web/common';
+export class Heartbeat extends EventSubscriber {
+    get interval() {
+        return this._interval;
+    }
+    constructor({ interval = 15 * 1000, deadlineLength = 3 * 1000, restartOnTabFocus = true, } = {}) {
+        super();
+        this.nextBeat = null;
+        this.deadline = null;
+        this.keepAlive = () => {
+            if (this.deadline) {
+                clearTimeout(this.deadline);
+                this.deadline = null;
+                this.start();
+            }
+        };
+        this.start = (immediate = false) => {
+            this.stop();
+            if (immediate) {
+                this.beat();
+            }
+            else {
+                this.nextBeat = setTimeout(this.beat, this._interval);
+            }
+        };
+        this.stop = () => {
+            if (this.nextBeat) {
+                clearTimeout(this.nextBeat);
+            }
+            if (this.deadline) {
+                clearTimeout(this.deadline);
+            }
+        };
+        this.beat = async () => {
+            this.emit('beat');
+            this.deadline = setTimeout(this.onDeadline, this.deadlineLength);
+        };
+        this.onDeadline = () => {
+            this.deadline = null;
+            this.emit('missed');
+        };
+        /**
+         * Only takes affect after the next beat
+         */
+        this.setInterval = (interval) => {
+            this._interval = interval;
+        };
+        this._interval = interval;
+        this.deadlineLength = deadlineLength;
+        if (typeof window !== 'undefined' && restartOnTabFocus) {
+            window.addEventListener('pageshow', () => this.start(true));
+            document.addEventListener('visibilitychange', () => {
+                if (document.visibilityState === 'visible') {
+                    this.start(true);
+                }
+            });
+        }
+    }
+}
 //# sourceMappingURL=Heartbeat.js.map

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

@@ -1,116 +1,116 @@
-var _a;
-import { EventSubscriber, Batcher, } from '@verdant-web/common';
-export const HANDLE_MESSAGE = Symbol('handleMessage');
-export class PresenceManager extends 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 Batcher(this.flushPresenceUpdates);
-        this._updateBatch = this._updateBatcher.add({
-            max: 25,
-            timeout: updateBatchTimeout,
-            items: [],
-            key: 'default',
-        });
-    }
-}
-_a = HANDLE_MESSAGE;
+var _a;
+import { EventSubscriber, Batcher, } from '@verdant-web/common';
+export const HANDLE_MESSAGE = Symbol('handleMessage');
+export class PresenceManager extends 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 Batcher(this.flushPresenceUpdates);
+        this._updateBatch = this._updateBatcher.add({
+            max: 25,
+            timeout: updateBatchTimeout,
+            items: [],
+            key: 'default',
+        });
+    }
+}
+_a = HANDLE_MESSAGE;
 //# sourceMappingURL=PresenceManager.js.map