flatpack-json 8.14.3

package/dist/RefElements.d.mts

@@ -0,0 +1,139 @@
+import type { ArrayElement, BigIntElement, DateElement, Index, MapElement, ObjectElement, ObjectWrapperElement, RegExpElement, SetElement, SimplePrimitive, StringElement, SubStringElement } from './types.mjs';
+export interface BaseRef {
+    /** Unique id of the reference */
+    id: number;
+}
+export type FnIndexLookup = (ref: RefElements | undefined) => Index;
+export interface RefElement<T> extends BaseRef {
+    toElement(lookupFn: FnIndexLookup): T;
+    clone(): RefElement<T>;
+    getDependencies(): RefElements[] | undefined;
+}
+export type RefElements = ArrayRefElement | BigIntRefElement | DateRefElement | MapRefElement | ObjectRefElement | ObjectWrapperRefElement | PrimitiveRefElement<boolean> | PrimitiveRefElement<null> | PrimitiveRefElement<number> | PrimitiveRefElement<SimplePrimitive> | PrimitiveRefElement<string> | PrimitiveRefElement<undefined> | RegExpRefElement | SetRefElement | StringPrimitiveRefElement | StringConcatRefElement | SubStringRefElement;
+export type StringRefElements = SubStringRefElement | StringConcatRefElement | StringPrimitiveRefElement;
+export declare class BaseRefElement implements BaseRef {
+    id: number;
+    setId(i: number): void;
+}
+export declare class PrimitiveRefElementBase<T extends SimplePrimitive> extends BaseRefElement implements RefElement<T> {
+    #private;
+    constructor(value: T);
+    toElement(): T;
+    get value(): T;
+    clone(): PrimitiveRefElement<T>;
+    getDependencies(): undefined;
+}
+export declare class PrimitiveRefElement<T extends SimplePrimitive> extends PrimitiveRefElementBase<T> {
+    constructor(value: T);
+    static fromJSON<T extends SimplePrimitive>(value: T): PrimitiveRefElement<T>;
+}
+export declare class NumberRefElement extends PrimitiveRefElementBase<number> {
+    constructor(value: number);
+    static fromJSON(value: number): NumberRefElement;
+}
+export declare class StringPrimitiveRefElement extends PrimitiveRefElementBase<string> {
+    constructor(value: string);
+    get length(): number;
+    static fromJSON(value: string): StringPrimitiveRefElement;
+}
+export declare class ObjectRefElement extends BaseRefElement implements RefElement<ObjectElement> {
+    #private;
+    constructor(keys?: ArrayRefElement, values?: ArrayRefElement);
+    keys(): ArrayRefElement | undefined;
+    values(): ArrayRefElement | undefined;
+    setKeysAndValues(keys: ArrayRefElement | undefined, values: ArrayRefElement): void;
+    toElement(lookup: FnIndexLookup): ObjectElement;
+    clone(): ObjectRefElement;
+    getDependencies(): RefElements[] | undefined;
+    static fromJSON(elem: ObjectElement, resolve: (index: number) => RefElements): ObjectRefElement;
+}
+export declare class ObjectWrapperRefElement extends BaseRefElement implements RefElement<ObjectElement> {
+    #private;
+    constructor(value?: RefElements);
+    setValue(value: RefElements): void;
+    toElement(lookup: FnIndexLookup): ObjectWrapperElement;
+    clone(): ObjectWrapperRefElement;
+    getDependencies(): RefElements[] | undefined;
+    static fromJSON(elem: ObjectWrapperElement, resolve: (index: number) => RefElements): ObjectWrapperRefElement;
+}
+export declare class SetRefElement extends BaseRefElement implements RefElement<SetElement> {
+    #private;
+    constructor(values?: ArrayRefElement);
+    setValues(values: ArrayRefElement): void;
+    toElement(lookup: FnIndexLookup): SetElement;
+    clone(): SetRefElement;
+    getDependencies(): RefElements[] | undefined;
+    values(): ArrayRefElement | undefined;
+    static fromJSON(elem: SetElement, resolve: (index: number) => RefElements): SetRefElement;
+}
+export declare class MapRefElement extends BaseRefElement implements RefElement<MapElement> {
+    #private;
+    constructor(keys?: ArrayRefElement, values?: ArrayRefElement);
+    setKeysAndValues(keys: ArrayRefElement, values: ArrayRefElement): void;
+    toElement(lookup: FnIndexLookup): MapElement;
+    clone(): MapRefElement;
+    getDependencies(): RefElements[] | undefined;
+    keys(): ArrayRefElement | undefined;
+    values(): ArrayRefElement | undefined;
+    static fromJSON(elem: MapElement, resolve: (index: number) => RefElements): MapRefElement;
+}
+export declare class RegExpRefElement extends BaseRefElement implements RefElement<RegExpElement> {
+    #private;
+    constructor(pattern: StringRefElements, flags: StringRefElements);
+    toElement(lookup: FnIndexLookup): RegExpElement;
+    clone(): RegExpRefElement;
+    getDependencies(): RefElements[] | undefined;
+    static fromJSON(elem: RegExpElement, resolve: (index: number) => RefElements): RegExpRefElement;
+}
+export declare class DateRefElement extends BaseRefElement implements RefElement<DateElement> {
+    #private;
+    constructor(value: number);
+    toElement(): DateElement;
+    clone(): DateRefElement;
+    getDependencies(): undefined;
+    static fromJSON(value: DateElement): DateRefElement;
+}
+export declare class BigIntRefElement extends BaseRefElement implements RefElement<BigIntElement> {
+    #private;
+    constructor(value: PrimitiveRefElement<number> | StringRefElements);
+    toElement(lookup: FnIndexLookup): BigIntElement;
+    clone(): BigIntRefElement;
+    getDependencies(): RefElements[] | undefined;
+    static fromJSON(elem: BigIntElement, resolve: (index: number) => RefElements): BigIntRefElement;
+}
+export declare class ArrayRefElement extends BaseRefElement implements RefElement<ArrayElement> {
+    #private;
+    constructor(values?: RefElements[]);
+    get hash(): number;
+    setValues(values: RefElements[]): void;
+    valueRefs(): RefElements[];
+    toElement(lookup: FnIndexLookup): ArrayElement;
+    get length(): number;
+    isEqual(other: ArrayRefElement): boolean;
+    clone(): ArrayRefElement;
+    getDependencies(): RefElements[] | undefined;
+    static fromJSON(elem: ArrayElement, resolve: (index: number) => RefElements): ArrayRefElement;
+}
+export declare class SubStringRefElement extends BaseRefElement implements RefElement<SubStringElement | string> {
+    #private;
+    constructor(value: StringRefElements, len: number, offset?: number);
+    toElement(lookup: FnIndexLookup): SubStringElement | string;
+    get value(): string;
+    get length(): number;
+    clone(): SubStringRefElement;
+    getDependencies(): RefElements[] | undefined;
+    static fromJSON(elem: SubStringElement, resolve: (index: number) => RefElements): SubStringRefElement;
+}
+export declare class StringConcatRefElement extends BaseRefElement implements RefElement<StringElement | string> {
+    #private;
+    constructor(values: StringRefElements[]);
+    toElement(lookup: FnIndexLookup): StringElement | string;
+    get value(): string;
+    get length(): number;
+    clone(): StringConcatRefElement;
+    getDependencies(): RefElements[] | undefined;
+    static fromJSON(elem: StringElement, resolve: (index: number) => RefElements): StringConcatRefElement;
+}
+export declare function isStringRefElements(elem: RefElements): elem is StringRefElements;
+export declare function isPrimitiveRefElement(elem: RefElements): elem is PrimitiveRefElement<SimplePrimitive>;
+//# sourceMappingURL=RefElements.d.mts.map

