proxy-facades 1.0.0

package/class-trackers/Array.ts

@@ -0,0 +1,245 @@
+import {
+    ChangeOperation,
+    ClassTrackingConfiguration,
+    DualUseTracker,
+    ForWatchedProxyHandler, IWatchedProxyHandler_common, makeIteratorTranslateValue,
+    ObjKey,
+    RecordedRead,
+    RecordedReadOnProxiedObject, runChangeOperation, UnspecificObjectChange
+} from "../common";
+import {arraysAreShallowlyEqual} from "../Util";
+import {
+    getChangeHooksForObject,
+    changeHooksForObject
+} from "../objectChangeTracking";
+import {installChangeTracker} from "../origChangeTracking";
+import {WatchedProxyHandler} from "../watchedProxyFacade";
+import {RecordedReadOnProxiedObjectExt} from "../RecordedReadOnProxiedObjectExt";
+
+
+/**
+ * Listeners for one array.
+ * Note for specificity: There will be only one of the **change** events fired. The Recorded...Read.onChange handler will add the listeners to all possible candidates. It's this way around.
+ * {@link ObjectChangeHooks} are also subscribed on Arrays
+ */
+class ArrayChangeHooks {
+
+}
+
+export const changeHooksForArray = new WeakMap<unknown[], ArrayChangeHooks>();
+export function getChangeHooksForArray(array: unknown[]) {
+    let result = changeHooksForArray.get(array);
+    if(result === undefined) {
+        changeHooksForArray.set(array, result = new ArrayChangeHooks());
+    }
+    return result;
+}
+
+/**
+ * Can be either used as a supervisor-class in a WatchedProxyHandler, or installed on the non-proxied object via Object.setPrototypeOf
+ * The "this" may be different in these cases.
+ */
+export class ArrayChangeTracker<T> extends Array<T> implements DualUseTracker<Array<T>>{
+
+
+    // TODO: In the future, implement more fine granular change listeners that act on change of a certain index.
+
+    get _watchedProxyHandler(): IWatchedProxyHandler_common | undefined {
+        return undefined;
+    }
+
+    protected _withUnspecificChange<R>(changeFn: () => R): R {
+        return runChangeOperation(this, new UnspecificObjectChange(this), [getChangeHooksForObject(this).unspecificChange], changeFn)
+    }
+
+    //push(...items: any[]): number //already calls set
+
+    pop(...args: any[]) {
+        return  this._withUnspecificChange(() => super.pop())
+    }
+
+    /**
+     * Will return the original object when this class is used as supervisor class in the WatchedProxyHandler
+     */
+    get _target(): Array<T> {
+        return this;
+    }
+
+    /**
+     * Pretend that this is an array
+     */
+    get ["constructor"]() {
+        return Array;
+    }
+
+    shift(...args: any[]): T | undefined {
+        return  this._withUnspecificChange(() => super.shift())
+    }
+
+    //@ts-ignore
+    sort(...args: any[]): Array<T> {
+        return this._withUnspecificChange(()=> super.sort());
+    }
+
+
+    //@ts-ignore
+    fill(...args: any[]): Array<T> {
+        return this._withUnspecificChange(() => super.fill(...args as [any, any, any]));
+    }
+
+}
+
+export class RecordedArrayValuesRead extends RecordedReadOnProxiedObjectExt {
+    values: unknown[];
+
+    protected get origObj() {
+        return this.obj as unknown[];
+    }
+
+
+    constructor(values: unknown[]) {
+        super();
+        this.values = values;
+    }
+
+    getAffectingChangeHooks(target: this["obj"]) {
+        return [
+            getChangeHooksForObject(target).changeOwnKeys,
+            getChangeHooksForObject(target).changeAnyProperty,
+            getChangeHooksForObject(target).unspecificChange,
+        ]
+    }
+
+    equals(other: RecordedRead): boolean {
+        if (!(other instanceof RecordedArrayValuesRead)) {
+            return false;
+        }
+
+        return this.proxyHandler === other.proxyHandler && this.obj === other.obj && arraysAreShallowlyEqual(this.values, other.values);
+    }
+
+    get isChanged(): boolean {
+        return !arraysAreShallowlyEqual(this.values, this.origObj);
+    }
+
+
+}
+
+/**
+ * Patches methods / accessors
+ */
+export class ArrayReadTracker<T> extends Array<T> implements ForWatchedProxyHandler<Array<T>> {
+    get _watchedProxyHandler(): WatchedProxyHandler {
+        throw new Error("not calling from inside a WatchedProxyHandler"); // Will return the handler when called through the handler
+    }
+
+    get _target(): Array<T> {
+        throw new Error("not calling from inside a WatchedProxyHandler"); // Will return the value when called through the handler
+    }
+
+    protected _fireAfterValuesRead() {
+        let recordedArrayValuesRead = new RecordedArrayValuesRead([...this._target]);
+        this._watchedProxyHandler?.fireAfterRead(recordedArrayValuesRead);
+    }
+
+    /**
+     * Pretend that this is an array
+     */
+    get ["constructor"]() {
+        return Array;
+    }
+
+    values(): ArrayIterator<T> {
+        const result = this._target.values();
+        this._fireAfterValuesRead();
+        return makeIteratorTranslateValue(result, (value) => this._watchedProxyHandler.getFacade().getProxyFor(value));
+    }
+
+    entries(): ArrayIterator<[number, T]> {
+        const result = this._target.entries();
+        this._fireAfterValuesRead();
+        return makeIteratorTranslateValue<[number, T], ArrayIterator<[number, T]>/*strange that TS does not infer the types here*/>(result, ([index,value]) => [index, this._watchedProxyHandler.getFacade().getProxyFor(value)]);
+    }
+
+    [Symbol.iterator](): ArrayIterator<T> {
+        const result = this._target[Symbol.iterator]();
+        this._fireAfterValuesRead();
+        return makeIteratorTranslateValue(result, (value) => this._watchedProxyHandler.getFacade().getProxyFor(value));
+    }
+
+    get length(): number {
+        const result = this._target.length;
+        this._fireAfterValuesRead();
+        return result;
+    }
+
+    //@ts-ignore
+    shift(...args: any[]) {
+        if(this.length == 0) {
+            return undefined;
+        }
+
+        return runChangeOperation(this, new UnspecificObjectChange(this), [getChangeHooksForObject(this).changeOwnKeys, getChangeHooksForObject(this).unspecificChange],() => {
+            //@ts-ignore
+            const result = super.shift(...args);
+            this._fireAfterValuesRead();
+            return result;
+        });
+    }
+
+
+    /**
+     * Keep this method so it it treated as handled and not as making-unspecific-reads
+     * @param args
+     */
+    forEach(...args: any[]) {
+        //@ts-ignore
+        return super.forEach(...args); //reads "length" an thererfore triggers the read
+    }
+
+
+    //@ts-ignore
+    pop(...args: any[]): T | undefined {
+        if(this.length == 0) {
+            return undefined;
+        }
+
+        return runChangeOperation(this, new UnspecificObjectChange(this),[getChangeHooksForObject(this).changeOwnKeys, getChangeHooksForObject(this).unspecificChange],() => {
+            //@ts-ignore
+            const result = super.pop(...args);
+            this._fireAfterValuesRead();
+            return result;
+        });
+
+    }
+
+}
+
+export const config = new class extends ClassTrackingConfiguration {
+    clazz= Array;
+    readTracker= ArrayReadTracker;
+    changeTracker = ArrayChangeTracker
+    /**
+     * Built-in Methods, which are using fields / calling methods on the proxy transparently/loyally, so those methods don't call/use internal stuff directly.
+     * Tested with, see dev_generateEsRuntimeBehaviourCheckerCode.ts
+     * May include read-only / reader methods
+     */
+    knownHighLevelMethods = new Set<keyof Array<unknown>>(["at", "concat", "map", "forEach", "join", "slice", "some", "filter", "find", "every", "findIndex", "includes", "indexOf", Symbol.iterator, "lastIndexOf", "push", "reduce", "reduceRight", "toLocaleString", "toString", "unshift", "splice", "copyWithin", "reverse"]) as Set<ObjKey>;
+
+    /**
+     * Non-high level. These fire `RecordedUnspecificRead`s then. So better implement them instead to fire i.e RecordedArrayValuesRead.
+     */
+    readOnlyMethods = new Set<keyof Array<unknown>>(["keys" /* TODO: Implement .keys, mind, that it is different to RecordedOwnKeysRead which allows gaps*/]) as Set<ObjKey>;
+
+    /**
+     * Non-high level. Same as above: better implement them
+     */
+    readOnlyFields = new Set<keyof Array<unknown>>([Symbol.unscopables]) as Set<ObjKey>;
+
+    /**
+     *
+     */
+    receiverMustBeNonProxied = false;
+
+    trackSettingObjectProperties = true;
+}

