@graffy/common 0.18.1-alpha.2 → 0.19.1-alpha.1

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(' '));
+//   // }
+// }

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

@@ -1,13 +1,9 @@
-export default function slice(graph: any, query: any, root: any): Result;
-export function sliceRange(graph: any, query: any, result: any): void;
 declare class Result {
     constructor(root: any);
-    root: any;
     addKnown(node: any): void;
-    known: any;
     addUnknown(node: any): void;
-    unknown: any;
     addLinked(children: any): any;
-    linked: any;
 }
+export default function slice(graph: any, query: any, root: any): Result;
+export declare function sliceRange(graph: any, query: any, result: any): void;
 export {};

package/ops/slice.js

@@ -0,0 +1,153 @@
+import { findFirst, findLast, isBranch, isLink, isOlder, isRange, } from "../node/index.js";
+import { cmp, isMinKey, MAX_KEY, MIN_KEY } from "../util.js";
+import add from "./add.js";
+import merge from "./merge.js";
+import { wrap } from "./path.js";
+import { keyAfter, keyBefore } from "./step.js";
+class Result {
+    constructor(root) {
+        // When linked queries are added, they are forwarded to the root.
+        this.root = root || this;
+    }
+    addKnown(node) {
+        this.known = this.known || [];
+        merge(this.known, [node]);
+    }
+    addUnknown(node) {
+        this.unknown = this.unknown || [];
+        this.unknown.push(node);
+    }
+    addLinked(children) {
+        if (this.root !== this)
+            return this.root.addLinked(children);
+        this.linked = this.linked || [];
+        add(this.linked, children);
+    }
+}
+export default function slice(graph, query, root) {
+    const result = new Result(root);
+    let currentQuery = query;
+    while (currentQuery) {
+        let index = 0;
+        for (const queryNode of currentQuery) {
+            if (isRange(queryNode)) {
+                sliceRange(graph, queryNode, result);
+            }
+            else {
+                const key = queryNode.key;
+                index = findFirst(graph, key);
+                sliceNode(graph[index], queryNode, result);
+            }
+        }
+        currentQuery = root ? undefined : result.linked;
+        delete result.linked;
+    }
+    delete result.root;
+    return result;
+}
+function sliceNode(graph, query, result) {
+    const { key, version } = query;
+    const { root } = result;
+    // console.log('Slicing', graph, query);
+    if (!graph || cmp(graph.key, key) > 0 || isOlder(graph, version)) {
+        // The node found doesn't match the query or it's too old.
+        result.addUnknown(query);
+    }
+    else if (isRange(graph)) {
+        // The graph is indicating that this value was deleted.
+        if (isBranch(query)) {
+            const { known } = slice([{ key: MIN_KEY, end: MAX_KEY, version: graph.version }], query.children);
+            result.addKnown({ key, version: graph.version, children: known });
+        }
+        else {
+            result.addKnown({ key, end: key, version: graph.version });
+        }
+    }
+    else if (isBranch(graph) && isBranch(query)) {
+        // Both sides are branches; recurse into them.
+        const { known, unknown } = slice(graph.children, query.children, root);
+        if (known)
+            result.addKnown({ ...graph, children: known });
+        if (unknown)
+            result.addUnknown({ ...query, children: unknown });
+    }
+    else if (isLink(graph)) {
+        result.addKnown(graph);
+        if (graph.prefix && isRange(query)) {
+            result.addLinked(wrap([query], graph.path, version, true));
+        }
+        else {
+            result.addLinked(wrap(query.children || query.value, graph.path, version, graph.prefix || query.prefix));
+        }
+    }
+    else if (isBranch(graph)) {
+        // The graph is a branch and query is requesting all children here.
+        result.addKnown(graph);
+    }
+    else if (isBranch(query)) {
+        // One graph is a leaf while the query is a leaf; return null.
+        const { known } = slice([{ key: MIN_KEY, end: MAX_KEY, version: graph.version }], query.children);
+        result.addKnown({ key, version: graph.version, children: known });
+    }
+    else {
+        result.addKnown(graph);
+    }
+}
+export function sliceRange(graph, query, result) {
+    let { key, end, limit = Number.POSITIVE_INFINITY, version } = query;
+    const step = cmp(key, end) < 0 ? 1 : -1;
+    // Prefixes are used to combine filtering and pagination. In schemas where
+    // prefixes are expected but a particular graph does not have a filter, it
+    // will have a prefix node with an empty string as key.
+    if (isMinKey(graph[0].key) && graph[0].prefix && graph[0].children) {
+        const { known, unknown } = slice(graph[0].children, [query], result.root);
+        if (known)
+            result.addKnown({ ...graph[0], children: known });
+        if (unknown)
+            result.addUnknown({ ...query[0], children: unknown });
+        return;
+    }
+    if (cmp(key, end) < 0) {
+        for (let i = findFirst(graph, key); cmp(key, end) <= 0 && limit > 0; i++) {
+            const node = graph[i];
+            if (!node || cmp(key, node.key) < 0 || isOlder(node, version))
+                break;
+            if (isRange(node)) {
+                result.addKnown(getOverlap(node, key, end));
+            }
+            else {
+                sliceNode(node, { ...query, key }, result);
+                limit--;
+            }
+            key = keyAfter(node.end || node.key);
+        }
+    }
+    else {
+        for (let i = findLast(graph, key) - 1; cmp(key, end) >= 0 && limit > 0; i--) {
+            const node = graph[i];
+            if (!node || cmp(key, node.end || node.key) > 0 || isOlder(node, version))
+                break;
+            if (isRange(node)) {
+                result.addKnown(getOverlap(node, end, key));
+            }
+            else {
+                sliceNode(node, { ...query, key }, result);
+                limit--;
+            }
+            key = keyBefore(node.key);
+        }
+    }
+    if (limit && (step < 0 ? cmp(key, end) > 0 : cmp(key, end) < 0)) {
+        const unknown = { ...query, key, end, limit };
+        result.addUnknown(unknown);
+    }
+}
+function getOverlap(node, key, end) {
+    if (cmp(node.key, key) >= 0 && cmp(node.end, end) <= 0)
+        return node;
+    return {
+        ...node,
+        key: cmp(node.key, key) > 0 ? node.key : key,
+        end: cmp(node.end, end) < 0 ? node.end : end,
+    };
+}

