proxy-facades 1.0.0

package/index.ts

@@ -0,0 +1,7 @@
+export {RecordedRead, RecordedReadOnProxiedObject, ClassTrackingConfiguration, dualUseTracker_callOrigMethodOnTarget, IteratorReturningProxiedValue, GetIteratorValueProxiedFn, DualUseTracker, ForWatchedProxyHandler} from "./common"
+export {ProxyFacade, FacadeProxyHandler, invalidateObject, getGlobalOrig} from "./proxyFacade";
+export {deleteProperty, changeTrackedOrigObjects, installChangeTracker} from "./origChangeTracking"
+export {RecordedArrayValuesRead} from "./class-trackers/Array"
+export {RecordedMap_has, RecordedMap_get, RecordedMapEntriesRead, RecordedMapKeysRead, RecordedMapValuesRead} from "./class-trackers/Map"
+export {RecordedSet_has, RecordedSetValuesRead} from "./class-trackers/Set"
+export {RecordedValueRead, RecordedUnspecificRead, RecordedPropertyRead,RecordedOwnKeysRead, WatchedProxyFacade,  WatchedProxyHandler} from "./watchedProxyFacade";

package/index_esm.mjs

@@ -0,0 +1,44 @@
+// A wrapper file for ESM to avoid the 'dual package hazard'. See https://nodejs.org/api/packages.html#approach-1-use-an-es-module-wrapper
+
+import cjsCommon from "./common.js"
+export const RecordedRead = cjsCommon.RecordedRead;
+export const RecordedReadOnProxiedObject = cjsCommon.RecordedReadOnProxiedObject;
+export const ClassTrackingConfiguration = cjsCommon.ClassTrackingConfiguration;
+export const dualUseTracker_callOrigMethodOnTarget = cjsCommon.dualUseTracker_callOrigMethodOnTarget;
+export const IteratorReturningProxiedValue = cjsCommon.IteratorReturningProxiedValue;
+export const GetIteratorValueProxiedFn = cjsCommon.GetIteratorValueProxiedFn;
+export const DualUseTracker = cjsCommon.DualUseTracker;
+export const ForWatchedProxyHandler = cjsCommon.ForWatchedProxyHandler
+
+import cjsProxyFacade from "./proxyFacade"
+export const ProxyFacade = cjsProxyFacade.ProxyFacade;
+export const FacadeProxyHandler = cjsProxyFacade.FacadeProxyHandler;
+export const invalidateObject = cjsProxyFacade.invalidateObject;
+export const getGlobalOrig = cjsProxyFacade.getGlobalOrig;
+
+import cjsOrigChangeTracking from "./origChangeTracking"
+export const deleteProperty = cjsOrigChangeTracking.deleteProperty;
+export const changeTrackedOrigObjects = cjsOrigChangeTracking.changeTrackedOrigObjects;
+export const installChangeTracker = cjsOrigChangeTracking.installChangeTracker;
+
+import cjsClassTrackers_Array from "./class-trackers/Array";
+export const RecordedArrayValuesRead = cjsClassTrackers_Array.RecordedArrayValuesRead
+
+import cjsClassTrackers_Map from "./class-trackers/Map";
+export const RecordedMap_has = cjsClassTrackers_Map.RecordedMap_has;
+export const RecordedMap_get = cjsClassTrackers_Map.RecordedMap_get;
+export const RecordedMapEntriesRead = cjsClassTrackers_Map.RecordedMapEntriesRead;
+export const RecordedMapKeysRead = cjsClassTrackers_Map.RecordedMapKeysRead;
+export const RecordedMapValuesRead = cjsClassTrackers_Map.RecordedMapValuesRead;
+
+import cjsClassTrackers_Set from "./class-trackers/Set";
+export const RecordedSet_has = cjsClassTrackers_Set.RecordedSet_has;
+export const RecordedSetValuesRead = cjsClassTrackers_Set.RecordedSetValuesRead;
+
+import cjsWatchedProxyFacade from "./watchedProxyFacade"
+export const RecordedValueRead = cjsWatchedProxyFacade.RecordedValueRead;
+export const RecordedUnspecificRead = cjsWatchedProxyFacade.RecordedUnspecificRead;
+export const RecordedPropertyRead = cjsWatchedProxyFacade.RecordedPropertyRead;
+export const RecordedOwnKeysRead = cjsWatchedProxyFacade.RecordedOwnKeysRead;
+export const WatchedProxyFacade = cjsWatchedProxyFacade.WatchedProxyFacade;
+export const WatchedProxyHandler = cjsWatchedProxyFacade.WatchedProxyHandler;

