@verdant-web/common 1.11.0

package/dist/cjs/oids.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"oids.test.js","sourceRoot":"","sources":["../../src/oids.test.ts"],"names":[],"mappings":"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"}

package/dist/cjs/operation.d.ts

@@ -0,0 +1,139 @@
+import { DocumentBaseline } from './baseline.js';
+import { FileRef } from './files.js';
+import { KeyPath, ObjectIdentifier } from './oids.js';
+export declare type ObjectRef = {
+    '@@type': 'ref';
+    id: ObjectIdentifier;
+};
+export declare function isObjectRef(obj: any): obj is ObjectRef;
+export declare type Normalized<T> = {
+    [key in keyof T]: T[key] extends Object ? ObjectRef : T[key];
+};
+export declare type PropertyName = string | number;
+/**
+ * List patches can target a particular child list or
+ * nested lists. The first path item is the property path
+ * of the first child list, any subsequent values are nested
+ * list indices.
+ */
+export declare type PropertyValue = string | number | boolean | null | undefined | ObjectRef;
+interface BaseOperationPatch {
+}
+export interface OperationPatchInitialize extends BaseOperationPatch {
+    op: 'initialize';
+    value: any;
+}
+export interface OperationPatchSet extends BaseOperationPatch {
+    op: 'set';
+    name: PropertyName;
+    value: PropertyValue;
+}
+export interface OperationPatchRemove extends BaseOperationPatch {
+    op: 'remove';
+    name: PropertyName;
+}
+export interface OperationPatchListPush extends BaseOperationPatch {
+    op: 'list-push';
+    value: PropertyValue;
+}
+export interface OperationPatchListInsert extends BaseOperationPatch {
+    op: 'list-insert';
+    index: number;
+    value?: PropertyValue;
+    values?: PropertyValue[];
+}
+export interface OperationPatchListDelete extends BaseOperationPatch {
+    op: 'list-delete';
+    index: number;
+    count: number;
+}
+/**
+ * Optimal for lists of object references. Moves
+ * the selected item to the target index even if it
+ * is not at the original index anymore.
+ */
+export interface OperationPatchListMoveByRef extends BaseOperationPatch {
+    op: 'list-move-by-ref';
+    value: ObjectRef;
+    index: number;
+}
+/**
+ * Suitable for any list move, whether object lists
+ * or primitive lists.
+ */
+export interface OperationPatchListMoveByIndex extends BaseOperationPatch {
+    op: 'list-move-by-index';
+    from: number;
+    to: number;
+}
+/**
+ * Removes all instances of the value from
+ * the list. Good for set behavior or removing
+ * a specific item even if it changes index
+ * from conflicts.
+ */
+export interface OperationPatchListRemove extends BaseOperationPatch {
+    op: 'list-remove';
+    value: PropertyValue;
+    only?: 'first' | 'last';
+}
+export interface OperationPatchListAdd extends BaseOperationPatch {
+    op: 'list-add';
+    value: PropertyValue;
+}
+export interface OperationPatchDelete extends BaseOperationPatch {
+    op: 'delete';
+}
+export declare type OperationPatch = OperationPatchInitialize | OperationPatchSet | OperationPatchRemove | OperationPatchListPush | OperationPatchListInsert | OperationPatchListDelete | OperationPatchListMoveByRef | OperationPatchListMoveByIndex | OperationPatchListRemove | OperationPatchDelete | OperationPatchListAdd;
+export declare type Operation = {
+    oid: ObjectIdentifier;
+    timestamp: string;
+    data: OperationPatch;
+};
+export declare function diffToPatches<T extends {
+    [key: string]: any;
+} | any[]>(from: T, to: T, getNow: () => string, keyPath: KeyPath, createSubId?: () => string, patches?: Operation[], options?: {
+    /**
+     * If an object is merged with another and the new one does not
+     * have an OID assigned, assume it is the same identity as previous
+     */
+    mergeUnknownObjects?: boolean;
+    /**
+     * If an incoming value is not assigned on the new object, use the previous value.
+     * If false, undefined properties will erase the previous value.
+     */
+    defaultUndefined?: boolean;
+}): Operation[];
+export declare function shallowDiffToPatches(from: any, to: any, getNow: () => string, patches?: Operation[]): Operation[];
+/**
+ * Takes a basic object and constructs a patch list to create it and
+ * all of its nested objects.
+ */
+export declare function initialToPatches(initial: any, rootOid: ObjectIdentifier, getNow: () => string, createSubId?: () => string, patches?: Operation[]): Operation[];
+export declare function shallowInitialToPatches(initial: any, rootOid: ObjectIdentifier, getNow: () => string, patches?: Operation[]): Operation[];
+export declare function groupPatchesByIdentifier(patches: Operation[]): Record<string, Operation[]>;
+export declare function groupPatchesByRootOid(patches: Operation[]): Record<string, Operation[]>;
+export declare function groupBaselinesByRootOid(baselines: DocumentBaseline[]): Record<string, DocumentBaseline<any>[]>;
+export declare type NormalizedObject = {
+    [key: PropertyName]: PropertyValue;
+} | Array<PropertyValue>;
+/**
+ * The incoming object should already be normalized!
+ * This function will mutate the base object.
+ */
+export declare function applyPatch<T extends NormalizedObject>(base: T | undefined, patch: OperationPatch, 
+/**
+ * Optionally supply a list to which any refs which
+ * are removed during the patch will be appended.
+ */
+deletedRefs?: (FileRef | ObjectRef)[]): T | undefined;
+export declare function applyOperations<T extends NormalizedObject>(base: T | undefined, operations: Operation[], deletedRefs?: (ObjectRef | FileRef)[]): T | undefined;
+/**
+ * Mutates the original object in place. Returns all referenced
+ * objects oids.
+ */
+export declare function substituteRefsWithObjects(base: any, refs: Map<ObjectIdentifier, any>, used?: ObjectIdentifier[]): ObjectIdentifier[];
+export declare function substituteFirstLevelObjectsWithRefs<Base extends {
+    [key: string]: any;
+} | any[]>(base: Base, refObjects?: Map<ObjectIdentifier, any>): Map<ObjectIdentifier, any>;
+export {};

