@graffy/common 0.19.0 → 0.19.1-alpha.2

package/node/types.js

@@ -0,0 +1,18 @@
+export function isRange(node) {
+    return node && typeof node.end !== 'undefined';
+}
+export function isBranch(node) {
+    return node && typeof node.children !== 'undefined';
+}
+export function isPrefix(node) {
+    return node?.prefix;
+}
+export function isLink(node) {
+    return node && typeof node.path !== 'undefined';
+}
+export function isOlder(node, version) {
+    return typeof node.version !== 'undefined' && node.version < version;
+}
+export function isNewer(node, version) {
+    return typeof node.version !== 'undefined' && node.version > version;
+}

package/object.d.ts

@@ -0,0 +1,4 @@
+export declare function mergeObject(base: any, change: any): any;
+export declare function cloneObject(object: any): any;
+export declare function wrapObject(object: any, path: any): any;
+export declare function unwrapObject(object: any, path: any): any;

package/object.js

@@ -0,0 +1,86 @@
+import isEqual from 'lodash/isEqual.js';
+import { splitArgs } from "./coding/index.js";
+import { isEmpty } from "./util.js";
+export function mergeObject(base, change) {
+    if (typeof change !== 'object' ||
+        typeof base !== 'object' ||
+        !base ||
+        !change) {
+        return change;
+    }
+    for (const prop in change) {
+        if (prop in base) {
+            const value = mergeObject(base[prop], change[prop]);
+            if (value === null) {
+                delete base[prop];
+            }
+            else {
+                base[prop] = value;
+            }
+        }
+        else {
+            base[prop] = change[prop];
+        }
+    }
+    return isEmpty(base) ? null : base;
+}
+export function cloneObject(object) {
+    if (typeof object !== 'object' || !object) {
+        return object;
+    }
+    const clone = {};
+    for (const prop in object) {
+        const value = cloneObject(object[prop]);
+        if (value === null)
+            continue;
+        clone[prop] = value;
+    }
+    return isEmpty(clone) ? null : clone;
+}
+export function wrapObject(object, path) {
+    if (!Array.isArray(path))
+        throw Error(`wrapObject.path_not_array ${path}`);
+    for (let i = path.length - 1; i >= 0; i--) {
+        const $key = path[i];
+        if (typeof $key === 'string') {
+            object = { [$key]: object };
+        }
+        else if (Array.isArray(object)) {
+            object = [{ $key, $chi: object }];
+        }
+        else {
+            object = [{ $key, ...object }];
+        }
+    }
+    return object;
+}
+export function unwrapObject(object, path) {
+    if (!Array.isArray(path))
+        throw Error(`unwrapObject.path_not_array ${path}`);
+    for (let i = 0; i < path.length; i++) {
+        if (!object || typeof object !== 'object')
+            return;
+        const $key = path[i];
+        if (typeof $key === 'string') {
+            if (Array.isArray(object)) {
+                throw Error(`unwrapObject.string_key_array:${$key}`);
+            }
+            object = object[$key];
+        }
+        else {
+            if (!Array.isArray(object)) {
+                throw Error(`unwrapObject.arg_key_object:${JSON.stringify($key)}`);
+            }
+            const [page, filter] = splitArgs($key);
+            if (page && !page.$cursor) {
+                // TODO: Return a slice of this array
+                return object;
+            }
+            const target = page?.$cursor
+                ? { ...filter, $cursor: page.$cursor }
+                : filter;
+            object = object.find(({ $key }) => isEqual($key, target));
+        }
+    }
+    return object;
+}

package/ops/add.js