package/objectChangeTracking.d.ts

@@ -0,0 +1,43 @@
+import { ClassTrackingConfiguration, EventHook, ObjKey } from "./common";
+/**
+ * Contains change listeners for one specific object.
+ * 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.
+ * Does not apply to setterInvoke.. These are fired in addition (not thought through for all situations)
+ */
+declare class ObjectChangeHooks {
+    /**
+     * For writes on **setters** (also if these are the same/unchanged values)
+     */
+    setterInvoke: import("./Util").DefaultMap<ObjKey, EventHook>;
+    changeSpecificProperty: import("./Util").DefaultMap<ObjKey, EventHook>;
+    changeAnyProperty: EventHook;
+    /**
+     * Means, the result of Object.keys will be different after the change. All iterations over the object/arrays's keys or values are informed that there was a change. Individual {@link changeSpecificProperty} are not affected!
+     */
+    changeOwnKeys: EventHook;
+    /**
+     * These will always be called, no matter how specific a change is
+     */
+    anyChange: EventHook;
+    /**
+     *
+     */
+    unspecificChange: EventHook;
+}
+export declare const changeHooksForObject: WeakMap<object, ObjectChangeHooks>;
+export declare function getChangeHooksForObject(obj: object): ObjectChangeHooks;
+export declare class ObjectProxyHandler implements ProxyHandler<object> {
+    target: object;
+    origPrototype: object | null;
+    proxy: object;
+    trackingConfig?: ClassTrackingConfiguration;
+    constructor(target: object, trackingConfig: ClassTrackingConfiguration | undefined);
+    installSetterTrap(key: ObjKey): void;
+    protected withUnspecificChange<R>(changeFn: () => R): R;
+    get(fake_target: object, key: ObjKey, receiver: any): any;
+    set(fake_target: object, key: ObjKey, value: any, receiver: any): boolean;
+    getPrototypeOf(target: object): object | null;
+    defineProperty(target: object, property: string | symbol, attributes: PropertyDescriptor): boolean;
+}
+export {};
+//# sourceMappingURL=objectChangeTracking.d.ts.map

package/objectChangeTracking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"objectChangeTracking.d.ts","sourceRoot":"","sources":["objectChangeTracking.ts"],"names":[],"mappings":"AAIA,OAAO,EACH,0BAA0B,EAC1B,SAAS,EAGT,MAAM,EAIT,MAAM,UAAU,CAAC;AAElB;;;;GAIG;AACH,cAAM,iBAAiB;IACnB;;OAEG;IACH,YAAY,iDAA4D;IACxE,sBAAsB,iDAA4D;IAClF,iBAAiB,YAAmB;IAEpC;;OAEG;IACH,aAAa,YAAmB;IAChC;;OAEG;IACH,SAAS,YAAmB;IAE5B;;OAEG;IACH,gBAAgB,YAAmB;CACtC;AAID,eAAO,MAAM,oBAAoB,oCAA2C,CAAC;AAC7E,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,qBAMlD;AAED,qBAAa,kBAAmB,YAAW,YAAY,CAAC,MAAM,CAAC;IAC3D,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,CAAC,EAAE,0BAA0B,CAAA;gBAE/B,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,0BAA0B,GAAG,SAAS;IAmBlF,iBAAiB,CAAC,GAAG,EAAE,MAAM;IAkE7B,SAAS,CAAC,oBAAoB,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC;IAIvD,GAAG,CAAC,WAAW,EAAC,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAC,GAAG,GAAG,GAAG;IA2EvD,GAAG,CAAC,WAAW,EAAC,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAC,GAAG,EAAE,QAAQ,EAAC,GAAG;IAkB5D,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAI7C,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,UAAU,EAAE,kBAAkB,GAAG,OAAO;CAIrG"}

