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

package/coding/alphabet.js

@@ -0,0 +1,5 @@
+/*
+  This is just like standard URL-safe Base64, except for using an alphabet
+  re-ordered for sortability.
+*/
+export default '-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz';

package/coding/args.d.ts

@@ -0,0 +1,5 @@
+export declare function splitArgs(arg: any): {}[];
+export declare function encode(arg: any): {
+    key: Uint8Array<any>;
+};
+export declare function decode(node: any): any;

package/coding/args.js

@@ -0,0 +1,93 @@
+import { keyAfter, keyBefore, keyStep } from "../ops/step.js";
+import { cmp, errIf, isDef, isEmpty, isMaxKey, isMinKey, isPlainObject, MAX_KEY, MIN_KEY, } from "../util.js";
+import { decode as decodeValue, encode as encodeValue } from "./struct.js";
+function decodeBound(bound) {
+    const { key, step } = keyStep(bound);
+    if (isMinKey(key) || isMaxKey(key))
+        return { step };
+    const value = decodeValue(key);
+    return { key: value, step };
+}
+const pageProps = {
+    $all: 1,
+    $first: 1,
+    $last: 1,
+    $after: 1,
+    $before: 1,
+    $since: 1,
+    $until: 1,
+    $cursor: 1,
+};
+export function splitArgs(arg) {
+    const page = {};
+    const filter = {};
+    for (const p in arg)
+        (p in pageProps ? page : filter)[p] = arg[p];
+    return [
+        isEmpty(page) ? undefined : page,
+        isEmpty(filter) ? undefined : filter,
+    ];
+}
+export function encode(arg) {
+    if (!isPlainObject(arg))
+        return { key: encodeValue(arg) };
+    const [page, filter] = splitArgs(arg);
+    errIf('page_and_filter', page && filter, arg);
+    if (!page)
+        return { key: encodeValue(filter || {}) };
+    const { $cursor, ...range } = page;
+    // @ts-expect-error
+    const { $first, $all, $last, $after, $before, $since, $until } = range;
+    const hasRange = !isEmpty(range);
+    errIf('first_and_last', isDef($first) && isDef($last), arg);
+    errIf('all_and_last', isDef($all) && isDef($last), arg);
+    errIf('all_and_first', isDef($first) && isDef($all), arg);
+    errIf('after_and_since', isDef($after) && isDef($since), arg);
+    errIf('before_and_until', isDef($before) && isDef($until), arg);
+    errIf('cursor_and_range_arg', isDef($cursor) && hasRange, arg);
+    let [key, end] = hasRange ? [MIN_KEY, MAX_KEY] : [];
+    if (isDef($cursor))
+        key = encodeValue($cursor);
+    if (isDef($after))
+        key = keyAfter(encodeValue($after));
+    if (isDef($before))
+        end = keyBefore(encodeValue($before));
+    if (isDef($since))
+        key = encodeValue($since);
+    if (isDef($until))
+        end = encodeValue($until);
+    if (isDef($last))
+        [key, end] = [end, key];
+    const node = { key };
+    if (isDef(end))
+        node.end = end;
+    if ($first || $last)
+        node.limit = $first || $last;
+    return node;
+}
+export function decode(node) {
+    const { key, end, limit } = node;
+    errIf('no_key', !isDef(key));
+    errIf('limit_without_end', isDef(limit) && !isDef(end));
+    const kParts = decodeBound(key);
+    if (!isDef(end) || cmp(key, end) === 0)
+        return kParts.key;
+    const eParts = decodeBound(end);
+    const reverse = cmp(key, end) > 0;
+    const [lower, upper] = reverse ? [eParts, kParts] : [kParts, eParts];
+    const args = {};
+    if (limit) {
+        args[reverse ? '$last' : '$first'] = limit;
+    }
+    else if ((isMinKey(key) && isMaxKey(end)) ||
+        (isMinKey(end) && isMaxKey(key))) {
+        args.$all = true;
+    }
+    if (isDef(lower.key) && !isMinKey(lower.key)) {
+        args[lower.step === 1 ? '$after' : '$since'] = lower.key;
+    }
+    if (isDef(upper.key) && !isMaxKey(upper.key)) {
+        args[upper.step === -1 ? '$before' : '$until'] = upper.key;
+    }
+    return args;
+}

package/coding/base64.d.ts