@@ -0,0 +1,64 @@
+import { isBranch } from "../node/index.js";
+import { cmp as compareKey, find } from "../util.js";
+export default function add(base, diff) {
+    let changed = false;
+    // console.log('Add', diff);
+    // console.log('before add', base);
+    let index = 0;
+    for (const node of diff) {
+        const cmp = compare(node);
+        const nodeIsBranch = isBranch(node);
+        index = find(base, cmp, index);
+        const item = base[index];
+        const itemIsBranch = isBranch(item);
+        if (!item || cmp(item)) {
+            // This node doesn't exist in the base, insert it.
+            base.splice(index, 0, clone(node));
+            changed = true;
+            continue;
+        }
+        if (nodeIsBranch && itemIsBranch) {
+            changed = add(item.children, node.children) || changed;
+        }
+        else if (nodeIsBranch) {
+            continue;
+        }
+        else if (itemIsBranch) {
+            item.value = node.value;
+            changed = true;
+        }
+        else {
+            item.value += node.value;
+        }
+        // If this item was decremented to zero, remove it.
+        const size = itemIsBranch ? item.children.length : item.value;
+        if (!size) {
+            base.splice(index, 1);
+            changed = true;
+        }
+    }
+    return changed;
+}
+function compare(node) {
+    return (item) => {
+        const v = compareKey(item.key, node.key) ||
+            compareValue(!!item.end, !!node.end) ||
+            (item.end && compareKey(item.end, node.end)) ||
+            compareValue(item.limit, node.limit);
+        return v;
+    };
+}
+function compareValue(a, b) {
+    if (a === b)
+        return 0;
+    return a < b ? -1 : 1;
+}
+/*
+  We clone to ensure that the original query (passed as diff) never gets modified, even after successive adds.
+*/
+function clone(node) {
+    const copy = { ...node };
+    if (node.children)
+        copy.children = node.children.map((child) => clone(child));
+    return copy;
+}

package/ops/finalize.js

@@ -0,0 +1,19 @@
+import { MAX_KEY, MIN_KEY } from "../util.js";
+import { merge, setVersion, slice } from "./index.js";
+/**
+ *
+ * @param {any} graph
+ * @param {any} query
+ * @param {number | false} version
+ * @returns any
+ */
+export default function finalize(graph, query, version = Date.now()) {
+    let result = [{ key: MIN_KEY, end: MAX_KEY, version: 0 }];
+    merge(result, graph);
+    if (query)
+        result = slice(result, query).known || [];
+    if (version !== false)
+        result = setVersion(result, version, true);
+    // console.log('Finalizing', result, '\n\n', query, '\n\n', graph);
+    return result;
+}

package/{types/ops → ops}/getKnown.d.ts

@@ -1,4 +1 @@
-export default function getKnown(graph: any, version?: number): {
-    key: any;
-    version: number;
-}[];
+export default function getKnown(graph: any, version?: number): any[];

package/ops/getKnown.js

@@ -0,0 +1,24 @@
+/*
+  getKnown accepts a graph and returns a query for the knowledge
+  in that graph.
+*/
+import { cmp } from "../util.js";
+export default function getKnown(graph, version = 0) {
+    const query = [];
+    for (const { key, end, children } of graph) {
+        const node = { key, version };
+        if (end) {
+            if (cmp(end, key) !== 0)
+                node.end = end;
+            node.value = 1;
+        }
+        if (children) {
+            node.children = getKnown(children);
+        }
+        else {
+            node.value = 1;
+        }
+        query.push(node);
+    }
+    return query;
+}

package/ops/index.d.ts

@@ -0,0 +1,9 @@
+export { default as add } from './add.js';
+export { default as finalize } from './finalize.js';
+export { default as getKnown } from './getKnown.js';
+export { default as merge } from './merge.js';
+export * from './path.js';
+export { default as setVersion } from './setVersion.js';
+export { default as sieve } from './sieve.js';
+export { default as slice } from './slice.js';
+export * from './step.js';

package/ops/merge.d.ts

@@ -0,0 +1,3 @@
+export default function merge(current: any, changes: any): any;
+export declare function insertRange(current: any, change: any, start?: number): number;
+export declare function insertNode(current: any, change: any, start?: number): any;

package/ops/merge.js

