@graffy/common 0.19.0 → 0.19.1-alpha.2

package/coding/encodeTree.js

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

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

@@ -0,0 +1,8 @@
+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/{types/coding/index.d.ts → coding/index.js}

@@ -1,8 +1,8 @@
+export { decode as decodeArgs, encode as encodeArgs, splitArgs, } from "./args.js";
 export * from "./decodeTree.js";
-export * from "./encodeTree.js";
-export * from "./pack.js";
 export { default as decorate } from "./decorate.js";
+export * from "./encodeTree.js";
 export { default as makeId } from "./id.js";
-export { decode as decodeArgs, encode as encodeArgs, splitArgs } from "./args.js";
-export { decode as decodePath, encode as encodePath, splitRef } from "./path.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

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

package/coding/number.js

@@ -0,0 +1,39 @@
+/*
+  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

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

package/coding/pack.js

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

@@ -0,0 +1,3 @@
+export declare function encode(path: any): any;
+export declare function decode(path: any): any[];
+export declare function splitRef($ref: any): any[] | [Record<string, any>, Record<string, any>];

package/coding/path.js

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

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

package/coding/string.js

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

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

package/coding/struct.js

@@ -0,0 +1,162 @@
+import { addStringify } from "../util.js";
+import { decode as decodeNumber, encode as encodeNumber } from "./number.js";
+import { decode as decodeString, encode as encodeString } from "./string.js";
+/*
+  Sortable encoding of JSON objects for Graffy keys.
+
+  The constraints are:
+  - Sorting a byte stream should
+*/
+export const END = 0;
+export const NULL = 1;
+export const FALSE = 2;
+export const TRUE = 3;
+export const NUM = 4;
+export const STR = 5;
+export const ARR = 6;
+export const OBJ = 7;
+export const EOK = 127; // end-of-key
+function encodeArray(array) {
+    return [ARR, ...array.flatMap((value) => encodeParts(value)), END];
+}
+function encodeObject(object) {
+    const keys = Object.keys(object).sort();
+    return [
+        OBJ,
+        ...keys.flatMap((key) => [
+            STR,
+            encodeString(key),
+            END,
+            ...encodeParts(object[key]),
+        ]),
+        END,
+    ];
+}
+function encodeParts(value) {
+    if (value === null)
+        return [NULL];
+    if (value === false)
+        return [FALSE];
+    if (value === true)
+        return [TRUE];
+    if (typeof value === 'number')
+        return [NUM, encodeNumber(value)];
+    if (typeof value === 'string')
+        return [STR, encodeString(value), END];
+    if (Array.isArray(value))
+        return encodeArray(value);
+    if (typeof value === 'object')
+        return encodeObject(value);
+    return [NULL];
+}
+export function encode(value) {
+    const parts = encodeParts(value);
+    // Ensure that there are no trailing zeros, so keyBefore() can work.
+    // decode() handles this by assuming as many trailing
+    // zeros as necessary.
+    while (parts[parts.length - 1] === END)
+        parts.pop();
+    // The last byte may occasionally a 0 or 255, which conflicts with keyBefore
+    // and keyAfter. This usually happens when the final part encodes a positive
+    // or negative integer. In such cases, we try to remove trailing zeros, and
+    // if that doesn't do it (we have a trailing 255) we instead append a dummy
+    // suffix that will be ignored by decode.
+    const lastPart = parts[parts.length - 1];
+    if (typeof lastPart !== 'number') {
+        let end = lastPart.length - 1;
+        while (end >= 0 && !lastPart[end])
+            end--;
+        if (lastPart[end] !== 0xff) {
+            parts[parts.length - 1] = lastPart.slice(0, end + 1);
+        }
+        else {
+            parts.push(EOK);
+        }
+    }
+    const length = parts.reduce((sum, part) => sum + (typeof part === 'number' ? 1 : part.length), 0);
+    const buffer = new Uint8Array(length);
+    let i = 0;
+    for (const part of parts) {
+        if (typeof part === 'number') {
+            buffer[i] = part;
+            i++;
+        }
+        else {
+            buffer.set(part, i);
+            i += part.length;
+        }
+    }
+    addStringify(buffer);
+    return buffer;
+}
+const nextKey = new WeakMap();
+export function decode(buffer) {
+    let i = 0;
+    const stack = [[]];
+    function readString() {
+        const start = i;
+        while (i < buffer.length && buffer[i] !== END)
+            i++;
+        const str = decodeString(buffer.subarray(start, i));
+        i++;
+        return str;
+    }
+    function pushToken(type, value) {
+        const current = stack[stack.length - 1];
+        if (type === ARR || type === OBJ)
+            stack.push(value);
+        if (!current)
+            return;
+        if (Array.isArray(current)) {
+            current.push(value);
+        }
+        else {
+            if (nextKey.has(current)) {
+                current[nextKey.get(current)] = value;
+                nextKey.delete(current);
+            }
+            else {
+                nextKey.set(current, value);
+            }
+        }
+    }
+    function popToken() {
+        stack.pop();
+    }
+    while (i < buffer.length) {
+        const type = buffer[i];
+        const start = ++i;
+        switch (type) {
+            case EOK:
+                return stack[0][0];
+            case END:
+                popToken();
+                break;
+            case NULL:
+                pushToken(type, null);
+                break;
+            case FALSE:
+                pushToken(type, false);
+                break;
+            case TRUE:
+                pushToken(type, true);
+                break;
+            case NUM:
+                i += 8;
+                pushToken(type, decodeNumber(buffer.subarray(start, i)));
+                break;
+            case STR:
+                pushToken(type, readString());
+                break;
+            case ARR:
+                pushToken(type, []);
+                break;
+            case OBJ:
+                pushToken(type, {});
+                break;
+            default:
+                throw new Error(`Invalid byte ${type} at ${start}`);
+        }
+    }
+    return stack[0][0];
+}

package/index.d.ts

@@ -0,0 +1,6 @@
+export * from './coding/index.js';
+export * from './node/index.js';
+export * from './object.js';
+export * from './ops/index.js';
+export * from './stream/index.js';
+export * from './util.js';

package/node/find.d.ts

@@ -0,0 +1,2 @@
+export declare function findFirst(children: any, target: any, first?: number, last?: any): number;
+export declare function findLast(children: any, end: any, first?: number, last?: any): number;

package/node/find.js

@@ -0,0 +1,14 @@
+import { cmp, find } from "../util.js";
+export function findFirst(children, target, first = 0, last = children.length) {
+    return find(children, ({ key, end }) => {
+        const keyCmp = cmp(key, target);
+        const endCmp = end && cmp(end, target);
+        if (end && keyCmp < 0 && endCmp >= 0)
+            return 0;
+        return keyCmp;
+    }, first, last);
+}
+export function findLast(children, end, first = 0, last = children.length) {
+    const ix = findFirst(children, end, first, last);
+    return children[ix] && cmp(children[ix].key, end) <= 0 ? ix + 1 : ix;
+}

package/node/index.d.ts

@@ -0,0 +1,2 @@
+export * from './find.js';
+export * from './types.js';

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

@@ -1,2 +1,3 @@
+// export { default as find } from './find.ts';
 export * from "./find.js";
 export * from "./types.js";

package/node/types.d.ts

@@ -0,0 +1,6 @@
+export declare function isRange(node: any): boolean;
+export declare function isBranch(node: any): boolean;
+export declare function isPrefix(node: any): any;
+export declare function isLink(node: any): boolean;
+export declare function isOlder(node: any, version: any): boolean;
+export declare function isNewer(node: any, version: any): boolean;