package/objectChangeTracking.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectProxyHandler = exports.changeHooksForObject = void 0;
+exports.getChangeHooksForObject = getChangeHooksForObject;
+/**
+ * Listeners for one object
+ */
+const Util_1 = require("./Util");
+const common_1 = require("./common");
+/**
+ * Contains change listeners for one specific object.
+ * 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.
+ * Does not apply to setterInvoke.. These are fired in addition (not thought through for all situations)
+ */
+class ObjectChangeHooks {
+    constructor() {
+        /**
+         * For writes on **setters** (also if these are the same/unchanged values)
+         */
+        this.setterInvoke = (0, Util_1.newDefaultMap)(() => new common_1.EventHook());
+        this.changeSpecificProperty = (0, Util_1.newDefaultMap)(() => new common_1.EventHook());
+        this.changeAnyProperty = new common_1.EventHook();
+        /**
+         * Means, the result of Object.keys will be different after the change. All iterations over the object/arrays's keys or values are informed that there was a change. Individual {@link changeSpecificProperty} are not affected!
+         */
+        this.changeOwnKeys = new common_1.EventHook();
+        /**
+         * These will always be called, no matter how specific a change is
+         */
+        this.anyChange = new common_1.EventHook();
+        /**
+         *
+         */
+        this.unspecificChange = new common_1.EventHook();
+    }
+}
+exports.changeHooksForObject = new WeakMap();
+function getChangeHooksForObject(obj) {
+    let result = exports.changeHooksForObject.get(obj);
+    if (result === undefined) {
+        exports.changeHooksForObject.set(obj, result = new ObjectChangeHooks());
+    }
+    return result;
+}
+class ObjectProxyHandler {
+    constructor(target, trackingConfig) {
+        this.target = target;
+        this.trackingConfig = trackingConfig;
+        this.origPrototype = Object.getPrototypeOf(target);
+        Object.getOwnPropertyNames(target).forEach(key => {
+            if (key === "length" && Array.isArray(target)) {
+                return; // Leave the length property as is. It won't be set directly anyway
+            }
+            this.installSetterTrap(key);
+        });
+        // Create proxy:
+        //const targetForProxy = {}; // The virtual way
+        const targetForProxy = target; // Preserves Object.keys and instanceof behaviour :), iterators and other stuff. But the downside with this is, that it does not allow to proxy read only properties
+        this.proxy = new Proxy(targetForProxy, this);
+    }
+    installSetterTrap(key) {
+        let target = this.target;
+        let origDescriptor = (0, common_1.getPropertyDescriptor)(target, key);
+        //@ts-ignore
+        let currentValue = (origDescriptor === null || origDescriptor === void 0 ? void 0 : origDescriptor.value /* performance */) || target[key];
+        const origSetter = origDescriptor === null || origDescriptor === void 0 ? void 0 : origDescriptor.set;
+        const origGetter = origDescriptor === null || origDescriptor === void 0 ? void 0 : origDescriptor.get;
+        let origOwnDescriptor = Object.getOwnPropertyDescriptor(target, key);
+        if (origOwnDescriptor !== undefined) {
+            if (origOwnDescriptor.configurable !== true) {
+                throw new Error("Cannot delete non- 'configurable' property:" + String(key));
+            }
+            //@ts-ignore
+            delete target[key]; // delete the old, or the following Object.defineProperty will conflict
+        }
+        const newSetter = (newValue) => {
+            const changeHooksForTarget = getChangeHooksForObject(target);
+            if (origSetter !== undefined) {
+                (0, common_1.runChangeOperation)(target, new common_1.UnspecificObjectChange(target), [changeHooksForTarget.setterInvoke.get(key)], () => {
+                    origSetter.apply(target, [newValue]); // call the setter
+                });
+                return;
+            }
+            if (origGetter !== undefined) {
+                currentValue = origGetter.apply(target); // call the getter. Is this a good idea to refresh the value here?
+                throw new TypeError("Target originally had a getter and no setter but the property is set.");
+            }
+            //@ts-ignore
+            if (newValue !== currentValue) { // modify ?
+                // run change operation and call listeners:
+                const hooksToServe = [];
+                if (Array.isArray(target)) {
+                    hooksToServe.push(changeHooksForTarget.unspecificChange);
+                }
+                hooksToServe.push(changeHooksForTarget.changeSpecificProperty.get(key));
+                hooksToServe.push(changeHooksForTarget.changeAnyProperty);
+                (0, common_1.runChangeOperation)(target, new common_1.UnspecificObjectChange(target), hooksToServe, () => {
+                    //@ts-ignore
+                    currentValue = newValue;
+                });
+            }
+        };
+        newSetter.origHadSetter = origSetter !== undefined;
+        const newGetter = () => {
+            if (origGetter !== undefined) {
+                currentValue = origGetter.apply(target); // call the getter
+            }
+            return currentValue;
+        };
+        newGetter.origHadGetter = origGetter !== undefined;
+        Object.defineProperty(target, key, {
+            set: newSetter,
+            get: newGetter,
+            enumerable: origOwnDescriptor !== undefined ? origOwnDescriptor === null || origOwnDescriptor === void 0 ? void 0 : origOwnDescriptor.enumerable : true,
+            configurable: true, // Allow to delete the property. Note that you should use the {@link deleteProperty} function
+        });
+    }
+    withUnspecificChange(changeFn) {
+        return (0, common_1.runChangeOperation)(this.target, new common_1.UnspecificObjectChange(this.target), [getChangeHooksForObject(this.target).unspecificChange], changeFn);
+    }
+    get(fake_target, key, receiver) {
+        var _a, _b, _c;
+        // Validity check
+        const target = this.target;
+        if (receiver !== target) {
+            throw new Error("Invalid state. Get was called on a different object than this write-tracker-proxy (which is set as the prototype) is for. Did you clone the object, resulting in shared prototypes?");
+        }
+        // Check for and use change tracker class:
+        const changeTrackerClass = (_a = this.trackingConfig) === null || _a === void 0 ? void 0 : _a.changeTracker;
+        if (changeTrackerClass !== undefined) {
+            let propOnSupervisor = Object.getOwnPropertyDescriptor(changeTrackerClass.prototype, key);
+            if (propOnSupervisor !== undefined) { // Supervisor class is responsible for the property (or method) ?
+                //@ts-ignore
+                if (propOnSupervisor.get) { // Prop is a getter?
+                    return propOnSupervisor.get.apply(target);
+                }
+                else if (propOnSupervisor.value) { // Prop is a value, meaning a function. (Supervisors don't have fields)
+                    return changeTrackerClass.prototype[key];
+                }
+            }
+            else {
+                const origValue = changeTrackerClass.prototype[key];
+                if (typeof origValue === "function") {
+                    origMethod = origValue;
+                    if ((_b = this.trackingConfig) === null || _b === void 0 ? void 0 : _b.knownHighLevelMethods.has(key)) {
+                        return trapForHighLevelWriterMethod;
+                    }
+                    else if (!((_c = this.trackingConfig) === null || _c === void 0 ? void 0 : _c.readOnlyMethods.has(key)) && !(key in Object.prototype)) { // Read-write method that was not handled directly by change tracker class?
+                        return trapForGenericWriterMethod; // Assume the worst, that it is a writer method
+                    }
+                }
+            }
+        }
+        // return this.target[key]; // This line does not work because it does not consult ObjectProxyHandler#getPrototypeOf and therefore uses the actual tinkered prototype chain which has this proxy in there and calls get (endless recursion)
+        const propDesc = (0, common_1.getPropertyDescriptor)(target, key);
+        if (propDesc !== undefined) {
+            let result;
+            let getter = propDesc.get;
+            if (getter !== undefined) {
+                result = getter.apply(target);
+            }
+            else {
+                result = propDesc.value;
+            }
+            return result;
+        }
+        var origMethod = undefined;
+        /**
+          * Calls the unspecificChange listeners
+          * @param args
+          */
+        function trapForGenericWriterMethod(...args) {
+            if (this !== receiver) {
+                //throw new Error("Invalid state. Method was called on invalid target")
+            }
+            return (0, common_1.runChangeOperation)(target, new common_1.UnspecificObjectChange(target), [getChangeHooksForObject(target).unspecificChange], () => {
+                return origMethod.apply(this, args); // call original method
+            });
+        }
+        /**
+         * Wraps it in runAndCallListenersOnce_after
+         * @param args
+         */
+        function trapForHighLevelWriterMethod(...args) {
+            if (this !== receiver) {
+                //throw new Error("Invalid state. Method was called on invalid target")
+            }
+            return (0, common_1.runChangeOperation)(target, undefined, [], () => {
+                return origMethod.apply(this, args); // call original method
+            });
+        }
+    }
+    set(fake_target, key, value, receiver) {
+        // Validity check
+        if (receiver !== this.target) {
+            throw new Error("Invalid state. Set was called on a different object than this write-tracker-proxy (which is set as the prototype) is for. Did you clone the object, resulting in shared prototypes?");
+        }
+        (0, common_1.runChangeOperation)(this.target, new common_1.UnspecificObjectChange(this.target), [getChangeHooksForObject(this.target).changeOwnKeys], () => {
+            // if this "set" method got called, there is no setter trap installed yet
+            this.installSetterTrap(key);
+            //@ts-ignore
+            this.target[key] = value; // Set value again. this should call the setter trap
+        });
+        return true;
+    }
+    getPrototypeOf(target) {
+        return this.origPrototype;
+    }
+    defineProperty(target, property, attributes) {
+        throw new Error("Defineproperty not yet supported");
+    }
+}
+exports.ObjectProxyHandler = ObjectProxyHandler;
+//# sourceMappingURL=objectChangeTracking.js.map

