@graffy/common 0.19.1-alpha.1 → 0.19.1

package/ops/sieve.js

@@ -1,193 +0,0 @@
-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/ops/slice.js

@@ -1,153 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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/stream/index.d.ts

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

package/stream/makeWatcher.d.ts

@@ -1,10 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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);

package/{ops/index.js → types/ops/index.d.ts}

@@ -3,7 +3,7 @@ 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 * from "./step.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";