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

package/dist/esm/timestamp.test.js

@@ -1,103 +1,103 @@
-import { describe, expect, it, vitest } from 'vitest';
-import { convertOldHlcTimestamp, encodeVersion, HybridLogicalClockTimestampProvider, OLD_encodeVersion, OLD_serializeHlcTimestamp, } from './timestamp.js';
-describe('the hybrid logical clock', () => {
-    it('always produces incrementing timestamps', async () => {
-        const clock = new HybridLogicalClockTimestampProvider();
-        let prev = clock.now(1);
-        clock.update(prev);
-        let now;
-        for (let i = 0; i < 1000; i++) {
-            now = clock.now(1);
-            expect(now > prev, `${now} not later than ${prev}`).toBe(true);
-            clock.update(now);
-            prev = now;
-        }
-        let time = new Date().getTime();
-        for (let i = 0; i < 1000; i++) {
-            vitest.setSystemTime(time++);
-            now = clock.now(1);
-            expect(now > prev, `${now} not later than ${prev}`).toBe(true);
-            clock.update(now);
-            prev = now;
-        }
-    });
-    it('groups blocks of time by version', () => {
-        const clock = new HybridLogicalClockTimestampProvider();
-        let prev = clock.now(1);
-        clock.update(prev);
-        let now;
-        for (let i = 0; i < 10; i++) {
-            now = clock.now(1);
-            expect(now > prev, `${now} not later than ${prev}`).toBe(true);
-            clock.update(now);
-            prev = now;
-        }
-        for (let i = 0; i < 10; i++) {
-            now = clock.now(2);
-            expect(now > prev, `${now} not later than ${prev}`).toBe(true);
-            clock.update(now);
-            prev = now;
-        }
-        const startOfVersion2 = now;
-        // jump back to 1
-        prev = clock.now(1);
-        clock.update(prev);
-        for (let i = 0; i < 10; i++) {
-            now = clock.now(1);
-            expect(now > prev, `${now} not later than ${prev}`).toBe(true);
-            expect(now < startOfVersion2, `${now} not earlier than ${startOfVersion2}`).toBe(true);
-            clock.update(now);
-            prev = now;
-        }
-    });
-    it('is shorter than the previous format', () => {
-        const clock = new HybridLogicalClockTimestampProvider();
-        expect(clock.now(1).length).toBeLessThan(clock.OLD_now(1).length);
-    });
-    it('correctly converts old to new format', () => {
-        const clock = new HybridLogicalClockTimestampProvider();
-        const oldFormat = clock.OLD_now(1);
-        const value = clock.timerState();
-        const converted = convertOldHlcTimestamp(oldFormat);
-        const newFormat = clock.get(1, value);
-        expect(converted).toEqual(newFormat);
-    });
-    // this is mostly to verify as I move to the new format.
-    // instead of attempting a distributed migration of timestamps, it
-    // will be easier that the new format just acts as always in the
-    // future of the old one. this will only mess with offline clients,
-    // but nobody is using verdant but me yet at time of this change (2022-12-19)
-    // which is kind of why I'm doing it now anyway.
-    it('old format always comes before new format', () => {
-        const clock = new HybridLogicalClockTimestampProvider();
-        const newFormat = clock.now(1);
-        const oldFormat = clock.OLD_now(1);
-        expect(oldFormat < newFormat).toBe(true);
-        // even far-future old timestamps are before new timestamps
-        const oldFormat2 = OLD_serializeHlcTimestamp({
-            counter: 999,
-            node: '9876543210',
-            time: new Date(3000, 1, 1).getTime(),
-        });
-        expect(OLD_encodeVersion(1) + oldFormat2 < newFormat).toBe(true);
-    });
-    it('decodes timestamps', () => {
-        const time = new Date();
-        vitest.setSystemTime(time);
-        const clock = new HybridLogicalClockTimestampProvider();
-        const now = clock.now(1);
-        expect(clock.getWallClockTime(now)).toEqual(time.getTime());
-    });
-});
-describe('version encoding', () => {
-    it('orders 1 before 2', () => {
-        expect(encodeVersion(1) < encodeVersion(2)).toBe(true);
-    });
-    it('orders 32 before 33', () => {
-        expect(encodeVersion(32) < encodeVersion(33)).toBe(true);
-    });
-    it('orders 34 before 35', () => {
-        expect(encodeVersion(34) < encodeVersion(35)).toBe(true);
-    });
-});
+import { describe, expect, it, vitest } from 'vitest';
+import { convertOldHlcTimestamp, encodeVersion, HybridLogicalClockTimestampProvider, OLD_encodeVersion, OLD_serializeHlcTimestamp, } from './timestamp.js';
+describe('the hybrid logical clock', () => {
+    it('always produces incrementing timestamps', async () => {
+        const clock = new HybridLogicalClockTimestampProvider();
+        let prev = clock.now(1);
+        clock.update(prev);
+        let now;
+        for (let i = 0; i < 1000; i++) {
+            now = clock.now(1);
+            expect(now > prev, `${now} not later than ${prev}`).toBe(true);
+            clock.update(now);
+            prev = now;
+        }
+        let time = new Date().getTime();
+        for (let i = 0; i < 1000; i++) {
+            vitest.setSystemTime(time++);
+            now = clock.now(1);
+            expect(now > prev, `${now} not later than ${prev}`).toBe(true);
+            clock.update(now);
+            prev = now;
+        }
+    });
+    it('groups blocks of time by version', () => {
+        const clock = new HybridLogicalClockTimestampProvider();
+        let prev = clock.now(1);
+        clock.update(prev);
+        let now;
+        for (let i = 0; i < 10; i++) {
+            now = clock.now(1);
+            expect(now > prev, `${now} not later than ${prev}`).toBe(true);
+            clock.update(now);
+            prev = now;
+        }
+        for (let i = 0; i < 10; i++) {
+            now = clock.now(2);
+            expect(now > prev, `${now} not later than ${prev}`).toBe(true);
+            clock.update(now);
+            prev = now;
+        }
+        const startOfVersion2 = now;
+        // jump back to 1
+        prev = clock.now(1);
+        clock.update(prev);
+        for (let i = 0; i < 10; i++) {
+            now = clock.now(1);
+            expect(now > prev, `${now} not later than ${prev}`).toBe(true);
+            expect(now < startOfVersion2, `${now} not earlier than ${startOfVersion2}`).toBe(true);
+            clock.update(now);
+            prev = now;
+        }
+    });
+    it('is shorter than the previous format', () => {
+        const clock = new HybridLogicalClockTimestampProvider();
+        expect(clock.now(1).length).toBeLessThan(clock.OLD_now(1).length);
+    });
+    it('correctly converts old to new format', () => {
+        const clock = new HybridLogicalClockTimestampProvider();
+        const oldFormat = clock.OLD_now(1);
+        const value = clock.timerState();
+        const converted = convertOldHlcTimestamp(oldFormat);
+        const newFormat = clock.get(1, value);
+        expect(converted).toEqual(newFormat);
+    });
+    // this is mostly to verify as I move to the new format.
+    // instead of attempting a distributed migration of timestamps, it
+    // will be easier that the new format just acts as always in the
+    // future of the old one. this will only mess with offline clients,
+    // but nobody is using verdant but me yet at time of this change (2022-12-19)
+    // which is kind of why I'm doing it now anyway.
+    it('old format always comes before new format', () => {
+        const clock = new HybridLogicalClockTimestampProvider();
+        const newFormat = clock.now(1);
+        const oldFormat = clock.OLD_now(1);
+        expect(oldFormat < newFormat).toBe(true);
+        // even far-future old timestamps are before new timestamps
+        const oldFormat2 = OLD_serializeHlcTimestamp({
+            counter: 999,
+            node: '9876543210',
+            time: new Date(3000, 1, 1).getTime(),
+        });
+        expect(OLD_encodeVersion(1) + oldFormat2 < newFormat).toBe(true);
+    });
+    it('decodes timestamps', () => {
+        const time = new Date();
+        vitest.setSystemTime(time);
+        const clock = new HybridLogicalClockTimestampProvider();
+        const now = clock.now(1);
+        expect(clock.getWallClockTime(now)).toEqual(time.getTime());
+    });
+});
+describe('version encoding', () => {
+    it('orders 1 before 2', () => {
+        expect(encodeVersion(1) < encodeVersion(2)).toBe(true);
+    });
+    it('orders 32 before 33', () => {
+        expect(encodeVersion(32) < encodeVersion(33)).toBe(true);
+    });
+    it('orders 34 before 35', () => {
+        expect(encodeVersion(34) < encodeVersion(35)).toBe(true);
+    });
+});
 //# sourceMappingURL=timestamp.test.js.map