package/dist/RefElements.mjs

@@ -0,0 +1,385 @@
+import assert from 'node:assert';
+import { ElementType } from './types.mjs';
+export class BaseRefElement {
+    id = 0;
+    setId(i) {
+        this.id = i;
+    }
+}
+export class PrimitiveRefElementBase extends BaseRefElement {
+    #v;
+    constructor(value) {
+        super();
+        this.#v = value;
+    }
+    toElement() {
+        return this.#v;
+    }
+    get value() {
+        return this.#v;
+    }
+    clone() {
+        return new PrimitiveRefElement(this.#v);
+    }
+    getDependencies() {
+        return undefined;
+    }
+}
+export class PrimitiveRefElement extends PrimitiveRefElementBase {
+    constructor(value) {
+        super(value);
+    }
+    static fromJSON(value) {
+        return new PrimitiveRefElement(value);
+    }
+}
+export class NumberRefElement extends PrimitiveRefElementBase {
+    constructor(value) {
+        super(value);
+    }
+    static fromJSON(value) {
+        return new NumberRefElement(value);
+    }
+}
+export class StringPrimitiveRefElement extends PrimitiveRefElementBase {
+    constructor(value) {
+        super(value);
+    }
+    get length() {
+        return this.value.length;
+    }
+    static fromJSON(value) {
+        return new StringPrimitiveRefElement(value);
+    }
+}
+export class ObjectRefElement extends BaseRefElement {
+    #k;
+    #v;
+    constructor(keys, values) {
+        super();
+        this.#k = keys;
+        this.#v = values;
+    }
+    keys() {
+        return this.#k;
+    }
+    values() {
+        return this.#v;
+    }
+    setKeysAndValues(keys, values) {
+        assert(!keys || keys.length === values.length);
+        this.#k = keys;
+        this.#v = values;
+    }
+    toElement(lookup) {
+        return [ElementType.Object, lookup(this.#k), lookup(this.#v)];
+    }
+    clone() {
+        return new ObjectRefElement(this.#k, this.#v);
+    }
+    getDependencies() {
+        return [this.#k, this.#v].filter((r) => !!r);
+    }
+    static fromJSON(elem, resolve) {
+        const keys = resolve(elem[1]);
+        const values = resolve(elem[2]);
+        if (isPrimitiveRefElement(values)) {
+            assert(values.value === undefined);
+            return new ObjectRefElement();
+        }
+        assert(keys instanceof ArrayRefElement || keys === undefined);
+        assert(values instanceof ArrayRefElement || values === undefined);
+        return new ObjectRefElement(keys, values);
+    }
+}
+export class ObjectWrapperRefElement extends BaseRefElement {
+    #v;
+    constructor(value) {
+        super();
+        this.#v = value;
+    }
+    setValue(value) {
+        this.#v = value;
+    }
+    toElement(lookup) {
+        return [ElementType.Object, 0, lookup(this.#v)];
+    }
+    clone() {
+        return new ObjectWrapperRefElement(this.#v);
+    }
+    getDependencies() {
+        return this.#v ? [this.#v] : undefined;
+    }
+    static fromJSON(elem, resolve) {
+        const values = resolve(elem[2]);
+        assert(elem[1] === 0);
+        return new ObjectWrapperRefElement(values);
+    }
+}
+export class SetRefElement extends BaseRefElement {
+    #v;
+    constructor(values) {
+        super();
+        this.#v = values;
+    }
+    setValues(values) {
+        this.#v = values;
+    }
+    toElement(lookup) {
+        return [ElementType.Set, lookup(this.#v)];
+    }
+    clone() {
+        return new SetRefElement(this.#v);
+    }
+    getDependencies() {
+        return this.#v ? [this.#v] : undefined;
+    }
+    values() {
+        return this.#v;
+    }
+    static fromJSON(elem, resolve) {
+        const values = resolve(elem[1]);
+        assert(values instanceof ArrayRefElement || values === undefined);
+        return new SetRefElement(values);
+    }
+}
+export class MapRefElement extends BaseRefElement {
+    #k;
+    #v;
+    constructor(keys, values) {
+        super();
+        this.#k = keys;
+        this.#v = values;
+    }
+    setKeysAndValues(keys, values) {
+        assert(keys.length === values.length);
+        this.#k = keys;
+        this.#v = values;
+    }
+    toElement(lookup) {
+        return [ElementType.Map, lookup(this.#k), lookup(this.#v)];
+    }
+    clone() {
+        return new MapRefElement(this.#k, this.#v);
+    }
+    getDependencies() {
+        return [this.#k, this.#v].filter((r) => !!r);
+    }
+    keys() {
+        return this.#k;
+    }
+    values() {
+        return this.#v;
+    }
+    static fromJSON(elem, resolve) {
+        const keys = resolve(elem[1]);
+        const values = resolve(elem[2]);
+        assert(keys instanceof ArrayRefElement || keys === undefined);
+        assert(values instanceof ArrayRefElement || values === undefined);
+        return new MapRefElement(keys, values);
+    }
+}
+export class RegExpRefElement extends BaseRefElement {
+    #p;
+    #f;
+    constructor(pattern, flags) {
+        super();
+        this.#p = pattern;
+        this.#f = flags;
+    }
+    toElement(lookup) {
+        return [ElementType.RegExp, lookup(this.#p), lookup(this.#f)];
+    }
+    clone() {
+        return new RegExpRefElement(this.#p, this.#f);
+    }
+    getDependencies() {
+        return [this.#p, this.#f].filter((r) => !!r);
+    }
+    static fromJSON(elem, resolve) {
+        const pattern = resolve(elem[1]);
+        const flags = resolve(elem[2]);
+        assert(isStringRefElements(pattern) || pattern === undefined);
+        assert(isStringRefElements(flags) || flags === undefined);
+        return new RegExpRefElement(pattern, flags);
+    }
+}
+export class DateRefElement extends BaseRefElement {
+    #v;
+    constructor(value) {
+        super();
+        this.#v = value;
+    }
+    toElement() {
+        return [ElementType.Date, this.#v];
+    }
+    clone() {
+        return new DateRefElement(this.#v);
+    }
+    getDependencies() {
+        return undefined;
+    }
+    static fromJSON(value) {
+        return new DateRefElement(value[1]);
+    }
+}
+export class BigIntRefElement extends BaseRefElement {
+    #v;
+    constructor(value) {
+        super();
+        this.#v = value;
+    }
+    toElement(lookup) {
+        return [ElementType.BigInt, lookup(this.#v)];
+    }
+    clone() {
+        return new BigIntRefElement(this.#v);
+    }
+    getDependencies() {
+        return [this.#v];
+    }
+    static fromJSON(elem, resolve) {
+        const value = resolve(elem[1]);
+        assert(value instanceof NumberRefElement || isStringRefElements(value));
+        return new BigIntRefElement(value);
+    }
+}
+export class ArrayRefElement extends BaseRefElement {
+    #v;
+    #hash = 0;
+    constructor(values) {
+        super();
+        this.#v = values || [];
+        this.#updateHash();
+    }
+    get hash() {
+        return this.#hash;
+    }
+    #updateHash() {
+        if (!this.#v.length) {
+            this.#hash = 0;
+        }
+        this.#hash = simpleHash(this.#v.map((v) => v.id));
+    }
+    setValues(values) {
+        this.#v = values;
+        this.#updateHash();
+    }
+    valueRefs() {
+        return this.#v;
+    }
+    toElement(lookup) {
+        return [ElementType.Array, ...this.#v.map(lookup)];
+    }
+    get length() {
+        return this.#v.length;
+    }
+    isEqual(other) {
+        if (this.length !== other.length)
+            return false;
+        for (let i = 0; i < this.length; ++i) {
+            if (this.#v[i] !== other.#v[i])
+                return false;
+        }
+        return true;
+    }
+    clone() {
+        return new ArrayRefElement(this.#v);
+    }
+    getDependencies() {
+        return this.#v;
+    }
+    static fromJSON(elem, resolve) {
+        const values = elem.slice(1).map(resolve);
+        return new ArrayRefElement(values);
+    }
+}
+function simpleHash(values) {
+    let hash = Math.sqrt(values.length);
+    for (const value of values) {
+        hash += value * value;
+    }
+    return hash;
+}
+export class SubStringRefElement extends BaseRefElement {
+    #v;
+    #l;
+    #o;
+    constructor(value, len, offset) {
+        super();
+        this.#v = value;
+        this.#l = len;
+        this.#o = offset;
+    }
+    toElement(lookup) {
+        const elm = this.#o
+            ? [ElementType.SubString, lookup(this.#v), this.#l, this.#o]
+            : [ElementType.SubString, lookup(this.#v), this.#l];
+        const v = this.value;
+        return JSON.stringify(elm).length < JSON.stringify(v).length ? elm : v;
+    }
+    get value() {
+        const offset = this.#o || 0;
+        const v = this.#v.value.slice(offset, offset + this.#l);
+        return v;
+    }
+    get length() {
+        return this.#l;
+    }
+    clone() {
+        return new SubStringRefElement(this.#v, this.#l, this.#o);
+    }
+    getDependencies() {
+        return [this.#v];
+    }
+    static fromJSON(elem, resolve) {
+        const idx = resolve(elem[1]);
+        assert(isStringRefElements(idx));
+        return new SubStringRefElement(idx, elem[2], elem[3]);
+    }
+}
+export class StringConcatRefElement extends BaseRefElement {
+    #v;
+    #s = '';
+    #l = 0;
+    constructor(values) {
+        super();
+        this.#v = values;
+    }
+    toElement(lookup) {
+        const elem = [ElementType.String, ...this.#v.map(lookup)];
+        const v = this.value;
+        return JSON.stringify(elem).length < JSON.stringify(v).length ? elem : v;
+    }
+    get value() {
+        if (!this.#s) {
+            this.#s = this.#v.map((r) => r.value).join('');
+        }
+        return this.#s;
+    }
+    get length() {
+        if (!this.#l) {
+            this.#l = this.#v.reduce((acc, r) => acc + r.length, 0);
+        }
+        return this.#l;
+    }
+    clone() {
+        return new StringConcatRefElement(this.#v);
+    }
+    getDependencies() {
+        return this.#v;
+    }
+    static fromJSON(elem, resolve) {
+        const values = elem.slice(1).map(resolve).filter(isStringRefElements);
+        return new StringConcatRefElement(values);
+    }
+}
+export function isStringRefElements(elem) {
+    return (elem instanceof SubStringRefElement ||
+        elem instanceof StringConcatRefElement ||
+        elem instanceof StringPrimitiveRefElement);
+}
+export function isPrimitiveRefElement(elem) {
+    return elem instanceof PrimitiveRefElementBase;
+}
+//# sourceMappingURL=RefElements.mjs.map

package/dist/Trie.d.mts

@@ -0,0 +1,18 @@
+export declare class Trie<T> {
+    root: RootNode<T>;
+    add(key: string | Iterable<string>, data: T): void;
+    find(key: string | Iterable<string>): {
+        data: T | undefined;
+        found: string;
+    } | undefined;
+}
+type ChildMap<T> = Map<string, TrieNode<T>>;
+interface TrieNode<T> {
+    d?: T | undefined;
+    c?: ChildMap<T>;
+}
+interface RootNode<T> extends TrieNode<T> {
+    d: undefined;
+}
+export {};
+//# sourceMappingURL=Trie.d.mts.map

package/dist/Trie.mjs

@@ -0,0 +1,35 @@
+export class Trie {
+    root = { d: undefined, c: new Map() };
+    add(key, data) {
+        let node = this.root;
+        for (const k of key) {
+            let c = node.c;
+            if (!c) {
+                node.c = c = new Map();
+            }
+            let n = c.get(k);
+            if (!n) {
+                c.set(k, (n = { d: data }));
+            }
+            node = n;
+        }
+    }
+    find(key) {
+        let node = this.root;
+        let found = '';
+        for (const k of key) {
+            const c = node.c;
+            if (!c) {
+                break;
+            }
+            const n = c.get(k);
+            if (!n) {
+                break;
+            }
+            found += k;
+            node = n;
+        }
+        return { data: node.d, found };
+    }
+}
+//# sourceMappingURL=Trie.mjs.map

package/dist/flatpackUtil.d.mts

@@ -0,0 +1,12 @@
+import { RefElements } from './RefElements.mjs';
+import { Flatpacked, type FlattenedElement } from './types.mjs';
+export declare function fromElement(elem: FlattenedElement, resolve: (index: number) => RefElements): RefElements;
+export declare function fromFlatpacked(flat: Flatpacked): RefElements[];
+export declare class FlatpackedWrapper {
+    readonly elements: Flatpacked;
+    constructor(elements: Flatpacked);
+    static parse(content: string): FlatpackedWrapper;
+    toRefElements(): RefElements[];
+}
+export declare function isFlatpacked(value: unknown): value is Flatpacked;
+//# sourceMappingURL=flatpackUtil.d.mts.map

package/dist/flatpackUtil.mjs

@@ -0,0 +1,95 @@
+import assert from 'node:assert';
+import { ArrayRefElement, BigIntRefElement, DateRefElement, MapRefElement, NumberRefElement, ObjectRefElement, ObjectWrapperRefElement, PrimitiveRefElement, RegExpRefElement, SetRefElement, StringConcatRefElement, StringPrimitiveRefElement, SubStringRefElement, } from './RefElements.mjs';
+import { dataHeader, ElementType, } from './types.mjs';
+export function fromElement(elem, resolve) {
+    function handleArrayElement(element) {
+        switch (element[0]) {
+            case ElementType.Array: {
+                break;
+            }
+            case ElementType.Object: {
+                if (element[1] === 0 && element[2]) {
+                    return ObjectWrapperRefElement.fromJSON(element, resolve);
+                }
+                return ObjectRefElement.fromJSON(element, resolve);
+            }
+            case ElementType.String: {
+                return StringConcatRefElement.fromJSON(element, resolve);
+            }
+            case ElementType.SubString: {
+                return SubStringRefElement.fromJSON(element, resolve);
+            }
+            case ElementType.Set: {
+                return SetRefElement.fromJSON(element, resolve);
+            }
+            case ElementType.Map: {
+                return MapRefElement.fromJSON(element, resolve);
+            }
+            case ElementType.RegExp: {
+                return RegExpRefElement.fromJSON(element, resolve);
+            }
+            case ElementType.Date: {
+                return DateRefElement.fromJSON(element);
+            }
+            case ElementType.BigInt: {
+                return BigIntRefElement.fromJSON(element, resolve);
+            }
+        }
+        return ArrayRefElement.fromJSON(element, resolve);
+    }
+    if (Array.isArray(elem)) {
+        return handleArrayElement(elem);
+    }
+    if (typeof elem === 'string') {
+        return StringPrimitiveRefElement.fromJSON(elem);
+    }
+    if (typeof elem === 'number') {
+        return NumberRefElement.fromJSON(elem);
+    }
+    if (typeof elem === 'object') {
+        if (elem === null) {
+            return PrimitiveRefElement.fromJSON(elem);
+        }
+        return new ObjectRefElement();
+    }
+    assert(typeof elem === 'boolean');
+    return PrimitiveRefElement.fromJSON(elem);
+}
+export function fromFlatpacked(flat) {
+    const elements = [];
+    const known = new Map();
+    function resolve(index) {
+        const found = known.get(index);
+        if (found)
+            return found;
+        const element = fromElement(flat[index], resolve);
+        known.set(index, element);
+        elements[index] = element;
+        element.setId(index);
+        return element;
+    }
+    elements[0] = new PrimitiveRefElement(undefined);
+    known.set(0, elements[0]);
+    for (let i = 1; i < flat.length; i++) {
+        resolve(i);
+    }
+    return elements;
+}
+export class FlatpackedWrapper {
+    elements;
+    constructor(elements) {
+        this.elements = elements;
+    }
+    static parse(content) {
+        const data = JSON.parse(content);
+        assert(isFlatpacked(data));
+        return new FlatpackedWrapper(data);
+    }
+    toRefElements() {
+        return fromFlatpacked(this.elements);
+    }
+}
+export function isFlatpacked(value) {
+    return Array.isArray(value) && value[0] === dataHeader;
+}
+//# sourceMappingURL=flatpackUtil.mjs.map

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { FlatpackStore } from './Flatpack.mjs';
+export { stringify, toJSON } from './storage.mjs';
+export { stringifyFlatpacked } from './stringify.mjs';
+export type { Flatpacked } from './types.mts';
+export { fromJSON, parse } from './unpack.mjs';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,5 @@
+export { FlatpackStore } from './Flatpack.mjs';
+export { stringify, toJSON } from './storage.mjs';
+export { stringifyFlatpacked } from './stringify.mjs';
+export { fromJSON, parse } from './unpack.mjs';
+//# sourceMappingURL=index.js.map