j-templates 5.0.38 → 5.0.40

package/DOM/domNodeConfig.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DOMNodeConfig = void 0;
 const window_1 = require("./window");
 const list_1 = require("../Utils/list");
 const utils_1 = require("./utils");
@@ -10,7 +11,7 @@ function processUpdates() {
     list_1.List.Add(pendingUpdates, null);
     var callback;
     while ((callback = list_1.List.Pop(pendingUpdates)))
-        thread_1.Synch(callback);
+        (0, thread_1.Synch)(callback);
     if (pendingUpdates.size === 0)
         updateScheduled = false;
     else

package/DOM/elements.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.td = exports.tr = exports.th = exports.table = exports.button = exports.style = exports.p = exports.h3 = exports.h2 = exports.h1 = exports.option = exports.select = exports.input = exports.source = exports.video = exports.img = exports.span = exports.b = exports.br = exports.li = exports.ul = exports.a = exports.div = void 0;
 const elementNode_1 = require("../Node/elementNode");
 function div(nodeDef, children) {
     return elementNode_1.ElementNode.Create("div", null, nodeDef, children);

package/DOM/index.js

@@ -1,8 +1,19 @@
 "use strict";
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-__export(require("./elements"));
-__export(require("./svgElements"));
-__export(require("./utils"));
+__exportStar(require("./elements"), exports);
+__exportStar(require("./svgElements"), exports);
+__exportStar(require("./utils"), exports);

package/DOM/svgElements.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.circle = exports.g = exports.svg = void 0;
 const elementNode_1 = require("../Node/elementNode");
 const svgNs = "http://www.w3.org/2000/svg";
 function svg(nodeDef, children) {

package/DOM/utils.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetProperties = void 0;
 function SetValue(target, value) {
     switch (target.nodeName) {
         case "INPUT":

package/DOM/window.js

@@ -1,3 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.wndw = void 0;
 exports.wndw = typeof window !== "undefined" ? window : (new (require("jsdom").JSDOM("")).window);

package/Node/boundNode.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoundNode = void 0;
 const nodeConfig_1 = require("./nodeConfig");
 const observableScope_1 = require("../Store/Tree/observableScope");
 var BoundNode;

package/Node/boundNode.types.d.ts

@@ -1,9 +1,9 @@
 import { NodeRefType } from "./nodeRef";
 import { INodeRefBase } from "./nodeRef.types";
-export declare type FunctionOr<T> = {
+export type FunctionOr<T> = {
     (...args: Array<any>): T | Promise<T>;
 } | T;
-export declare type NodeRefEvents = {
+export type NodeRefEvents = {
     [name: string]: {
         (...args: Array<any>): void;
     };

package/Node/component.d.ts

@@ -27,7 +27,7 @@ export declare namespace Component {
     function Register<D = void, T = void, E = void>(name: string, constructor: ComponentConstructor<D, T, E>): void;
     function Attach(node: Node, nodeRef: NodeRefTypes): void;
 }
-export declare type ComponentConstructor<D, T, E> = {
+export type ComponentConstructor<D, T, E> = {
     new (data: {
         (): D | Promise<D>;
     }, templates: T, nodeRef: INodeRefBase, componentEvents: ComponentNodeEvents<E>): Component<D, T, E>;

package/Node/component.js

@@ -1,17 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Component = void 0;
 const nodeRef_1 = require("./nodeRef");
 const componentNode_1 = require("./componentNode");
 const decorators_1 = require("../Utils/decorators");
 const observableScope_1 = require("../Store/Tree/observableScope");
 class Component {
-    constructor(data, templates, nodeRef, componentEvents) {
-        this.nodeRef = nodeRef;
-        this.componentEvents = componentEvents;
-        this.scope = new observableScope_1.ObservableScope(data);
-        this.templates = templates || {};
-        this.decoratorMap = new Map();
-    }
+    nodeRef;
+    componentEvents;
+    scope;
+    templates;
+    decoratorMap;
     get Injector() {
         return this.nodeRef.injector;
     }
@@ -33,6 +32,13 @@ class Component {
     get Templates() {
         return this.templates;
     }
+    constructor(data, templates, nodeRef, componentEvents) {
+        this.nodeRef = nodeRef;
+        this.componentEvents = componentEvents;
+        this.scope = new observableScope_1.ObservableScope(data);
+        this.templates = templates || {};
+        this.decoratorMap = new Map();
+    }
     Template() {
         return [];
     }

package/Node/componentNode.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentNode = void 0;
 const boundNode_1 = require("./boundNode");
 const nodeRef_1 = require("./nodeRef");
 const nodeConfig_1 = require("./nodeConfig");
@@ -49,15 +50,15 @@ function SetChildren(node) {
 }
 function AddPreReqTemplate(node) {
     return new Promise(resolve => {
-        thread_1.Thread(function () {
+        (0, thread_1.Thread)(function () {
             var preNodes;
             injector_1.Injector.Scope(node.injector, () => preNodes = decorators_1.PreReqTemplate.Get(node.component));
-            thread_1.Schedule(function () {
+            (0, thread_1.Schedule)(function () {
                 if (node.destroyed)
                     return;
                 nodeRef_1.NodeRef.InitAll(preNodes);
             });
-            thread_1.Thread(function () {
+            (0, thread_1.Thread)(function () {
                 if (node.destroyed)
                     return;
                 for (var x = 0; x < preNodes.length; x++)
@@ -80,7 +81,7 @@ function AddPreReqTemplate(node) {
     });
 }
 function AddTemplate(node, init) {
-    thread_1.Thread(function () {
+    (0, thread_1.Thread)(function () {
         if (node.destroyed)
             return;
         var nodes;
@@ -89,10 +90,10 @@ function AddTemplate(node, init) {
         });
         if (!Array.isArray(nodes))
             nodes = [nodes];
-        thread_1.Schedule(function () {
+        (0, thread_1.Schedule)(function () {
             nodeRef_1.NodeRef.InitAll(nodes);
         });
-        thread_1.Thread(function () {
+        (0, thread_1.Thread)(function () {
             if (node.destroyed)
                 return;
             if (init)
@@ -107,7 +108,7 @@ function AddTemplate(node, init) {
                 });
         });
         if (node.component.Bound !== component_1.Component.prototype.Bound)
-            thread_1.After(function () {
+            (0, thread_1.After)(function () {
                 nodeConfig_1.NodeConfig.scheduleUpdate(() => setTimeout(() => node.component.Bound(), 0));
             });
     });

package/Node/componentNode.types.d.ts

@@ -1,7 +1,7 @@
 import { BoundNodeFunctionParam, IBoundNodeBase, NodeDefinition } from "./boundNode.types";
 import { Component, ComponentConstructor } from "./component";
 import { NodeRefType } from "./nodeRef";
-export declare type ComponentNodeEvents<E = void> = {
+export type ComponentNodeEvents<E = void> = {
     [P in keyof E]: {
         (data?: E[P]): void;
     };
@@ -18,7 +18,7 @@ export interface ComponentNodeFunctionParam<D = void, E = void> extends BoundNod
         (): D | Promise<D>;
     };
 }
-export declare type ComponentNodeFunction<D = void, T = void, E = void> = (nodeDef: ComponentNodeFunctionParam<D, E>, templates?: T) => IComponentNode<D, T, E>;
+export type ComponentNodeFunction<D = void, T = void, E = void> = (nodeDef: ComponentNodeFunctionParam<D, E>, templates?: T) => IComponentNode<D, T, E>;
 export interface IComponentNodeBase<D, T, E> extends IBoundNodeBase {
     nodeDef: ComponentNodeFunctionParam<D, E>;
     constructor: ComponentConstructor<D, T, E>;

package/Node/elementNode.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElementNode = void 0;
 const boundNode_1 = require("./boundNode");
 const nodeConfig_1 = require("./nodeConfig");
 const injector_1 = require("../Utils/injector");
@@ -59,18 +60,18 @@ function ScheduleSetData(node, scope) {
     });
 }
 function SetDefaultData(node) {
-    thread_1.Synch(function () {
+    (0, thread_1.Synch)(function () {
         var nodes;
         injector_1.Injector.Scope(node.injector, function () {
             nodes = CreateNodeArray(node.childrenFunc, true);
         });
         if (nodes.length > 0) {
-            thread_1.Schedule(function () {
+            (0, thread_1.Schedule)(function () {
                 if (node.destroyed)
                     return;
                 nodeRef_1.NodeRef.InitAll(nodes);
             });
-            thread_1.Thread(function () {
+            (0, thread_1.Thread)(function () {
                 if (node.destroyed)
                     return;
                 DetachAndAddNodes(node, [], [nodes]);
@@ -79,7 +80,7 @@ function SetDefaultData(node) {
     });
 }
 function SetData(node, value, init = false) {
-    thread_1.Synch(function () {
+    (0, thread_1.Synch)(function () {
         var newNodesMap = new Map();
         var values = value || valueDefault;
         if (!Array.isArray(values))
@@ -99,7 +100,7 @@ function SetData(node, value, init = false) {
                 injector_1.Injector.Scope(node.injector, function () {
                     nodes = CreateNodeArray(node.childrenFunc, value);
                 });
-                thread_1.Schedule(function () {
+                (0, thread_1.Schedule)(function () {
                     if (node.destroyed || newNodesMap.size === 0)
                         return;
                     nodeRef_1.NodeRef.InitAll(nodes);
@@ -117,7 +118,7 @@ function SetData(node, value, init = false) {
             node.nodesMap.clear();
         }
         node.nodesMap = newNodesMap;
-        thread_1.Thread(function () {
+        (0, thread_1.Thread)(function () {
             if (node.destroyed)
                 return;
             if (init)

package/Node/elementNode.types.d.ts

@@ -15,10 +15,10 @@ export interface ElementNodeFunctionParam<T> extends BoundNodeFunctionParam {
         (): T | Array<T> | Promise<Array<T>> | Promise<T>;
     };
 }
-export declare type ElementChildrenFunction<T> = {
+export type ElementChildrenFunction<T> = {
     (data?: T): string | NodeRefTypes | NodeRefTypes[];
 };
-export declare type ElementNodeFunction<T> = {
+export type ElementNodeFunction<T> = {
     (nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunction<T>): INodeRefBase;
 };
 export interface IElementNodeBase<T> extends IBoundNodeBase {

package/Node/nodeConfig.js

@@ -1,4 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeConfig = void 0;
 const domNodeConfig_1 = require("../DOM/domNodeConfig");
 exports.NodeConfig = domNodeConfig_1.DOMNodeConfig;

package/Node/nodeRef.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeRef = exports.NodeRefType = void 0;
 const nodeConfig_1 = require("./nodeConfig");
 const injector_1 = require("../Utils/injector");
 const boundNode_1 = require("./boundNode");

package/Node/nodeRef.types.d.ts

@@ -18,4 +18,4 @@ export interface INodeRefBase {
 export interface INodeRef extends INodeRefBase {
     type: NodeRefType.NodeRef;
 }
-export declare type NodeRefTypes = INodeRef | IBoundNode | IElementNode<any> | IComponentNode<any, any, any>;
+export type NodeRefTypes = INodeRef | IBoundNode | IElementNode<any> | IComponentNode<any, any, any>;

package/Store/Diff/diffAsync.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffAsync = void 0;
 const diffTree_1 = require("./diffTree");
 const workerQueue_1 = require("./workerQueue");
 const diffWorker_1 = require("./diffWorker");
-const diffCnstr = diffTree_1.DiffTreeScope();
+const diffCnstr = (0, diffTree_1.DiffTreeScope)();
 class DiffAsync {
+    workerQueue;
     constructor(keyFunc) {
         this.workerQueue = new workerQueue_1.WorkerQueue(diffWorker_1.DiffWorker.Create());
         this.workerQueue.Push({ method: "create", arguments: [keyFunc.toString()] });

package/Store/Diff/diffSync.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffSync = void 0;
 const diffTree_1 = require("./diffTree");
-const diffCnstr = diffTree_1.DiffTreeScope();
+const diffCnstr = (0, diffTree_1.DiffTreeScope)();
 class DiffSync {
+    diffTree;
     constructor(keyFunc) {
         this.diffTree = new diffCnstr(keyFunc);
     }

package/Store/Diff/diffTree.d.ts

@@ -2,7 +2,7 @@ export interface IDiffMethod {
     method: "create" | "diffpath" | "diffbatch" | "updatepath" | "getpath";
     arguments: Array<any>;
 }
-export declare type IDiffResponse = {
+export type IDiffResponse = {
     path: string;
     value: any;
 }[];

package/Store/Diff/diffTree.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffTreeScope = void 0;
 function DiffTreeScope(worker) {
     const ctx = this;
     if (ctx && worker) {
@@ -38,9 +39,10 @@ function DiffTreeScope(worker) {
         return !(jsonConstructor === value.constructor || Array.isArray(value));
     }
     class DiffTree {
+        keyFunc;
+        rootStateMap = new Map();
         constructor(keyFunc) {
             this.keyFunc = keyFunc;
-            this.rootStateMap = new Map();
         }
         static GetKeyRef(key) {
             return `___DiffTreeKeyRef.${key}`;

package/Store/Diff/diffWorker.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffWorker = void 0;
 const diffTree_1 = require("./diffTree");
 var DiffWorker;
 (function (DiffWorker) {

package/Store/Diff/workerQueue.js

@@ -1,7 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerQueue = void 0;
 const list_1 = require("../../Utils/list");
 class WorkerQueue {
+    callbacks;
+    worker;
     constructor(worker) {
         this.worker = worker;
         this.callbacks = list_1.List.Create();

package/Store/Store/store.js

@@ -1,18 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Store = void 0;
 const observableTree_1 = require("../Tree/observableTree");
 const storeWriter_1 = require("./storeWriter");
 class Store {
+    observableTree = new observableTree_1.ObservableTree();
+    storeWriter = new storeWriter_1.StoreWriter(this.observableTree);
+    rootScope = this.observableTree.Scope("ROOT", root => root);
+    get Root() {
+        return this.rootScope;
+    }
     constructor(init) {
-        this.observableTree = new observableTree_1.ObservableTree();
-        this.storeWriter = new storeWriter_1.StoreWriter(this.observableTree);
-        this.rootScope = this.observableTree.Scope("ROOT", root => root);
         if (init)
             this.Write(init);
     }
-    get Root() {
-        return this.rootScope;
-    }
     Action(action) {
         var proxy = this.observableTree.Get("ROOT");
         action(proxy, this.storeWriter);

package/Store/Store/storeAsync.js

@@ -1,10 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.StoreAsync = void 0;
 const observableTree_1 = require("../Tree/observableTree");
 const diffAsync_1 = require("../Diff/diffAsync");
 const storeAsyncWriter_1 = require("./storeAsyncWriter");
 const asyncQueue_1 = require("../../Utils/asyncQueue");
 class StoreAsync {
+    idFunc;
+    diffAsync;
+    observableTree;
+    asyncWriter;
+    asyncQueue;
     constructor(idFunc, init) {
         this.idFunc = idFunc;
         this.diffAsync = new diffAsync_1.DiffAsync(this.idFunc);

package/Store/Store/storeAsyncWriter.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.StoreAsyncWriter = void 0;
 class StoreAsyncWriter {
+    idFunc;
+    diffAsync;
+    observableTree;
     constructor(idFunc, diffAsync, observableTree) {
         this.idFunc = idFunc;
         this.diffAsync = diffAsync;

package/Store/Store/storeSync.js

@@ -1,20 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.StoreSync = void 0;
 const diffSync_1 = require("../Diff/diffSync");
 const observableTree_1 = require("../Tree/observableTree");
 const storeSyncWriter_1 = require("./storeSyncWriter");
 class StoreSync {
+    diffSync = new diffSync_1.DiffSync();
+    observableTree = new observableTree_1.ObservableTree();
+    storeWriter = new storeSyncWriter_1.StoreSyncWriter(this.diffSync, this.observableTree);
+    rootScope = this.observableTree.Scope("ROOT", root => root);
+    get Root() {
+        return this.rootScope;
+    }
     constructor(init) {
-        this.diffSync = new diffSync_1.DiffSync();
-        this.observableTree = new observableTree_1.ObservableTree();
-        this.storeWriter = new storeSyncWriter_1.StoreSyncWriter(this.diffSync, this.observableTree);
-        this.rootScope = this.observableTree.Scope("ROOT", root => root);
         if (init)
             this.Write(init);
     }
-    get Root() {
-        return this.rootScope;
-    }
     Action(action) {
         var proxy = this.observableTree.Get("ROOT");
         action(proxy, this.storeWriter);

package/Store/Store/storeSyncWriter.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.StoreSyncWriter = void 0;
 class StoreSyncWriter {
+    diffSync;
+    observableTree;
     constructor(diffSync, observableTree) {
         this.diffSync = diffSync;
         this.observableTree = observableTree;

package/Store/Store/storeWriter.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.StoreWriter = void 0;
 class StoreWriter {
+    observableTree;
     constructor(observableTree) {
         this.observableTree = observableTree;
     }

package/Store/Tree/observableScope.js

@@ -1,16 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObservableScope = exports.ObservableScopeWrapper = exports.ObservableScopeValue = void 0;
 const emitter_1 = require("../../Utils/emitter");
 class ObservableScopeValue {
-    constructor(scope) {
-        this.scope = scope;
-    }
+    scope;
     get Value() {
         return ObservableScope.Value(this.scope);
     }
+    constructor(scope) {
+        this.scope = scope;
+    }
 }
 exports.ObservableScopeValue = ObservableScopeValue;
 class ObservableScopeWrapper extends ObservableScopeValue {
+    scopeEmitter;
     constructor(scope) {
         super(scope);
         if (scope.emitter) {

package/Store/Tree/observableTree.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObservableTree = void 0;
 const observableScope_1 = require("../Tree/observableScope");
 var Type;
 (function (Type) {
@@ -18,50 +19,15 @@ function TypeOf(value) {
     return Type.Value;
 }
 class ObservableTree {
+    valuePathResolver;
+    undefinedScope = observableScope_1.ObservableScope.Create(function () { return undefined; });
+    scopeCache = new WeakMap();
+    leafScopeCache = new WeakMap();
+    proxyCache = new WeakMap();
+    pathCache = new WeakMap();
+    rootStateMap = new Map();
     constructor(valuePathResolver) {
         this.valuePathResolver = valuePathResolver;
-        this.undefinedScope = observableScope_1.ObservableScope.Create(function () { return undefined; });
-        this.scopeCache = new WeakMap();
-        this.leafScopeCache = new WeakMap();
-        this.proxyCache = new WeakMap();
-        this.pathCache = new WeakMap();
-        this.rootStateMap = new Map();
-        this.ObjectProxyGetter = (value, prop) => {
-            function toJSON() {
-                return value;
-            }
-            ;
-            switch (prop) {
-                case "toJSON":
-                    return toJSON;
-                default:
-                    if (typeof prop === 'symbol')
-                        return value[prop];
-                    return observableScope_1.ObservableScope.Value(this.GetPropertyScope(value, prop));
-            }
-        };
-        this.ArrayProxyGetter = (value, prop) => {
-            function toJSON() {
-                return value;
-            }
-            ;
-            switch (prop) {
-                case "toJSON":
-                    return toJSON;
-                default:
-                    if (typeof prop === 'symbol')
-                        return value[prop];
-                    if (isNaN(parseInt(prop))) {
-                        const ret = value[prop];
-                        if (typeof ret === 'function') {
-                            const copy = value.map((val, index) => observableScope_1.ObservableScope.Value(this.GetPropertyScope(value, index.toString())));
-                            return ret.bind(copy);
-                        }
-                        return ret;
-                    }
-                    return observableScope_1.ObservableScope.Value(this.GetPropertyScope(value, prop));
-            }
-        };
     }
     Get(path) {
         const val = path.split(".").reduce((pre, curr, index) => {
@@ -157,11 +123,47 @@ class ObservableTree {
         }
         return proxy;
     }
+    ObjectProxyGetter = (value, prop) => {
+        function toJSON() {
+            return value;
+        }
+        ;
+        switch (prop) {
+            case "toJSON":
+                return toJSON;
+            default:
+                if (typeof prop === 'symbol')
+                    return value[prop];
+                return observableScope_1.ObservableScope.Value(this.GetPropertyScope(value, prop));
+        }
+    };
     CreateObjectProxy(value) {
         return new Proxy(value, {
             get: this.ObjectProxyGetter
         });
     }
+    ArrayProxyGetter = (value, prop) => {
+        function toJSON() {
+            return value;
+        }
+        ;
+        switch (prop) {
+            case "toJSON":
+                return toJSON;
+            default:
+                if (typeof prop === 'symbol')
+                    return value[prop];
+                if (isNaN(parseInt(prop))) {
+                    const ret = value[prop];
+                    if (typeof ret === 'function') {
+                        const copy = value.map((val, index) => observableScope_1.ObservableScope.Value(this.GetPropertyScope(value, index.toString())));
+                        return ret.bind(copy);
+                    }
+                    return ret;
+                }
+                return observableScope_1.ObservableScope.Value(this.GetPropertyScope(value, prop));
+        }
+    };
     CreateArrayProxy(value) {
         return new Proxy(value, {
             get: this.ArrayProxyGetter
@@ -197,8 +199,13 @@ class ObservableTree {
         if (!parentValue)
             throw new Error("Unable to write path: " + path + ". Falsey value found at: " + pathParts.slice(0, x).join("."));
         const prop = pathParts[x];
+        const oldValue = parentValue[prop];
+        const oldType = TypeOf(oldValue);
         parentValue[prop] = value;
-        const leafScopes = this.leafScopeCache.get(parentValue);
+        if (oldType !== Type.Value)
+            return this.scopeCache.get(oldValue) ||
+                this.scopeCache.get(parentValue);
+        const leafScopes = Object.hasOwn(parentValue, prop) && this.leafScopeCache.get(parentValue);
         return leafScopes && leafScopes[prop] || this.scopeCache.get(parentValue);
     }
     UpdatePathCache(path, value) {