package/dist/cjs/operation.js

@@ -0,0 +1,533 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.substituteFirstLevelObjectsWithRefs = exports.substituteRefsWithObjects = exports.applyOperations = exports.applyPatch = exports.groupBaselinesByRootOid = exports.groupPatchesByRootOid = exports.groupPatchesByIdentifier = exports.shallowInitialToPatches = exports.initialToPatches = exports.shallowDiffToPatches = exports.diffToPatches = exports.isObjectRef = void 0;
+const oids_js_1 = require("./oids.js");
+const refs_js_1 = require("./refs.js");
+const utils_js_1 = require("./utils.js");
+function isObjectRef(obj) {
+    return obj && typeof obj === 'object' && obj['@@type'] === 'ref';
+}
+exports.isObjectRef = isObjectRef;
+function isDiffableObject(val) {
+    return (0, utils_js_1.isObject)(val) && !(0, refs_js_1.isRef)(val);
+}
+function compareNonDiffable(a, b) {
+    if (a === b)
+        return true;
+    if ((0, refs_js_1.isRef)(a) && (0, refs_js_1.isRef)(b))
+        return (0, refs_js_1.compareRefs)(a, b);
+    return false;
+}
+function diffToPatches(from, to, getNow, keyPath, createSubId, patches = [], options = {}) {
+    const oid = (0, oids_js_1.getOid)(from);
+    function diffItems(key, value, oldValue) {
+        if (!isDiffableObject(value)) {
+            // for primitive fields, we can use plain sets and
+            // do not need to recurse, of course
+            if (!compareNonDiffable(value, oldValue)) {
+                patches.push({
+                    oid,
+                    timestamp: getNow(),
+                    data: {
+                        op: 'set',
+                        name: key,
+                        value,
+                    },
+                });
+            }
+        }
+        else {
+            const oldValueOid = (0, oids_js_1.maybeGetOid)(oldValue);
+            let valueOid;
+            if (!options.mergeUnknownObjects) {
+                valueOid = (0, oids_js_1.ensureOid)(value, oid, key, createSubId);
+            }
+            else {
+                // if merge unknown objects is requested, we copy the previous value's oid
+                // to any mirrored new value if it doesn't have one assigned already.
+                valueOid = (0, oids_js_1.maybeGetOid)(value);
+                if (!valueOid && oldValueOid) {
+                    (0, oids_js_1.assignOid)(value, oldValueOid);
+                    valueOid = oldValueOid;
+                }
+                else {
+                    valueOid = (0, oids_js_1.ensureOid)(value, oid, key, createSubId);
+                }
+            }
+            if (oldValue === undefined || valueOid !== oldValueOid) {
+                // first case: previous value exists but the OIDs are different,
+                // meaning the object identity has changed
+                // we add the whole new object and also update the reference on this
+                // key of the parent to point to the new object
+                initialToPatches(value, valueOid, getNow, createSubId, patches);
+                patches.push({
+                    oid,
+                    timestamp: getNow(),
+                    data: {
+                        op: 'set',
+                        name: key,
+                        value: (0, oids_js_1.createRef)(valueOid),
+                    },
+                });
+                // if there was an old value, we need to delete it altogether.
+                if (oldValueOid !== undefined) {
+                    patches.push({
+                        oid: oldValueOid,
+                        timestamp: getNow(),
+                        data: {
+                            op: 'delete',
+                        },
+                    });
+                }
+            }
+            else {
+                // third case: OIDs are the same, meaning the identity is the same,
+                // and we must diff the objects
+                diffToPatches(oldValue, value, getNow, [...keyPath, key], createSubId, patches, options);
+            }
+        }
+    }
+    if (Array.isArray(from) && Array.isArray(to)) {
+        // diffing is more naive than native array operations.
+        // we can only look at each element and decide if it should
+        // be replaced or removed - no moves or pushes, etc.
+        for (let i = 0; i < to.length; i++) {
+            const value = to[i];
+            const oldValue = from[i];
+            diffItems(i, value, oldValue);
+        }
+        // remove any remaining items at the end of the array
+        const deletedItemsAtEnd = from.length - to.length;
+        if (deletedItemsAtEnd > 0) {
+            // if sub-items were objects, we need to delete them all
+            for (let i = to.length; i < from.length; i++) {
+                const value = from[i];
+                const valueOid = (0, oids_js_1.maybeGetOid)(value);
+                if (valueOid) {
+                    patches.push({
+                        oid: valueOid,
+                        timestamp: getNow(),
+                        data: {
+                            op: 'delete',
+                        },
+                    });
+                }
+            }
+            // push the list-delete for the deleted items
+            patches.push({
+                oid,
+                timestamp: getNow(),
+                data: {
+                    op: 'list-delete',
+                    index: to.length,
+                    count: deletedItemsAtEnd,
+                },
+            });
+        }
+    }
+    else if (Array.isArray(from) || Array.isArray(to)) {
+        throw new Error('Cannot diff an array with an object');
+    }
+    else if (isDiffableObject(from) && isDiffableObject(to)) {
+        const oldKeys = new Set(Object.keys(from));
+        for (const [key, value] of Object.entries(to)) {
+            if (value === undefined && options.defaultUndefined)
+                continue;
+            oldKeys.delete(key);
+            if ((0, oids_js_1.isOidKey)(key))
+                continue;
+            const oldValue = from[key];
+            diffItems(key, value, oldValue);
+        }
+        // this set now only contains keys which were not in the new object
+        if (!options.defaultUndefined) {
+            for (const key of oldKeys) {
+                if ((0, oids_js_1.isOidKey)(key))
+                    continue;
+                // push the delete for the property
+                patches.push({
+                    oid,
+                    timestamp: getNow(),
+                    data: {
+                        op: 'remove',
+                        name: key,
+                    },
+                });
+            }
+        }
+    }
+    return patches;
+}
+exports.diffToPatches = diffToPatches;
+function shallowDiffToPatches(from, to, getNow, patches = []) {
+    const oid = (0, oids_js_1.getOid)(from);
+    function diffItems(key, value, oldValue) {
+        if (!isDiffableObject(value)) {
+            // for primitive fields, we can use plain sets and
+            // do not need to recurse, of course
+            if (!compareNonDiffable(value, oldValue)) {
+                patches.push({
+                    oid,
+                    timestamp: getNow(),
+                    data: {
+                        op: 'set',
+                        name: key,
+                        value,
+                    },
+                });
+            }
+        }
+        else {
+            throw new Error('Shallow diff was given a nested object. This is an error in verdant!');
+        }
+    }
+    if (Array.isArray(from) && Array.isArray(to)) {
+        // diffing is more naive than native array operations.
+        // we can only look at each element and decide if it should
+        // be replaced or removed - no moves or pushes, etc.
+        for (let i = 0; i < to.length; i++) {
+            const value = to[i];
+            const oldValue = from[i];
+            diffItems(i, value, oldValue);
+        }
+        // remove any remaining items at the end of the array
+        const deletedItemsAtEnd = from.length - to.length;
+        if (deletedItemsAtEnd > 0) {
+            // push the list-delete for the deleted items
+            patches.push({
+                oid,
+                timestamp: getNow(),
+                data: {
+                    op: 'list-delete',
+                    index: to.length,
+                    count: deletedItemsAtEnd,
+                },
+            });
+        }
+    }
+    else if (Array.isArray(from) || Array.isArray(to)) {
+        throw new Error('Cannot diff an array with an object');
+    }
+    else if (isDiffableObject(from) && isDiffableObject(to)) {
+        const oldKeys = new Set(Object.keys(from));
+        for (const [key, value] of Object.entries(to)) {
+            oldKeys.delete(key);
+            if ((0, oids_js_1.isOidKey)(key))
+                continue;
+            const oldValue = from[key];
+            diffItems(key, value, oldValue);
+        }
+        // this set now only contains keys which were not in the new object
+        for (const key of oldKeys) {
+            if ((0, oids_js_1.isOidKey)(key))
+                continue;
+            // push the delete for the property
+            patches.push({
+                oid,
+                timestamp: getNow(),
+                data: {
+                    op: 'remove',
+                    name: key,
+                },
+            });
+        }
+    }
+    return patches;
+}
+exports.shallowDiffToPatches = shallowDiffToPatches;
+/**
+ * Takes a basic object and constructs a patch list to create it and
+ * all of its nested objects.
+ */
+function initialToPatches(initial, rootOid, getNow, createSubId, patches = []) {
+    (0, oids_js_1.assignOid)(initial, rootOid);
+    (0, oids_js_1.assignOidsToAllSubObjects)(initial, createSubId);
+    const normalized = (0, oids_js_1.normalize)(initial);
+    for (const key of normalized.keys()) {
+        const value = normalized.get(key);
+        patches.push({
+            oid: key,
+            timestamp: getNow(),
+            data: {
+                op: 'initialize',
+                value: (0, oids_js_1.removeOid)(value),
+            },
+        });
+    }
+    return patches;
+}
+exports.initialToPatches = initialToPatches;
+function shallowInitialToPatches(initial, rootOid, getNow, patches = []) {
+    patches.push({
+        oid: rootOid,
+        timestamp: getNow(),
+        data: {
+            op: 'initialize',
+            value: initial,
+        },
+    });
+    return patches;
+}
+exports.shallowInitialToPatches = shallowInitialToPatches;
+function groupPatchesByIdentifier(patches) {
+    const grouped = {};
+    for (const patch of patches) {
+        if (patch.oid in grouped) {
+            grouped[patch.oid].push(patch);
+        }
+        else {
+            grouped[patch.oid] = [patch];
+        }
+    }
+    return grouped;
+}
+exports.groupPatchesByIdentifier = groupPatchesByIdentifier;
+function groupPatchesByRootOid(patches) {
+    const grouped = {};
+    for (const patch of patches) {
+        const root = (0, oids_js_1.getOidRoot)(patch.oid);
+        if (root in grouped) {
+            grouped[root].push(patch);
+        }
+        else {
+            grouped[root] = [patch];
+        }
+    }
+    return grouped;
+}
+exports.groupPatchesByRootOid = groupPatchesByRootOid;
+function groupBaselinesByRootOid(baselines) {
+    const grouped = {};
+    for (const patch of baselines) {
+        const root = (0, oids_js_1.getOidRoot)(patch.oid);
+        if (root in grouped) {
+            grouped[root].push(patch);
+        }
+        else {
+            grouped[root] = [patch];
+        }
+    }
+    return grouped;
+}
+exports.groupBaselinesByRootOid = groupBaselinesByRootOid;
+function listCheck(obj) {
+    if (!Array.isArray(obj)) {
+        console.error(`Cannot apply list patch; expected array, received ${JSON.stringify(obj)}. This suggests your data is changing from a list to an object over time. (OID: ${(0, oids_js_1.maybeGetOid)(obj)})`);
+        return false;
+    }
+    else {
+        return true;
+    }
+}
+/**
+ * The incoming object should already be normalized!
+ * This function will mutate the base object.
+ */
+function applyPatch(base, patch, 
+/**
+ * Optionally supply a list to which any refs which
+ * are removed during the patch will be appended.
+ */
+deletedRefs) {
+    // deleted objects are represented by undefined
+    // and remain deleted unless re-initialized
+    if ((base === undefined || base === null) && patch.op !== 'initialize') {
+        return base;
+    }
+    // ditch typing internally.
+    const baseAsAny = base;
+    let index;
+    let spliceResult;
+    // a helper, pass it a value which is about
+    // to be removed and it will append it to the list
+    // if it was a ref
+    function checkRef(field) {
+        // don't bother if not supplied
+        if (!deletedRefs)
+            return;
+        if ((0, refs_js_1.isRef)(field)) {
+            deletedRefs.push(field);
+        }
+    }
+    switch (patch.op) {
+        case 'set':
+            checkRef(baseAsAny[patch.name]);
+            baseAsAny[patch.name] = patch.value;
+            break;
+        case 'remove':
+            checkRef(baseAsAny[patch.name]);
+            delete baseAsAny[patch.name];
+            break;
+        case 'list-push':
+            if (listCheck(base)) {
+                base.push(patch.value);
+            }
+            break;
+        case 'list-delete':
+            if (listCheck(base)) {
+                checkRef(base[patch.index]);
+                base.splice(patch.index, patch.count);
+            }
+            break;
+        case 'list-move-by-index':
+            if (listCheck(base)) {
+                spliceResult = base.splice(patch.from, 1);
+                base.splice(patch.to, 0, spliceResult[0]);
+            }
+            break;
+        case 'list-remove':
+            if (listCheck(base)) {
+                do {
+                    const valueToRemove = patch.value;
+                    if (patch.only === 'last') {
+                        if (isObjectRef(valueToRemove)) {
+                            index = (0, utils_js_1.findLastIndex)(base, (item) => item.id === valueToRemove.id);
+                        }
+                        else {
+                            index = base.lastIndexOf(valueToRemove);
+                        }
+                    }
+                    else {
+                        if (isObjectRef(valueToRemove)) {
+                            index = base.findIndex((item) => item.id === valueToRemove.id);
+                        }
+                        else {
+                            index = base.indexOf(valueToRemove);
+                        }
+                    }
+                    if (index !== -1) {
+                        checkRef(base[index]);
+                        base.splice(index, 1);
+                    }
+                } while (!patch.only && index !== -1);
+            }
+            break;
+        case 'list-add':
+            if (listCheck(base)) {
+                const alreadyHas = base.some((item) => {
+                    if (isObjectRef(item) && isObjectRef(patch.value)) {
+                        return item.id === patch.value.id;
+                    }
+                    else {
+                        return item === patch.value;
+                    }
+                });
+                if (!alreadyHas) {
+                    base.push(patch.value);
+                }
+            }
+            break;
+        case 'list-move-by-ref':
+            if (listCheck(base)) {
+                index = base.indexOf(patch.value);
+                spliceResult = base.splice(index, 1);
+                base.splice(patch.index, 0, spliceResult[0]);
+            }
+            break;
+        case 'list-insert':
+            if (listCheck(base)) {
+                if (!patch.value && !patch.values) {
+                    throw new Error(`Cannot apply list insert patch; expected value or values, received ${JSON.stringify(patch)}`);
+                }
+                if (patch.value) {
+                    base.splice(patch.index, 0, patch.value);
+                }
+                else {
+                    base.splice(patch.index, 0, ...patch.values);
+                }
+            }
+            break;
+        case 'delete':
+            // collect all refs that are deleted
+            if (Array.isArray(base)) {
+                base.forEach(checkRef);
+            }
+            else if ((0, utils_js_1.isObject)(base)) {
+                Object.values(base || {}).forEach(checkRef);
+            }
+            return undefined;
+        case 'initialize':
+            return (0, utils_js_1.cloneDeep)(patch.value);
+        default:
+            throw new Error(`Unsupported patch operation: ${patch.op}`);
+    }
+    return base;
+}
+exports.applyPatch = applyPatch;
+function applyOperations(base, operations, deletedRefs) {
+    let cur = base;
+    for (const op of operations) {
+        cur = applyPatch(cur, op.data, deletedRefs);
+    }
+    return cur;
+}
+exports.applyOperations = applyOperations;
+/**
+ * Mutates the original object in place. Returns all referenced
+ * objects oids.
+ */
+function substituteRefsWithObjects(base, refs, used = []) {
+    if (Array.isArray(base)) {
+        for (let i = 0; i < base.length; i++) {
+            const item = base[i];
+            base[i] = dereference(item, refs, used);
+            if ((0, utils_js_1.isObject)(base[i])) {
+                substituteRefsWithObjects(base[i], refs, used);
+            }
+        }
+    }
+    else if ((0, utils_js_1.isObject)(base)) {
+        // not sure where to put this assertion but it's important to make
+        // sure all nested objects include an OID
+        (0, utils_js_1.assert)((0, oids_js_1.maybeGetOid)(base), `Object ${JSON.stringify(base)} must have an oid`);
+        for (const key of Object.keys(base)) {
+            base[key] = dereference(base[key], refs, used);
+            // now that objects are in place, recursively substitute
+            if ((0, utils_js_1.isObject)(base[key])) {
+                substituteRefsWithObjects(base[key], refs, used);
+            }
+        }
+    }
+    return used;
+}
+exports.substituteRefsWithObjects = substituteRefsWithObjects;
+function dereference(input, refs, used) {
+    if (isObjectRef(input)) {
+        used.push(input.id);
+        const resolved = refs.get(input.id);
+        (0, utils_js_1.assert)(!!resolved, `No value was found in object map for ${input.id}`);
+        return (0, oids_js_1.assignOid)(resolved, input.id);
+    }
+    else {
+        return input;
+    }
+}
+function substituteFirstLevelObjectsWithRefs(base, refObjects = new Map()) {
+    if (Array.isArray(base)) {
+        for (let i = 0; i < base.length; i++) {
+            const item = base[i];
+            if ((0, utils_js_1.isObject)(item)) {
+                const oid = (0, oids_js_1.getOid)(item);
+                base[i] = {
+                    '@@type': 'ref',
+                    id: oid,
+                };
+                refObjects.set(oid, item);
+            }
+        }
+    }
+    else {
+        for (const [key, value] of Object.entries(base)) {
+            if ((0, utils_js_1.isObject)(value)) {
+                base[key] = {
+                    '@@type': 'ref',
+                    id: (0, oids_js_1.getOid)(value),
+                };
+                refObjects.set((0, oids_js_1.getOid)(value), value);
+            }
+        }
+    }
+    return refObjects;
+}
+exports.substituteFirstLevelObjectsWithRefs = substituteFirstLevelObjectsWithRefs;
+//# sourceMappingURL=operation.js.map