@@ -0,0 +1,2 @@
+export declare function encode(u8Arr: any): string;
+export declare function decode(string: any, start?: number): any;

package/coding/base64.js

@@ -0,0 +1,41 @@
+import { addStringify } from "../util.js";
+import alpha from "./alphabet.js";
+function getByte(view, offset) {
+    return offset < view.byteLength ? view.getUint8(offset) : 0;
+}
+function getChar(string, offset) {
+    return offset < string.length ? alpha.indexOf(string[offset]) : 0;
+}
+export function encode(u8Arr) {
+    const { buffer, byteOffset, byteLength } = u8Arr;
+    const view = new DataView(buffer, byteOffset, byteLength);
+    let str = '';
+    for (let i = 0; i < view.byteLength; i += 3) {
+        let value = (getByte(view, i) << 16) +
+            (getByte(view, i + 1) << 8) +
+            getByte(view, i + 2);
+        let gstr = '';
+        for (let j = 0; j < 4; j++) {
+            gstr = alpha[value & 0x3f] + gstr;
+            value = (value >> 6) | 0;
+        }
+        str += gstr;
+    }
+    return str.substring(0, Math.ceil((view.byteLength * 4) / 3));
+}
+export function decode(string, start = 0) {
+    const buffer = new ArrayBuffer(Math.floor(((string.length - start) * 3) / 4));
+    const view = new DataView(buffer);
+    for (let i = start; i < string.length; i += 4) {
+        let value = (getChar(string, i) << 18) +
+            (getChar(string, i + 1) << 12) +
+            (getChar(string, i + 2) << 6) +
+            getChar(string, i + 3);
+        for (let j = (i * 3) / 4 + 2; j >= (i * 3) / 4; j--) {
+            if (j < view.byteLength)
+                view.setUint8(j, value & 0xff);
+            value = (value >> 8) | 0;
+        }
+    }
+    return addStringify(new Uint8Array(buffer));
+}

package/coding/decodeTree.d.ts

@@ -0,0 +1,2 @@
+export declare function decodeGraph(graph: any): any[];
+export declare function decodeQuery(query: any): any[];

package/coding/decodeTree.js

