@graffy/common 0.19.1-alpha.1 → 0.19.1

package/coding/decorate.js

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

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

package/coding/encodeTree.js

@@ -1,248 +0,0 @@
-import isEqual from 'lodash/isEqual.js';
-import { add, merge, setVersion, wrap } from "../ops/index.js";
-import { clone, cmp, isDef, isEmpty, isPlainObject, MAX_KEY, MIN_KEY, } from "../util.js";
-import { encode as encodeArgs, splitArgs } from "./args.js";
-import { encode as encodePath, splitRef } from "./path.js";
-const ROOT_KEY = Symbol();
-/**
-  @param {any} value
-  @param {{version?: number, isGraph?: boolean}} options
-*/
-function encode(value, { version, isGraph } = {}) {
-    const links = [];
-    function pushLink($ref, $ver, props, $val, $chi) {
-        const [range, _] = splitRef($ref);
-        const node = !isEmpty(props)
-            ? makeNode(range ? [{ $key: range, ...props }] : props, undefined, $ver)
-            : isDef($chi)
-                ? makeNode(range ? [{ $key: range, $chi }] : $chi, undefined, $ver)
-                : null;
-        // biome-ignore format: ternary chain
-        const children = node ? node.children :
-            isDef($val) ? $val :
-                isGraph ? undefined : 1;
-        if (children) {
-            links.push(wrap(children, encodePath($ref), $ver, !!range)[0]);
-        }
-    }
-    const combine = isGraph ? merge : add;
-    function makeNode(object, key, ver, parentPuts = []) {
-        if (!isDef(object))
-            return;
-        const { $key, $ver, $ref, $val, $chi, $put, ...props } = object || {};
-        // Turn any non-enumerable properties of object into enumerable,
-        // so they're included in ...object below.
-        if (typeof object === 'object' && object && !Array.isArray(object)) {
-            object = {
-                ...Object.fromEntries(Object.entries({
-                    $key,
-                    $ver,
-                    $ref,
-                    $val,
-                    $chi,
-                    $put,
-                }).filter(([_, val]) => isDef(val))),
-                ...props,
-            };
-        }
-        // An empty object is considered equivalent to undefined.
-        if (typeof object === 'object' && object && isEmpty(object))
-            return;
-        if (isDef($ver))
-            ver = $ver;
-        if (isPlainObject($key)) {
-            const [page, filter] = splitArgs($key);
-            if (page) {
-                /*
-                CONSTRUCT PREFIX NODES
-                When we encounter a range key in a graph, it means one of these:
-                1. an empty range, e.g. { $key: { $after: 'foo' } }
-                2. a range reference, e.g.
-                    { $key: { x: 1, $all: true }, $ref: ['foo', { $all: true }] }
-                3. as a shortcut to avoid repetition in query results e.g.
-                    { $key: { x: 1, $all: true }, $chi: [
-                      { $key: 'a', $val: 'A' },
-                      { $key: 'b', $val: 'B' } ] }
-                  is equivalent to:
-                    [ { $key: { x: 1, $before: 'a' } },
-                      { $key: { x: 1, $cursor: 'a' }, $val: 'A' },
-                      { $key: { x: 1, $after: 'a', $before: 'b' } },
-                      { $key: { x: 1, $cursor: 'b' }, $val: 'B' } ]
-        
-                Cases 2. and 3. are handled below: Basically we strip out the "page"
-                part from the key (leaving only the filter), construct a node with that,
-                then add the "prefix" flag to the node.
-        
-                The page part is passed as $put for constructing children (when it's a
-                graph with children)
-              */
-                const foundPuts = parentPuts
-                    .filter(([_, putFilter]) => isEqual(filter, putFilter))
-                    .map(([range]) => range);
-                if (isGraph &&
-                    !isDef(page.$cursor) &&
-                    ($ref || $val || $chi || $put || !isEmpty(props))) {
-                    object.$key = filter || {};
-                    object.$put = foundPuts;
-                    const node = makeNode(object, key, ver);
-                    if (!filter)
-                        node.key = MIN_KEY;
-                    node.prefix = true;
-                    return node;
-                }
-                if ((!isDef(key) || Number.isInteger(key)) &&
-                    (filter || isDef(page.$cursor))) {
-                    object.$key = isDef(page.$cursor) ? page.$cursor : page;
-                    const wrapper = { $key: filter || {}, $chi: [object] };
-                    if (isGraph)
-                        wrapper.$put = foundPuts;
-                    const node = makeNode(wrapper, key, ver);
-                    if (!filter)
-                        node.key = MIN_KEY;
-                    node.prefix = true;
-                    return node;
-                }
-                // console.log('No prefix made', { key, $key, object });
-            }
-        }
-        let putRange = [];
-        const prefixPuts = [];
-        // If this is a plain array (without keyed objects), we should "put" the
-        // entire positive integer range to give it atomic write behavior.
-        if (Array.isArray(object) &&
-            !isDef($put) &&
-            !isDef($val) &&
-            !object.some((it) => isDef(it?.$key))) {
-            putRange = [encodeArgs({ $since: 0, $until: Number.POSITIVE_INFINITY })];
-        }
-        function classifyPut(put) {
-            const [range, filter] = splitArgs(put);
-            if (filter) {
-                prefixPuts.push([range, filter]);
-            }
-            else {
-                putRange.push(encodeArgs(put));
-            }
-        }
-        if ($put === true) {
-            putRange = [{ key: MIN_KEY, end: MAX_KEY }];
-        }
-        else if (Array.isArray($put)) {
-            $put.forEach(classifyPut);
-        }
-        else if (isDef($put)) {
-            classifyPut($put);
-        }
-        if (isDef($key) && (Number.isInteger(key) || !isDef(key)))
-            key = $key;
-        const node = key === ROOT_KEY || !isDef(key) ? {} : encodeArgs(key);
-        // console.log('Set version', node.key, ver);
-        node.version = ver;
-        // console.log('Constructed', { node, $key, key });
-        if (object === null) {
-            node.end = node.key;
-        }
-        else if (isDef($key) && isDef(key) && key !== $key) {
-            // An array has been omitted because there is only one child.
-            node.children = [makeNode(object, undefined, ver, prefixPuts)].filter(Boolean);
-            // We don't want to add a $put at this level.
-            return node;
-        }
-        else if ($ref) {
-            pushLink($ref, node.version, props, $val, $chi);
-            if (!isGraph)
-                return; // Drop query aliases from encoded format
-            node.path = encodePath($ref);
-        }
-        else if ($val === true) {
-            node.value = Array.isArray(object) ? clone(object) : props;
-        }
-        else if (isDef($val)) {
-            node.value = $val;
-        }
-        else if (typeof object !== 'object') {
-            node.value = isGraph || typeof object === 'number' ? object : 1;
-        }
-        else if (isDef($chi)) {
-            const children = $chi
-                .map((obj) => makeNode(obj, undefined, ver, prefixPuts))
-                .filter(Boolean)
-                .sort((a, b) => cmp(a.key, b.key));
-            if (children.length) {
-                node.children = children;
-            }
-        }
-        else if (Array.isArray(object)) {
-            const children = object
-                .map((obj, i) => makeNode(obj, i, ver, prefixPuts))
-                .filter(Boolean)
-                .reduce((acc, it) => {
-                combine(acc, [it]);
-                return acc;
-            }, []);
-            if (children.length) {
-                node.children = children;
-            }
-        }
-        else {
-            const children = Object.keys(props)
-                .sort()
-                .map((key) => makeNode(object[key], key, ver))
-                .filter(Boolean);
-            if (children.length) {
-                node.children = children;
-            }
-            else if (putRange.length) {
-                // Do nothing; this is to avoid falling into the later branches
-            }
-            else if (isGraph) {
-                // Some inconsistency here.
-                // { foo: {} } === undefined (we know nothing)
-                // but { $key: 'foo' }] === { foo: null } (we know foo doesn't exist)
-                // This is because when using the $key notation, we can't use null.
-                if (!(isDef($key) || isDef($put)))
-                    return;
-                if (node.key && !node.end)
-                    node.end = node.key;
-            }
-            else {
-                if (!isDef($key))
-                    return;
-                node.value = 1;
-            }
-        }
-        if (isGraph && putRange.length && !isDef(node.path) && !isDef(node.value)) {
-            const putRangeClone = putRange.map(({ key, end }) => ({
-                key,
-                end,
-                version: 0,
-            }));
-            node.children = merge(putRangeClone, node.children || []);
-        }
-        if (
-        // (key === ROOT_KEY || isDef(node.key)) &&
-        node.children?.length ||
-            isDef(node.end) ||
-            isDef(node.value) ||
-            isDef(node.path)) {
-            return node;
-        }
-    }
-    if (value?.$key)
-        value = [value];
-    const result = makeNode(value, ROOT_KEY, version)?.children || [];
-    while (links.length) {
-        combine(result, [links.pop()]);
-    }
-    // console.log('Encoded', isGraph, value);
-    // console.log('Result', result);
-    return result;
-}
-export function encodeGraph(obj, version = Date.now()) {
-    const encoded = encode(obj, { version, isGraph: true });
-    const versioned = setVersion(encoded, version, true);
-    return versioned;
-}
-export function encodeQuery(obj, version = 0) {
-    return encode(obj, { version, isGraph: false });
-}