@@ -0,0 +1,112 @@
+import { findFirst, findLast, isBranch, isRange } from "../node/index.js";
+import { cmp, MAX_KEY, MIN_KEY } from "../util.js";
+import { keyAfter, keyBefore } from "./step.js";
+export default function merge(current, changes) {
+    let index = 0;
+    if (typeof changes === 'undefined')
+        return current;
+    for (const change of changes) {
+        index = isRange(change)
+            ? insertRange(current, change, index)
+            : insertNode(current, change, index);
+    }
+    return current;
+}
+export function insertRange(current, change, start = 0) {
+    const { key, end } = change;
+    const keyIx = findFirst(current, key, start);
+    const endIx = findLast(current, end, keyIx);
+    // If current contains nodes that are newer than this range, keep them.
+    // We do this by merging them back into insertions first.
+    const insertions = [change];
+    for (let i = keyIx; i < endIx; i++) {
+        const node = current[i];
+        if (isRange(node)) {
+            insertions.push(...mergeRanges(insertions.pop(), node));
+        }
+        else {
+            insertNode(insertions, node, insertions.length - 1);
+        }
+    }
+    current.splice(keyIx, endIx - keyIx, ...insertions);
+    return keyIx + insertions.length - 1;
+}
+function mergeRanges(base, node) {
+    // assertVersion(node, base.version);
+    if (node.version < base.version)
+        [node, base] = [base, node];
+    return [
+        cmp(base.key, node.key) < 0 && { ...base, end: keyBefore(node.key) },
+        node,
+        cmp(base.end, node.end) > 0 && { ...base, key: keyAfter(node.end) },
+    ].filter(Boolean);
+}
+export function insertNode(current, change, start = 0) {
+    if (!current)
+        throw new Error(`merge.insertNode: ${current}`);
+    const key = change.key;
+    const index = findFirst(current, key, start);
+    const node = current[index];
+    if (node && cmp(node.key, key) <= 0) {
+        // This change overlaps with something that exists.
+        return isRange(node)
+            ? insertNodeIntoRange(current, index, change)
+            : updateNode(current, index, change);
+    }
+    // This change does not overlap with any existing knowledge. Insert it
+    current.splice(index, 0, change);
+    return index + 1;
+}
+function insertNodeIntoRange(current, index, change) {
+    const key = change.key;
+    const range = current[index];
+    const newChange = getNewer(change, range);
+    if (!newChange)
+        return;
+    const insertions = [
+        cmp(range.key, key) < 0 && { ...range, end: keyBefore(key) },
+        newChange,
+        cmp(range.end, key) > 0 && { ...range, key: keyAfter(key) },
+    ].filter(Boolean);
+    current.splice(index, 1, ...insertions);
+    // Subtract 1 to keep the final range in consideration for future insertions.
+    return index + insertions.length - 1;
+}
+function updateNode(current, index, change) {
+    const node = current[index];
+    if (isBranch(change) && isBranch(node)) {
+        // Both are branches: Recursively merge children.
+        merge(node.children, change.children);
+    }
+    else if (isBranch(node)) {
+        // Current node is a branch but the change is a leaf; if the branch
+        // has newer children, ignore the change and keep only those children;
+        // Otherwise, discard the branch and keep the change.
+        const newNode = getNewer(node, change);
+        current[index] = newNode || change;
+    }
+    else {
+        // Current node is a leaf. Replace with the change if it is newer.
+        const newChange = getNewer(change, node);
+        if (newChange)
+            current[index] = newChange;
+    }
+    if (change.prefix)
+        current[index].prefix = true;
+    return index + 1;
+}
+function getNewer(node, base) {
+    const { version } = base;
+    if (isBranch(node)) {
+        const children = [{ key: MIN_KEY, end: MAX_KEY, version }];
+        merge(children, node.children);
+        return children.length === 1 ? null : { ...node, children };
+    }
+    // assertVersion(node, version);
+    return node.version >= version ? node : null;
+}
+// function assertVersion(node, version) {
+//   // if (node.version === version) {
+//   //   throw Error('merge.version_collision ' + [node.key, version].join(' '));
+//   // }
+// }