package/ops/step.d.ts

@@ -0,0 +1,6 @@
+export declare function keyStep(key: any): {
+    key: any;
+    step: any;
+};
+export declare function keyBefore(key: any): any;
+export declare function keyAfter(key: any): any;

package/ops/step.js

@@ -0,0 +1,61 @@
+import { addStringify, isMaxKey, isMinKey } from "../util.js";
+export function keyStep(key) {
+    if (isMinKey(key))
+        return { key, step: 1 };
+    if (isMaxKey(key))
+        return { key, step: -1 };
+    const l = key.length - 1;
+    let newKey;
+    let step;
+    switch (key[l]) {
+        case 0:
+            newKey = key.slice(0, l);
+            addStringify(newKey);
+            step = 1;
+            break;
+        case 0xff:
+            newKey = key.slice(0, l);
+            addStringify(newKey);
+            newKey[l - 1]++;
+            step = -1;
+            break;
+        default:
+            newKey = key;
+            step = 0;
+    }
+    return { key: newKey, step };
+}
+export function keyBefore(key) {
+    if (isMinKey(key) || isMaxKey(key))
+        return key;
+    const l = key.length - 1;
+    let newKey;
+    if (key[l] === 0) {
+        newKey = key.slice(0, l);
+    }
+    else {
+        newKey = new Uint8Array(l + 2);
+        newKey.set(key, 0);
+        newKey[l]--;
+        newKey[l + 1] = 0xff;
+    }
+    addStringify(newKey);
+    return newKey;
+}
+export function keyAfter(key) {
+    if (isMaxKey(key))
+        return key;
+    const l = key.length - 1;
+    let newKey;
+    if (key[l] === 0xff) {
+        newKey = key.slice(0, l);
+        newKey[l - 1]++;
+    }
+    else {
+        newKey = new Uint8Array(l + 2);
+        newKey.set(key, 0);
+        newKey[l + 1] = 0;
+    }
+    addStringify(newKey);
+    return newKey;
+}

