@verdant-web/common 1.15.3-next.0 → 1.15.4

package/dist/cjs/EventSubscriber.d.ts

@@ -1,17 +1,17 @@
-export declare class EventSubscriber<Events extends {
-    [key: string]: (...args: any[]) => void;
-}> {
-    private _onAllUnsubscribed?;
-    protected subscribers: Record<string, Record<string, (...args: any[]) => void>>;
-    protected counts: Record<string, number>;
-    private _disabled;
-    constructor(_onAllUnsubscribed?: ((event: keyof Events) => void) | undefined);
-    get disabled(): boolean;
-    subscriberCount: (event: Extract<keyof Events, string>) => number;
-    totalSubscriberCount: () => number;
-    subscribe: <K extends Extract<keyof Events, string>>(event: K, callback: Events[K]) => () => void;
-    emit: <K extends Extract<keyof Events, string>>(event: K, ...args: Parameters<Events[K]>) => void;
-    dispose: () => void;
-    disable: () => void;
-}
-export declare type EventsOf<T extends EventSubscriber<any>> = T extends EventSubscriber<infer E> ? keyof E : never;
+export declare class EventSubscriber<Events extends {
+    [key: string]: (...args: any[]) => void;
+}> {
+    private _onAllUnsubscribed?;
+    protected subscribers: Record<string, Record<string, (...args: any[]) => void>>;
+    protected counts: Record<string, number>;
+    private _disabled;
+    constructor(_onAllUnsubscribed?: ((event: keyof Events) => void) | undefined);
+    get disabled(): boolean;
+    subscriberCount: (event: Extract<keyof Events, string>) => number;
+    totalSubscriberCount: () => number;
+    subscribe: <K extends Extract<keyof Events, string>>(event: K, callback: Events[K]) => () => void;
+    emit: <K extends Extract<keyof Events, string>>(event: K, ...args: Parameters<Events[K]>) => void;
+    dispose: () => void;
+    disable: () => void;
+}
+export declare type EventsOf<T extends EventSubscriber<any>> = T extends EventSubscriber<infer E> ? keyof E : never;

package/dist/cjs/EventSubscriber.js

@@ -1,67 +1,67 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventSubscriber = void 0;
-const utils_js_1 = require("./utils.js");
-class EventSubscriber {
-    constructor(_onAllUnsubscribed) {
-        this._onAllUnsubscribed = _onAllUnsubscribed;
-        this.subscribers = {};
-        this.counts = {};
-        this._disabled = false;
-        this.subscriberCount = (event) => {
-            var _a;
-            return (_a = this.counts[event]) !== null && _a !== void 0 ? _a : 0;
-        };
-        this.totalSubscriberCount = () => {
-            return Object.values(this.counts).reduce((acc, count) => acc + count, 0);
-        };
-        this.subscribe = (event, callback) => {
-            const key = (0, utils_js_1.generateId)();
-            let subscribers = this.subscribers[event];
-            if (!subscribers) {
-                subscribers = this.subscribers[event] = {};
-            }
-            subscribers[key] = callback;
-            this.counts[event] = (this.counts[event] || 0) + 1;
-            return () => {
-                // already removed
-                if (!this.subscribers[event])
-                    return;
-                delete this.subscribers[event][key];
-                this.counts[event]--;
-                if (this.counts[event] === 0) {
-                    delete this.subscribers[event];
-                    delete this.counts[event];
-                    if (this._onAllUnsubscribed) {
-                        this._onAllUnsubscribed(event);
-                    }
-                }
-            };
-        };
-        this.emit = (event, ...args) => {
-            if (this._disabled)
-                return;
-            if (this.subscribers[event]) {
-                Object.values(this.subscribers[event]).forEach((c) => c(...args));
-            }
-        };
-        this.dispose = () => {
-            const events = Object.keys(this.subscribers);
-            this.subscribers = {};
-            this.counts = {};
-            events.forEach((event) => {
-                if (this._onAllUnsubscribed) {
-                    this._onAllUnsubscribed(event);
-                }
-            });
-        };
-        this.disable = () => {
-            this._disabled = true;
-        };
-    }
-    get disabled() {
-        return this._disabled;
-    }
-}
-exports.EventSubscriber = EventSubscriber;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventSubscriber = void 0;
+const utils_js_1 = require("./utils.js");
+class EventSubscriber {
+    constructor(_onAllUnsubscribed) {
+        this._onAllUnsubscribed = _onAllUnsubscribed;
+        this.subscribers = {};
+        this.counts = {};
+        this._disabled = false;
+        this.subscriberCount = (event) => {
+            var _a;
+            return (_a = this.counts[event]) !== null && _a !== void 0 ? _a : 0;
+        };
+        this.totalSubscriberCount = () => {
+            return Object.values(this.counts).reduce((acc, count) => acc + count, 0);
+        };
+        this.subscribe = (event, callback) => {
+            const key = (0, utils_js_1.generateId)();
+            let subscribers = this.subscribers[event];
+            if (!subscribers) {
+                subscribers = this.subscribers[event] = {};
+            }
+            subscribers[key] = callback;
+            this.counts[event] = (this.counts[event] || 0) + 1;
+            return () => {
+                // already removed
+                if (!this.subscribers[event])
+                    return;
+                delete this.subscribers[event][key];
+                this.counts[event]--;
+                if (this.counts[event] === 0) {
+                    delete this.subscribers[event];
+                    delete this.counts[event];
+                    if (this._onAllUnsubscribed) {
+                        this._onAllUnsubscribed(event);
+                    }
+                }
+            };
+        };
+        this.emit = (event, ...args) => {
+            if (this._disabled)
+                return;
+            if (this.subscribers[event]) {
+                Object.values(this.subscribers[event]).forEach((c) => c(...args));
+            }
+        };
+        this.dispose = () => {
+            const events = Object.keys(this.subscribers);
+            this.subscribers = {};
+            this.counts = {};
+            events.forEach((event) => {
+                if (this._onAllUnsubscribed) {
+                    this._onAllUnsubscribed(event);
+                }
+            });
+        };
+        this.disable = () => {
+            this._disabled = true;
+        };
+    }
+    get disabled() {
+        return this._disabled;
+    }
+}
+exports.EventSubscriber = EventSubscriber;
 //# sourceMappingURL=EventSubscriber.js.map