package/class-trackers/Iterator.d.ts

@@ -0,0 +1,38 @@
+import { Clazz, ForWatchedProxyHandler, GetIteratorValueProxiedFn } from "../common";
+import { WatchedProxyHandler } from "../watchedProxyFacade";
+export declare class IteratorReadTracker<T> extends Iterator<T> implements ForWatchedProxyHandler<Iterator<T>> {
+    /**
+     * This field should be set by the method that returns the Iterator. I.e. Array#values
+     */
+    _getValueProxied?: GetIteratorValueProxiedFn<T>;
+    get _watchedProxyHandler(): WatchedProxyHandler;
+    get _target(): Iterator<T>;
+    constructor();
+    /**
+     * Pretend that this is an Iterator
+     */
+    get ["constructor"](): IteratorConstructor;
+    next(...args: unknown[]): IteratorResult<T, any>;
+}
+export declare const IteratorConfig: {
+    clazz: Clazz;
+    worksForSubclasses: boolean;
+    readTracker: typeof IteratorReadTracker;
+    changeTracker: undefined;
+    /**
+     * The methods, not implemented in readTracker, are high-level
+     */
+    receiverMustBeNonProxied: boolean;
+    /**
+     * The Array/Set/Map's [Symbol.Iterator]/keys/values methods already fires a read of **all** values (simply stupid). So the Iterator/IteratorResult does not need to fire any more. The tests also don't expect this to fire.
+     * Still could be enabled in the future for really fine granular behaviour tracking
+     */
+    trackTreads: boolean;
+    proxyUnhandledMethodResults: boolean;
+    knownHighLevelMethods: Set<import("../common").ObjKey>;
+    readOnlyMethods: Set<import("../common").ObjKey>;
+    readOnlyFields: Set<import("../common").ObjKey>;
+    trackSettingObjectProperties: boolean;
+    getTrackerClasses(): Clazz[];
+};
+//# sourceMappingURL=Iterator.d.ts.map