package/package.json

@@ -2,23 +2,29 @@
   "name": "@graffy/common",
   "description": "Common libraries that used by various Graffy modules.",
   "author": "aravind (https://github.com/aravindet)",
-  "version": "0.18.1-alpha.2",
-  "main": "./index.cjs",
+  "version": "0.19.1-alpha.1",
+  "main": "./cjs/index.js",
   "exports": {
-    "import": "./index.mjs",
-    "require": "./index.cjs"
+    ".": {
+      "import": "./index.js",
+      "types": "./index.d.ts"
+    },
+    "./*": {
+      "import": "./*.js",
+      "types": "./*.d.ts"
+    }
   },
-  "module": "./index.mjs",
-  "types": "./types/index.d.ts",
+  "types": "./index.d.ts",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/usegraffy/graffy.git"
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "lodash": "^4.17.23",
     "debug": "^4.4.3",
-    "@graffy/stream": "0.18.1-alpha.2",
+    "lodash": "^4.17.23",
+    "nanoid": "^5.1.6",
+    "@graffy/stream": "0.19.1-alpha.1",
     "merge-async-iterators": "^0.2.1"
   }
 }

package/stream/index.d.ts

@@ -0,0 +1,2 @@
+export { default as makeWatcher } from './makeWatcher.js';
+export { default as mergeStreams } from './mergeStreams.js';

package/stream/makeWatcher.d.ts

@@ -0,0 +1,10 @@
+export default function makeWatcher(): {
+    write: (change: any) => void;
+    watch: (...args: any[]) => {
+        debugId: any;
+        next: () => any;
+        return(value: any): any;
+        throw(error: any): any;
+        [Symbol.asyncIterator](): any;
+    };
+};

package/stream/makeWatcher.js

@@ -0,0 +1,19 @@
+import { makeStream } from '@graffy/stream';
+export default function makeWatcher() {
+    const listeners = new Set();
+    function write(change) {
+        for (const push of listeners)
+            push(change);
+    }
+    function watch(...args) {
+        return makeStream((push, _end) => {
+            listeners.add(push);
+            // We do this instead of binding the first value to a variable
+            // to decide between pushing undefined and not making a push.
+            if (args.length)
+                Promise.resolve(args[0]).then(push);
+            return () => listeners.delete(push);
+        });
+    }
+    return { write, watch };
+}

package/stream/mergeStreams.js

@@ -0,0 +1,20 @@
+import mergeIterators from 'merge-async-iterators';
+import { merge } from "../ops/index.js";
+export default async function* mergeStreams(...streams) {
+    const firstValues = (await Promise.all(streams.map((stream) => stream.next()))).map((iter) => iter.value);
+    // If even one is a change-only stream, the result is a change-only stream
+    if (firstValues.some((value) => typeof value === 'undefined')) {
+        yield undefined;
+        for (const value of firstValues) {
+            if (typeof value !== 'undefined')
+                yield value;
+        }
+    }
+    else {
+        const merged = [];
+        for (const value of firstValues)
+            merge(merged, value);
+        yield merged;
+    }
+    yield* mergeIterators(streams);
+}

package/util.d.ts

