proxy-facades 1.0.0

package/class-trackers/Map.ts

@@ -0,0 +1,403 @@
+import {
+    ChangeListener, EventHook, ClassTrackingConfiguration,
+    DualUseTracker, dualUseTracker_callOrigMethodOnTarget,
+    ForWatchedProxyHandler, IWatchedProxyHandler_common, makeIteratorTranslateValue,
+    ObjKey,
+    RecordedRead,
+    RecordedReadOnProxiedObject,
+    runChangeOperation, UnspecificObjectChange
+} from "../common";
+import {getChangeHooksForObject, changeHooksForObject} from "../objectChangeTracking";
+import {arraysAreShallowlyEqual, arraysWithEntriesAreShallowlyEqual, MapSet, newDefaultMap} from "../Util";
+import {installChangeTracker} from "../origChangeTracking";
+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
+ */
+class MapChangeHooks {
+    specificKeyAddedOrRemoved = newDefaultMap<unknown, EventHook>( () => new EventHook());
+    anyKeyAddedOrRemoved = new EventHook();
+
+    specificValueChanged = newDefaultMap<unknown, EventHook>( () => new EventHook());
+    anyValueChanged = new EventHook();
+}
+
+export const changeHooksForMap = new WeakMap<Map<unknown,unknown>, MapChangeHooks>();
+export function getChangeHooksForMap(map: Map<unknown,unknown>) {
+    let result = changeHooksForMap.get(map);
+    if(result === undefined) {
+        changeHooksForMap.set(map, result = new MapChangeHooks());
+    }
+    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 MapChangeTracker<K,V> extends Map<K,V> implements DualUseTracker<Map<K,V>>{
+
+    get _watchedProxyHandler(): IWatchedProxyHandler_common | undefined {
+        return undefined;
+    }
+
+    protected _withUnspecificChange<R>(changeFn: () => R): R {
+        return runChangeOperation(this, new UnspecificObjectChange(this), [getChangeHooksForObject(this).unspecificChange], changeFn)
+    }
+
+    /**
+     * Will return the original object when this class is used as supervisor class in the WatchedProxyHandler
+     */
+    get _target(): Map<K, V> {
+        return this;
+    }
+
+    /**
+     * Pretend that this is a Map
+     */
+    get ["constructor"]() {
+        return Map;
+    }
+
+    set(key:K, value: V): this {
+        key = this._watchedProxyHandler?this._watchedProxyHandler.getFacade().getUnproxiedValue(key):key; // Translate to unproxied key
+        value = this._watchedProxyHandler?this._watchedProxyHandler.getFacade().getUnproxiedValue(value):value; // Translate to unproxied value
+        
+        const isNewKey = !this._target.has(key);
+        const valueChanged = isNewKey || this._target.get(key) !== value;
+        if(!isNewKey && !valueChanged) {
+            return this;
+        }
+
+        const hooksForThisMap = getChangeHooksForMap(this);
+        const hooksToServe = [
+            ...(isNewKey?[hooksForThisMap.specificKeyAddedOrRemoved.get(key), hooksForThisMap.anyKeyAddedOrRemoved]:[]),
+            ...(valueChanged?[hooksForThisMap.specificValueChanged.get(key), hooksForThisMap.anyValueChanged]:[])
+        ];
+        runChangeOperation(this, new UnspecificObjectChange(this),hooksToServe,() => {
+            return dualUseTracker_callOrigMethodOnTarget(this, "set", [key, value])
+        });
+
+        return this;
+    }
+
+    delete(key: K): boolean {
+        key = this._watchedProxyHandler?this._watchedProxyHandler.getFacade().getUnproxiedValue(key):key; // Translate to unproxied key
+
+        if(!this._target.has(key)) { // no change?
+            return false;
+        }
+
+        const hooksForThisMap = getChangeHooksForMap(this);
+        const hooksToServe = [hooksForThisMap.specificKeyAddedOrRemoved.get(key),hooksForThisMap.anyKeyAddedOrRemoved,hooksForThisMap.specificValueChanged.get(key),hooksForThisMap.anyValueChanged];
+        return runChangeOperation(this, new UnspecificObjectChange(this),hooksToServe,() => {
+            return dualUseTracker_callOrigMethodOnTarget(this, "delete", [key]);
+        });
+    }
+
+    clear() {
+        const hooksToServe = [getChangeHooksForMap(this).anyKeyAddedOrRemoved, getChangeHooksForMap(this).anyValueChanged, getChangeHooksForObject(this).unspecificChange];
+        return runChangeOperation(this, new UnspecificObjectChange(this),hooksToServe,() => {
+            return dualUseTracker_callOrigMethodOnTarget(this, "clear", []);
+        });
+    }
+
+}
+
+export 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) {
+        super();
+        this.key = key;
+        this.keyExists = keyExists;
+        this.value = value;
+    }
+
+    get isChanged() {
+        return !(this.keyExists === this.obj.has(this.key) && this.value === this.obj.get(this.key));
+    }
+
+    getAffectingChangeHooks(target: this["obj"]) {
+        return [
+            getChangeHooksForMap(target).specificKeyAddedOrRemoved.get(this.key),
+            getChangeHooksForMap(target).specificValueChanged.get(this.key),
+            getChangeHooksForObject(target).unspecificChange
+        ]
+    }
+
+    equals(other: RecordedRead) {
+        if (!(other instanceof RecordedMap_get)) {
+            return false;
+        }
+
+        return this.proxyHandler === other.proxyHandler && this.obj === other.obj && this.key === other.key && this.keyExists == other.keyExists && this.value === other.value;
+    }
+}
+
+export class RecordedMap_has extends RecordedReadOnProxiedObjectExt {
+    key!: unknown;
+
+    /**
+     * Result of the .has call
+     */
+    keyExists: boolean;
+    obj!: Map<unknown, unknown>;
+
+
+    constructor(key: unknown, keyExists: boolean) {
+        super();
+        this.key = key;
+        this.keyExists = keyExists;
+    }
+
+    get isChanged() {
+        return this.keyExists !== this.obj.has(this.key);
+    }
+
+    getAffectingChangeHooks(target: this["obj"]) {
+        return [
+            getChangeHooksForMap(target).specificKeyAddedOrRemoved.get(this.key),
+            getChangeHooksForObject(target).unspecificChange,
+        ]
+    }
+
+    equals(other: RecordedRead) {
+        if (!(other instanceof RecordedMap_has)) {
+            return false;
+        }
+
+        return this.proxyHandler === other.proxyHandler && this.obj === other.obj && this.key === other.key && this.keyExists === other.keyExists;
+    }
+}
+
+export class RecordedMapKeysRead extends RecordedReadOnProxiedObjectExt {
+    keys: Array<unknown>;
+    obj!: Map<unknown, unknown>;
+
+
+    constructor(keys: Array<unknown>) {
+        super();
+        this.keys = keys;
+    }
+
+    getAffectingChangeHooks(target: this["obj"]) {
+        return [
+            getChangeHooksForMap(target).anyKeyAddedOrRemoved,
+            getChangeHooksForObject(target).unspecificChange
+        ]
+    }
+
+    equals(other: RecordedRead): boolean {
+        if (!(other instanceof RecordedMapKeysRead)) {
+            return false;
+        }
+
+        return this.proxyHandler === other.proxyHandler && this.obj === other.obj && arraysAreShallowlyEqual(this.keys, other.keys);
+    }
+
+    get isChanged(): boolean {
+        return !arraysAreShallowlyEqual(this.keys, [...(this.obj).keys()]);
+    }
+}
+
+export class RecordedMapValuesRead extends RecordedReadOnProxiedObjectExt {
+    values: Array<unknown>;
+
+    obj!:Map<unknown, unknown>;
+
+    constructor(values: Array<unknown>) {
+        super();
+        this.values = values;
+    }
+
+    getAffectingChangeHooks(target: this["obj"]) {
+        return [
+            getChangeHooksForMap(target).anyValueChanged,
+            getChangeHooksForObject(target).unspecificChange
+        ]
+    }
+
+    equals(other: RecordedRead): boolean {
+        if (!(other instanceof RecordedMapValuesRead)) {
+            return false;
+        }
+
+        return this.proxyHandler === other.proxyHandler && this.obj === other.obj && arraysAreShallowlyEqual(this.values, other.values);
+    }
+
+    get isChanged(): boolean {
+        return !arraysAreShallowlyEqual(this.values, [...(this.obj).values()]);
+    }
+}
+
+export class RecordedMapEntriesRead extends RecordedReadOnProxiedObjectExt {
+    values: Array<[unknown, unknown]>;
+
+    obj!: Map<unknown, unknown>;
+
+
+    constructor(values: Array<[unknown, unknown]>) {
+        super();
+        this.values = values;
+    }
+
+    getAffectingChangeHooks(target: this["obj"]) {
+        return [
+            getChangeHooksForMap(target).anyKeyAddedOrRemoved,
+            getChangeHooksForMap(target).anyValueChanged,
+            getChangeHooksForObject(target).unspecificChange
+        ]
+    }
+
+    equals(other: RecordedRead): boolean {
+        if (!(other instanceof RecordedMapEntriesRead)) {
+            return false;
+        }
+
+        return this.proxyHandler === other.proxyHandler && this.obj === other.obj && arraysWithEntriesAreShallowlyEqual(this.values, other.values);
+    }
+
+    get isChanged(): boolean {
+        return !arraysWithEntriesAreShallowlyEqual(this.values, [...(this.obj).entries()]);
+    }
+}
+
+export class MapReadTracker<K, V> extends Map<K, V> implements ForWatchedProxyHandler<Map<K, V>> {
+    get _watchedProxyHandler(): WatchedProxyHandler {
+        throw new Error("not calling from inside a WatchedProxyHandler"); // Will return the handler when called through the handler
+    }
+
+    get _target(): Map<K, V> {
+        throw new Error("not calling from inside a WatchedProxyHandler"); // Will return the value when called through the handler
+    }
+
+    protected _fireAfterEntriesRead() {
+        let recordedMapEntriesRead = new RecordedMapEntriesRead([...this._target.entries()]);
+        this._watchedProxyHandler?.fireAfterRead(recordedMapEntriesRead);
+    }
+
+    /**
+     * Pretend that this is a Map
+     */
+    get ["constructor"]() {
+        return Map;
+    }
+
+    get(key: K): V | undefined {
+        key = this._watchedProxyHandler.getFacade().getUnproxiedValue(key);
+        const keyExists = this._target.has(key);
+        const result = this._target.get(key);
+
+        const read = new RecordedMap_get(key, keyExists, result);
+        this._watchedProxyHandler?.fireAfterRead(read);
+
+        return this._watchedProxyHandler.getFacade().getProxyFor(result);
+    }
+
+    has(key: K): boolean {
+        key = this._watchedProxyHandler.getFacade().getUnproxiedValue(key);
+        const result = this._target.has(key);
+
+        const read = new RecordedMap_has(key, result);
+        this._watchedProxyHandler?.fireAfterRead(read);
+
+        return result;
+    }
+
+    values(): MapIterator<V> {
+        const result = this._target.values();
+
+        let recordedMapValuesRead = new RecordedMapValuesRead([...result]);
+        this._watchedProxyHandler?.fireAfterRead(recordedMapValuesRead);
+
+        return makeIteratorTranslateValue(result, (value) => this._watchedProxyHandler.getFacade().getProxyFor(value));
+    }
+
+    entries(): MapIterator<[K, V]> {
+        const result = this._target.entries();
+        this._fireAfterEntriesRead();
+
+        const facade = this._watchedProxyHandler.getFacade();
+        return makeIteratorTranslateValue<[K, V], MapIterator<[K, V]>/*strange that TS does not infer the types here*/>(result, ([key,value]) => [facade.getProxyFor(key), facade.getProxyFor(value)]);
+    }
+
+    keys(): MapIterator<K> {
+        const result = this._target.keys();
+
+        let recordedMapKeysRead = new RecordedMapKeysRead([...result]);
+        this._watchedProxyHandler?.fireAfterRead(recordedMapKeysRead);
+
+        return makeIteratorTranslateValue(result, (key) => this._watchedProxyHandler.getFacade().getProxyFor(key));
+    }
+
+    forEach(callbackfn: (value: V, key: K, map: Map<K, V>, ...restOfArgs: unknown[]) => void, ...restOfArgs: unknown[]) {
+        const getProxyFor: (<T>(val: T)=>T) = (value) => this._watchedProxyHandler.getFacade().getProxyFor(value);
+
+        /**
+         * Calls callbackFn but supplies it it's arguments *proxied*
+         */
+        function callCallbackFnWithProxies(this: Map<K, V>, value: V, key: K, map: Map<K, V>, ...restOfArgs: unknown[]): void{
+            callbackfn.apply(this, [getProxyFor(value), getProxyFor(key), getProxyFor(map), ...restOfArgs]);
+        }
+
+        const result = this._target.forEach(callCallbackFnWithProxies, ...restOfArgs);
+        this._fireAfterEntriesRead();
+        return result;
+    }
+
+    [Symbol.iterator](): MapIterator<[K, V]> {
+        const result = this._target[Symbol.iterator]();
+        this._fireAfterEntriesRead();
+
+        const facade = this._watchedProxyHandler.getFacade();
+        return makeIteratorTranslateValue<[K, V], MapIterator<[K, V]>/*strange that TS does not infer the types here*/>(result, ([key,value]) => [facade.getProxyFor(key), facade.getProxyFor(value)]);
+    }
+
+    get size(): number {
+        const result = this._target.size;
+
+        let recordedMapKeysRead = new RecordedMapKeysRead([...this._target.keys()]); // TODO: RecordedMapSizeRead
+        this._watchedProxyHandler?.fireAfterRead(recordedMapKeysRead);
+
+        return result;
+    }
+}
+
+export const config = new class extends ClassTrackingConfiguration {
+    clazz=Map;
+    readTracker= MapReadTracker;
+    changeTracker = 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 = new Set<keyof Map<unknown,unknown>>([]) as Set<ObjKey>;
+
+    /**
+     * Non-high level
+     */
+    readOnlyMethods = new Set<keyof Map<unknown,unknown>>([]) as Set<ObjKey>;
+
+    /**
+     * Non-high level
+     */
+    readOnlyFields = new Set<keyof Map<unknown,unknown>>(["size"]) as Set<ObjKey>;
+
+    receiverMustBeNonProxied = true;
+}