package/coding/id.js

@@ -1,4 +0,0 @@
-import { customAlphabet } from 'nanoid/non-secure';
-import alpha from "./alphabet.js";
-// The ID is 20 digits for a similar collision probability as UUID v4
-export default customAlphabet(alpha, 20);

package/coding/index.d.ts

@@ -1,8 +0,0 @@
-export { decode as decodeArgs, encode as encodeArgs, splitArgs, } from './args.js';
-export * from './decodeTree.js';
-export { default as decorate } from './decorate.js';
-export * from './encodeTree.js';
-export { default as makeId } from './id.js';
-export * from './pack.js';
-export { decode as decodePath, encode as encodePath, splitRef, } from './path.js';
-export { decode as decodeValue, encode as encodeValue } from './struct.js';

package/coding/number.d.ts

@@ -1,2 +0,0 @@
-export declare function encode(number: any): Uint8Array<ArrayBuffer>;
-export declare function decode(u8Arr: any): number;

package/coding/number.js

@@ -1,39 +0,0 @@
-/*
-  Order-preserving encoding of 64-bit floating point numbers.
-*/
-function TwosComplement(view) {
-    const lo = -view.getUint32(4) >>> 0;
-    const carry = lo ? 0 : -1;
-    const hi = (~view.getUint32(0) + carry) >>> 0;
-    view.setUint32(0, hi);
-    view.setUint32(4, lo);
-}
-export function encode(number) {
-    const buffer = new ArrayBuffer(8);
-    const view = new DataView(buffer);
-    view.setFloat64(0, number);
-    /* if first bit is set */
-    if (number < 0) {
-        TwosComplement(view);
-    }
-    else {
-        /* non-negative number, just set the leading bit. */
-        view.setUint8(0, view.getUint8(0) | 0x80);
-    }
-    return new Uint8Array(buffer);
-}
-export function decode(u8Arr) {
-    const copy = new Uint8Array(8);
-    copy.set(u8Arr, 0);
-    const { buffer, byteOffset, byteLength } = copy;
-    const view = new DataView(buffer, byteOffset, byteLength);
-    const high = view.getUint8(0);
-    if (high & 0x80) {
-        // originally a non-negative number. Just set the sign bit back to 0.
-        view.setUint8(0, high & 0x7f);
-    }
-    else {
-        TwosComplement(view);
-    }
-    return view.getFloat64(0);
-}