package/class-trackers/Iterator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Iterator.d.ts","sourceRoot":"","sources":["Iterator.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6B,KAAK,EAAE,sBAAsB,EAAE,yBAAyB,EAAC,MAAM,WAAW,CAAC;AAC/G,OAAO,EAAC,mBAAmB,EAAC,MAAM,uBAAuB,CAAC;AAqB1D,qBAAa,mBAAmB,CAAC,CAAC,CAAE,SAAQ,QAAQ,CAAC,CAAC,CAAE,YAAW,sBAAsB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAClG;;OAEG;IACH,gBAAgB,CAAC,EAAE,yBAAyB,CAAC,CAAC,CAAC,CAAC;IAEhD,IAAI,oBAAoB,IAAI,mBAAmB,CAE9C;IAED,IAAI,OAAO,IAAI,QAAQ,CAAC,CAAC,CAAC,CAEzB;;IAMD;;OAEG;IACH,IAAI,CAAC,aAAa,CAAC,wBAElB;IAED,IAAI,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,cAAc,CAAC,CAAC,EAAE,GAAG,CAAC;CAQnD;AAED,eAAO,MAAM,cAAc;WACE,KAAK;;;;IAI9B;;OAEG;;IAEH;;;OAGG;;;;;;;;CAGN,CAAA"}

