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

package/dist/esm/batching.js

@@ -1,87 +1,87 @@
-export 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;
-    }
-}
-export 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;
-    }
-}
+export 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;
+    }
+}
+export 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;
+    }
+}
 //# sourceMappingURL=batching.js.map

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

@@ -1,13 +1,13 @@
-export function isFileRef(value) {
-    return value && value['@@type'] === 'file';
-}
-export function createFileRef(id) {
-    return {
-        '@@type': 'file',
-        id,
-    };
-}
-export function getAllFileFields(snapshot) {
-    return Object.entries(snapshot).filter((entry) => isFileRef(entry[1]));
-}
+export function isFileRef(value) {
+    return value && value['@@type'] === 'file';
+}
+export function createFileRef(id) {
+    return {
+        '@@type': 'file',
+        id,
+    };
+}
+export function getAllFileFields(snapshot) {
+    return Object.entries(snapshot).filter((entry) => isFileRef(entry[1]));
+}
 //# sourceMappingURL=files.js.map

package/dist/esm/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';

package/dist/esm/index.js

@@ -1,17 +1,17 @@
-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 * from './patch.js';
-export * from './oids.js';
-export * from './EventSubscriber.js';
-export * from './undo.js';
-export * from './batching.js';
-export * from './files.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 * from './patch.js';
+export * from './oids.js';
+export * from './EventSubscriber.js';
+export * from './undo.js';
+export * from './batching.js';
+export * from './files.js';
+export { makeObjectRef, makeFileRef, isRef, compareRefs } from './refs.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/indexes.d.ts

@@ -1,17 +1,17 @@
-import { StorageCollectionSchema, StorageDirectSyntheticSchema } from './index.js';
-export declare const COMPOUND_INDEX_SEPARATOR = "\uFFFFFE";
-export declare const COMPOUND_INDEX_LOWER_BOUND_SEPARATOR = "\0";
-export declare const COMPOUND_INDEX_UPPER_BOUND_SEPARATOR = "\uFFFFFF";
-declare type IndexableFieldValue = string | number | boolean | any[];
-export declare type CompoundIndexValue = string | string[];
-export declare function createCompoundIndexValue(...fields: IndexableFieldValue[]): CompoundIndexValue;
-export declare function createUpperBoundIndexValue(...fields: IndexableFieldValue[]): string;
-export declare function createLowerBoundIndexValue(...fields: IndexableFieldValue[]): string;
-export declare function isDirectSynthetic(index: any): index is StorageDirectSyntheticSchema<any>;
-export declare function computeSynthetics(schema: StorageCollectionSchema, obj: any): Record<string, any>;
-export declare function computeCompoundIndices(schema: StorageCollectionSchema<any, any, any>, doc: any): any;
-export declare function getIndexValues(schema: StorageCollectionSchema<any, any, any>, doc: any): any;
-export declare function assignIndexValues(schema: StorageCollectionSchema<any, any, any>, doc: any): any;
-export declare const NULL_INDEX_VALUE = "null";
-export declare function sanitizeIndexValue(value: unknown): string | number | (string | number)[];
-export {};
+import { StorageCollectionSchema, StorageDirectSyntheticSchema } from './index.js';
+export declare const COMPOUND_INDEX_SEPARATOR = "\uFFFFFE";
+export declare const COMPOUND_INDEX_LOWER_BOUND_SEPARATOR = "\0";
+export declare const COMPOUND_INDEX_UPPER_BOUND_SEPARATOR = "\uFFFFFF";
+declare type IndexableFieldValue = string | number | boolean | any[];
+export declare type CompoundIndexValue = string | string[];
+export declare function createCompoundIndexValue(...fields: IndexableFieldValue[]): CompoundIndexValue;
+export declare function createUpperBoundIndexValue(...fields: IndexableFieldValue[]): string;
+export declare function createLowerBoundIndexValue(...fields: IndexableFieldValue[]): string;
+export declare function isDirectSynthetic(index: any): index is StorageDirectSyntheticSchema<any>;
+export declare function computeSynthetics(schema: StorageCollectionSchema, obj: any): Record<string, any>;
+export declare function computeCompoundIndices(schema: StorageCollectionSchema<any, any, any>, doc: any): any;
+export declare function getIndexValues(schema: StorageCollectionSchema<any, any, any>, doc: any): any;
+export declare function assignIndexValues(schema: StorageCollectionSchema<any, any, any>, doc: any): any;
+export declare const NULL_INDEX_VALUE = "null";
+export declare function sanitizeIndexValue(value: unknown): string | number | (string | number)[];
+export {};

package/dist/esm/indexes.js