package/class-trackers/Set.d.ts

@@ -0,0 +1,85 @@
+import { DualUseTracker, ForWatchedProxyHandler, IWatchedProxyHandler_common, ObjKey, RecordedRead, EventHook } from "../common";
+import { WatchedProxyHandler } from "../watchedProxyFacade";
+import { RecordedReadOnProxiedObjectExt } from "../RecordedReadOnProxiedObjectExt";
+/**
+ * Listeners for one set.
+ * 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 Sets
+ */
+declare class SetChangeHooks {
+    afterSpecificValueChanged: import("../Util").DefaultMap<unknown, EventHook>;
+    afterAnyValueChanged: EventHook;
+}
+export declare const changeHooksForSet: WeakMap<Set<unknown>, SetChangeHooks>;
+export declare function getChangeHooksForSet(set: Set<unknown>): SetChangeHooks;
+/**
+ * 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 SetChangeTracker<T> extends Set<T> implements DualUseTracker<Set<T>> {
+    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(): Set<T>;
+    /**
+     * Pretend that this is a Set
+     */
+    get ["constructor"](): SetConstructor;
+    add(value: T): this;
+    delete(value: T): boolean;
+    clear(): void;
+}
+export declare class RecordedSet_has extends RecordedReadOnProxiedObjectExt {
+    value: unknown;
+    /**
+     * Result of the .has call
+     */
+    result: boolean;
+    obj: Set<unknown>;
+    constructor(value: unknown, result: boolean);
+    get isChanged(): boolean;
+    getAffectingChangeHooks(target: this["obj"]): EventHook[];
+    equals(other: RecordedRead): boolean;
+}
+export declare class RecordedSetValuesRead extends RecordedReadOnProxiedObjectExt {
+    values: Array<unknown>;
+    obj: Set<unknown>;
+    constructor(values: Array<unknown>);
+    getAffectingChangeHooks(target: this["obj"]): EventHook[];
+    equals(other: RecordedRead): boolean;
+    get isChanged(): boolean;
+}
+export declare class SetReadTracker<T> extends Set<T> implements ForWatchedProxyHandler<Set<T>> {
+    get _watchedProxyHandler(): WatchedProxyHandler;
+    get _target(): Set<T>;
+    protected _fireAfterValuesRead(): void;
+    /**
+     * Pretend that this is a Set
+     */
+    get ["constructor"](): SetConstructor;
+    has(value: T): boolean;
+    values(): SetIterator<T>;
+    entries(): SetIterator<[T, T]>;
+    keys(): SetIterator<T>;
+    forEach(callbackfn: (value: T, value2: T, set: Set<T>, ...restOfArgs: unknown[]) => void, ...restOfArgs: unknown[]): void;
+    [Symbol.iterator](): SetIterator<T>;
+    get size(): number;
+}
+export declare const config: {
+    clazz: SetConstructor;
+    readTracker: typeof SetReadTracker;
+    changeTracker: typeof SetChangeTracker;
+    receiverMustBeNonProxied: boolean;
+    worksForSubclasses: boolean;
+    knownHighLevelMethods: Set<ObjKey>;
+    readOnlyMethods: Set<ObjKey>;
+    readOnlyFields: Set<ObjKey>;
+    trackTreads: boolean;
+    trackSettingObjectProperties: boolean;
+    proxyUnhandledMethodResults: boolean;
+    getTrackerClasses(): import("../common").Clazz[];
+};
+export {};
+//# sourceMappingURL=Set.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Set.d.ts","sourceRoot":"","sources":["Set.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,cAAc,EACd,sBAAsB,EAAE,2BAA2B,EACnD,MAAM,EACN,YAAY,EAEZ,SAAS,EACZ,MAAM,WAAW,CAAC;AAGnB,OAAO,EAAC,mBAAmB,EAAC,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAC,8BAA8B,EAAC,MAAM,mCAAmC,CAAC;AAGjF;;;;GAIG;AACH,cAAM,cAAc;IAChB,yBAAyB,mDAA6D;IACtF,oBAAoB,YAAmB;CAC1C;AAED,eAAO,MAAM,iBAAiB,uCAA8C,CAAC;AAC7E,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,GAAG,CAAC,OAAO,CAAC,kBAMrD;AAED;;;GAGG;AACH,qBAAa,gBAAgB,CAAC,CAAC,CAAE,SAAQ,GAAG,CAAC,CAAC,CAAE,YAAW,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAE7E,IAAI,oBAAoB,IAAI,2BAA2B,GAAG,SAAS,CAElE;IAED,SAAS,CAAC,qBAAqB,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC;IAIxD;;OAEG;IACH,IAAI,OAAO,IAAI,GAAG,CAAC,CAAC,CAAC,CAEpB;IAED;;OAEG;IACH,IAAI,CAAC,aAAa,CAAC,mBAElB;IAED,GAAG,CAAC,KAAK,EAAC,CAAC,GAAG,IAAI;IAYlB,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO;IAYzB,KAAK;CAMR;AAED,qBAAa,eAAgB,SAAQ,8BAA8B;IAC/D,KAAK,EAAG,OAAO,CAAC;IAChB;;OAEG;IACH,MAAM,EAAE,OAAO,CAAC;IAChB,GAAG,EAAG,GAAG,CAAC,OAAO,CAAC,CAAC;gBAGP,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO;IAM3C,IAAI,SAAS,YAEZ;IAED,uBAAuB,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC;IAO3C,MAAM,CAAC,KAAK,EAAE,YAAY;CAO7B;AAED,qBAAa,qBAAsB,SAAQ,8BAA8B;IACrE,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;IAEvB,GAAG,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;gBAGN,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC;IAKlC,uBAAuB,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC;IAO3C,MAAM,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO;IAQpC,IAAI,SAAS,IAAI,OAAO,CAEvB;CACJ;AAED,qBAAa,cAAc,CAAC,CAAC,CAAE,SAAQ,GAAG,CAAC,CAAC,CAAE,YAAW,sBAAsB,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IACnF,IAAI,oBAAoB,IAAI,mBAAmB,CAE9C;IAED,IAAI,OAAO,IAAI,GAAG,CAAC,CAAC,CAAC,CAEpB;IAED,SAAS,CAAC,oBAAoB;IAK9B;;OAEG;IACH,IAAI,CAAC,aAAa,CAAC,mBAElB;IAED,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO;IAUtB,MAAM,IAAI,WAAW,CAAC,CAAC,CAAC;IAMxB,OAAO,IAAI,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAQ9B,IAAI,IAAI,WAAW,CAAC,CAAC,CAAC;IAMtB,OAAO,CAAC,UAAU,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,UAAU,EAAE,OAAO,EAAE,KAAK,IAAI,EAAE,GAAG,UAAU,EAAE,OAAO,EAAE;IAelH,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,WAAW,CAAC,CAAC,CAAC;IAMnC,IAAI,IAAI,IAAI,MAAM,CAIjB;CACJ;AAED,eAAO,MAAM,MAAM;;;;;;;;;;;;;CAKlB,CAAA"}