package/class-trackers/Iterator.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IteratorConfig = exports.IteratorReadTracker = void 0;
+const common_1 = require("../common");
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+// ******** THIS FILE IS NOT USED !!!!!! *********
+// ***********************************************
+// Currently we use a much simpler way to translate the iteration values to proxies, see common.ts/makeIteratorTranslateValue
+// Still we leave this file, cause may be in the future there will be super fine per-iteration read tracking
+// ---------------------------------------------------------------------------------------------------------
+// Supplying a proxy with ReadTracker for to
+// - easily handle all kinds of Subclasses (Array/Set/Map-Iterator)
+// - easily allow high-level methods like forEach, filter, ... This would be difficult when subclassing these
+//
+// TO make it work:
+//inside class ArrayReadTacker {
+//    values(): ArrayIterator<T> {
+//        const result = this._target.values();
+//        this._fireAfterValuesRead();
+//        result._getValueProxied = (value) => this._watchedProxyHandler.getFacade().getProxyFor(value)
+//        return this._watchedProxyHandler.getFacade().getProxyFor(result); // Wrap in proxy. There's special handling for proxied iterators to return the iteration value proxied.
+//  }
+//}
+class IteratorReadTracker extends Iterator {
+    get _watchedProxyHandler() {
+        throw new Error("not calling from inside a WatchedProxyHandler"); // Will return the handler when called through the handler
+    }
+    get _target() {
+        throw new Error("not calling from inside a WatchedProxyHandler"); // Will return the value when called through the handler
+    }
+    constructor() {
+        super();
+    }
+    /**
+     * Pretend that this is an Iterator
+     */
+    get ["constructor"]() {
+        return Iterator; // TODO: subclass
+    }
+    next(...args) {
+        const { value, done } = this._target.next(...args);
+        //@ts-ignore
+        return {
+            value: this._watchedProxyHandler.getFacade().getProxyFor(value),
+            done
+        };
+    }
+}
+exports.IteratorReadTracker = IteratorReadTracker;
+exports.IteratorConfig = new class extends common_1.ClassTrackingConfiguration {
+    constructor() {
+        super(...arguments);
+        this.clazz = Iterator;
+        this.worksForSubclasses = true;
+        this.readTracker = IteratorReadTracker;
+        this.changeTracker = undefined;
+        /**
+         * The methods, not implemented in readTracker, are high-level
+         */
+        this.receiverMustBeNonProxied = false;
+        /**
+         * The Array/Set/Map's [Symbol.Iterator]/keys/values methods already fires a read of **all** values (simply stupid). So the Iterator/IteratorResult does not need to fire any more. The tests also don't expect this to fire.
+         * Still could be enabled in the future for really fine granular behaviour tracking
+         */
+        this.trackTreads = false;
+        this.proxyUnhandledMethodResults = false;
+    }
+};
+//# sourceMappingURL=Iterator.js.map

package/class-trackers/Iterator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Iterator.js","sourceRoot":"","sources":["Iterator.ts"],"names":[],"mappings":";;;AAAA,sCAA+G;AAG/G,kDAAkD;AAClD,kDAAkD;AAClD,kDAAkD;AAClD,6HAA6H;AAC7H,4GAA4G;AAC5G,4GAA4G;AAC5G,4CAA4C;AAC5C,mEAAmE;AACnE,6GAA6G;AAC7G,EAAE;AACF,mBAAmB;AACnB,gCAAgC;AAChC,kCAAkC;AAClC,+CAA+C;AAC/C,sCAAsC;AACtC,uGAAuG;AACvG,mLAAmL;AACnL,KAAK;AACL,GAAG;AACH,MAAa,mBAAuB,SAAQ,QAAW;IAMnD,IAAI,oBAAoB;QACpB,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC,CAAC,0DAA0D;IAChI,CAAC;IAED,IAAI,OAAO;QACP,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC,CAAC,wDAAwD;IAC9H,CAAC;IAED;QACI,KAAK,EAAE,CAAC;IACZ,CAAC;IAED;;OAEG;IACH,IAAI,CAAC,aAAa,CAAC;QACf,OAAO,QAAQ,CAAC,CAAC,iBAAiB;IACtC,CAAC;IAED,IAAI,CAAC,GAAG,IAAe;QACnB,MAAM,EAAC,KAAK,EAAE,IAAI,EAAC,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,IAAW,CAAC,CAAC;QACxD,YAAY;QACZ,OAAO;YACH,KAAK,EAAE,IAAI,CAAC,oBAAoB,CAAC,SAAS,EAAE,CAAC,WAAW,CAAC,KAAK,CAAC;YAC/D,IAAI;SACP,CAAA;IACL,CAAC;CACJ;AAjCD,kDAiCC;AAEY,QAAA,cAAc,GAAG,IAAI,KAAM,SAAQ,mCAA0B;IAAxC;;QAC9B,UAAK,GAAC,QAAwB,CAAC;QAC/B,uBAAkB,GAAC,IAAI,CAAC;QACxB,gBAAW,GAAE,mBAAmB,CAAC;QACjC,kBAAa,GAAG,SAAS,CAAC;QAC1B;;WAEG;QACH,6BAAwB,GAAG,KAAK,CAAC;QACjC;;;WAGG;QACH,gBAAW,GAAG,KAAK,CAAC;QACpB,gCAA2B,GAAG,KAAK,CAAC;IACxC,CAAC;CAAA,CAAA"}

package/class-trackers/Iterator.ts