package/dist/esm/undo.d.ts

@@ -1,3 +1,3 @@
-import { ObjectIdentifier } from './oids.js';
-import { Operation } from './operation.js';
-export declare function getUndoOperations(oid: ObjectIdentifier, initial: any, operations: Operation[], getNow: () => string): Operation[];
+import { ObjectIdentifier } from './oids.js';
+import { Operation } from './operation.js';
+export declare function getUndoOperations(oid: ObjectIdentifier, initial: any, operations: Operation[], getNow: () => string): Operation[];

package/dist/esm/undo.js

@@ -1,195 +1,195 @@
-import { applyPatch } from './operation.js';
-import { cloneDeep } from './utils.js';
-export function getUndoOperations(oid, initial, operations, getNow) {
-    if (initial === undefined) {
-        // if the initial state is nothing, then the undo is to delete everything.
-        // there's nothing else to worry about!
-        return [
-            {
-                oid,
-                timestamp: getNow(),
-                data: {
-                    op: 'delete',
-                },
-            },
-        ];
-    }
-    // otherwise, traverse the operations one by one,
-    // applying them, and using the prior state to determine
-    // what the undo operation is.
-    let state = cloneDeep(initial);
-    const undoOperations = [];
-    for (const operation of operations) {
-        const undo = getUndoOperation(oid, state, operation, getNow);
-        undoOperations.unshift(...undo);
-        applyPatch(state, operation.data);
-    }
-    return undoOperations;
-}
-function getUndoOperation(oid, initial, operation, getNow) {
-    const data = operation.data;
-    switch (data.op) {
-        case 'set':
-        case 'remove':
-            return [
-                {
-                    oid,
-                    timestamp: getNow(),
-                    data: {
-                        op: 'set',
-                        name: data.name,
-                        value: initial[data.name],
-                    },
-                },
-            ];
-        case 'list-insert':
-            return [
-                {
-                    oid,
-                    timestamp: getNow(),
-                    data: {
-                        op: 'list-delete',
-                        index: data.index,
-                        count: 1,
-                    },
-                },
-            ];
-        case 'list-delete':
-            return [
-                {
-                    oid,
-                    timestamp: getNow(),
-                    data: {
-                        op: 'list-insert',
-                        index: data.index,
-                        values: initial.slice(data.index, data.count),
-                    },
-                },
-            ];
-        case 'list-move-by-ref':
-            return [
-                {
-                    oid,
-                    timestamp: getNow(),
-                    data: {
-                        op: 'list-move-by-ref',
-                        value: data.value,
-                        index: initial.indexOf(data.value),
-                    },
-                },
-            ];
-        case 'list-move-by-index':
-            return [
-                {
-                    oid,
-                    timestamp: getNow(),
-                    data: {
-                        op: 'list-move-by-index',
-                        from: data.to,
-                        to: data.from,
-                    },
-                },
-            ];
-        case 'delete':
-            return [
-                {
-                    oid,
-                    timestamp: getNow(),
-                    data: {
-                        op: 'initialize',
-                        value: initial,
-                    },
-                },
-            ];
-        case 'list-push':
-            return [
-                {
-                    oid,
-                    timestamp: getNow(),
-                    data: {
-                        op: 'list-remove',
-                        value: data.value,
-                        // best heuristic here - remove the last instance of the item.
-                        only: 'last',
-                    },
-                },
-            ];
-        case 'list-remove':
-            if (data.only === 'last') {
-                const index = initial.lastIndexOf(data.value);
-                return [
-                    {
-                        oid,
-                        timestamp: getNow(),
-                        data: {
-                            op: 'list-insert',
-                            index,
-                            values: [data.value],
-                        },
-                    },
-                ];
-            }
-            else if (data.only === 'first') {
-                const index = initial.indexOf(data.value);
-                return [
-                    {
-                        oid,
-                        timestamp: getNow(),
-                        data: {
-                            op: 'list-insert',
-                            index,
-                            values: [data.value],
-                        },
-                    },
-                ];
-            }
-            else {
-                // find all instances of value and restore them at their
-                // original index
-                const indexesOfValue = [];
-                let index = initial.indexOf(data.value);
-                while (index !== -1) {
-                    indexesOfValue.push(index);
-                    index = initial.indexOf(data.value, index + 1);
-                }
-                return indexesOfValue.map((index) => ({
-                    oid,
-                    timestamp: getNow(),
-                    data: {
-                        op: 'list-insert',
-                        index,
-                        value: data.value,
-                    },
-                }));
-            }
-        case 'list-add':
-            // this one is kind of ambiguous. in theory the set may have
-            // already included the value and so no change happened. but
-            // basically we infer the intent is to remove what was meant
-            // to be added by this change.
-            return [
-                {
-                    oid,
-                    timestamp: getNow(),
-                    data: {
-                        op: 'list-remove',
-                        value: data.value,
-                        only: 'last',
-                    },
-                },
-            ];
-        case 'initialize':
-            return [
-                {
-                    oid,
-                    timestamp: getNow(),
-                    data: {
-                        op: 'delete',
-                    },
-                },
-            ];
-        default:
-            throw new Error(`Cannot undo operation type: ${data.op}`);
-    }
-}
+import { applyPatch } from './operation.js';
+import { cloneDeep } from './utils.js';
+export function getUndoOperations(oid, initial, operations, getNow) {
+    if (initial === undefined) {
+        // if the initial state is nothing, then the undo is to delete everything.
+        // there's nothing else to worry about!
+        return [
+            {
+                oid,
+                timestamp: getNow(),
+                data: {
+                    op: 'delete',
+                },
+            },
+        ];
+    }
+    // otherwise, traverse the operations one by one,
+    // applying them, and using the prior state to determine
+    // what the undo operation is.
+    let state = cloneDeep(initial);
+    const undoOperations = [];
+    for (const operation of operations) {
+        const undo = getUndoOperation(oid, state, operation, getNow);
+        undoOperations.unshift(...undo);
+        applyPatch(state, operation.data);
+    }
+    return undoOperations;
+}
+function getUndoOperation(oid, initial, operation, getNow) {
+    const data = operation.data;
+    switch (data.op) {
+        case 'set':
+        case 'remove':
+            return [
+                {
+                    oid,
+                    timestamp: getNow(),
+                    data: {
+                        op: 'set',
+                        name: data.name,
+                        value: initial[data.name],
+                    },
+                },
+            ];
+        case 'list-insert':
+            return [
+                {
+                    oid,
+                    timestamp: getNow(),
+                    data: {
+                        op: 'list-delete',
+                        index: data.index,
+                        count: 1,
+                    },
+                },
+            ];
+        case 'list-delete':
+            return [
+                {
+                    oid,
+                    timestamp: getNow(),
+                    data: {
+                        op: 'list-insert',
+                        index: data.index,
+                        values: initial.slice(data.index, data.count),
+                    },
+                },
+            ];
+        case 'list-move-by-ref':
+            return [
+                {
+                    oid,
+                    timestamp: getNow(),
+                    data: {
+                        op: 'list-move-by-ref',
+                        value: data.value,
+                        index: initial.indexOf(data.value),
+                    },
+                },
+            ];
+        case 'list-move-by-index':
+            return [
+                {
+                    oid,
+                    timestamp: getNow(),
+                    data: {
+                        op: 'list-move-by-index',
+                        from: data.to,
+                        to: data.from,
+                    },
+                },
+            ];
+        case 'delete':
+            return [
+                {
+                    oid,
+                    timestamp: getNow(),
+                    data: {
+                        op: 'initialize',
+                        value: initial,
+                    },
+                },
+            ];
+        case 'list-push':
+            return [
+                {
+                    oid,
+                    timestamp: getNow(),
+                    data: {
+                        op: 'list-remove',
+                        value: data.value,
+                        // best heuristic here - remove the last instance of the item.
+                        only: 'last',
+                    },
+                },
+            ];
+        case 'list-remove':
+            if (data.only === 'last') {
+                const index = initial.lastIndexOf(data.value);
+                return [
+                    {
+                        oid,
+                        timestamp: getNow(),
+                        data: {
+                            op: 'list-insert',
+                            index,
+                            values: [data.value],
+                        },
+                    },
+                ];
+            }
+            else if (data.only === 'first') {
+                const index = initial.indexOf(data.value);
+                return [
+                    {
+                        oid,
+                        timestamp: getNow(),
+                        data: {
+                            op: 'list-insert',
+                            index,
+                            values: [data.value],
+                        },
+                    },
+                ];
+            }
+            else {
+                // find all instances of value and restore them at their
+                // original index
+                const indexesOfValue = [];
+                let index = initial.indexOf(data.value);
+                while (index !== -1) {
+                    indexesOfValue.push(index);
+                    index = initial.indexOf(data.value, index + 1);
+                }
+                return indexesOfValue.map((index) => ({
+                    oid,
+                    timestamp: getNow(),
+                    data: {
+                        op: 'list-insert',
+                        index,
+                        value: data.value,
+                    },
+                }));
+            }
+        case 'list-add':
+            // this one is kind of ambiguous. in theory the set may have
+            // already included the value and so no change happened. but
+            // basically we infer the intent is to remove what was meant
+            // to be added by this change.
+            return [
+                {
+                    oid,
+                    timestamp: getNow(),
+                    data: {
+                        op: 'list-remove',
+                        value: data.value,
+                        only: 'last',
+                    },
+                },
+            ];
+        case 'initialize':
+            return [
+                {
+                    oid,
+                    timestamp: getNow(),
+                    data: {
+                        op: 'delete',
+                    },
+                },
+            ];
+        default:
+            throw new Error(`Cannot undo operation type: ${data.op}`);
+    }
+}
 //# sourceMappingURL=undo.js.map

