flatpack-json 9.6.4 → 9.8.0

package/dist/RefCounter.d.mts

@@ -0,0 +1,17 @@
+export declare class RefCounter<T> {
+    #private;
+    constructor(values?: Iterable<T>);
+    /**
+     * Increment the reference count for a value. If the value does not exist in the map, it will be added with a count of 1.
+     */
+    add(value: T): void;
+    set(value: T, count: number): void;
+    has(value: T): boolean;
+    get(value: T): number;
+    isReferenced(value: T): boolean;
+    clear(): void;
+    delete(value: T): boolean;
+    [Symbol.iterator](): IterableIterator<[T, number]>;
+    toJSON(): Map<T, number>;
+}
+//# sourceMappingURL=RefCounter.d.mts.map

package/dist/RefCounter.mjs

@@ -0,0 +1,42 @@
+export class RefCounter {
+    #refCounts = new Map();
+    constructor(values) {
+        if (values) {
+            for (const value of values) {
+                this.add(value);
+            }
+        }
+    }
+    /**
+     * Increment the reference count for a value. If the value does not exist in the map, it will be added with a count of 1.
+     */
+    add(value) {
+        const count = this.#refCounts.get(value) ?? 0;
+        this.#refCounts.set(value, count + 1);
+    }
+    set(value, count) {
+        this.#refCounts.set(value, count);
+    }
+    has(value) {
+        return this.#refCounts.has(value);
+    }
+    get(value) {
+        return this.#refCounts.get(value) ?? 0;
+    }
+    isReferenced(value) {
+        return !!this.get(value);
+    }
+    clear() {
+        this.#refCounts.clear();
+    }
+    delete(value) {
+        return this.#refCounts.delete(value);
+    }
+    [Symbol.iterator]() {
+        return this.#refCounts.entries();
+    }
+    toJSON() {
+        return this.#refCounts;
+    }
+}
+//# sourceMappingURL=RefCounter.mjs.map

package/dist/RefElements.d.mts