package/class-trackers/Set.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = exports.SetReadTracker = exports.RecordedSetValuesRead = exports.RecordedSet_has = exports.SetChangeTracker = exports.changeHooksForSet = void 0;
+exports.getChangeHooksForSet = getChangeHooksForSet;
+const common_1 = require("../common");
+const objectChangeTracking_1 = require("../objectChangeTracking");
+const Util_1 = require("../Util");
+const RecordedReadOnProxiedObjectExt_1 = require("../RecordedReadOnProxiedObjectExt");
+/**
+ * Listeners for one set.
+ * 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 Sets
+ */
+class SetChangeHooks {
+    constructor() {
+        this.afterSpecificValueChanged = (0, Util_1.newDefaultMap)(() => new common_1.EventHook());
+        this.afterAnyValueChanged = new common_1.EventHook();
+    }
+}
+exports.changeHooksForSet = new WeakMap();
+function getChangeHooksForSet(set) {
+    let result = exports.changeHooksForSet.get(set);
+    if (result === undefined) {
+        exports.changeHooksForSet.set(set, result = new SetChangeHooks());
+    }
+    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.
+ */
+class SetChangeTracker extends Set {
+    get _watchedProxyHandler() {
+        return undefined;
+    }
+    _withUnspecificChange(changeFn) {
+        return (0, common_1.runChangeOperation)(this, new common_1.UnspecificObjectChange(this), [(0, objectChangeTracking_1.getChangeHooksForObject)(this).unspecificChange], changeFn);
+    }
+    /**
+     * Will return the original object when this class is used as supervisor class in the WatchedProxyHandler
+     */
+    get _target() {
+        return this;
+    }
+    /**
+     * Pretend that this is a Set
+     */
+    get ["constructor"]() {
+        return Set;
+    }
+    add(value) {
+        value = this._watchedProxyHandler ? this._watchedProxyHandler.getFacade().getUnproxiedValue(value) : value; // Translate to unproxied value
+        if (this._target.has(value)) { // No change?
+            return this;
+        }
+        (0, common_1.runChangeOperation)(this, new common_1.UnspecificObjectChange(this), [getChangeHooksForSet(this).afterSpecificValueChanged.get(value), getChangeHooksForSet(this).afterAnyValueChanged], () => {
+            (0, common_1.dualUseTracker_callOrigMethodOnTarget)(this, "add", [value]);
+        });
+        return this;
+    }
+    delete(value) {
+        value = this._watchedProxyHandler ? this._watchedProxyHandler.getFacade().getUnproxiedValue(value) : value; // Translate to unproxied value
+        if (!this._target.has(value)) { // no change?
+            return false;
+        }
+        return (0, common_1.runChangeOperation)(this, new common_1.UnspecificObjectChange(this), [getChangeHooksForSet(this).afterSpecificValueChanged.get(value), getChangeHooksForSet(this).afterAnyValueChanged], () => {
+            return (0, common_1.dualUseTracker_callOrigMethodOnTarget)(this, "delete", [value]);
+        });
+    }
+    clear() {
+        return (0, common_1.runChangeOperation)(this, new common_1.UnspecificObjectChange(this), [getChangeHooksForSet(this).afterAnyValueChanged, (0, objectChangeTracking_1.getChangeHooksForObject)(this).unspecificChange], () => {
+            return (0, common_1.dualUseTracker_callOrigMethodOnTarget)(this, "clear", []);
+        });
+    }
+}
+exports.SetChangeTracker = SetChangeTracker;
+class RecordedSet_has extends RecordedReadOnProxiedObjectExt_1.RecordedReadOnProxiedObjectExt {
+    constructor(value, result) {
+        super();
+        this.value = value;
+        this.result = result;
+    }
+    get isChanged() {
+        return this.result !== this.obj.has(this.value);
+    }
+    getAffectingChangeHooks(target) {
+        return [
+            getChangeHooksForSet(target).afterSpecificValueChanged.get(this.value),
+            (0, objectChangeTracking_1.getChangeHooksForObject)(target).unspecificChange
+        ];
+    }
+    equals(other) {
+        if (!(other instanceof RecordedSet_has)) {
+            return false;
+        }
+        return this.proxyHandler === other.proxyHandler && this.obj === other.obj && this.value === other.value && this.result === other.result;
+    }
+}
+exports.RecordedSet_has = RecordedSet_has;
+class RecordedSetValuesRead extends RecordedReadOnProxiedObjectExt_1.RecordedReadOnProxiedObjectExt {
+    constructor(values) {
+        super();
+        this.values = values;
+    }
+    getAffectingChangeHooks(target) {
+        return [
+            getChangeHooksForSet(target).afterAnyValueChanged,
+            (0, objectChangeTracking_1.getChangeHooksForObject)(target).unspecificChange
+        ];
+    }
+    equals(other) {
+        if (!(other instanceof RecordedSetValuesRead)) {
+            return false;
+        }
+        return this.proxyHandler === other.proxyHandler && this.obj === other.obj && (0, Util_1.arraysAreShallowlyEqual)(this.values, other.values);
+    }
+    get isChanged() {
+        return !(0, Util_1.arraysAreShallowlyEqual)(this.values, [...(this.obj).values()]);
+    }
+}
+exports.RecordedSetValuesRead = RecordedSetValuesRead;
+class SetReadTracker extends Set {
+    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
+    }
+    _fireAfterValuesRead() {
+        var _a;
+        let recordedSetValuesRead = new RecordedSetValuesRead([...this._target]);
+        (_a = this._watchedProxyHandler) === null || _a === void 0 ? void 0 : _a.fireAfterRead(recordedSetValuesRead);
+    }
+    /**
+     * Pretend that this is a Set
+     */
+    get ["constructor"]() {
+        return Set;
+    }
+    has(value) {
+        var _a;
+        value = this._watchedProxyHandler.getFacade().getUnproxiedValue(value);
+        const result = this._target.has(value);
+        const read = new RecordedSet_has(value, result);
+        (_a = this._watchedProxyHandler) === null || _a === void 0 ? void 0 : _a.fireAfterRead(read);
+        return result;
+    }
+    values() {
+        const result = this._target.values();
+        this._fireAfterValuesRead();
+        return (0, common_1.makeIteratorTranslateValue)(result, (value) => this._watchedProxyHandler.getFacade().getProxyFor(value));
+    }
+    entries() {
+        const result = this._target.entries();
+        this._fireAfterValuesRead();
+        const facade = this._watchedProxyHandler.getFacade();
+        return (0, common_1.makeIteratorTranslateValue)(result, ([value1, value2]) => [facade.getProxyFor(value1), facade.getProxyFor(value2)]);
+    }
+    keys() {
+        const result = this._target.keys();
+        this._fireAfterValuesRead();
+        return (0, common_1.makeIteratorTranslateValue)(result, (value) => this._watchedProxyHandler.getFacade().getProxyFor(value));
+    }
+    forEach(callbackfn, ...restOfArgs) {
+        const getProxyFor = (value) => this._watchedProxyHandler.getFacade().getProxyFor(value);
+        /**
+         * Calls callbackFn but supplies it it's arguments *proxied*
+         */
+        function callCallbackFnWithProxies(value, value2, set, ...restOfArgs) {
+            callbackfn.apply(this, [getProxyFor(value), getProxyFor(value2), getProxyFor(set), ...restOfArgs]);
+        }
+        const result = this._target.forEach(callCallbackFnWithProxies, ...restOfArgs);
+        this._fireAfterValuesRead();
+        return result;
+    }
+    [Symbol.iterator]() {
+        const result = this._target[Symbol.iterator]();
+        this._fireAfterValuesRead();
+        return (0, common_1.makeIteratorTranslateValue)(result, (value) => this._watchedProxyHandler.getFacade().getProxyFor(value));
+    }
+    get size() {
+        const result = this._target.size;
+        this._fireAfterValuesRead();
+        return result;
+    }
+}
+exports.SetReadTracker = SetReadTracker;
+exports.config = new class extends common_1.ClassTrackingConfiguration {
+    constructor() {
+        super(...arguments);
+        this.clazz = Set;
+        this.readTracker = SetReadTracker;
+        this.changeTracker = SetChangeTracker;
+        this.receiverMustBeNonProxied = true;
+    }
+};
+//# sourceMappingURL=Set.js.map