package/dist/cjs/baseline.d.ts

@@ -1,5 +1,5 @@
-export declare type DocumentBaseline<T extends any = any> = {
-    oid: string;
-    snapshot: T;
-    timestamp: string;
-};
+export declare type DocumentBaseline<T extends any = any> = {
+    oid: string;
+    snapshot: T;
+    timestamp: string;
+};

package/dist/cjs/baseline.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=baseline.js.map

package/dist/cjs/batching.d.ts

@@ -1,42 +1,42 @@
-/// <reference types="node" resolution-mode="require"/>
-export declare class Batcher<T, UserData = any> {
-    private flusher;
-    private batches;
-    constructor(flusher: (items: T[], batchKey: string, userData: UserData) => any);
-    add({ key, userData, items, max, timeout, }: {
-        key: string;
-        userData?: UserData;
-        items: T[];
-        max?: number | null;
-        timeout?: number | null;
-    }): Batch<T, UserData>;
-    flush: (key: string) => any;
-    discard: (key: string) => void;
-    flushAll: () => any[];
-}
-export declare class Batch<T, UserData = any> {
-    items: Array<T>;
-    max: number | null;
-    startedAt: number;
-    timeout: number | null;
-    flushTimeout?: NodeJS.Timeout;
-    userData?: any;
-    flusher: (items: T[], batchKey: string, userData: UserData) => any;
-    key: string;
-    constructor({ max, startedAt, timeout, userData, flusher, key, }: {
-        key: string;
-        max: number | null;
-        startedAt: number;
-        timeout: number | null;
-        userData?: UserData;
-        flusher: (items: T[], batchKey: string, userData: UserData) => any;
-    });
-    update: ({ items, max, timeout, userData, }: {
-        items: Array<T>;
-        max?: number | null | undefined;
-        timeout?: number | null | undefined;
-        userData?: UserData | undefined;
-    }) => void;
-    flush: () => any;
-    discard: () => void;
-}
+/// <reference types="node" resolution-mode="require"/>
+export declare class Batcher<T, UserData = any> {
+    private flusher;
+    private batches;
+    constructor(flusher: (items: T[], batchKey: string, userData: UserData) => any);
+    add({ key, userData, items, max, timeout, }: {
+        key: string;
+        userData?: UserData;
+        items: T[];
+        max?: number | null;
+        timeout?: number | null;
+    }): Batch<T, UserData>;
+    flush: (key: string) => any;
+    discard: (key: string) => void;
+    flushAll: () => any[];
+}
+export declare class Batch<T, UserData = any> {
+    items: Array<T>;
+    max: number | null;
+    startedAt: number;
+    timeout: number | null;
+    flushTimeout?: NodeJS.Timeout;
+    userData?: any;
+    flusher: (items: T[], batchKey: string, userData: UserData) => any;
+    key: string;
+    constructor({ max, startedAt, timeout, userData, flusher, key, }: {
+        key: string;
+        max: number | null;
+        startedAt: number;
+        timeout: number | null;
+        userData?: UserData;
+        flusher: (items: T[], batchKey: string, userData: UserData) => any;
+    });
+    update: ({ items, max, timeout, userData, }: {
+        items: Array<T>;
+        max?: number | null | undefined;
+        timeout?: number | null | undefined;
+        userData?: UserData | undefined;
+    }) => void;
+    flush: () => any;
+    discard: () => void;
+}