package/coding/pack.d.ts

@@ -1,2 +0,0 @@
-export declare function pack(children: any, parentVersion: any): any;
-export declare function unpack(children: any, parentVersion: any): any;

package/coding/pack.js

@@ -1,71 +0,0 @@
-import { decode, encode } from "./base64.js";
-import { decodeValue, encodeValue } from "./index.js";
-import { STR } from "./struct.js";
-const props = [
-    'end',
-    'version',
-    'limit',
-    'value',
-    'path',
-    'prefix',
-    'children',
-];
-function serializeKey(key) {
-    if (key[0] === STR) {
-        const last = key[key.length - 1];
-        if (last !== 0 && last !== 0xff) {
-            return decodeValue(key);
-        }
-    }
-    return `\0${encode(key)}`;
-}
-function deserializeKey(key) {
-    if (key[0] === '\0')
-        return decode(key.slice(1));
-    return encodeValue(key);
-}
-export function pack(children, parentVersion) {
-    if (!Array.isArray(children))
-        return children;
-    const array = children.map((node) => props.reduce((array, prop, i) => {
-        if (!(prop in node))
-            return array;
-        let value = node[prop];
-        if (prop === 'version' && value === parentVersion)
-            return array;
-        if (prop === 'children')
-            value = pack(value, node.version);
-        if (prop === 'end')
-            value = serializeKey(value);
-        if (prop === 'path')
-            value = value.map(serializeKey);
-        array[1] |= 1 << i;
-        array.push(value);
-        return array;
-    }, [serializeKey(node.key), 0]));
-    return array;
-}
-export function unpack(children, parentVersion) {
-    if (!Array.isArray(children))
-        return children;
-    const node = children.map(([key, type, ...values]) => props.reduce((node, prop, i) => {
-        if (!(type & (1 << i)))
-            return node;
-        let value = values.shift();
-        if (prop === 'children')
-            value = unpack(value, node.version);
-        if (prop === 'end')
-            value = deserializeKey(value);
-        if (prop === 'path')
-            value = value.map(deserializeKey);
-        node[prop] = value;
-        return node;
-    }, { key: deserializeKey(key), version: parentVersion }));
-    return node;
-}
-// export function serialize(payload) {
-//   return JSON.stringify(pack(payload));
-// }
-// export function deserialize(str) {
-//   return unpack(JSON.parse(str));
-// }