package/ops/path.d.ts

@@ -0,0 +1,6 @@
+export declare const IS_VAL: unique symbol;
+export declare function wrapValue(value: any, path: any, version?: number): any;
+export declare function wrap(children: any, path: any, version?: number, prefix?: boolean): any;
+export declare function unwrap(tree: any, path: any): any;
+export declare function getNodeValue(node: any): any;
+export declare function remove(children: any, path: any): any;

package/ops/path.js

@@ -0,0 +1,91 @@
+import { findFirst, isBranch, isRange } from "../node/index.js";
+import { cmp } from "../util.js";
+export const IS_VAL = Symbol('IS_VAL');
+function makeNode(seg, props) {
+    if (ArrayBuffer.isView(seg))
+        return { key: seg, ...props };
+    return { ...seg, ...props };
+}
+export function wrapValue(value, path, version = 0) {
+    const node = makeNode(path[path.length - 1], { value, version });
+    return wrap([node], path.slice(0, -1), version);
+}
+export function wrap(children, path, version = 0, prefix = false) {
+    if (!Array.isArray(path))
+        throw Error(`wrap.path_not_array ${path}`);
+    if (!path.length)
+        return children;
+    let i = path.length - 1;
+    // If it is a plain value, make it a value node
+    if (!Array.isArray(children)) {
+        children = [makeNode(path[i--], { value: children, version })];
+    }
+    else {
+        if (!children.length)
+            return;
+        children = [makeNode(path[i--], { children, version })];
+    }
+    if (prefix)
+        children[0].prefix = true;
+    while (i >= 0)
+        children = [makeNode(path[i--], { children, version })];
+    return children;
+}
+export function unwrap(tree, path) {
+    if (!Array.isArray(path))
+        throw Error(`unwrap.path_not_array ${path}`);
+    let children = tree;
+    let node = { children };
+    for (let i = 0; i < path.length; i++) {
+        const key = path[i];
+        if (!ArrayBuffer.isView(key))
+            throw Error('unwrap.ranges_unsupported');
+        children = node.children;
+        if (!children)
+            return null; // This path does not exist.
+        node = children[findFirst(children, key)];
+        if (!node || cmp(node.key, key) > 0)
+            return undefined; // We lack knowledge.
+        if (isRange(node))
+            return null; // This is known to be null.
+        if (node.path)
+            return unwrap(tree, node.path.concat(path.slice(i + 1)));
+    }
+    return getNodeValue(node);
+}
+export function getNodeValue(node) {
+    if (node.children)
+        return node.children;
+    if (node.value && typeof node.value === 'object') {
+        node.value[IS_VAL] = true;
+    }
+    return node.value;
+}
+export function remove(children, path) {
+    if (!Array.isArray(path))
+        throw Error(`del.path_not_array ${path}`);
+    if (!children)
+        return null; // This path does not exist.
+    if (!path.length)
+        return []; // Remove everything.
+    const key = path[0];
+    const ix = findFirst(children, key);
+    const node = children[ix];
+    if (!node || cmp(node.key, key) > 0 || isRange(node))
+        return children;
+    // let filteredNode;
+    if (path.length === 1) {
+        // This is the final segment, delete the matching node from children.
+        return children.slice(0, ix).concat(children.slice(ix + 1));
+    }
+    if (!isBranch(node))
+        return children;
+    // Recurse into the next slice.
+    const filteredChildren = remove(node.children, path.slice(1));
+    if (filteredChildren === children)
+        return children;
+    const filteredNode = filteredChildren.length
+        ? { ...node, children: filteredChildren }
+        : [];
+    return children.slice(0, ix).concat(filteredNode, children.slice(ix + 1));
+}

package/ops/setVersion.js