@@ -0,0 +1,15 @@
+export declare const MIN_KEY: Uint8Array<ArrayBuffer>;
+export declare const MAX_KEY: Uint8Array<ArrayBuffer>;
+export declare function isMinKey(key: any): boolean;
+export declare function isMaxKey(key: any): boolean;
+export declare function err(message: any, { cause, ...args }?: {
+    cause?: any;
+}): void;
+export declare function errIf(message: any, condition: any, args: any): void;
+export declare function isEmpty(object: any): boolean;
+export declare function isDef(value: any): boolean;
+export declare function isPlainObject(arg: any): boolean;
+export declare function clone(obj: any): any;
+export declare function cmp(a: any, b: any): 0 | 1 | -1;
+export declare function find(items: any, compare: any, first?: number, last?: any): number;
+export declare function addStringify(buffer: any): any;

package/util.js

@@ -0,0 +1,106 @@
+import debug from 'debug';
+const isDebugMode = debug('graffy*').enabled;
+export const MIN_KEY = new Uint8Array();
+export const MAX_KEY = new Uint8Array([0xff]);
+export function isMinKey(key) {
+    return key.length === 0;
+}
+export function isMaxKey(key) {
+    return key.length === 1 && key[0] === 0xff;
+}
+export function err(message, { cause = null, ...args } = {}) {
+    const e = new Error(message + (args ? ` ${JSON.stringify(args)}` : ''));
+    e.cause = cause;
+    throw e;
+}
+export function errIf(message, condition, args) {
+    if (condition)
+        err(message, args);
+}
+export function isEmpty(object) {
+    for (const _ in object)
+        return false;
+    return true;
+}
+export function isDef(value) {
+    return typeof value !== 'undefined';
+}
+export function isPlainObject(arg) {
+    return (typeof arg === 'object' &&
+        arg &&
+        !Array.isArray(arg) &&
+        !ArrayBuffer.isView(arg));
+}
+export function clone(obj) {
+    if (Array.isArray(obj)) {
+        return obj.slice(0);
+    }
+    return { ...obj };
+}
+export function cmp(a, b) {
+    const l = a.length < b.length ? a.length : b.length;
+    for (let i = 0; i < l; i++) {
+        if (a[i] < b[i])
+            return -1;
+        if (a[i] > b[i])
+            return 1;
+    }
+    if (a.length < b.length)
+        return -1;
+    if (a.length > b.length)
+        return 1;
+    return 0;
+}
+export function find(items, compare, first = 0, last = items.length) {
+    let currentFirst = first;
+    let currentLast = last;
+    while (currentFirst < currentLast) {
+        // console.log(currentFirst, currentLast);
+        const ix = ((currentFirst + currentLast) / 2) | 0;
+        const d = compare(items[ix]);
+        // console.log(ix, items[ix], d);
+        if (d < 0) {
+            currentFirst = ix + 1;
+        }
+        else if (d > 0) {
+            currentLast = ix;
+        }
+        else {
+            return ix;
+        }
+    }
+    return currentFirst;
+}
+function stringify() {
+    if (this?.length === 0)
+        return '\u00b7';
+    let str = '';
+    let bull = false;
+    this?.forEach?.((value, i) => {
+        if (value >= 32 && value <= 126) {
+            str += String.fromCharCode(value);
+            bull = true;
+        }
+        else {
+            str +=
+                (bull ? '\u00b7' : '') +
+                    `0${value.toString(16)}`.slice(-2) +
+                    (i < this.length - 1 ? '\u00b7' : '');
+            bull = false;
+        }
+    });
+    return str;
+}
+const inspectSymbol = Symbol.for('nodejs.util.inspect.custom');
+export function addStringify(buffer) {
+    if (!isDebugMode)
+        return buffer;
+    if ('toJSON' in buffer || inspectSymbol in buffer)
+        return buffer;
+    buffer.toJSON = stringify;
+    buffer.toString = stringify;
+    buffer[inspectSymbol] = stringify;
+    return buffer;
+}
+addStringify(MIN_KEY);
+addStringify(MAX_KEY);