package/coding/path.d.ts

@@ -1,3 +0,0 @@
-export declare function encode(path: any): any;
-export declare function decode(path: any): any[];
-export declare function splitRef($ref: any): {}[];

package/coding/path.js

@@ -1,41 +0,0 @@
-import { isPlainObject, MIN_KEY } from "../util.js";
-import { decode as decodeArgs, encode as encodeArgs, splitArgs, } from "./args.js";
-const PATH_SEPARATOR = '.';
-export function encode(path) {
-    if (typeof path === 'string') {
-        if (!path.length || path === PATH_SEPARATOR)
-            return [];
-        path = path.split(PATH_SEPARATOR);
-    }
-    if (!Array.isArray(path)) {
-        throw Error(`encodePath.invalid:${JSON.stringify(path)}`);
-    }
-    function encodeSegment(seg) {
-        if (ArrayBuffer.isView(seg))
-            return seg;
-        const node = encodeArgs(seg);
-        if (node.end)
-            return node;
-        return node.key;
-    }
-    if (isPlainObject(path[path.length - 1])) {
-        const [page, filter] = splitArgs(path[path.length - 1]);
-        if (page)
-            path = path.slice(0, -1).concat([filter || MIN_KEY]);
-    }
-    return path.map(encodeSegment);
-}
-export function decode(path) {
-    if (!Array.isArray(path)) {
-        throw Error(`decodePath.invalid:${JSON.stringify(path)}`);
-    }
-    return path.map((key) => decodeArgs({ key }));
-}
-export function splitRef($ref) {
-    if (!Array.isArray($ref))
-        return [];
-    const tail = $ref[$ref.length - 1];
-    if (!isPlainObject(tail))
-        return [];
-    return splitArgs(tail);
-}

package/coding/string.d.ts

@@ -1,2 +0,0 @@
-export declare function encode(string: any): Uint8Array<ArrayBuffer>;
-export declare function decode(u8Arr: any): string;

package/coding/string.js

@@ -1,8 +0,0 @@
-const textEncoder = new TextEncoder();
-const textDecoder = new TextDecoder('utf-8');
-export function encode(string) {
-    return textEncoder.encode(string);
-}
-export function decode(u8Arr) {
-    return textDecoder.decode(u8Arr);
-}

package/coding/struct.d.ts

@@ -1,11 +0,0 @@
-export declare const END = 0;
-export declare const NULL = 1;
-export declare const FALSE = 2;
-export declare const TRUE = 3;
-export declare const NUM = 4;
-export declare const STR = 5;
-export declare const ARR = 6;
-export declare const OBJ = 7;
-export declare const EOK = 127;
-export declare function encode(value: any): Uint8Array<any>;
-export declare function decode(buffer: any): any;