@@ -0,0 +1,29 @@
+// import { isRange } from '../node/index.ts';
+// import { keyAfter } from './step.ts';
+export default function setVersion(graph, version, onlyIfZero = false) {
+    // mergeRanges(graph);
+    for (const node of graph) {
+        if (!(onlyIfZero && node.version))
+            node.version = version;
+        if (node.children)
+            setVersion(node.children, version, onlyIfZero);
+    }
+    return graph;
+}
+// function mergeRanges(graph) {
+//   for (let i = 0; i < graph.length; i++) {
+//     if (!isRange(graph[i])) continue;
+//     let j = i;
+//     do {
+//       j++;
+//     } while (isRange(graph[j]) && cmp(graph[j].key , keyAfter(graph[j - 1].end)) === 0);
+//     j = j - 1;
+//     if (j === i) continue;
+//     graph.splice(i, j - i + 1, {
+//       key: graph[i].key,
+//       end: graph[j].end,
+//       version: graph[i].version,
+//     });
+//     // i = j;
+//   }
+// }

package/ops/sieve.d.ts

@@ -0,0 +1,3 @@
+export default function sieve(current: any, changes: any, result?: any[]): any[];
+export declare function insertRange(current: any, change: any, result: any, start?: number): number;
+export declare function insertNode(current: any, change: any, result: any, start?: number): any;

package/ops/sieve.js