package/dist/cjs/batching.js

@@ -1,92 +1,92 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Batch = exports.Batcher = void 0;
-class Batcher {
-    constructor(flusher) {
-        this.flusher = flusher;
-        this.batches = new Map();
-        this.flush = (key) => {
-            const batch = this.batches.get(key);
-            if (!batch)
-                return;
-            return batch.flush();
-        };
-        this.discard = (key) => {
-            const batch = this.batches.get(key);
-            if (!batch)
-                return;
-            batch.discard();
-            this.batches.delete(key);
-        };
-        this.flushAll = () => {
-            return [...this.batches.values()].map((batch) => batch.flush());
-        };
-    }
-    add({ key, userData, items, max, timeout, }) {
-        let batch = this.batches.get(key);
-        if (!batch) {
-            batch = new Batch({
-                max: max || null,
-                startedAt: Date.now(),
-                userData,
-                timeout: timeout || null,
-                flusher: this.flusher,
-                key,
-            });
-            this.batches.set(key, batch);
-        }
-        batch.update({
-            items,
-            max,
-            timeout,
-            userData,
-        });
-        return batch;
-    }
-}
-exports.Batcher = Batcher;
-class Batch {
-    constructor({ max, startedAt, timeout, userData, flusher, key, }) {
-        this.items = [];
-        this.update = ({ items, max, timeout, userData, }) => {
-            this.items.push(...items);
-            if (max !== undefined)
-                this.max = max;
-            if (timeout !== undefined)
-                this.timeout = timeout;
-            if (userData)
-                this.userData = userData;
-            // if the batch has items and a timeout but has not
-            // scheduled yet, schedule it
-            const needsSchedule = this.items.length !== 0 && this.timeout !== null && !this.flushTimeout;
-            // if the batch has already reached its max, skip scheduling
-            // and flush immediately
-            if (this.max !== null && this.items.length >= this.max) {
-                this.flush();
-            }
-            else if (needsSchedule && this.timeout !== null) {
-                this.flushTimeout = setTimeout(this.flush, this.timeout);
-            }
-        };
-        this.flush = () => {
-            this.flushTimeout && clearTimeout(this.flushTimeout);
-            this.flushTimeout = undefined;
-            const items = this.items;
-            this.items = [];
-            return this.flusher(items, this.key, this.userData);
-        };
-        this.discard = () => {
-            this.flushTimeout && clearTimeout(this.flushTimeout);
-            this.flushTimeout = undefined;
-            this.items = [];
-        };
-        this.max = max;
-        this.startedAt = startedAt;
-        this.timeout = timeout;
-        this.userData = userData;
-        this.flusher = flusher;
-        this.key = key;
-    }
-}
-exports.Batch = Batch;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Batch = exports.Batcher = void 0;
+class Batcher {
+    constructor(flusher) {
+        this.flusher = flusher;
+        this.batches = new Map();
+        this.flush = (key) => {
+            const batch = this.batches.get(key);
+            if (!batch)
+                return;
+            return batch.flush();
+        };
+        this.discard = (key) => {
+            const batch = this.batches.get(key);
+            if (!batch)
+                return;
+            batch.discard();
+            this.batches.delete(key);
+        };
+        this.flushAll = () => {
+            return [...this.batches.values()].map((batch) => batch.flush());
+        };
+    }
+    add({ key, userData, items, max, timeout, }) {
+        let batch = this.batches.get(key);
+        if (!batch) {
+            batch = new Batch({
+                max: max || null,
+                startedAt: Date.now(),
+                userData,
+                timeout: timeout || null,
+                flusher: this.flusher,
+                key,
+            });
+            this.batches.set(key, batch);
+        }
+        batch.update({
+            items,
+            max,
+            timeout,
+            userData,
+        });
+        return batch;
+    }
+}
+exports.Batcher = Batcher;
+class Batch {
+    constructor({ max, startedAt, timeout, userData, flusher, key, }) {
+        this.items = [];
+        this.update = ({ items, max, timeout, userData, }) => {
+            this.items.push(...items);
+            if (max !== undefined)
+                this.max = max;
+            if (timeout !== undefined)
+                this.timeout = timeout;
+            if (userData)
+                this.userData = userData;
+            // if the batch has items and a timeout but has not
+            // scheduled yet, schedule it
+            const needsSchedule = this.items.length !== 0 && this.timeout !== null && !this.flushTimeout;
+            // if the batch has already reached its max, skip scheduling
+            // and flush immediately
+            if (this.max !== null && this.items.length >= this.max) {
+                this.flush();
+            }
+            else if (needsSchedule && this.timeout !== null) {
+                this.flushTimeout = setTimeout(this.flush, this.timeout);
+            }
+        };
+        this.flush = () => {
+            this.flushTimeout && clearTimeout(this.flushTimeout);
+            this.flushTimeout = undefined;
+            const items = this.items;
+            this.items = [];
+            return this.flusher(items, this.key, this.userData);
+        };
+        this.discard = () => {
+            this.flushTimeout && clearTimeout(this.flushTimeout);
+            this.flushTimeout = undefined;
+            this.items = [];
+        };
+        this.max = max;
+        this.startedAt = startedAt;
+        this.timeout = timeout;
+        this.userData = userData;
+        this.flusher = flusher;
+        this.key = key;
+    }
+}
+exports.Batch = Batch;
 //# sourceMappingURL=batching.js.map