@@ -1,9 +1,9 @@
-import type { ArrayElement, BigIntElement, DateElement, Index, MapElement, ObjectElement, ObjectWrapperElement, RegExpElement, SetElement, SimplePrimitive, StringElement, SubStringElement } from './types.mjs';
+import type { ArrayElement, BigIntElement, DateElement, FlatpackIndex, 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 type FnIndexLookup = (ref: RefElements | undefined) => FlatpackIndex;
 export interface RefElement<T> extends BaseRef {
     toElement(lookupFn: FnIndexLookup): T;
     clone(): RefElement<T>;

package/dist/Trie.d.mts

@@ -1,18 +1,48 @@
-export declare class Trie<T> {
-    root: RootNode<T>;
-    add(key: string | Iterable<string>, data: T): void;
+/**
+ * @deprecated This class is a bit wonky and will be removed in the future. Use {@link Trie} instead.
+ */
+export declare class TrieOfStrings<T> {
+    root: RootNode<string, T>;
+    /**
+     * Add a string to the Trie.
+     * The behavior is a bit wonky and will get deprecated in the future.
+     * Wonky behavior:
+     * - It adds the data element to every new node created.
+     */
+    add(key: string | Iterable<string>, data: T): TrieNode<string, T>;
     find(key: string | Iterable<string>): {
         data: T | undefined;
         found: string;
     } | undefined;
+    findNode(key: string | Iterable<string>): FoundNode<string, T> | undefined;
 }
-type ChildMap<T> = Map<string, TrieNode<T>>;
-interface TrieNode<T> {
+export declare class Trie<K, T> {
+    root: TrieNode<K, T>;
+    size: number;
+    set(key: Iterable<K>, data: T): TrieNode<K, T>;
+    get(key: Iterable<K>): T | undefined;
+    has(key: Iterable<K>): boolean;
+    delete(key: Iterable<K>): boolean;
+    clear(): void;
+    /**
+     * Look for the longest prefix of the key that exists in the trie and return the node and the found prefix.
+     * @param key - The key to search for.
+     * @returns The node and path found. If the full key is not found, `found` will be false.
+     */
+    findNode(key: Iterable<K>): FoundNode<K, T> | undefined;
+}
+type ChildMap<K, T> = Map<K, TrieNode<K, T>>;
+interface TrieNode<K, T> {
     d?: T | undefined;
-    c?: ChildMap<T>;
+    c?: ChildMap<K, T>;
 }
-interface RootNode<T> extends TrieNode<T> {
+interface RootNode<K, T> extends TrieNode<K, T> {
     d: undefined;
 }
+interface FoundNode<K, T> {
+    node: TrieNode<K, T>;
+    found: boolean;
+    path: K[];
+}
 export {};
 //# sourceMappingURL=Trie.d.mts.map

package/dist/Trie.mjs

@@ -1,5 +1,14 @@
-export class Trie {
+/**
+ * @deprecated This class is a bit wonky and will be removed in the future. Use {@link Trie} instead.
+ */
+export class TrieOfStrings {
     root = { d: undefined, c: new Map() };
+    /**
+     * Add a string to the Trie.
+     * The behavior is a bit wonky and will get deprecated in the future.
+     * Wonky behavior:
+     * - It adds the data element to every new node created.
+     */
     add(key, data) {
         let node = this.root;
         for (const k of key) {
@@ -13,23 +22,105 @@ export class Trie {
             }
             node = n;
         }
+        return node;
     }
     find(key) {
+        const foundNode = this.findNode(key);
+        if (!foundNode) {
+            return undefined;
+        }
+        const { node, path: found } = foundNode;
+        return { data: node.d, found: found.join('') };
+    }
+    findNode(key) {
+        let node = this.root;
+        const path = [];
+        let found = true;
+        for (const k of key) {
+            const c = node.c;
+            if (!c) {
+                found = false;
+                break;
+            }
+            const n = c.get(k);
+            if (!n) {
+                found = false;
+                break;
+            }
+            path.push(k);
+            node = n;
+        }
+        return { node, path, found };
+    }
+}
+export class Trie {
+    root = {};
+    size = 0;
+    set(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 = {}));
+            }
+            node = n;
+        }
+        const wasSet = Object.hasOwn(node, 'd');
+        node.d = data;
+        if (!wasSet) {
+            ++this.size;
+        }
+        return node;
+    }
+    get(key) {
+        const f = this.findNode(key);
+        return f?.found ? f.node.d : undefined;
+    }
+    has(key) {
+        const f = this.findNode(key);
+        return !!f?.found && Object.hasOwn(f.node, 'd');
+    }
+    delete(key) {
+        const f = this.findNode(key);
+        if (!f?.found || !Object.hasOwn(f.node, 'd')) {
+            return false;
+        }
+        delete f.node.d;
+        --this.size;
+        return true;
+    }
+    clear() {
+        this.root = {};
+        this.size = 0;
+    }
+    /**
+     * Look for the longest prefix of the key that exists in the trie and return the node and the found prefix.
+     * @param key - The key to search for.
+     * @returns The node and path found. If the full key is not found, `found` will be false.
+     */
+    findNode(key) {
         let node = this.root;
-        let found = '';
+        const path = [];
+        let found = true;
         for (const k of key) {
             const c = node.c;
             if (!c) {
+                found = false;
                 break;
             }
             const n = c.get(k);
             if (!n) {
+                found = false;
                 break;
             }
-            found += k;
+            path.push(k);
             node = n;
         }
-        return { data: node.d, found };
+        return { node, path, found };
     }
 }
 //# sourceMappingURL=Trie.mjs.map

package/dist/WeakCache.d.mts

@@ -0,0 +1,15 @@
+/**
+ * A cache that can store values for both primitive and object keys. Primitive keys are stored in a Map,
+ * while object keys are stored in a WeakMap. This allows the cache to automatically clean up entries for
+ * objects that are no longer referenced elsewhere in the program, while still allowing primitive keys to
+ * be stored without issue.
+ */
+export declare class WeakCache<V> {
+    #private;
+    constructor(entries?: Iterable<readonly [unknown, V]>);
+    get(key: unknown): V | undefined;
+    set(key: unknown, value: V): void;
+    clear(): void;
+    has(key: unknown): boolean;
+}
+//# sourceMappingURL=WeakCache.d.mts.map

package/dist/WeakCache.mjs

@@ -0,0 +1,41 @@
+/**
+ * A cache that can store values for both primitive and object keys. Primitive keys are stored in a Map,
+ * while object keys are stored in a WeakMap. This allows the cache to automatically clean up entries for
+ * objects that are no longer referenced elsewhere in the program, while still allowing primitive keys to
+ * be stored without issue.
+ */
+export class WeakCache {
+    #primitiveCache = new Map();
+    #objectCache = new WeakMap();
+    constructor(entries) {
+        if (entries) {
+            for (const [key, value] of entries) {
+                this.set(key, value);
+            }
+        }
+    }
+    get(key) {
+        if (typeof key === 'object' && key !== null) {
+            return this.#objectCache.get(key);
+        }
+        return this.#primitiveCache.get(key);
+    }
+    set(key, value) {
+        if (typeof key === 'object' && key !== null) {
+            this.#objectCache.set(key, value);
+        }
+        else {
+            this.#primitiveCache.set(key, value);
+        }
+    }
+    clear() {
+        this.#primitiveCache.clear();
+        this.#objectCache = new WeakMap();
+    }
+    has(key) {
+        // Note: WeakMap.has will always return false for primitive keys,
+        // so we can check both caches without first checking if it is an object.
+        return this.#primitiveCache.has(key) || this.#objectCache.has(key);
+    }
+}
+//# sourceMappingURL=WeakCache.mjs.map

package/dist/flatpackUtil.d.mts

@@ -1,6 +1,5 @@
 import type { RefElements } from './RefElements.mjs';
-import type { Flatpacked } from './types.mjs';
-import { type FlattenedElement } from './types.mjs';
+import type { Flatpacked, 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 {

package/dist/flatpacked.d.mts

@@ -0,0 +1,14 @@
+import type { Flatpacked, FlatpackIndex, FlattenedElement, ObjectElement, StringTableElement, UnpackMetaData } from './types.mjs';
+export declare function getIndexesReferencedByElement(elem: FlattenedElement): FlatpackIndex[];
+export declare function extractObjectKeyAndValueIndexes(elem: FlattenedElement): FlatpackIndex[];
+type KeyValueIndexes = [key: FlatpackIndex, value: FlatpackIndex];
+export declare function extractObjectKeyAndValueIndexesFrom(elem: ObjectElement): KeyValueIndexes;
+export declare function extractObjectKeyAndValueIndexesFrom(elem: undefined): undefined;
+export declare function extractObjectKeyAndValueIndexesFrom(elem: FlattenedElement | undefined): KeyValueIndexes | undefined;
+export declare function getFlatpackedRootIdx(flatpack: Flatpacked): FlatpackIndex;
+export declare function getFlatpackedRoot(flatpack: Flatpacked): FlattenedElement;
+export declare function generateUnpackMetaData(flatpack: Flatpacked): UnpackMetaData;
+export declare function isStringTableElement(elem: FlattenedElement | undefined): elem is StringTableElement;
+export declare function isObjectElement(elem: FlattenedElement | undefined): elem is ObjectElement;
+export {};
+//# sourceMappingURL=flatpacked.d.mts.map

package/dist/flatpacked.mjs

@@ -0,0 +1,129 @@
+import assert from 'node:assert';
+import { RefCounter } from './RefCounter.mjs';
+import { ElementType } from './types.mjs';
+export function getIndexesReferencedByElement(elem) {
+    if (!elem) {
+        return [];
+    }
+    if (Array.isArray(elem)) {
+        return extractElementIndexes(elem);
+    }
+    if (typeof elem === 'string') {
+        return [];
+    }
+    if (typeof elem === 'number') {
+        return [];
+    }
+    if (typeof elem === 'object') {
+        return [];
+    }
+    assert(typeof elem === 'boolean', `Expected boolean, got ${typeof elem}`);
+    return [];
+}
+function extractElementIndexes(element) {
+    switch (element[0]) {
+        case ElementType.Array: {
+            return element.slice(1);
+        }
+        case ElementType.Object: {
+            return element.slice(1).filter((v) => !!v);
+        }
+        case ElementType.String: {
+            return element.slice(1);
+        }
+        case ElementType.SubString: {
+            return [element[1]];
+        }
+        case ElementType.Set: {
+            return element.slice(1, 2);
+        }
+        case ElementType.Map: {
+            return element.slice(1, 3);
+        }
+        case ElementType.RegExp: {
+            return element.slice(1, 3);
+        }
+        case ElementType.Date: {
+            return [];
+        }
+        case ElementType.BigInt: {
+            return [element[1]];
+        }
+    }
+    if (!element.length)
+        return [];
+    assert(false, 'Invalid element type.');
+}
+export function extractObjectKeyAndValueIndexes(elem) {
+    if (!elem || typeof elem !== 'object' || !Array.isArray(elem))
+        return [];
+    const element = elem;
+    switch (element[0]) {
+        case ElementType.Object: {
+            return element.slice(1).filter((v) => !!v);
+        }
+        case ElementType.Set: {
+            return []; // element.slice(1, 2);
+        }
+        case ElementType.Map: {
+            return []; // element.slice(1, 3);
+        }
+    }
+    return [];
+}
+export function extractObjectKeyAndValueIndexesFrom(elem) {
+    if (!isObjectElement(elem))
+        return undefined;
+    return [elem[1], elem[2]];
+}
+export function getFlatpackedRootIdx(flatpack) {
+    let idx = 1;
+    if (isStringTableElement(flatpack[idx])) {
+        idx++;
+    }
+    assert(!isStringTableElement(flatpack[idx]), 'String table element should be at index 1 if it exists');
+    return idx;
+}
+export function getFlatpackedRoot(flatpack) {
+    return flatpack[getFlatpackedRootIdx(flatpack)];
+}
+export function generateUnpackMetaData(flatpack) {
+    const referenced = new RefCounter();
+    const rootIndex = getFlatpackedRootIdx(flatpack);
+    calcReferenced(rootIndex);
+    // Make sure the string table is always included.
+    if (rootIndex > 1) {
+        referenced.add(1);
+    }
+    const metaData = {
+        flatpack,
+        referenced,
+        rootIndex,
+    };
+    return metaData;
+    function calcReferenced(idx) {
+        if (!idx)
+            return;
+        if (referenced.isReferenced(idx)) {
+            referenced.add(idx);
+            return;
+        }
+        referenced.add(idx);
+        for (const ref of getIndexesReferencedByElement(flatpack[idx])) {
+            calcReferenced(ref);
+        }
+    }
+}
+export function isStringTableElement(elem) {
+    if (!Array.isArray(elem)) {
+        return false;
+    }
+    return elem[0] === ElementType.StringTable;
+}
+export function isObjectElement(elem) {
+    if (!Array.isArray(elem)) {
+        return false;
+    }
+    return elem[0] === ElementType.Object;
+}
+//# sourceMappingURL=flatpacked.mjs.map

package/dist/optimizeFlatpacked.mjs

@@ -1,43 +1,75 @@
 import assert from 'node:assert';
+import { getIndexesReferencedByElement } from './flatpacked.mjs';
+import { StringTableBuilder } from './stringTable.mjs';
 import { ElementType, supportedHeaders } from './types.mjs';
 export function optimizeFlatpacked(data) {
-    const [header] = data;
+    const [header, maybeStringTable] = data;
+    if (data[1] === undefined || data[2] === undefined) {
+        return data;
+    }
     if (!supportedHeaders.has(header)) {
         throw new Error('Invalid header');
     }
-    const elementRefs = data.map((element, index) => ({ origIndex: index, refCount: 0, index: 0, element }));
-    const indexToRefElement = new Map(elementRefs.entries());
+    const stringTable = maybeStringTable && Array.isArray(maybeStringTable) && maybeStringTable[0] === ElementType.StringTable
+        ? maybeStringTable
+        : undefined;
+    const startIndex = stringTable ? 2 : 1;
+    const elements = data.slice(startIndex);
+    const elementRefs = elements.map((element, index) => ({
+        origIndex: index + startIndex,
+        refCount: 0,
+        index: 0,
+        element,
+    }));
+    const indexToRefElement = new Map(elementRefs.map((refElement) => [refElement.origIndex, refElement]));
+    const stringTableBuilder = new StringTableBuilder(stringTable);
     for (const refElement of elementRefs) {
-        if (refElement.origIndex === 0) {
-            continue;
-        }
-        const indexes = getRefIndexes(refElement.element);
+        const indexes = getIndexesReferencedByElement(refElement.element);
         for (const index of indexes) {
+            if (index < 0) {
+                stringTableBuilder.addRef(-index);
+                continue;
+            }
+            if (!index) {
+                continue;
+            }
             const ref = indexToRefElement.get(index);
             assert(ref, `Invalid reference index: ${index}`);
             ref.refCount++;
         }
     }
-    const sortedRefElements = elementRefs.slice(2).sort((a, b) => b.refCount - a.refCount || a.origIndex - b.origIndex);
-    sortedRefElements.forEach((refElement, index) => {
-        refElement.index = index + 2;
-    });
+    const sortedRefElements = elementRefs.sort((a, b) => b.refCount - a.refCount || a.origIndex - b.origIndex);
     const indexMap = new Map([
         [0, 0],
         [1, 1],
     ]);
-    sortedRefElements.forEach((refElement) => {
-        indexMap.set(refElement.origIndex, refElement.index);
-    });
-    const optimizedElements = [
-        data[1],
-        ...sortedRefElements.map((refElement) => refElement.element),
-    ].map((element) => patchIndexes(element, indexMap));
-    return [header, ...optimizedElements];
+    if (stringTable) {
+        indexMap.set(2, 2);
+    }
+    for (const refElement of sortedRefElements) {
+        const idx = indexMap.get(refElement.origIndex) ?? indexMap.size;
+        refElement.index = idx;
+        indexMap.set(refElement.origIndex, idx);
+    }
+    for (const [oldStrIndex, newStrIndex] of stringTableBuilder.sortEntriesByRefCount()) {
+        if (!oldStrIndex || !newStrIndex) {
+            continue;
+        }
+        indexMap.set(-oldStrIndex, -newStrIndex);
+    }
+    const stringTableElements = stringTable ? [stringTableBuilder.build()] : [];
+    const result = [header, ...stringTableElements];
+    for (const refElement of sortedRefElements) {
+        const element = patchIndexes(refElement.element, indexMap);
+        result[refElement.index] = element;
+    }
+    return result;
 }
 function patchIndexes(elem, indexMap) {
     function mapIndex(index) {
         const v = indexMap.get(index);
+        if (v === undefined && index < 0)
+            return index;
         assert(v !== undefined, `Invalid index: ${index}`);
         return v;
     }
@@ -76,6 +108,8 @@ function patchIndexes(elem, indexMap) {
                 return [element[0], mapIndex(element[1])];
             }
         }
+        if (!element.length)
+            return [];
         assert(false, 'Invalid element type');
     }
     if (Array.isArray(elem)) {
@@ -90,58 +124,7 @@ function patchIndexes(elem, indexMap) {
     if (typeof elem === 'object') {
         return elem;
     }
-    assert(typeof elem === 'boolean');
+    assert(typeof elem === 'boolean', `Expected boolean, got ${typeof elem}`);
     return elem;
 }
-function getRefIndexes(elem) {
-    function handleArrayElement(element) {
-        switch (element[0]) {
-            case ElementType.Array: {
-                return element.slice(1);
-            }
-            case ElementType.Object: {
-                return element.slice(1).filter((v) => !!v);
-            }
-            case ElementType.String: {
-                return element.slice(1);
-            }
-            case ElementType.SubString: {
-                return [element[1]];
-            }
-            case ElementType.Set: {
-                return element.slice(1);
-            }
-            case ElementType.Map: {
-                return element.slice(1);
-            }
-            case ElementType.RegExp: {
-                return element.slice(1);
-            }
-            case ElementType.Date: {
-                return [];
-            }
-            case ElementType.BigInt: {
-                return [element[1]];
-            }
-        }
-        assert(false, 'Invalid element type');
-    }
-    if (Array.isArray(elem)) {
-        return handleArrayElement(elem);
-    }
-    if (typeof elem === 'string') {
-        return [];
-    }
-    if (typeof elem === 'number') {
-        return [];
-    }
-    if (typeof elem === 'object') {
-        if (elem === null) {
-            return [];
-        }
-        return [];
-    }
-    assert(typeof elem === 'boolean');
-    return [];
-}
 //# sourceMappingURL=optimizeFlatpacked.mjs.map

package/dist/proxy.mjs

@@ -134,7 +134,6 @@ export function proxyMap(values, onUpdate) {
         }
         set(key, value) {
             const r = super.set(key, value);
-            console.log('set', key, value);
             onUpdate?.(this, key, value);
             return r;
         }