package/objectChangeTracking.js.map

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

package/objectChangeTracking.ts

@@ -0,0 +1,251 @@
+/**
+ * Listeners for one object
+ */
+import {newDefaultMap} from "./Util";
+import {
+    ClassTrackingConfiguration,
+    EventHook,
+    getPropertyDescriptor,
+    GetterFlags,
+    ObjKey,
+    runChangeOperation,
+    SetterFlags,
+    UnspecificObjectChange,
+} from "./common";
+
+/**
+ * Contains change listeners for one specific object.
+ * 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.
+ * Does not apply to setterInvoke.. These are fired in addition (not thought through for all situations)
+ */
+class ObjectChangeHooks {
+    /**
+     * For writes on **setters** (also if these are the same/unchanged values)
+     */
+    setterInvoke = newDefaultMap<ObjKey, EventHook>( () => new EventHook());
+    changeSpecificProperty = newDefaultMap<ObjKey, EventHook>( () => new EventHook());
+    changeAnyProperty = new EventHook();
+
+    /**
+     * Means, the result of Object.keys will be different after the change. All iterations over the object/arrays's keys or values are informed that there was a change. Individual {@link changeSpecificProperty} are not affected!
+     */
+    changeOwnKeys = new EventHook();
+    /**
+     * These will always be called, no matter how specific a change is
+     */
+    anyChange = new EventHook();
+
+    /**
+     *
+     */
+    unspecificChange = new EventHook();
+}
+
+
+
+export const changeHooksForObject = new WeakMap<object, ObjectChangeHooks>();
+export function getChangeHooksForObject(obj: object) {
+    let result = changeHooksForObject.get(obj);
+    if(result === undefined) {
+        changeHooksForObject.set(obj, result = new ObjectChangeHooks());
+    }
+    return result;
+}
+
+export class ObjectProxyHandler implements ProxyHandler<object> {
+    target: object;
+    origPrototype: object | null;
+    proxy: object;
+    trackingConfig?: ClassTrackingConfiguration
+
+    constructor(target: object, trackingConfig: ClassTrackingConfiguration | undefined) {
+        this.target = target;
+        this.trackingConfig = trackingConfig;
+        this.origPrototype = Object.getPrototypeOf(target);
+
+
+        Object.getOwnPropertyNames(target).forEach(key => {
+            if(key === "length" && Array.isArray(target)) {
+                return; // Leave the length property as is. It won't be set directly anyway
+            }
+            this.installSetterTrap(key)
+        });
+
+        // Create proxy:
+        //const targetForProxy = {}; // The virtual way
+        const targetForProxy=target // Preserves Object.keys and instanceof behaviour :), iterators and other stuff. But the downside with this is, that it does not allow to proxy read only properties
+        this.proxy = new Proxy(targetForProxy, this);
+    }
+
+    installSetterTrap(key: ObjKey) {
+        let target = this.target;
+        let origDescriptor = getPropertyDescriptor(target, key);
+        //@ts-ignore
+        let currentValue = origDescriptor?.value /* performance */ || target[key];
+        const origSetter = origDescriptor?.set;
+        const origGetter = origDescriptor?.get;
+
+        let origOwnDescriptor = Object.getOwnPropertyDescriptor(target, key);
+        if(origOwnDescriptor !== undefined) {
+            if(origOwnDescriptor.configurable !== true) {
+                throw new Error("Cannot delete non- 'configurable' property:" + String(key));
+            }
+            //@ts-ignore
+            delete target[key]; // delete the old, or the following Object.defineProperty will conflict
+        }
+
+        const newSetter=  (newValue: any) => {
+            const changeHooksForTarget = getChangeHooksForObject(target);
+
+            if(origSetter !== undefined) {
+                runChangeOperation(target, new UnspecificObjectChange(target),[changeHooksForTarget.setterInvoke.get(key)],() => {
+                    origSetter.apply(target, [newValue]);  // call the setter
+                });
+                return;
+            }
+
+            if(origGetter !== undefined) {
+                currentValue = origGetter.apply(target);  // call the getter. Is this a good idea to refresh the value here?
+                throw new TypeError("Target originally had a getter and no setter but the property is set.");
+            }
+
+            //@ts-ignore
+            if (newValue !== currentValue) { // modify ?
+                // run change operation and call listeners:
+                const hooksToServe: EventHook[] = [];
+                if(Array.isArray(target)) {
+                    hooksToServe.push(changeHooksForTarget.unspecificChange);
+                }
+                hooksToServe.push(changeHooksForTarget.changeSpecificProperty.get(key))
+                hooksToServe.push(changeHooksForTarget.changeAnyProperty)
+                runChangeOperation(target, new UnspecificObjectChange(target),hooksToServe,() => {
+                    //@ts-ignore
+                    currentValue = newValue;
+                });
+            }
+
+        }
+        (newSetter as SetterFlags).origHadSetter = origSetter !== undefined;
+
+        const newGetter = () => {
+            if(origGetter !== undefined) {
+                currentValue = origGetter.apply(target);  // call the getter
+            }
+            return currentValue;
+        }
+        (newGetter as GetterFlags).origHadGetter = origGetter !== undefined;
+
+        Object.defineProperty( target, key, { // TODO: [Performance optimization tipps, see js example](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty#description)
+            set: newSetter,
+            get: newGetter,
+            enumerable: origOwnDescriptor !== undefined?origOwnDescriptor?.enumerable:true,
+            configurable: true, // Allow to delete the property. Note that you should use the {@link deleteProperty} function
+        })
+    }
+
+    protected withUnspecificChange<R>(changeFn: () => R): R {
+        return runChangeOperation(this.target, new UnspecificObjectChange(this.target), [getChangeHooksForObject(this.target).unspecificChange], changeFn)
+    }
+
+    get(fake_target:object, key: ObjKey, receiver:any): any {
+        // Validity check
+        const target = this.target;
+
+        if(receiver !== target) {
+            throw new Error("Invalid state. Get was called on a different object than this write-tracker-proxy (which is set as the prototype) is for. Did you clone the object, resulting in shared prototypes?")
+        }
+
+        // Check for and use change tracker class:
+        const changeTrackerClass = this.trackingConfig?.changeTracker
+        if (changeTrackerClass !== undefined) {
+            let propOnSupervisor = Object.getOwnPropertyDescriptor(changeTrackerClass.prototype, key);
+            if (propOnSupervisor !== undefined) { // Supervisor class is responsible for the property (or method) ?
+                //@ts-ignore
+                if (propOnSupervisor.get) { // Prop is a getter?
+                    return propOnSupervisor.get.apply(target)
+                } else if (propOnSupervisor.value) { // Prop is a value, meaning a function. (Supervisors don't have fields)
+                    return changeTrackerClass.prototype[key];
+                }
+            }
+            else {
+                const origValue = changeTrackerClass.prototype[key]
+                if(typeof origValue === "function") {
+                    origMethod = origValue;
+                    if (this.trackingConfig?.knownHighLevelMethods.has(key)) {
+                        return trapForHighLevelWriterMethod
+                    } else if (!this.trackingConfig?.readOnlyMethods.has(key) && !(key as any in Object.prototype)) { // Read-write method that was not handled directly by change tracker class?
+                        return trapForGenericWriterMethod // Assume the worst, that it is a writer method
+                    }
+                }
+            }
+        }
+
+        // return this.target[key]; // This line does not work because it does not consult ObjectProxyHandler#getPrototypeOf and therefore uses the actual tinkered prototype chain which has this proxy in there and calls get (endless recursion)
+        const propDesc = getPropertyDescriptor(target, key)
+        if (propDesc !== undefined) {
+            let result: unknown;
+            let getter = propDesc.get;
+            if (getter !== undefined) {
+                result = getter.apply(target);
+            }
+            else {
+                result = propDesc.value;
+            }
+            return result;
+        }
+
+        var origMethod: ((this:unknown, ...args:unknown[]) => unknown) | undefined = undefined;
+       /**
+         * Calls the unspecificChange listeners
+         * @param args
+         */
+        function trapForGenericWriterMethod(this:object, ...args: unknown[]) {
+            if(this !== receiver) {
+                //throw new Error("Invalid state. Method was called on invalid target")
+            }
+           return runChangeOperation(target, new UnspecificObjectChange(target),[getChangeHooksForObject(target as Array<unknown>).unspecificChange],() => {
+                return origMethod!.apply(this, args);  // call original method
+            });
+        }
+
+        /**
+         * Wraps it in runAndCallListenersOnce_after
+         * @param args
+         */
+        function trapForHighLevelWriterMethod(this:object, ...args: unknown[]) {
+            if(this !== receiver) {
+                //throw new Error("Invalid state. Method was called on invalid target")
+            }
+            return runChangeOperation(target, undefined,[],() => {
+                return origMethod!.apply(this, args);  // call original method
+            });
+        }
+    }
+
+    set(fake_target:object, key: ObjKey, value:any, receiver:any) {
+        // Validity check
+        if(receiver !== this.target) {
+            throw new Error("Invalid state. Set was called on a different object than this write-tracker-proxy (which is set as the prototype) is for. Did you clone the object, resulting in shared prototypes?")
+        }
+
+        runChangeOperation(this.target, new UnspecificObjectChange(this.target),[getChangeHooksForObject(this.target).changeOwnKeys],() => { // There was no setter trap yet. This means that the key is new. Inform those listeners:
+
+            // if this "set" method got called, there is no setter trap installed yet
+            this.installSetterTrap(key);
+
+            //@ts-ignore
+            this.target[key] = value; // Set value again. this should call the setter trap
+        });
+
+        return true;
+    }
+
+    getPrototypeOf(target: object): object | null {
+        return this.origPrototype;
+    }
+
+    defineProperty(target: object, property: string | symbol, attributes: PropertyDescriptor): boolean {
+        throw new Error("Defineproperty not yet supported");
+    }
+
+}