package/dist/esm/utils.d.ts

@@ -1,20 +1,20 @@
-export declare function take<T extends object, Keys extends keyof T>(obj: T, keys: Keys[]): Pick<T, Keys>;
-export declare function omit<T extends object, Keys extends keyof T>(obj: T, keys: Keys[]): Omit<T, Keys>;
-export declare function getSortedIndex<T>(array: T[], insert: T, compare: (a: T, b: T) => number): number;
-/**
- * Consistently stringifies an object regardless
- * of key insertion order
- */
-export declare function stableStringify(obj: any): string;
-/**
- * A version of structured cloning which preserves object identity
- * references in the system.
- */
-export declare function cloneDeep<T>(obj: T, copyOids?: boolean): T;
-export declare function hashObject(obj: any): string;
-export declare function isObject(obj: any): any;
-export declare function roughSizeOfObject(object: any): number;
-export declare function assert(condition: any, message?: string): asserts condition;
-export declare function generateId(length?: number): string;
-export declare function findLastIndex<T>(array: T[], predicate: (item: T) => boolean): number;
-export declare function debounce<T extends (...args: any[]) => any>(fn: T, wait: number): T;
+export declare function take<T extends object, Keys extends keyof T>(obj: T, keys: Keys[]): Pick<T, Keys>;
+export declare function omit<T extends object, Keys extends keyof T>(obj: T, keys: Keys[]): Omit<T, Keys>;
+export declare function getSortedIndex<T>(array: T[], insert: T, compare: (a: T, b: T) => number): number;
+/**
+ * Consistently stringifies an object regardless
+ * of key insertion order
+ */
+export declare function stableStringify(obj: any): string;
+/**
+ * A version of structured cloning which preserves object identity
+ * references in the system.
+ */
+export declare function cloneDeep<T>(obj: T, copyOids?: boolean): T;
+export declare function hashObject(obj: any): string;
+export declare function isObject(obj: any): any;
+export declare function roughSizeOfObject(object: any): number;
+export declare function assert(condition: any, message?: string): asserts condition;
+export declare function generateId(length?: number): string;
+export declare function findLastIndex<T>(array: T[], predicate: (item: T) => boolean): number;
+export declare function debounce<T extends (...args: any[]) => any>(fn: T, wait: number): T;