@graffy/common 0.19.0 → 0.19.1-alpha.2

package/ops/slice.d.ts

@@ -0,0 +1,13 @@
+declare class Result {
+    root: Result;
+    known?: any[];
+    unknown?: any[];
+    linked?: any[];
+    constructor(root?: any);
+    addKnown(node: any): void;
+    addUnknown(node: any): void;
+    addLinked(children: any): 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.19.0",
-  "main": "./index.cjs",
+  "version": "0.19.1-alpha.2",
+  "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.19.0",
+    "lodash": "^4.18.1",
+    "nanoid": "^5.1.11",
+    "@graffy/stream": "0.19.1-alpha.2",
     "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: string;
+        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);