package/origChangeTracking.d.ts

@@ -0,0 +1,14 @@
+import { PartialGraph } from "./common";
+export declare const changeTrackedOrigObjects: PartialGraph;
+/**
+ *
+ * @param obj
+ */
+export declare function installChangeTracker(obj: object): void;
+/**
+ * Use this to delete properties on objects that have a write tracker installed. Otherwise they are not deletable and the write tracker cannot track the object's keys modification and inform listeners
+ * @param obj
+ * @param key
+ */
+export declare function deleteProperty<O extends object>(obj: O, key: keyof O): boolean;
+//# sourceMappingURL=origChangeTracking.d.ts.map

package/origChangeTracking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"origChangeTracking.d.ts","sourceRoot":"","sources":["origChangeTracking.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,YAAY,EAA6C,MAAM,UAAU,CAAC;AAUlF,eAAO,MAAM,wBAAwB,cAAqB,CAAC;AAI3D;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,QA2B/C;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,WAepE"}

package/origChangeTracking.js

@@ -0,0 +1,63 @@
+"use strict";
+// This file has functions / classes that allow to watch writes to the original unproxied objects (or arrays/sets/maps)
+// unproxied=not part of a proxy facade. Technically this can install Proxys as the prototype, to catch writes.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.changeTrackedOrigObjects = void 0;
+exports.installChangeTracker = installChangeTracker;
+exports.deleteProperty = deleteProperty;
+const common_1 = require("./common");
+const objectChangeTracking_1 = require("./objectChangeTracking");
+const index_1 = require("./class-trackers/index");
+const proxyFacade_1 = require("./proxyFacade");
+const Util_1 = require("./Util");
+exports.changeTrackedOrigObjects = new common_1.PartialGraph();
+/**
+ *
+ * @param obj
+ */
+function installChangeTracker(obj) {
+    !(0, proxyFacade_1.isProxyForAFacade)(obj) || (0, Util_1.throwError)("Cannot install change tracker on a proxy. The proxy should already support change tracking.");
+    if (exports.changeTrackedOrigObjects.hasObj(obj)) {
+        return;
+    }
+    function inner() {
+        const trackingConfig = (0, index_1.getTrackingConfigFor)(obj);
+        if (trackingConfig) {
+            if (trackingConfig.trackSettingObjectProperties) {
+                // Achieve this with the ObjectProxyhandler. It will consider getTrackingConfigFor(obj).changeTracker itsself:
+                const proxy = new objectChangeTracking_1.ObjectProxyHandler(obj, trackingConfig).proxy;
+                Object.setPrototypeOf(obj, proxy);
+                return;
+            }
+            if (trackingConfig.changeTracker !== undefined) {
+                Object.setPrototypeOf(obj, trackingConfig.changeTracker.prototype);
+            }
+        }
+        else { // Non-special object ?
+            const proxy = new objectChangeTracking_1.ObjectProxyHandler(obj, trackingConfig).proxy;
+            Object.setPrototypeOf(obj, proxy);
+        }
+    }
+    inner();
+    exports.changeTrackedOrigObjects._register(obj);
+}
+/**
+ * Use this to delete properties on objects that have a write tracker installed. Otherwise they are not deletable and the write tracker cannot track the object's keys modification and inform listeners
+ * @param obj
+ * @param key
+ */
+function deleteProperty(obj, key) {
+    if (!exports.changeTrackedOrigObjects.hasObj(obj)) {
+        return delete obj[key];
+    }
+    const doesExist = Object.getOwnPropertyDescriptor(obj, key) !== undefined;
+    if (!doesExist) {
+        return true;
+    }
+    return (0, common_1.runChangeOperation)(obj, new common_1.UnspecificObjectChange(obj), [(0, objectChangeTracking_1.getChangeHooksForObject)(obj).changeOwnKeys], () => {
+        //@ts-ignore
+        obj[key] = undefined; // Set to undefined first, so property change listeners will get informed
+        return delete obj[key];
+    });
+}
+//# sourceMappingURL=origChangeTracking.js.map