package/dist/cjs/files.d.ts

@@ -1,19 +1,19 @@
-export declare type FileRef = {
-    '@@type': 'file';
-    id: string;
-};
-export declare function isFileRef(value: any): value is FileRef;
-export declare function createFileRef(id: string): FileRef;
-export declare type FileData = {
-    id: string;
-    /**
-     * For locally created files, this starts false, until it's uploaded
-     * Remote files this is always true
-     */
-    remote: boolean;
-    name: string;
-    type: string;
-    file?: Blob;
-    url?: string;
-};
-export declare function getAllFileFields(snapshot: any): [string, FileRef][];
+export declare type FileRef = {
+    '@@type': 'file';
+    id: string;
+};
+export declare function isFileRef(value: any): value is FileRef;
+export declare function createFileRef(id: string): FileRef;
+export declare type FileData = {
+    id: string;
+    /**
+     * For locally created files, this starts false, until it's uploaded
+     * Remote files this is always true
+     */
+    remote: boolean;
+    name: string;
+    type: string;
+    file?: Blob;
+    url?: string;
+};
+export declare function getAllFileFields(snapshot: any): [string, FileRef][];

package/dist/cjs/files.js

@@ -1,19 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAllFileFields = exports.createFileRef = exports.isFileRef = void 0;
-function isFileRef(value) {
-    return value && value['@@type'] === 'file';
-}
-exports.isFileRef = isFileRef;
-function createFileRef(id) {
-    return {
-        '@@type': 'file',
-        id,
-    };
-}
-exports.createFileRef = createFileRef;
-function getAllFileFields(snapshot) {
-    return Object.entries(snapshot).filter((entry) => isFileRef(entry[1]));
-}
-exports.getAllFileFields = getAllFileFields;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllFileFields = exports.createFileRef = exports.isFileRef = void 0;
+function isFileRef(value) {
+    return value && value['@@type'] === 'file';
+}
+exports.isFileRef = isFileRef;
+function createFileRef(id) {
+    return {
+        '@@type': 'file',
+        id,
+    };
+}
+exports.createFileRef = createFileRef;
+function getAllFileFields(snapshot) {
+    return Object.entries(snapshot).filter((entry) => isFileRef(entry[1]));
+}
+exports.getAllFileFields = getAllFileFields;
 //# sourceMappingURL=files.js.map

package/dist/cjs/index.d.ts

@@ -1,19 +1,19 @@
-export * from './protocol.js';
-export * from './timestamp.js';
-export * from './operation.js';
-export * from './baseline.js';
-export * from './replica.js';
-export * from './schema/index.js';
-export * from './utils.js';
-export * from './indexes.js';
-export { migrate, migrationRange, createDefaultMigration, createMigration, } from './migration.js';
-export type { Migration, MigrationIndexDescription, MigrationEngine, } from './migration.js';
-export type { UserInfo } from './presence.js';
-export * from './patch.js';
-export * from './oids.js';
-export * from './EventSubscriber.js';
-export * from './undo.js';
-export * from './batching.js';
-export * from './files.js';
-export type { Ref } from './refs.js';
-export { makeObjectRef, makeFileRef, isRef, compareRefs } from './refs.js';
+export * from './protocol.js';
+export * from './timestamp.js';
+export * from './operation.js';
+export * from './baseline.js';
+export * from './replica.js';
+export * from './schema/index.js';
+export * from './utils.js';
+export * from './indexes.js';
+export { migrate, migrationRange, createDefaultMigration, createMigration, } from './migration.js';
+export type { Migration, MigrationIndexDescription, MigrationEngine, } from './migration.js';
+export type { UserInfo } from './presence.js';
+export * from './patch.js';
+export * from './oids.js';
+export * from './EventSubscriber.js';
+export * from './undo.js';
+export * from './batching.js';
+export * from './files.js';
+export type { Ref } from './refs.js';
+export { makeObjectRef, makeFileRef, isRef, compareRefs } from './refs.js';