flatpack-json 9.6.4 → 9.8.0

package/dist/FlatpackData.mjs

@@ -0,0 +1,122 @@
+import assert from 'node:assert';
+import { getFlatpackedRootIdx, getIndexesReferencedByElement, isStringTableElement } from './flatpacked.mjs';
+import { StringTableBuilder } from './stringTable.mjs';
+import { dataHeaderV2_0, ElementType } from './types.mjs';
+const emptyElement = [];
+export class FlatpackData {
+    flatpack;
+    stringTable;
+    rootIndex;
+    used = new Set();
+    ownedBy = new Map();
+    available = [];
+    constructor(flatpack) {
+        this.flatpack = flatpack ? [...flatpack] : [dataHeaderV2_0, [ElementType.StringTable]];
+        assert(isStringTableElement(this.flatpack[1]), 'Expected a string table element at index 1 of the flatpack data');
+        this.stringTable = new StringTableBuilder(this.flatpack[1]);
+        this.rootIndex = getFlatpackedRootIdx(this.flatpack);
+        this.#calcAvailableIndexes();
+        this.available.push(this.rootIndex);
+    }
+    add(element) {
+        const idx = this.#getNextAvailableIndex();
+        this.flatpack[idx] = element;
+        this.used.delete(idx);
+        this.markUsed(idx);
+        return idx;
+    }
+    reserve() {
+        const idx = this.add(emptyElement);
+        return idx;
+    }
+    set(idx, element) {
+        this.flatpack[idx] = element;
+        this.used.delete(idx);
+        this.markUsed(idx);
+    }
+    get(idx) {
+        return this.flatpack[idx];
+    }
+    markUsed(idx) {
+        if (this.used.has(idx))
+            return;
+        this.used.add(idx);
+        const children = getIndexesReferencedByElement(this.flatpack[idx]);
+        // First claim ownership of children before recursively marking them as used.
+        // We need to ensure they are owned at the top.
+        for (const childIdx of children) {
+            this.claimOwnership(childIdx, idx);
+        }
+        for (const childIdx of children) {
+            this.markUsed(childIdx);
+        }
+    }
+    isUsed(idx) {
+        return this.used.has(idx);
+    }
+    duplicateIndex(idx) {
+        const element = this.get(idx);
+        return this.add(element);
+    }
+    delete(idx) {
+        this.used.delete(idx);
+        this.available.push(idx);
+        this.flatpack[idx] = emptyElement;
+    }
+    claimOwnership(idx, ownerIdx) {
+        const currentOwner = this.ownedBy.get(idx);
+        if (currentOwner !== undefined)
+            return currentOwner;
+        this.ownedBy.set(idx, ownerIdx);
+        return ownerIdx;
+    }
+    #getNextAvailableIndex() {
+        for (let idx = this.available.pop(); idx !== undefined; idx = this.available.pop()) {
+            if (!this.used.has(idx)) {
+                return idx;
+            }
+        }
+        return this.flatpack.length;
+    }
+    /**
+     * Calculate available indexes based on the current flatpack data.
+     * Any empty array is used as a placeholder for an available flatpack element.
+     */
+    #calcAvailableIndexes() {
+        const stop = this.rootIndex;
+        const data = this.flatpack;
+        for (let i = data.length - 1; i >= stop; i--) {
+            const elem = data[i];
+            if (elem === undefined || (Array.isArray(elem) && !elem.length)) {
+                this.available.push(i);
+                this.used.delete(i);
+                continue;
+            }
+        }
+    }
+    markUnusedAsAvailable() {
+        const available = new Set(this.available);
+        const stop = this.rootIndex;
+        const data = this.flatpack;
+        const empty = emptyElement;
+        for (let i = data.length - 1; i > stop; i--) {
+            if (this.used.has(i))
+                continue;
+            data[i] = empty;
+            available.add(i);
+        }
+        this.available = [...available];
+    }
+    finalize() {
+        this.flatpack[1] = this.stringTable.clearUnusedEntries().build();
+        this.#calcAvailableIndexes();
+        this.markUnusedAsAvailable();
+        let idx = this.flatpack.length - 1;
+        while (idx >= this.rootIndex && !this.used.has(idx)) {
+            --idx;
+        }
+        this.flatpack.length = idx + 1;
+        return this.flatpack;
+    }
+}
+//# sourceMappingURL=FlatpackData.mjs.map

