@graffy/common 0.19.1-alpha.1 → 0.19.1

package/package.json

@@ -2,29 +2,23 @@
   "name": "@graffy/common",
   "description": "Common libraries that used by various Graffy modules.",
   "author": "aravind (https://github.com/aravindet)",
-  "version": "0.19.1-alpha.1",
-  "main": "./cjs/index.js",
+  "version": "0.19.1",
+  "main": "./index.cjs",
   "exports": {
-    ".": {
-      "import": "./index.js",
-      "types": "./index.d.ts"
-    },
-    "./*": {
-      "import": "./*.js",
-      "types": "./*.d.ts"
-    }
+    "import": "./index.mjs",
+    "require": "./index.cjs"
   },
-  "types": "./index.d.ts",
+  "module": "./index.mjs",
+  "types": "./types/index.d.ts",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/usegraffy/graffy.git"
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "debug": "^4.4.3",
     "lodash": "^4.17.23",
-    "nanoid": "^5.1.6",
-    "@graffy/stream": "0.19.1-alpha.1",
+    "debug": "^4.4.3",
+    "@graffy/stream": "0.19.1",
     "merge-async-iterators": "^0.2.1"
   }
 }

package/types/coding/args.d.ts

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

package/types/coding/base64.d.ts

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

package/types/coding/decodeTree.d.ts

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

package/types/coding/encodeTree.d.ts

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

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

@@ -1,8 +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 { default as decorate } from "./decorate.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 { decode as decodeValue, encode as encodeValue } from "./struct.js";

package/types/coding/number.d.ts

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

package/types/coding/pack.d.ts

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

package/types/coding/path.d.ts

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

package/types/coding/string.d.ts

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

package/types/coding/struct.d.ts

@@ -0,0 +1,11 @@
+export function encode(value: any): Uint8Array<any>;
+export function decode(buffer: any): any;
+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;

package/types/node/find.d.ts

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

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

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

package/types/node/types.d.ts

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

package/types/object.d.ts

@@ -0,0 +1,4 @@
+export function mergeObject(base: any, change: any): any;
+export function cloneObject(object: any): any;
+export function wrapObject(object: any, path: any): any;
+export function unwrapObject(object: any, path: any): any;

package/{ops → types/ops}/finalize.d.ts

@@ -5,7 +5,7 @@
  * @param {number | false} version
  * @returns any
  */
-export default function finalize(graph: any, query: any, version?: number): {
+export default function finalize(graph: any, query: any, version?: number | false): {
     key: Uint8Array<ArrayBuffer>;
     end: Uint8Array<ArrayBuffer>;
     version: number;

package/{ops → types/ops}/getKnown.d.ts

@@ -1 +1,4 @@
-export default function getKnown(graph: any, version?: number): any[];
+export default function getKnown(graph: any, version?: number): {
+    key: any;
+    version: number;
+}[];

package/types/ops/merge.d.ts

@@ -0,0 +1,3 @@
+export default function merge(current: any, changes: any): any;
+export function insertRange(current: any, change: any, start?: number): number;
+export function insertNode(current: any, change: any, start?: number): any;

package/types/ops/path.d.ts

@@ -0,0 +1,6 @@
+export function wrapValue(value: any, path: any, version?: number): any;
+export function wrap(children: any, path: any, version?: number, prefix?: boolean): any;
+export function unwrap(tree: any, path: any): any;
+export function getNodeValue(node: any): any;
+export function remove(children: any, path: any): any;
+export const IS_VAL: unique symbol;

package/types/ops/sieve.d.ts

@@ -0,0 +1,3 @@
+export default function sieve(current: any, changes: any, result?: any[]): any[];
+export function insertRange(current: any, change: any, result: any, start?: number): number;
+export function insertNode(current: any, change: any, result: any, start?: number): any;

package/{ops → types/ops}/slice.d.ts

@@ -1,9 +1,13 @@
+export default function slice(graph: any, query: any, root: any): Result;
+export function sliceRange(graph: any, query: any, result: any): void;
 declare class Result {
     constructor(root: any);
+    root: any;
     addKnown(node: any): void;
+    known: any;
     addUnknown(node: any): void;
+    unknown: any;
     addLinked(children: any): any;
+    linked: any;
 }
-export default function slice(graph: any, query: any, root: any): Result;
-export declare function sliceRange(graph: any, query: any, result: any): void;
 export {};

package/types/ops/step.d.ts

@@ -0,0 +1,6 @@
+export function keyStep(key: any): {
+    key: any;
+    step: number;
+};
+export function keyBefore(key: any): any;
+export function keyAfter(key: any): any;

package/types/stream/makeWatcher.d.ts

@@ -0,0 +1,16 @@
+export default function makeWatcher(): {
+    write: (change: any) => void;
+    watch: (...args: any[]) => {
+        debugId: any;
+        next: () => any;
+        return(value: any): Promise<{
+            value: any;
+            done: boolean;
+        }>;
+        throw(error: any): Promise<{
+            value: any;
+            done: boolean;
+        }>;
+        [Symbol.asyncIterator](): /*elided*/ any;
+    };
+};

package/types/util.d.ts

@@ -0,0 +1,15 @@
+export function isMinKey(key: any): boolean;
+export function isMaxKey(key: any): boolean;
+export function err(message: any, { cause, ...args }?: {
+    cause?: any;
+}): void;
+export function errIf(message: any, condition: any, args: any): void;
+export function isEmpty(object: any): boolean;
+export function isDef(value: any): boolean;
+export function isPlainObject(arg: any): boolean;
+export function clone(obj: any): any;
+export function cmp(a: any, b: any): 0 | 1 | -1;
+export function find(items: any, compare: any, first?: number, last?: any): number;
+export function addStringify(buffer: any): any;
+export const MIN_KEY: Uint8Array<ArrayBuffer>;
+export const MAX_KEY: Uint8Array<ArrayBuffer>;

package/coding/alphabet.js

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

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

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

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

package/coding/base64.js

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

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

package/coding/decodeTree.js

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