@@ -0,0 +1,197 @@
+import { isBranch, isLink, isPrefix, isRange } from "../node/index.js";
+import { keyAfter } from "../ops/index.js";
+import { clone, cmp, isDef, isEmpty, isMaxKey, isMinKey } from "../util.js";
+import { decode as decodeArgs, splitArgs } from "./args.js";
+import { decode as decodePath } from "./path.js";
+const PRE_CHI_PUT = Symbol('PREFIX_CHILDREN_$PUT');
+/**
+  @param {any[]} nodes
+  @param {{ isGraph?: boolean }} options
+*/
+function decode(nodes = [], { isGraph } = {}) {
+    function decodeChildren(nodes) {
+        let result = [];
+        let allStrs = true;
+        let allNums = true;
+        //Pushes objects to the result set and updates allStrs and allNums.
+        function pushResult(...objects) {
+            for (const object of objects) {
+                if (isDef(object) && !Number.isInteger(object.$key))
+                    allNums = false;
+                if (isDef(object) && typeof object.$key !== 'string')
+                    allStrs = false;
+            }
+            result.push(...objects);
+        }
+        const putRanges = [];
+        const prefixChildPuts = [];
+        let lastNode = null;
+        // Graphs only: Constructs the $put array. Returns true if this is a range
+        // node that does not require to be added to the results.
+        function addPutRange({ key, end }) {
+            if (lastNode) {
+                if (lastNode.end) {
+                    if (cmp(key, keyAfter(lastNode.end)) === 0) {
+                        lastNode.end = end || key;
+                        return end && cmp(end, key) !== 0;
+                    }
+                }
+                else {
+                    if (cmp(key, keyAfter(lastNode.key)) === 0) {
+                        key = lastNode.key;
+                    }
+                }
+            }
+            if (end && cmp(key, end) !== 0) {
+                lastNode = { key, end };
+                putRanges.push(lastNode);
+                return true;
+            }
+            lastNode = { key };
+            return false;
+        }
+        for (const node of nodes) {
+            if (isGraph && addPutRange(node))
+                continue;
+            if (isPrefix(node)) {
+                const decodedChildren = decodePrefixNode(node);
+                if (PRE_CHI_PUT in decodedChildren) {
+                    prefixChildPuts.push(...decodedChildren[PRE_CHI_PUT]);
+                }
+                pushResult(...decodedChildren);
+            }
+            else if (isGraph && isRange(node))
+                pushResult(decodeRangeNode(node));
+            else if (isBranch(node))
+                pushResult(decodeBranchNode(node));
+            else if (isLink(node))
+                pushResult(decodeLinkNode(node));
+            else
+                pushResult(decodeLeafNode(node));
+        }
+        // Use a simplified format if all the keys are strings or it's a plain array.
+        if (allStrs ||
+            (allNums &&
+                putRanges.length === 1 &&
+                cmp(putRanges[0].key, 0) === 0 &&
+                cmp(putRanges[0].end, Number.POSITIVE_INFINITY) === 0)) {
+            result = result.reduce((collection, item) => {
+                if (Array.isArray(item)) {
+                    collection[item.$key] = item;
+                    delete item.$key;
+                    return collection;
+                }
+                let { $key, $val } = item;
+                delete item.$key;
+                delete item.$val;
+                if ($val === null) {
+                    $val = { $val };
+                }
+                else if (typeof $val === 'object') {
+                    $val = clone($val);
+                    Object.defineProperty($val, '$val', { value: true });
+                }
+                // biome-ignore format: tertnary chain
+                collection[$key] = (isDef($val) ? $val :
+                    !isEmpty(item) || item.$ref || item.$put ? item :
+                        isGraph ? null : true);
+                return collection;
+            }, allStrs ? {} : []);
+        }
+        if (isGraph && putRanges.length) {
+            if (isMinKey(putRanges[0].key) && isMaxKey(putRanges[0].end)) {
+                Object.defineProperty(result, '$put', { value: true });
+            }
+            else {
+                Object.defineProperty(result, '$put', {
+                    value: putRanges
+                        .map((rNode) => decodeArgs(rNode))
+                        .concat(prefixChildPuts),
+                });
+            }
+        }
+        else if (prefixChildPuts.length) {
+            Object.defineProperty(result, '$put', { value: prefixChildPuts });
+        }
+        return result;
+    }
+    function decodePrefixNode(node) {
+        let args = decodeArgs(node);
+        if (!args)
+            args = {};
+        if (typeof args === 'string') {
+            throw Error(`decode.unencoded_prefix: ${args}`);
+        }
+        if (isLink(node)) {
+            args.$all = true;
+            const $ref = decodePath(node.path);
+            const lastKey = $ref[$ref.length - 1];
+            if (typeof lastKey === 'string') {
+                throw Error(`decode.unencoded_prefix_ref: ${node.path}`);
+            }
+            lastKey.$all = true;
+            const linkObject = { $key: args };
+            Object.defineProperty(linkObject, '$ref', { value: $ref });
+            return [linkObject];
+        }
+        /** @type {any[] & {$put?: any}} */
+        const children = decodeChildren(node.children);
+        if (!Array.isArray(children)) {
+            throw Error(`decode.prefix_without_encoded_child_keys:${node.key}`);
+        }
+        for (const child of children) {
+            if (typeof child.$key === 'string') {
+                throw Error(`decode.prefix_with_unencoded_child_key:${child.$key}`);
+            }
+            if (!splitArgs(child.$key)[0]) {
+                // splitArgs returns [page, filter]. If page is blank, it indicates
+                // we have a bare cursor.
+                child.$key = { $cursor: child.$key };
+            }
+            child.$key = { ...args, ...child.$key };
+        }
+        if (children.$put === true) {
+            children[PRE_CHI_PUT] = [{ ...args, $all: true }];
+        }
+        else if (Array.isArray(children.$put)) {
+            children[PRE_CHI_PUT] = children.$put.map((rarg) => ({
+                ...args,
+                ...rarg,
+            }));
+        }
+        else if (isDef(children.$put)) {
+            children[PRE_CHI_PUT] = [{ ...args, ...children.$put }];
+        }
+        return children;
+    }
+    function decodeBranchNode(node) {
+        const child = decodeChildren(node.children);
+        child.$key = decodeArgs(node);
+        return child;
+    }
+    function decodeLeafNode(node) {
+        const child = isGraph ? { $val: node.value } : {};
+        child.$key = decodeArgs(node);
+        return child;
+    }
+    /**
+      Only for graphs;
+    */
+    function decodeRangeNode(node) {
+        if (cmp(node.key, node.end) === 0) {
+            return { $key: decodeArgs({ key: node.key }) };
+        }
+    }
+    function decodeLinkNode(node) {
+        const linkObject = { $key: decodeArgs(node) };
+        Object.defineProperty(linkObject, '$ref', { value: decodePath(node.path) });
+        return linkObject;
+    }
+    return decodeChildren(nodes);
+}
+export function decodeGraph(graph) {
+    return decode(graph, { isGraph: true });
+}
+export function decodeQuery(query) {
+    return decode(query, { isGraph: false });
+}

