@verdant-web/store 2.0.1 → 2.0.2

package/dist/cjs/reactives/FakeWeakRef.d.ts

@@ -1,11 +1,11 @@
-/**
- * This module exists since I'm a little anxious about using WeakRef in production
- * and want to be able to roll it back quickly to debug issues. Basically by adding
- * import { WeakRef } from 'FakeWeakRef' to the top of the file, we can switch back
- * to using a simple object reference.
- */
-export declare class WeakRef<T> {
-    constructor(value: T);
-    value: T;
-    deref(): T | undefined;
-}
+/**
+ * This module exists since I'm a little anxious about using WeakRef in production
+ * and want to be able to roll it back quickly to debug issues. Basically by adding
+ * import { WeakRef } from 'FakeWeakRef' to the top of the file, we can switch back
+ * to using a simple object reference.
+ */
+export declare class WeakRef<T> {
+    constructor(value: T);
+    value: T;
+    deref(): T | undefined;
+}

package/dist/cjs/reactives/FakeWeakRef.js

@@ -1,19 +1,19 @@
-"use strict";
-/**
- * This module exists since I'm a little anxious about using WeakRef in production
- * and want to be able to roll it back quickly to debug issues. Basically by adding
- * import { WeakRef } from 'FakeWeakRef' to the top of the file, we can switch back
- * to using a simple object reference.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WeakRef = void 0;
-class WeakRef {
-    constructor(value) {
-        this.value = value;
-    }
-    deref() {
-        return this.value;
-    }
-}
-exports.WeakRef = WeakRef;
+"use strict";
+/**
+ * This module exists since I'm a little anxious about using WeakRef in production
+ * and want to be able to roll it back quickly to debug issues. Basically by adding
+ * import { WeakRef } from 'FakeWeakRef' to the top of the file, we can switch back
+ * to using a simple object reference.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WeakRef = void 0;
+class WeakRef {
+    constructor(value) {
+        this.value = value;
+    }
+    deref() {
+        return this.value;
+    }
+}
+exports.WeakRef = WeakRef;
 //# sourceMappingURL=FakeWeakRef.js.map

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

@@ -1,23 +1,23 @@
-import { FileData } from '@verdant-web/common';
-import { ServerSyncEndpointProvider } from './ServerSyncEndpointProvider.js';
-export interface FileUploadResult {
-    success: boolean;
-    retry: boolean;
-}
-export type FilePullResult = {
-    success: true;
-    data: FileData;
-} | {
-    success: false;
-    retry: boolean;
-};
-export declare class FileSync {
-    private endpointProvider;
-    private log;
-    constructor({ endpointProvider, log, }: {
-        endpointProvider: ServerSyncEndpointProvider;
-        log: (...args: any[]) => any;
-    });
-    uploadFile: (data: FileData) => Promise<FileUploadResult>;
-    getFile: (id: string) => Promise<FilePullResult>;
-}
+import { FileData } from '@verdant-web/common';
+import { ServerSyncEndpointProvider } from './ServerSyncEndpointProvider.js';
+export interface FileUploadResult {
+    success: boolean;
+    retry: boolean;
+}
+export type FilePullResult = {
+    success: true;
+    data: FileData;
+} | {
+    success: false;
+    retry: boolean;
+};
+export declare class FileSync {
+    private endpointProvider;
+    private log;
+    constructor({ endpointProvider, log, }: {
+        endpointProvider: ServerSyncEndpointProvider;
+        log: (...args: any[]) => any;
+    });
+    uploadFile: (data: FileData) => Promise<FileUploadResult>;
+    getFile: (id: string) => Promise<FilePullResult>;
+}

package/dist/cjs/sync/FileSync.js

@@ -1,85 +1,85 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileSync = void 0;
-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;
-    }
-}
-exports.FileSync = FileSync;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSync = void 0;
+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;
+    }
+}
+exports.FileSync = FileSync;
 //# sourceMappingURL=FileSync.js.map

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

@@ -1,24 +1,24 @@
-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, }?: {
-        interval?: number;
-        deadlineLength?: number;
-    });
-    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, }?: {
+        interval?: number;
+        deadlineLength?: number;
+    });
+    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/cjs/sync/Heartbeat.js

@@ -1,56 +1,56 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Heartbeat = void 0;
-const common_1 = require("@verdant-web/common");
-class Heartbeat extends common_1.EventSubscriber {
-    get interval() {
-        return this._interval;
-    }
-    constructor({ interval = 15 * 1000, deadlineLength = 3 * 1000, } = {}) {
-        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;
-    }
-}
-exports.Heartbeat = Heartbeat;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Heartbeat = void 0;
+const common_1 = require("@verdant-web/common");
+class Heartbeat extends common_1.EventSubscriber {
+    get interval() {
+        return this._interval;
+    }
+    constructor({ interval = 15 * 1000, deadlineLength = 3 * 1000, } = {}) {
+        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;
+    }
+}
+exports.Heartbeat = Heartbeat;
 //# sourceMappingURL=Heartbeat.js.map

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

@@ -1,41 +1,41 @@
-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 _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>;
-    };
-    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 _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>;
+    };
+    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;
+}