@@ -0,0 +1,193 @@
+import { findFirst, findLast, isBranch, isRange } from "../node/index.js";
+import { cmp, MAX_KEY, MIN_KEY } from "../util.js";
+import { keyAfter, keyBefore } from "./step.js";
+export default function sieve(current, changes, result = []) {
+    let index = 0;
+    for (const change of changes) {
+        index = isRange(change)
+            ? insertRange(current, change, result, index)
+            : insertNode(current, change, result, index);
+    }
+    return result;
+}
+export function insertRange(current, change, result, start = 0) {
+    const { key, end } = change;
+    const keyIx = findFirst(current, key, start);
+    const endIx = findLast(current, end, keyIx);
+    if (keyIx === endIx &&
+        !(current[keyIx] &&
+            cmp(current[keyIx].key, end) <= 0 &&
+            cmp(current[keyIx].end || current[keyIx].key, key) >= 0)) {
+        // This range does not overlap with any existing data. Ignore it.
+        return keyIx;
+    }
+    const appliedChange = [];
+    let currentKey = change.key;
+    for (let i = keyIx; i < endIx; i++) {
+        const node = current[i];
+        // We treat a negative version as a non-existent node
+        // as this is a hack used by subscribe.
+        if (isRange(node) && node.version >= 0) {
+            if (cmp(node.key, currentKey) > 0) {
+                appliedChange.push({
+                    key: currentKey,
+                    end: keyBefore(node.key),
+                    version: change.version,
+                });
+            }
+            currentKey = keyAfter(node.end);
+        }
+        else {
+            if (getNewerChange(node, change)) {
+                appliedChange.push({
+                    key: currentKey,
+                    end: keyBefore(node.key),
+                    version: change.version,
+                });
+                currentKey = keyAfter(node.key);
+            }
+        }
+        if (cmp(currentKey, change.end) >= 0) {
+            break;
+        }
+    }
+    if (cmp(currentKey, change.end) <= 0) {
+        appliedChange.push({
+            key: currentKey,
+            end: change.end,
+            version: change.version,
+        });
+    }
+    if (appliedChange.length)
+        result.push(...appliedChange);
+    // If current contains nodes that are newer than this range, keep them.
+    // We do this by merging them back into insertions first.
+    const insertions = [change];
+    for (let i = keyIx; i < endIx; i++) {
+        const node = current[i];
+        if (isRange(node)) {
+            // console.log('Sieve Range-Range', debug(change), debug(node));
+            insertions.push(...mergeRanges(insertions.pop(), node));
+        }
+        else {
+            // console.log('Sieve Change-Node', debug(change), debug(node));
+            insertNode(insertions, node, [], insertions.length - 1);
+        }
+    }
+    // console.log('Sieve:insertions', debug(insertions));
+    current.splice(keyIx, endIx - keyIx, ...insertions);
+    return keyIx + insertions.length - 1;
+}
+function mergeRanges(base, node) {
+    // assertVersion(node, base.version);
+    if (node.version < base.version)
+        [node, base] = [base, node];
+    // Ensure node is newer than base
+    return [
+        cmp(base.key, node.key) < 0 && { ...base, end: keyBefore(node.key) },
+        node,
+        cmp(base.end, node.end) > 0 && { ...base, key: keyAfter(node.end) },
+    ].filter(Boolean);
+}
+export function insertNode(current, change, result, start = 0) {
+    const key = change.key;
+    const index = findFirst(current, key, start);
+    const node = current[index];
+    if (node && cmp(node.key, key) <= 0) {
+        // This change overlaps with something that exists.
+        return isRange(node)
+            ? insertNodeIntoRange(current, index, change, result)
+            : updateNode(current, index, change, result);
+    }
+    // This change does not overlap with any existing knowledge. Skip it
+    // current.splice(index, 0, change);
+    return index;
+}
+function insertNodeIntoRange(current, index, change, result) {
+    const key = change.key;
+    const range = current[index];
+    const newChange = getNewerChange(change, range);
+    const newNode = getNewerNode(change, range);
+    if (!newChange)
+        return;
+    result.push(newChange);
+    const insertions = [
+        cmp(range.key, key) < 0 && { ...range, end: keyBefore(key) },
+        newNode,
+        cmp(range.end, key) > 0 && { ...range, key: keyAfter(key) },
+    ].filter(Boolean);
+    current.splice(index, 1, ...insertions);
+    return index + insertions.length - 1;
+}
+function updateNode(current, index, change, result) {
+    const node = current[index];
+    if (isBranch(change) && isBranch(node)) {
+        // Both are branches: Recursively merge children.
+        const nextResult = [];
+        node.version = change.version;
+        sieve(node.children, change.children, nextResult);
+        if (nextResult.length)
+            result.push({ ...change, children: nextResult });
+    }
+    else if (isBranch(node)) {
+        // Current node is a branch but the change is a leaf; if the branch
+        // has newer children, ignore the change and keep only those children;
+        // Otherwise, discard the branch and keep the change.
+        const newNode = getNewerNode(node, change);
+        current[index] = newNode || change;
+        if (!newNode)
+            result.push(change);
+        // TODO: In the case of partial removal, what should result be?
+    }
+    else {
+        // Current node is a leaf. Replace with the change if it is newer.
+        const newChange = getNewerChange(change, node);
+        const newNode = getNewerNode(change, node);
+        if (newNode)
+            current[index] = newNode;
+        // console.log(current);
+        if (newChange &&
+            (change.value !== node.value || !isPathEqual(change.path, node.path))) {
+            result.push(newChange);
+        }
+    }
+    return index + 1;
+}
+function isPathEqual(first, second) {
+    if (!(first || second))
+        return true;
+    if (!(first && second))
+        return false;
+    if (first.length !== second.length)
+        return false;
+    for (let i = 0; i < first.length; i++) {
+        if (first[i] !== second[i])
+            return false;
+    }
+    return true;
+}
+function getNewerNode(node, base) {
+    if (isBranch(node)) {
+        const emptyNode = { key: MIN_KEY, end: MAX_KEY, version: base.version };
+        const children = [emptyNode];
+        sieve(children, node.children);
+        return children.length === 1 && children[0] === emptyNode
+            ? null
+            : { ...node, children };
+    }
+    // assertVersion(node, version);
+    return node.version >= base.version ? node : null;
+}
+function getNewerChange(node, base) {
+    if (isBranch(node)) {
+        const children = node.children.filter((child) => getNewerChange(child, base));
+        return children.length && { ...node, children };
+    }
+    // assertVersion(node, version);
+    return node.version >= base.version ? node : null;
+}
+// function assertVersion(node, version) {
+//   // if (node.version === version) {
+//   //   throw Error('merge.version_collision ' + [node.key, version].join(' '));
+//   // }
+// }