package/dist/FlatpackV1.d.mts

@@ -0,0 +1,100 @@
+import { FlatpackedWrapper } from './flatpackUtil.mjs';
+import type { FlatpackApi, Flatpacked, FlatpackOptions, Serializable, Unpacked } from './types.mjs';
+export declare class FlatpackStoreV1 implements FlatpackApi {
+    #private;
+    readonly options?: FlatpackOptions | undefined;
+    private knownElements;
+    private assignedElements;
+    private elements;
+    private root;
+    private dedupe;
+    private sortKeys;
+    private emptyObjIdx;
+    private ids;
+    /**
+     * Cache of primitives and objects that have been added to the data.
+     */
+    private cache;
+    /**
+     * Set of elements that have been referenced by other indexes.
+     */
+    private referenced;
+    /**
+     * Cache of arrays that have been deduped.
+     * The key is a hash of the array elements as a function of the index of the element.
+     */
+    private cachedArrays;
+    private cachedObjects;
+    private cachedSets;
+    private cachedMaps;
+    private cachedProxies;
+    /**
+     * Cache of strings that have been deduped and stored in the data array.
+     */
+    private knownStrings;
+    /**
+     * Cache of reversed strings that have been deduped and stored in the data array.
+     * This is used to find matching suffixes.
+     */
+    private knownStringsRev;
+    private refUndefined;
+    constructor(value: Serializable | FlatpackedWrapper, options?: FlatpackOptions | undefined);
+    setValue(value: Serializable): void;
+    private nextId;
+    private addElement;
+    private addValueAndElement;
+    private primitiveToRef;
+    private createSubStringRef;
+    private addKnownString;
+    private addStringPrimitive;
+    private addStringElement;
+    private stringPrefix;
+    private stringSuffix;
+    private stringToRef;
+    private cvtSetToRef;
+    private dedupeSetRefs;
+    private proxySetRef;
+    private createUniqueKeys;
+    private cvtMapToRef;
+    private dedupeMapRefs;
+    private proxyMapRef;
+    private cvtRegExpToRef;
+    private cvtDateToRef;
+    private proxyDateRef;
+    private cvtBigintToRef;
+    private cvtObjToRef;
+    private dedupeObject;
+    private proxyObjectRef;
+    private proxyObjectWrapperRef;
+    /**
+     *
+     * @param value - The array converted to an ArrayRefElement.
+     * @param element - the element to dedupe.
+     * @param cacheValue - Whether to cache the value. It is false when it is a dynamic array, like object keys,
+     *      in that case, we want to dedupe the keys and values.
+     * @returns the element to use.
+     */
+    private dedupeArray;
+    /**
+     * Convert an array to an index.
+     * @param value - The array to convert to an index.
+     * @param cacheValue - Whether to cache the value.
+     * @returns the index of the array.
+     */
+    private arrToRef;
+    private proxyArrayRef;
+    private valueToRef;
+    /**
+     * Reset things in a way that allows for reuse.
+     */
+    private softReset;
+    toJSON(): Flatpacked;
+    static fromJSON(data: Flatpacked): FlatpackStoreV1;
+    static parse(content: string): FlatpackStoreV1;
+    stringify(): string;
+    toValue(): Unpacked;
+    _toValueProxy(): Unpacked;
+}
+export declare function toJSON<V extends Serializable>(json: V, options?: FlatpackOptions): Flatpacked;
+export declare function stringify(data: Unpacked, pretty?: boolean): string;
+//# sourceMappingURL=FlatpackV1.d.mts.map