@@ -0,0 +1,73 @@
+import {ClassTrackingConfiguration, Clazz, ForWatchedProxyHandler, GetIteratorValueProxiedFn} from "../common";
+import {WatchedProxyHandler} from "../watchedProxyFacade";
+import _ from "underscore";
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+// ******** THIS FILE IS NOT USED !!!!!! *********
+// ***********************************************
+// Currently we use a much simpler way to translate the iteration values to proxies, see common.ts/makeIteratorTranslateValue
+// Still we leave this file, cause may be in the future there will be super fine per-iteration read tracking
+// ---------------------------------------------------------------------------------------------------------
+// Supplying a proxy with ReadTracker for to
+// - easily handle all kinds of Subclasses (Array/Set/Map-Iterator)
+// - easily allow high-level methods like forEach, filter, ... This would be difficult when subclassing these
+//
+// TO make it work:
+//inside class ArrayReadTacker {
+//    values(): ArrayIterator<T> {
+//        const result = this._target.values();
+//        this._fireAfterValuesRead();
+//        result._getValueProxied = (value) => this._watchedProxyHandler.getFacade().getProxyFor(value)
+//        return this._watchedProxyHandler.getFacade().getProxyFor(result); // Wrap in proxy. There's special handling for proxied iterators to return the iteration value proxied.
+//  }
+//}
+export class IteratorReadTracker<T> extends Iterator<T> implements ForWatchedProxyHandler<Iterator<T>> {
+    /**
+     * This field should be set by the method that returns the Iterator. I.e. Array#values
+     */
+    _getValueProxied?: GetIteratorValueProxiedFn<T>;
+
+    get _watchedProxyHandler(): WatchedProxyHandler {
+        throw new Error("not calling from inside a WatchedProxyHandler"); // Will return the handler when called through the handler
+    }
+
+    get _target(): Iterator<T> {
+        throw new Error("not calling from inside a WatchedProxyHandler"); // Will return the value when called through the handler
+    }
+
+    constructor() {
+        super();
+    }
+
+    /**
+     * Pretend that this is an Iterator
+     */
+    get ["constructor"]() {
+        return Iterator; // TODO: subclass
+    }
+
+    next(...args: unknown[]): IteratorResult<T, any> {
+        const {value, done} = this._target.next(...args as any);
+        //@ts-ignore
+        return {
+            value: this._watchedProxyHandler.getFacade().getProxyFor(value),
+            done
+        }
+    }
+}
+
+export const IteratorConfig = new class extends ClassTrackingConfiguration {
+    clazz=Iterator as any as Clazz;
+    worksForSubclasses=true;
+    readTracker= IteratorReadTracker;
+    changeTracker = undefined;
+    /**
+     * The methods, not implemented in readTracker, are high-level
+     */
+    receiverMustBeNonProxied = false;
+    /**
+     * The Array/Set/Map's [Symbol.Iterator]/keys/values methods already fires a read of **all** values (simply stupid). So the Iterator/IteratorResult does not need to fire any more. The tests also don't expect this to fire.
+     * Still could be enabled in the future for really fine granular behaviour tracking
+     */
+    trackTreads = false;
+    proxyUnhandledMethodResults = false;
+}

package/class-trackers/Map.d.ts

