flatpack-json 8.14.4 → 8.15.1

package/dist/Flatpack.d.mts

@@ -27,6 +27,7 @@ export declare class FlatpackStore {
     private cachedObjects;
     private cachedSets;
     private cachedMaps;
+    private cachedProxies;
     /**
      * Cache of strings that have been deduped and stored in the data array.
      */
@@ -52,14 +53,19 @@ export declare class FlatpackStore {
     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.
@@ -76,6 +82,7 @@ export declare class FlatpackStore {
      * @returns the index of the array.
      */
     private arrToRef;
+    private proxyArrayRef;
     private valueToRef;
     /**
      * Reset things in a way that allows for reuse.
@@ -86,6 +93,7 @@ export declare class FlatpackStore {
     static parse(content: string): FlatpackStore;
     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;

package/dist/Flatpack.mjs

@@ -1,5 +1,7 @@
+import assert from 'node:assert';
 import { FlatpackedWrapper } from './flatpackUtil.mjs';
-import { ArrayRefElement, BigIntRefElement, DateRefElement, isStringRefElements, MapRefElement, ObjectRefElement, ObjectWrapperRefElement, PrimitiveRefElement, RegExpRefElement, SetRefElement, StringConcatRefElement, StringPrimitiveRefElement, SubStringRefElement, } from './RefElements.mjs';
+import { proxyDate, proxyObject, proxySet } from './proxy.mjs';
+import { ArrayRefElement, BigIntRefElement, DateRefElement, isStringRefElements, MapRefElement, ObjectRefElement, ObjectWrapperRefElement, PrimitiveRefElement, PrimitiveRefElementBase, RegExpRefElement, SetRefElement, StringConcatRefElement, StringPrimitiveRefElement, SubStringRefElement, } from './RefElements.mjs';
 import { stringifyFlatpacked } from './stringify.mjs';
 import { Trie } from './Trie.mjs';
 import { blockSplitRegex, dataHeader } from './types.mjs';
@@ -43,6 +45,7 @@ export class FlatpackStore {
     cachedObjects = new Map();
     cachedSets = new Map();
     cachedMaps = new Map();
+    cachedProxies = new WeakMap();
     /**
      * Cache of strings that have been deduped and stored in the data array.
      */
@@ -212,7 +215,7 @@ export class FlatpackStore {
     dedupeSetRefs(value, element) {
         if (!this.dedupe)
             return element;
-        const values = element.values();
+        const values = element.valueRefs();
         const found = this.cachedSets.get(values);
         if (!found) {
             this.cachedSets.set(values, element);
@@ -224,6 +227,9 @@ export class FlatpackStore {
         this.cache.set(value, found);
         return found;
     }
+    proxySetRef(ref) {
+        return proxySet(new Set(this.#toValue(ref.valueRefs())), () => { });
+    }
     createUniqueKeys(keys) {
         const cacheValue = false;
         let k = this.arrToRef(keys, cacheValue);
@@ -255,8 +261,8 @@ export class FlatpackStore {
     dedupeMapRefs(value, element) {
         if (!this.dedupe)
             return element;
-        const keys = element.keys();
-        const values = element.values();
+        const keys = element.keyRefs();
+        const values = element.valueRefs();
         let found = this.cachedMaps.get(keys);
         if (!found) {
             found = new Map();
@@ -275,6 +281,9 @@ export class FlatpackStore {
         found.set(values, element);
         return element;
     }
+    proxyMapRef(_ref) {
+        return new Map();
+    }
     cvtRegExpToRef(value) {
         const found = this.cache.get(value);
         if (found !== undefined) {
@@ -289,6 +298,9 @@ export class FlatpackStore {
         }
         return this.addValueAndElement(value, new DateRefElement(value.getTime()));
     }
+    proxyDateRef(ref) {
+        return proxyDate(ref.value, (date) => ref.setTime(date.getTime()));
+    }
     cvtBigintToRef(value) {
         const found = this.cache.get(value);
         if (found !== undefined) {
@@ -328,8 +340,8 @@ export class FlatpackStore {
     dedupeObject(value, element) {
         if (!this.dedupe)
             return element;
-        const keys = element.keys();
-        const values = element.values();
+        const keys = element.keyRefs();
+        const values = element.valueRefs();
         let found = this.cachedObjects.get(keys);
         if (!found) {
             found = new Map();
@@ -348,6 +360,16 @@ export class FlatpackStore {
         found.set(values, element);
         return element;
     }
+    proxyObjectRef(ref) {
+        const keys = this.#toValue(ref.keyRefs());
+        const values = this.#toValue(ref.valueRefs());
+        const obj = keys && values ? Object.fromEntries(keys.map((key, i) => [key, values[i]])) : {};
+        return proxyObject(obj, (_value) => { });
+    }
+    proxyObjectWrapperRef(ref) {
+        const value = Object(this.#toValue(ref.valueRef()));
+        return proxyObject(value, (_value) => { });
+    }
     /**
      *
      * @param value - The array converted to an ArrayRefElement.
@@ -394,6 +416,10 @@ export class FlatpackStore {
         element.setValues(value.map((v) => this.valueToRef(v)));
         return this.dedupeArray(value, element, cacheValue);
     }
+    proxyArrayRef(ref) {
+        const arr = ref.valueRefs().map((v) => this.#toValue(v));
+        return proxyObject(arr, (_value) => { });
+    }
     valueToRef(value) {
         if (value === null) {
             return this.primitiveToRef(value);
@@ -520,6 +546,36 @@ export class FlatpackStore {
             this.cache.delete(key);
         }
     }
+    #resolveToValueProxy(ref) {
+        if (!ref)
+            return undefined;
+        if (ref instanceof ArrayRefElement)
+            return this.proxyArrayRef(ref);
+        if (ref instanceof ObjectRefElement)
+            return this.proxyObjectRef(ref);
+        if (ref instanceof PrimitiveRefElementBase)
+            return ref.value;
+        if (isStringRefElements(ref))
+            return ref.value;
+        if (ref instanceof MapRefElement)
+            return this.proxyMapRef(ref);
+        if (ref instanceof SetRefElement)
+            return this.proxySetRef(ref);
+        if (ref instanceof BigIntRefElement)
+            return ref.value;
+        if (ref instanceof RegExpRefElement)
+            return ref.value;
+        if (ref instanceof DateRefElement)
+            return this.proxyDateRef(ref);
+        if (ref instanceof ObjectWrapperRefElement)
+            return this.proxyObjectWrapperRef(ref);
+        assert(false, 'Unknown ref type');
+    }
+    #toValue(ref) {
+        if (!ref)
+            return undefined;
+        return getOrResolve(this.cachedProxies, ref, (ref) => this.#resolveToValueProxy(ref));
+    }
     toJSON() {
         const data = [dataHeader];
         const idxLookup = this.assignedElements;
@@ -550,6 +606,9 @@ export class FlatpackStore {
     toValue() {
         return fromJSON(this.toJSON());
     }
+    _toValueProxy() {
+        return this.#toValue(this.root);
+    }
 }
 function isObjectWrapper(value) {
     return (typeof value === 'object' &&
@@ -572,4 +631,12 @@ export function toJSON(json, options) {
 export function stringify(data, pretty = true) {
     return pretty ? stringifyFlatpacked(toJSON(data)) : JSON.stringify(toJSON(data));
 }
+function getOrResolve(map, key, resolver) {
+    let value = map.get(key);
+    if (value === undefined && !map.has(key)) {
+        value = resolver(key);
+        map.set(key, value);
+    }
+    return value;
+}
 //# sourceMappingURL=Flatpack.mjs.map

package/dist/RefElements.d.mts

@@ -39,8 +39,8 @@ export declare class StringPrimitiveRefElement extends PrimitiveRefElementBase<s
 export declare class ObjectRefElement extends BaseRefElement implements RefElement<ObjectElement> {
     #private;
     constructor(keys?: ArrayRefElement, values?: ArrayRefElement);
-    keys(): ArrayRefElement | undefined;
-    values(): ArrayRefElement | undefined;
+    keyRefs(): ArrayRefElement | undefined;
+    valueRefs(): ArrayRefElement | undefined;
     setKeysAndValues(keys: ArrayRefElement | undefined, values: ArrayRefElement): void;
     toElement(lookup: FnIndexLookup): ObjectElement;
     clone(): ObjectRefElement;
@@ -51,6 +51,7 @@ export declare class ObjectWrapperRefElement extends BaseRefElement implements R
     #private;
     constructor(value?: RefElements);
     setValue(value: RefElements): void;
+    valueRef(): RefElements | undefined;
     toElement(lookup: FnIndexLookup): ObjectWrapperElement;
     clone(): ObjectWrapperRefElement;
     getDependencies(): RefElements[] | undefined;
@@ -63,7 +64,7 @@ export declare class SetRefElement extends BaseRefElement implements RefElement<
     toElement(lookup: FnIndexLookup): SetElement;
     clone(): SetRefElement;
     getDependencies(): RefElements[] | undefined;
-    values(): ArrayRefElement | undefined;
+    valueRefs(): ArrayRefElement | undefined;
     static fromJSON(elem: SetElement, resolve: (index: number) => RefElements): SetRefElement;
 }
 export declare class MapRefElement extends BaseRefElement implements RefElement<MapElement> {
@@ -73,14 +74,15 @@ export declare class MapRefElement extends BaseRefElement implements RefElement<
     toElement(lookup: FnIndexLookup): MapElement;
     clone(): MapRefElement;
     getDependencies(): RefElements[] | undefined;
-    keys(): ArrayRefElement | undefined;
-    values(): ArrayRefElement | undefined;
+    keyRefs(): ArrayRefElement | undefined;
+    valueRefs(): 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;
+    get value(): RegExp;
     clone(): RegExpRefElement;
     getDependencies(): RefElements[] | undefined;
     static fromJSON(elem: RegExpElement, resolve: (index: number) => RefElements): RegExpRefElement;
@@ -89,6 +91,8 @@ export declare class DateRefElement extends BaseRefElement implements RefElement
     #private;
     constructor(value: number);
     toElement(): DateElement;
+    get value(): Date;
+    setTime(time: number): void;
     clone(): DateRefElement;
     getDependencies(): undefined;
     static fromJSON(value: DateElement): DateRefElement;
@@ -96,6 +100,7 @@ export declare class DateRefElement extends BaseRefElement implements RefElement
 export declare class BigIntRefElement extends BaseRefElement implements RefElement<BigIntElement> {
     #private;
     constructor(value: PrimitiveRefElement<number> | StringRefElements);
+    get value(): bigint;
     toElement(lookup: FnIndexLookup): BigIntElement;
     clone(): BigIntRefElement;
     getDependencies(): RefElements[] | undefined;

package/dist/RefElements.mjs

@@ -60,10 +60,10 @@ export class ObjectRefElement extends BaseRefElement {
         this.#k = keys;
         this.#v = values;
     }
-    keys() {
+    keyRefs() {
         return this.#k;
     }
-    values() {
+    valueRefs() {
         return this.#v;
     }
     setKeysAndValues(keys, values) {
@@ -101,6 +101,9 @@ export class ObjectWrapperRefElement extends BaseRefElement {
     setValue(value) {
         this.#v = value;
     }
+    valueRef() {
+        return this.#v;
+    }
     toElement(lookup) {
         return [ElementType.Object, 0, lookup(this.#v)];
     }
@@ -134,7 +137,7 @@ export class SetRefElement extends BaseRefElement {
     getDependencies() {
         return this.#v ? [this.#v] : undefined;
     }
-    values() {
+    valueRefs() {
         return this.#v;
     }
     static fromJSON(elem, resolve) {
@@ -165,10 +168,10 @@ export class MapRefElement extends BaseRefElement {
     getDependencies() {
         return [this.#k, this.#v].filter((r) => !!r);
     }
-    keys() {
+    keyRefs() {
         return this.#k;
     }
-    values() {
+    valueRefs() {
         return this.#v;
     }
     static fromJSON(elem, resolve) {
@@ -190,6 +193,9 @@ export class RegExpRefElement extends BaseRefElement {
     toElement(lookup) {
         return [ElementType.RegExp, lookup(this.#p), lookup(this.#f)];
     }
+    get value() {
+        return new RegExp(this.#p.value, this.#f.value);
+    }
     clone() {
         return new RegExpRefElement(this.#p, this.#f);
     }
@@ -213,6 +219,12 @@ export class DateRefElement extends BaseRefElement {
     toElement() {
         return [ElementType.Date, this.#v];
     }
+    get value() {
+        return new Date(this.#v);
+    }
+    setTime(time) {
+        this.#v = time;
+    }
     clone() {
         return new DateRefElement(this.#v);
     }
@@ -229,6 +241,9 @@ export class BigIntRefElement extends BaseRefElement {
         super();
         this.#v = value;
     }
+    get value() {
+        return BigInt(this.#v.value);
+    }
     toElement(lookup) {
         return [ElementType.BigInt, lookup(this.#v)];
     }

package/dist/proxy.d.mts

@@ -0,0 +1,6 @@
+export declare function proxyDate(date: Date, onUpdate?: (date: Date) => void): Date;
+export declare function proxyObject<T extends object>(obj: T, onUpdate?: (obj: T, prop: keyof T, value: T[keyof T]) => void): T;
+export declare function deepEqual(a: any, b: any): boolean;
+export declare function proxyMap<K, V>(values: Iterable<[K, V]>, onUpdate?: (map: Map<K, V>, key: K | undefined, value: V | undefined) => void): Map<K, V>;
+export declare function proxySet<T>(values: Iterable<T>, onUpdate?: (set: Set<T>, value: T | undefined) => void): Set<T>;
+//# sourceMappingURL=proxy.d.mts.map

package/dist/proxy.mjs

@@ -0,0 +1,180 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export function proxyDate(date, onUpdate) {
+    class PDate extends Date {
+        constructor() {
+            super();
+            super.setTime(date.getTime());
+            proxy(this);
+        }
+    }
+    function proxy(obj) {
+        const props = Object.getOwnPropertyNames(Object.getPrototypeOf(Object.getPrototypeOf(obj)));
+        for (const prop of props) {
+            if (prop.toString() === 'constructor')
+                continue;
+            if (typeof obj[prop] === 'function') {
+                const fn = obj[prop];
+                const callback = prop.toString().startsWith('set') ? onUpdate : undefined;
+                const fObj = obj;
+                fObj[prop] = function (...args) {
+                    let r = fn.apply(obj, args);
+                    if (date[prop] !== fn)
+                        return r;
+                    r = fn.apply(date, args);
+                    callback?.(date);
+                    return r;
+                };
+            }
+        }
+        return obj;
+    }
+    return new PDate();
+}
+const debug = false;
+const log = debug ? console.log : () => { };
+export function proxyObject(obj, onUpdate) {
+    const proxy = new Proxy(obj, {
+        get(target, prop, _receiver) {
+            const value = target[prop];
+            // log('get %o', { prop, match: value === obj[prop as keyof T] });
+            if (value instanceof Function) {
+                return value.bind(target);
+            }
+            return value;
+        },
+        ownKeys(target) {
+            const result = Reflect.ownKeys(target);
+            // log('ownKeys %o', { result, r_orig: Reflect.ownKeys(obj), match: deepEqual(result, Reflect.ownKeys(obj)) });
+            return result;
+        },
+        getOwnPropertyDescriptor(target, prop) {
+            const result = Reflect.getOwnPropertyDescriptor(target, prop);
+            // log('getOwnPropertyDescriptor %o', {
+            //     prop,
+            //     result,
+            //     r_orig: Object.getOwnPropertyDescriptor(obj, prop),
+            //     match: deepEqual(result, Object.getOwnPropertyDescriptor(obj, prop)),
+            // });
+            return result;
+        },
+        has(target, prop) {
+            const result = Reflect.has(target, prop);
+            // log('has %o', { prop, result, match: result === prop in obj });
+            return result;
+        },
+        set(target, prop, value) {
+            // log('set %o', { prop });
+            const r = Reflect.set(target, prop, value);
+            onUpdate?.(target, prop, value);
+            return r;
+        },
+        deleteProperty(target, prop) {
+            // log('deleteProperty %o', { prop });
+            return Reflect.deleteProperty(target, prop);
+        },
+        defineProperty(target, prop, descriptor) {
+            log('defineProperty %o', { prop });
+            return Reflect.defineProperty(target, prop, descriptor);
+        },
+        getPrototypeOf(target) {
+            const result = Reflect.getPrototypeOf(target);
+            // log('getPrototypeOf %o', {
+            //     match: result === Object.getPrototypeOf(obj) ? true : Object.getPrototypeOf(obj),
+            // });
+            return result;
+        },
+        setPrototypeOf(target, prototype) {
+            log('setPrototypeOf');
+            return Reflect.setPrototypeOf(target, prototype);
+        },
+        isExtensible(target) {
+            const result = Reflect.isExtensible(target);
+            // log('isExtensible %o', { result, match: result === Object.isExtensible(obj) });
+            return result;
+        },
+        preventExtensions(target) {
+            log('preventExtensions');
+            return Reflect.preventExtensions(target);
+        },
+        apply(target, thisArg, argArray) {
+            log('apply');
+            return Reflect.apply(target, thisArg, argArray);
+        },
+        construct(target, argArray, newTarget) {
+            log('construct');
+            return Reflect.construct(target, argArray, newTarget);
+        },
+    });
+    return proxy;
+}
+export function deepEqual(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a === 'function' && typeof b === 'function')
+        return true;
+    if (typeof a !== 'object' || typeof b !== 'object')
+        return false;
+    for (const key in a) {
+        if (!(key in b))
+            return false;
+        if (!deepEqual(a[key], b[key]))
+            return false;
+    }
+    return true;
+}
+export function proxyMap(values, onUpdate) {
+    class PMap extends Map {
+        constructor() {
+            super();
+            // Initialize the map with the values from the original map.
+            // This needs to be done instead of `super(fromMap)`, otherwise `this.set` will be called.
+            for (const [key, value] of values) {
+                super.set(key, value);
+            }
+        }
+        set(key, value) {
+            const r = super.set(key, value);
+            console.log('set', key, value);
+            onUpdate?.(this, key, value);
+            return r;
+        }
+        delete(key) {
+            const r = super.delete(key);
+            onUpdate?.(this, key, undefined);
+            return r;
+        }
+        clear() {
+            super.clear();
+            onUpdate?.(this, undefined, undefined);
+        }
+    }
+    return new PMap();
+}
+export function proxySet(values, onUpdate) {
+    class PSet extends Set {
+        constructor() {
+            super();
+            // Initialize the set with the values from the original set.
+            // This needs to be done instead of `super(fromSet)`, otherwise `this.add` will be called.
+            for (const value of values) {
+                super.add(value);
+            }
+        }
+        add(value) {
+            const r = super.add(value);
+            onUpdate?.(this, value);
+            return r;
+        }
+        delete(value) {
+            const r = super.delete(value);
+            onUpdate?.(this, value);
+            return r;
+        }
+        clear() {
+            super.clear();
+            onUpdate?.(this, undefined);
+        }
+    }
+    return new PSet();
+}
+//# sourceMappingURL=proxy.mjs.map

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "flatpack-json",
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
   },
-  "version": "8.14.4",
+  "version": "8.15.1",
   "description": "A library to normalize JSON objects to reduce the size.",
   "keywords": [
     "cspell",
@@ -52,8 +53,8 @@
     "node": ">=18"
   },
   "devDependencies": {
-    "@cspell/filetypes": "8.14.4",
+    "@cspell/filetypes": "8.15.1",
     "diff": "^7.0.0"
   },
-  "gitHead": "aeedd49f6ef20799eed04076093291fcacbc4b84"
+  "gitHead": "6a99d22627f0e360fcfc5b98afa670464ec763f6"
 }