package/coding/decorate.js

@@ -0,0 +1,211 @@
+import { findFirst, isRange } from "../node/index.js";
+import { getNodeValue, IS_VAL, unwrap } from "../ops/index.js";
+import { cmp, isDef, isEmpty, isMinKey, isPlainObject, MIN_KEY, } from "../util.js";
+import { decode as decodeArgs, encode as encodeArgs, splitArgs, } from "./args.js";
+import { decodeGraph } from "./decodeTree.js";
+import { decode as decodePath, encode as encodePath, splitRef, } from "./path.js";
+const REF = Symbol();
+const PRE = Symbol();
+export default function decorate(rootGraph, rootQuery) {
+    // console.log('Decorating', rootGraph, rootQuery);
+    function construct(plumGraph, query) {
+        if (plumGraph === null)
+            return null;
+        if (!isDef(plumGraph))
+            plumGraph = [];
+        if (query.$key)
+            query = [query];
+        // console.log('Constructing', plumGraph, query);
+        let graph;
+        if (query.$ref) {
+            const { $ref, ...props } = query;
+            const [range, filter] = splitRef($ref);
+            const path = encodePath($ref);
+            const targetPlumGraph = unwrap(rootGraph, path);
+            if (targetPlumGraph) {
+                if (range)
+                    targetPlumGraph[PRE] = filter;
+                graph = construct(targetPlumGraph, range ? { $key: range, ...props } : props);
+                Object.defineProperty(graph, '$ref', { value: $ref });
+            }
+        }
+        else if (Array.isArray(query)) {
+            let pageKey;
+            graph = query.flatMap((item, i) => {
+                if (!item?.$key) {
+                    // This is an integer-indexed array.
+                    return construct(descend(plumGraph, i), item);
+                }
+                const { $key, $chi, ...props } = item;
+                const subQuery = $chi || (isEmpty(props) ? 1 : props);
+                if (!(isPlainObject($key) && splitArgs($key)[0])) {
+                    // This is a non-string argument without pagination
+                    return construct(descend(plumGraph, $key), subQuery);
+                }
+                // This is a pagination query.
+                if (pageKey) {
+                    throw Error(`decorate.multi_range_query:${JSON.stringify({ $key, pageKey })}`);
+                }
+                pageKey = $key;
+                const children = slice(plumGraph, $key);
+                return children
+                    .filter((node) => !isRange(node))
+                    .map((node) => {
+                    const $key = decodeArgs(node);
+                    const subResult = construct(getValue(node), subQuery);
+                    if (typeof subResult === 'object' && subResult) {
+                        subResult.$key =
+                            children[PRE] && !isMinKey(children[PRE])
+                                ? { ...children[PRE], $cursor: $key }
+                                : $key;
+                    }
+                    return subResult;
+                });
+            });
+            // .filter(Boolean);
+            if (pageKey)
+                addPageMeta(graph, pageKey);
+        }
+        else if (typeof query === 'object') {
+            graph = {};
+            for (const prop in query) {
+                graph[prop] = construct(descend(plumGraph, prop), query[prop]);
+            }
+        }
+        else if (query) {
+            if (Array.isArray(plumGraph) && !plumGraph.length) {
+                graph = undefined;
+            }
+            else if (typeof plumGraph !== 'object' || !plumGraph) {
+                graph = plumGraph;
+            }
+            else if (plumGraph[IS_VAL]) {
+                graph = Array.isArray(plumGraph)
+                    ? plumGraph.slice(0)
+                    : { ...plumGraph };
+                graph.$val = true;
+            }
+            else if (Array.isArray(plumGraph)) {
+                graph = deValNull(decodeGraph(plumGraph));
+            }
+            else {
+                throw Error('decorate.unexpected_graph');
+            }
+        }
+        if (plumGraph[REF]) {
+            Object.defineProperty(graph, '$ref', {
+                value: decodePath(plumGraph[REF]),
+            });
+        }
+        return graph;
+    }
+    function descend(children, $key) {
+        const key = ArrayBuffer.isView($key) ? $key : encodeArgs($key).key;
+        if (!Array.isArray(children))
+            return null;
+        const ix = findFirst(children, key);
+        const node = children[ix];
+        if (!node)
+            return;
+        if (isRange(node) && node.end >= key)
+            return null;
+        if (cmp(node.key, key) !== 0)
+            return;
+        const result = getValue(node);
+        if (node.prefix)
+            result[PRE] = $key;
+        return result;
+    }
+    function getValue(node) {
+        let result;
+        if (node.path) {
+            result = unwrap(rootGraph, node.path);
+            if (typeof result === 'object' && result)
+                result[REF] = node.path;
+        }
+        else {
+            result = getNodeValue(node);
+        }
+        return result;
+    }
+    function slice(children, $key) {
+        const [range, filter] = splitArgs($key);
+        if (isDef(filter)) {
+            children = descend(children, filter);
+        }
+        else if (isMinKey(children[0].key) && children[0].prefix) {
+            children = descend(children, MIN_KEY);
+        }
+        const { key, end, limit = Number.POSITIVE_INFINITY } = encodeArgs(range);
+        const ix = findFirst(children, key);
+        let i = ix;
+        let result;
+        if (cmp(key, end) < 0) {
+            for (let n = 0; i < children.length && n < limit; i++) {
+                if (!isRange(children[i]))
+                    n++;
+            }
+            // console.log('slicing fwd', children, ix, i);
+            result = children.slice(ix, i);
+        }
+        else {
+            for (let n = 0; i >= 0 && n < limit; i--) {
+                if (!isRange(children[i]))
+                    n++;
+            }
+            // console.log('slicing bkd', children, i + 1, ix + 1);
+            result = children.slice(i + 1, ix + 1);
+        }
+        if (children[REF])
+            result[REF] = children[REF];
+        if (children[PRE])
+            result[PRE] = children[PRE];
+        return result;
+    }
+    const result = construct(rootGraph, rootQuery);
+    // console.log('Decorate', result, rootGraph, rootQuery);
+    return result;
+}
+// Replace $val: null produced by
+function deValNull(graph) {
+    if (typeof graph !== 'object' || !graph)
+        return graph;
+    if ('$val' in graph && graph.$val !== true)
+        return graph.$val;
+    // Important: update graph in-place to avoid losing non-enumerable props.
+    for (const prop in graph)
+        graph[prop] = deValNull(graph[prop]);
+    return graph;
+}
+function addPageMeta(graph, args) {
+    if (args.$all) {
+        Object.assign(graph, { $page: args, $prev: null, $next: null });
+        return;
+    }
+    const [{ $first, $last, ...bounds }, filter] = splitArgs(args);
+    const count = $first || $last;
+    /** @type {any} */
+    const $page = { ...filter, ...bounds, $all: true };
+    if (graph.length === count) {
+        // This result was limited by the count; update the "outer" bound.
+        if ($first) {
+            const boundKey = graph[graph.length - 1].$key;
+            $page.$until = isDef(boundKey?.$cursor) ? boundKey.$cursor : boundKey;
+            delete $page.$before;
+        }
+        else {
+            const boundKey = graph[0].$key;
+            $page.$since = isDef(boundKey?.$cursor) ? boundKey.$cursor : boundKey;
+            delete $page.$after;
+        }
+    }
+    // biome-ignore format: ternary chain
+    const $prev = isDef($page.$after) ? { ...filter, $last: count, $until: $page.$after } :
+        isDef($page.$since) ? { ...filter, $last: count, $before: $page.$since } :
+            null;
+    // biome-ignore format: ternary chain
+    const $next = isDef($page.$before) ? { ...filter, $first: count, $since: $page.$before } :
+        isDef($page.$until) ? { ...filter, $first: count, $after: $page.$until } :
+            null;
+    Object.assign(graph, { $page, $next, $prev });
+}

package/coding/encodeTree.d.ts

@@ -0,0 +1,2 @@
+export declare function encodeGraph(obj: any, version?: number): any;
+export declare function encodeQuery(obj: any, version?: number): any;