@@ -1,131 +1,131 @@
-import { isIndexed, } from './index.js';
-// unlikely to be used unicode character
-export const COMPOUND_INDEX_SEPARATOR = '\uFFFFFE';
-// 1 lower than separator
-export const COMPOUND_INDEX_LOWER_BOUND_SEPARATOR = '\u0000';
-// 1 higher than separator
-export const COMPOUND_INDEX_UPPER_BOUND_SEPARATOR = '\uFFFFFF';
-export function createCompoundIndexValue(...fields) {
-    const value = expandArrayIndex(fields);
-    if (value.length === 1) {
-        return value[0];
-    }
-    return value;
-}
-export function createUpperBoundIndexValue(...fields) {
-    return (fields.join(COMPOUND_INDEX_SEPARATOR) +
-        `${COMPOUND_INDEX_UPPER_BOUND_SEPARATOR}`);
-}
-export function createLowerBoundIndexValue(...fields) {
-    return (fields.join(COMPOUND_INDEX_SEPARATOR) +
-        `${COMPOUND_INDEX_SEPARATOR}${COMPOUND_INDEX_LOWER_BOUND_SEPARATOR}`);
-}
-/**
- * Whenever an array value is included in a compound index, we have to expand
- * the value to include all permutations of values in the array.
- * For example if we had an index id + tags on a document
- *
- * {
- *   id: '1',
- *   tags: ['a', 'b']
- * }
- *
- * we want to create an index:
- *
- * id_tags: ['1#a', '1#b']
- *
- * If multiple arrays are indexed we have to exponentially expand...
- *
- * id_tags_tags2: ['1#a#a', '1#a#b', '1#b#a', '1#b#b']
- *
- * To generalize this we construct a 2-level array of strings.
- * Iterating over indexed values, we expand each item into N items if
- * the current value is an array.
- *
- * Then we combine all nested arrays into compound index values.
- * This will produce an array of 1 element if none of the indexed values
- * were arrays. The caller should unwrap that.
- *
- * This function also deduplicates values.
- */
-function expandArrayIndex(fields) {
-    let value = [[]];
-    for (const field of fields) {
-        if (Array.isArray(field)) {
-            const newValue = [];
-            for (const previousValue of value) {
-                for (const fieldValue of field) {
-                    newValue.push(previousValue.concat(fieldValue));
-                }
-            }
-            value = newValue;
-        }
-        else {
-            for (const item of value) {
-                item.push(`${field}`);
-            }
-        }
-    }
-    return Array.from(new Set(value.map((item) => {
-        return item.join(COMPOUND_INDEX_SEPARATOR);
-    })));
-}
-export function isDirectSynthetic(index) {
-    return !!index.field;
-}
-export function computeSynthetics(schema, obj) {
-    const result = {};
-    for (const [name, property] of Object.entries(schema.indexes || {})) {
-        const index = property;
-        if (isDirectSynthetic(index)) {
-            result[name] = sanitizeIndexValue(obj[index.field]);
-        }
-        else {
-            result[name] = sanitizeIndexValue(index.compute(obj));
-        }
-    }
-    return result;
-}
-export function computeCompoundIndices(schema, doc) {
-    return Object.entries(schema.compounds || {}).reduce((acc, [indexKey, index]) => {
-        acc[indexKey] = createCompoundIndexValue(...index.of.map((key) => doc[key]));
-        return acc;
-    }, {});
-}
-function computeIndexedFields(schema, doc) {
-    return Object.entries(schema.fields).reduce((acc, [key, field]) => {
-        if (isIndexed(field)) {
-            acc[key] = sanitizeIndexValue(doc[key]);
-        }
-        return acc;
-    }, {});
-}
-export function getIndexValues(schema, doc) {
-    return Object.assign(Object.assign(Object.assign(Object.assign({ [schema.primaryKey]: doc[schema.primaryKey] }, computeIndexedFields(schema, doc)), computeSynthetics(schema, doc)), computeCompoundIndices(schema, doc)), { '@@@snapshot': doc });
-}
-export function assignIndexValues(schema, doc) {
-    Object.assign(doc, computeSynthetics(schema, doc));
-    Object.assign(doc, computeCompoundIndices(schema, doc));
-    return doc;
-}
-export const NULL_INDEX_VALUE = 'null';
-export function sanitizeIndexValue(value) {
-    if (value === null) {
-        return NULL_INDEX_VALUE;
-    }
-    if (typeof value === 'string' || typeof value === 'number') {
-        return value;
-    }
-    if (typeof value === 'boolean' || value === null) {
-        return `${value}`;
-    }
-    if (value === undefined) {
-        // this shouldn't happen ,but for resiliency...
-        return 'undefined';
-    }
-    if (Array.isArray(value)) {
-        return value.map(sanitizeIndexValue);
-    }
-    throw new Error(`Unsupported index value: ${value}`);
-}
+import { isIndexed, } from './index.js';
+// unlikely to be used unicode character
+export const COMPOUND_INDEX_SEPARATOR = '\uFFFFFE';
+// 1 lower than separator
+export const COMPOUND_INDEX_LOWER_BOUND_SEPARATOR = '\u0000';
+// 1 higher than separator
+export const COMPOUND_INDEX_UPPER_BOUND_SEPARATOR = '\uFFFFFF';
+export function createCompoundIndexValue(...fields) {
+    const value = expandArrayIndex(fields);
+    if (value.length === 1) {
+        return value[0];
+    }
+    return value;
+}
+export function createUpperBoundIndexValue(...fields) {
+    return (fields.join(COMPOUND_INDEX_SEPARATOR) +
+        `${COMPOUND_INDEX_UPPER_BOUND_SEPARATOR}`);
+}
+export function createLowerBoundIndexValue(...fields) {
+    return (fields.join(COMPOUND_INDEX_SEPARATOR) +
+        `${COMPOUND_INDEX_SEPARATOR}${COMPOUND_INDEX_LOWER_BOUND_SEPARATOR}`);
+}
+/**
+ * Whenever an array value is included in a compound index, we have to expand
+ * the value to include all permutations of values in the array.
+ * For example if we had an index id + tags on a document
+ *
+ * {
+ *   id: '1',
+ *   tags: ['a', 'b']
+ * }
+ *
+ * we want to create an index:
+ *
+ * id_tags: ['1#a', '1#b']
+ *
+ * If multiple arrays are indexed we have to exponentially expand...
+ *
+ * id_tags_tags2: ['1#a#a', '1#a#b', '1#b#a', '1#b#b']
+ *
+ * To generalize this we construct a 2-level array of strings.
+ * Iterating over indexed values, we expand each item into N items if
+ * the current value is an array.
+ *
+ * Then we combine all nested arrays into compound index values.
+ * This will produce an array of 1 element if none of the indexed values
+ * were arrays. The caller should unwrap that.
+ *
+ * This function also deduplicates values.
+ */
+function expandArrayIndex(fields) {
+    let value = [[]];
+    for (const field of fields) {
+        if (Array.isArray(field)) {
+            const newValue = [];
+            for (const previousValue of value) {
+                for (const fieldValue of field) {
+                    newValue.push(previousValue.concat(fieldValue));
+                }
+            }
+            value = newValue;
+        }
+        else {
+            for (const item of value) {
+                item.push(`${field}`);
+            }
+        }
+    }
+    return Array.from(new Set(value.map((item) => {
+        return item.join(COMPOUND_INDEX_SEPARATOR);
+    })));
+}
+export function isDirectSynthetic(index) {
+    return !!index.field;
+}
+export function computeSynthetics(schema, obj) {
+    const result = {};
+    for (const [name, property] of Object.entries(schema.indexes || {})) {
+        const index = property;
+        if (isDirectSynthetic(index)) {
+            result[name] = sanitizeIndexValue(obj[index.field]);
+        }
+        else {
+            result[name] = sanitizeIndexValue(index.compute(obj));
+        }
+    }
+    return result;
+}
+export function computeCompoundIndices(schema, doc) {
+    return Object.entries(schema.compounds || {}).reduce((acc, [indexKey, index]) => {
+        acc[indexKey] = createCompoundIndexValue(...index.of.map((key) => doc[key]));
+        return acc;
+    }, {});
+}
+function computeIndexedFields(schema, doc) {
+    return Object.entries(schema.fields).reduce((acc, [key, field]) => {
+        if (isIndexed(field)) {
+            acc[key] = sanitizeIndexValue(doc[key]);
+        }
+        return acc;
+    }, {});
+}
+export function getIndexValues(schema, doc) {
+    return Object.assign(Object.assign(Object.assign(Object.assign({ [schema.primaryKey]: doc[schema.primaryKey] }, computeIndexedFields(schema, doc)), computeSynthetics(schema, doc)), computeCompoundIndices(schema, doc)), { '@@@snapshot': doc });
+}
+export function assignIndexValues(schema, doc) {
+    Object.assign(doc, computeSynthetics(schema, doc));
+    Object.assign(doc, computeCompoundIndices(schema, doc));
+    return doc;
+}
+export const NULL_INDEX_VALUE = 'null';
+export function sanitizeIndexValue(value) {
+    if (value === null) {
+        return NULL_INDEX_VALUE;
+    }
+    if (typeof value === 'string' || typeof value === 'number') {
+        return value;
+    }
+    if (typeof value === 'boolean' || value === null) {
+        return `${value}`;
+    }
+    if (value === undefined) {
+        // this shouldn't happen ,but for resiliency...
+        return 'undefined';
+    }
+    if (Array.isArray(value)) {
+        return value.map(sanitizeIndexValue);
+    }
+    throw new Error(`Unsupported index value: ${value}`);
+}
 //# sourceMappingURL=indexes.js.map

package/dist/esm/indexes.test.d.ts

@@ -1 +1 @@
-export {};
+export {};