@@ -0,0 +1,128 @@
+import { EventHook, DualUseTracker, ForWatchedProxyHandler, IWatchedProxyHandler_common, ObjKey, RecordedRead } from "../common";
+import { WatchedProxyHandler } from "../watchedProxyFacade";
+import { RecordedReadOnProxiedObjectExt } from "../RecordedReadOnProxiedObjectExt";
+/**
+ * Hooks for one map.
+ * Note for specificity: There will be only one of the **change** events fired. The Recorded...Read.onChange handler will add the listeners to all possible candidates. It's this way around.
+ * {@link ObjectChangeHooks} are also subscribed on Maps
+ */
+declare class MapChangeHooks {
+    specificKeyAddedOrRemoved: import("../Util").DefaultMap<unknown, EventHook>;
+    anyKeyAddedOrRemoved: EventHook;
+    specificValueChanged: import("../Util").DefaultMap<unknown, EventHook>;
+    anyValueChanged: EventHook;
+}
+export declare const changeHooksForMap: WeakMap<Map<unknown, unknown>, MapChangeHooks>;
+export declare function getChangeHooksForMap(map: Map<unknown, unknown>): MapChangeHooks;
+/**
+ * Can be either used as a supervisor-class in a WatchedProxyHandler, or installed on the non-proxied object via Object.setPrototypeOf
+ * The "this" may be different in these cases.
+ */
+export declare class MapChangeTracker<K, V> extends Map<K, V> implements DualUseTracker<Map<K, V>> {
+    get _watchedProxyHandler(): IWatchedProxyHandler_common | undefined;
+    protected _withUnspecificChange<R>(changeFn: () => R): R;
+    /**
+     * Will return the original object when this class is used as supervisor class in the WatchedProxyHandler
+     */
+    get _target(): Map<K, V>;
+    /**
+     * Pretend that this is a Map
+     */
+    get ["constructor"](): MapConstructor;
+    set(key: K, value: V): this;
+    delete(key: K): boolean;
+    clear(): void;
+}
+export declare class RecordedMap_get extends RecordedReadOnProxiedObjectExt {
+    key: unknown;
+    keyExists: boolean;
+    /**
+     * Result of the .get call
+     */
+    value: unknown;
+    obj: Map<unknown, unknown>;
+    constructor(key: unknown, keyExists: boolean, value: unknown);
+    get isChanged(): boolean;
+    getAffectingChangeHooks(target: this["obj"]): EventHook[];
+    equals(other: RecordedRead): boolean;
+}
+export declare class RecordedMap_has extends RecordedReadOnProxiedObjectExt {
+    key: unknown;
+    /**
+     * Result of the .has call
+     */
+    keyExists: boolean;
+    obj: Map<unknown, unknown>;
+    constructor(key: unknown, keyExists: boolean);
+    get isChanged(): boolean;
+    getAffectingChangeHooks(target: this["obj"]): EventHook[];
+    equals(other: RecordedRead): boolean;
+}
+export declare class RecordedMapKeysRead extends RecordedReadOnProxiedObjectExt {
+    keys: Array<unknown>;
+    obj: Map<unknown, unknown>;
+    constructor(keys: Array<unknown>);
+    getAffectingChangeHooks(target: this["obj"]): EventHook[];
+    equals(other: RecordedRead): boolean;
+    get isChanged(): boolean;
+}
+export declare class RecordedMapValuesRead extends RecordedReadOnProxiedObjectExt {
+    values: Array<unknown>;
+    obj: Map<unknown, unknown>;
+    constructor(values: Array<unknown>);
+    getAffectingChangeHooks(target: this["obj"]): EventHook[];
+    equals(other: RecordedRead): boolean;
+    get isChanged(): boolean;
+}
+export declare class RecordedMapEntriesRead extends RecordedReadOnProxiedObjectExt {
+    values: Array<[unknown, unknown]>;
+    obj: Map<unknown, unknown>;
+    constructor(values: Array<[unknown, unknown]>);
+    getAffectingChangeHooks(target: this["obj"]): EventHook[];
+    equals(other: RecordedRead): boolean;
+    get isChanged(): boolean;
+}
+export declare class MapReadTracker<K, V> extends Map<K, V> implements ForWatchedProxyHandler<Map<K, V>> {
+    get _watchedProxyHandler(): WatchedProxyHandler;
+    get _target(): Map<K, V>;
+    protected _fireAfterEntriesRead(): void;
+    /**
+     * Pretend that this is a Map
+     */
+    get ["constructor"](): MapConstructor;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    values(): MapIterator<V>;
+    entries(): MapIterator<[K, V]>;
+    keys(): MapIterator<K>;
+    forEach(callbackfn: (value: V, key: K, map: Map<K, V>, ...restOfArgs: unknown[]) => void, ...restOfArgs: unknown[]): void;
+    [Symbol.iterator](): MapIterator<[K, V]>;
+    get size(): number;
+}
+export declare const config: {
+    clazz: MapConstructor;
+    readTracker: typeof MapReadTracker;
+    changeTracker: typeof MapChangeTracker;
+    /**
+     * Built-in Methods, which are using fields / calling methods on the proxy transparently/loyally, so those methods don't call/use internal stuff directly.
+     * Tested with, see dev_generateEsRuntimeBehaviourCheckerCode.ts
+     * May include read-only / reader methods
+     */
+    knownHighLevelMethods: Set<ObjKey>;
+    /**
+     * Non-high level
+     */
+    readOnlyMethods: Set<ObjKey>;
+    /**
+     * Non-high level
+     */
+    readOnlyFields: Set<ObjKey>;
+    receiverMustBeNonProxied: boolean;
+    worksForSubclasses: boolean;
+    trackTreads: boolean;
+    trackSettingObjectProperties: boolean;
+    proxyUnhandledMethodResults: boolean;
+    getTrackerClasses(): import("../common").Clazz[];
+};
+export {};
+//# sourceMappingURL=Map.d.ts.map

package/class-trackers/Map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Map.d.ts","sourceRoot":"","sources":["Map.ts"],"names":[],"mappings":"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"}