j-templates 7.0.66 → 7.0.68

package/DOM/domNodeConfig.js

@@ -169,7 +169,9 @@ exports.DOMNodeConfig = {
             target.appendChild(children[x]);
     },
     reconcileChild(target, child) {
-        if (target.childElementCount > 1 || target.firstChild !== child)
+        if (target.childElementCount === 0)
+            target.appendChild(child);
+        else if (target.childElementCount > 1 || target.firstChild !== child)
             target.replaceChildren(child);
     },
 };

package/Node/component.d.ts

@@ -1,7 +1,7 @@
 import { ComponentEvents } from "./component.types";
-import { ObservableScope } from "../Store/Tree/observableScope";
 import { FunctionOr, vNode as vNodeType } from "./vNode.types";
 import { RecursivePartial } from "../Utils/utils.types";
+import { IObservableScope } from "../Store/Tree/observableScope";
 /**
  * Base Component class.
  *
@@ -25,7 +25,7 @@ export declare class Component<D = void, T = void, E = {}> {
     /**
      * Internal scoped Observable for component state.
      */
-    protected get Scope(): ObservableScope<D>;
+    protected get Scope(): IObservableScope<D>;
     /**
      * Current data value from the scoped Observable.
      */

package/Node/component.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Component = void 0;
 const decorators_1 = require("../Utils/decorators");
-const observableScope_1 = require("../Store/Tree/observableScope");
 const vNode_1 = require("./vNode");
+const Store_1 = require("../Store");
 /**
  * Base Component class.
  *
@@ -34,7 +34,7 @@ class Component {
      * Current data value from the scoped Observable.
      */
     get Data() {
-        return this.scope.Value;
+        return Store_1.ObservableScope.Value(this.scope);
     }
     /**
      * Accessor for the component's virtual node.
@@ -71,10 +71,16 @@ class Component {
     constructor(vNode, config, templates) {
         this.vNode = vNode;
         const { data, on } = config;
+        /* if (typeof data === "function")
+          this.scope = new ObservableScope<D>(data as () => D | Promise<D>);
+        else this.scope = new ObservableScope<D>(() => data); */
         if (typeof data === "function")
-            this.scope = new observableScope_1.ObservableScope(data);
+            this.scope = Store_1.ObservableScope.Create(data);
         else
-            this.scope = new observableScope_1.ObservableScope(() => data);
+            this.scope = {
+                type: "static",
+                value: data,
+            };
         this.componentEvents = on;
         this.templates = templates || {};
     }
@@ -108,7 +114,7 @@ class Component {
      * Destroys the component, cleaning up its scoped data and decorators.
      */
     Destroy() {
-        this.scope.Destroy();
+        Store_1.ObservableScope.Destroy(this.scope);
         decorators_1.Destroy.All(this);
     }
 }

package/Node/vNode.js

@@ -104,12 +104,13 @@ function InitNode(vnode) {
     if (props) {
         const assignProperties = nodeConfig_1.NodeConfig.createPropertyAssignment(node);
         if (typeof props === "function") {
-            const [value, scope] = Store_1.ObservableScope.CreateIf(props);
-            if (scope) {
-                vnode.scopes.push(scope);
-                Store_1.ObservableScope.Watch(scope, ScheduledAssignment(assignProperties));
-            }
-            assignProperties(value);
+            const scope = Store_1.ObservableScope.Create(props);
+            // const [value, scope] = ObservableScope.CreateIf(props as () => any);
+            // if (scope) {
+            vnode.scopes.push(scope);
+            Store_1.ObservableScope.Watch(scope, ScheduledAssignment(assignProperties));
+            // }
+            assignProperties(Store_1.ObservableScope.Value(scope));
         }
         else
             assignProperties(props);
@@ -117,12 +118,13 @@ function InitNode(vnode) {
     if (on) {
         const assignEvents = nodeConfig_1.NodeConfig.createEventAssignment(node);
         if (typeof on === "function") {
-            const [value, scope] = Store_1.ObservableScope.CreateIf(on);
-            if (scope) {
-                vnode.scopes.push(scope);
-                Store_1.ObservableScope.Watch(scope, ScheduledAssignment(assignEvents));
-            }
-            assignEvents(value);
+            const scope = Store_1.ObservableScope.Create(on);
+            // const [value, scope] = ObservableScope.CreateIf(on);
+            // if (scope) {
+            vnode.scopes.push(scope);
+            Store_1.ObservableScope.Watch(scope, ScheduledAssignment(assignEvents));
+            // }
+            assignEvents(Store_1.ObservableScope.Value(scope));
         }
         else
             assignEvents(on);
@@ -130,12 +132,13 @@ function InitNode(vnode) {
     if (attrs) {
         const assignAttributes = nodeConfig_1.NodeConfig.createAttributeAssignment(node);
         if (typeof attrs === "function") {
-            const [value, scope] = Store_1.ObservableScope.CreateIf(attrs);
-            if (scope) {
-                vnode.scopes.push(scope);
-                Store_1.ObservableScope.Watch(scope, ScheduledAssignment(assignAttributes));
-            }
-            assignAttributes(value);
+            const scope = Store_1.ObservableScope.Create(attrs);
+            // const [value, scope] = ObservableScope.CreateIf(attrs);
+            // if (scope) {
+            vnode.scopes.push(scope);
+            Store_1.ObservableScope.Watch(scope, ScheduledAssignment(assignAttributes));
+            //}
+            assignAttributes(Store_1.ObservableScope.Value(scope));
         }
         else
             assignAttributes(attrs);
@@ -160,7 +163,7 @@ function InitNode(vnode) {
     UpdateChildren(vnode, true, !!childrenArray);
 }
 function Children(vnode, children, data) {
-    const [childNodes, childrenScope] = CreateChildrenScope(vnode, children, data);
+    const childrenScope = CreateChildrenScope(vnode, children, data);
     if (childrenScope) {
         vnode.scopes.push(childrenScope);
         Store_1.ObservableScope.Watch(childrenScope, CreateScheduledCallback(function (scope) {
@@ -175,7 +178,7 @@ function Children(vnode, children, data) {
             }
         }));
     }
-    vnode.children = childNodes;
+    vnode.children = Store_1.ObservableScope.Value(childrenScope);
     // AssignChildren(vnode, childrenScope);
 }
 /* function AssignChildren(
@@ -204,7 +207,7 @@ function CreateChildrenScope(vnode, children, data = DefaultData) {
             });
         };
     }
-    return Store_1.ObservableScope.CreateIf(WrapChildren(vnode.injector, children, data));
+    return Store_1.ObservableScope.Create(WrapChildren(vnode.injector, children, data));
 }
 function WrapChildren(injector, children, data) {
     let nodeArray = [];
@@ -265,10 +268,14 @@ function EvaluateNextNodesSmall(injector, getNextChildren, nextData, nodeArray)
             nodeArray[i] = null;
         }
         else {
-            const [nextChildren, scope] = Store_1.ObservableScope.CreateIf(function () {
+            const scope = Store_1.ObservableScope.Create(function () {
                 return injector_1.Injector.Scope(injector, getNextChildren, data);
             });
-            nextNodes[x] = [data, CreateNodeArray(nextChildren), scope];
+            nextNodes[x] = [
+                data,
+                CreateNodeArray(Store_1.ObservableScope.Value(scope)),
+                scope,
+            ];
         }
     }
     for (let x = 0; x < nodeArray.length; x++) {
@@ -294,27 +301,37 @@ function EvaluateNextNodesLarge(injector, getNextChildren, nextData, nodeArray)
         for (; currentChildIndex >= 0 && currentChildren[currentChildIndex] === null; currentChildIndex--) { }
         if (currentChildIndex !== -1) {
             const currentChild = currentChildren[currentChildIndex];
-            if (currentChild[2]) {
-                const scope = currentChild[2];
-                const value = scope.value;
-                const updatedValue = Store_1.ObservableScope.Value(scope);
-                if (value !== updatedValue)
-                    currentChild[1] = CreateNodeArray(updatedValue);
-            }
-            if (currentChild[2]?.dirty) {
-                const nextChildren = Store_1.ObservableScope.Value(currentChild[2]);
-                currentChild[1] = CreateNodeArray(nextChildren);
+            currentChildren[currentChildIndex] = null;
+            // if (currentChild[2]) {
+            const scope = currentChild[2];
+            const value = scope.value;
+            const updatedValue = Store_1.ObservableScope.Value(scope);
+            if (value !== updatedValue) {
+                vNode.DestroyAll(currentChild[1]);
+                currentChild[1] = CreateNodeArray(updatedValue);
             }
+            // }
+            /* if (currentChild[2]?.dirty) {
+              const nextChildren = ObservableScope.Value(currentChild[2]);
+              currentChild[1] = CreateNodeArray(nextChildren);
+              } */
             nextNodes[x] = currentChild;
-            currentChildren[currentChildIndex] = null;
+            // currentChildren[currentChildIndex] = null;
             if (currentChildIndex === 0)
                 dataMap.delete(data);
         }
         else {
-            const [nextChildren, scope] = Store_1.ObservableScope.CreateIf(function () {
+            const scope = Store_1.ObservableScope.Create(function () {
                 return injector_1.Injector.Scope(injector, getNextChildren, data);
             });
-            nextNodes[x] = [data, CreateNodeArray(nextChildren), scope];
+            /* const [nextChildren, scope] = ObservableScope.CreateIf(function () {
+              return Injector.Scope(injector, getNextChildren, data);
+              }); */
+            nextNodes[x] = [
+                data,
+                CreateNodeArray(Store_1.ObservableScope.Value(scope)),
+                scope,
+            ];
         }
     }
     for (const value of dataMap.values()) {
@@ -394,8 +411,7 @@ function ScheduledAssignment(assign) {
             return;
         scheduled = true;
         nodeConfig_1.NodeConfig.scheduleUpdate(function () {
-            if (scope.destroyed)
-                return;
+            // if (scope.destroyed) return;
             scheduled = false;
             const value = Store_1.ObservableScope.Peek(scope);
             assign(value);

package/Store/Tree/observableNode.d.ts

@@ -4,6 +4,7 @@ export declare const GET_OBSERVABLE_VALUE = "____getObservableValue";
 export declare const GET_TO_JSON = "toJSON";
 export declare namespace ObservableNode {
     function BypassProxy(value: boolean): void;
+    function Unwrap<T>(value: T): T;
     function Create<T>(value: T): T;
     function Touch(value: unknown, prop?: string | number): void;
     function ApplyDiff(rootNode: any, diffResult: JsonDiffResult): void;

package/Store/Tree/observableNode.js

@@ -87,7 +87,7 @@ function CreateProxyFactory(alias) {
     const ToJson = alias !== undefined ? ToJsonCopy : ToJsonDefault;
     const readOnly = alias !== undefined;
     function CreateArrayProxy(value) {
-        const scope = observableScope_1.ObservableScope.Create(() => value);
+        const scope = observableScope_1.ObservableScope.Create(() => value, false, true);
         const proxy = new Proxy(value, {
             get: ArrayProxyGetter,
             set: ArrayProxySetter,
@@ -235,7 +235,7 @@ function CreateProxyFactory(alias) {
         leafScopes[prop] ??= observableScope_1.ObservableScope.Create(function () {
             const value = parent[prop];
             return CreateProxyFromValue(value);
-        });
+        }, false, true);
         return observableScope_1.ObservableScope.Value(leafScopes[prop]);
     }
     function CreateProxyFromValue(value) {
@@ -268,6 +268,10 @@ var ObservableNode;
         bypassProxy = value;
     }
     ObservableNode.BypassProxy = BypassProxy;
+    function Unwrap(value) {
+        return UnwrapProxy(value);
+    }
+    ObservableNode.Unwrap = Unwrap;
     function Create(value) {
         return DefaultCreateProxy(value);
     }

package/Store/Tree/observableScope.d.ts

@@ -1,64 +1,39 @@
 import { Emitter, EmitterCallback } from "../../Utils/emitter";
-import { IDestroyable } from "../../Utils/utils.types";
-export declare class ObservableScopeValue<T> {
-    protected scope: IObservableScope<T>;
-    get Value(): T;
-    constructor(scope: IObservableScope<T>);
-}
-export declare class ObservableScopeWrapper<T> extends ObservableScopeValue<T> implements IDestroyable {
-    private scopeEmitter;
-    constructor(scope: IObservableScope<T>);
-    Scope<O>(callback: {
-        (parent: T): O;
-    }): ObservableScope<O>;
-    Watch(callback: {
-        (scope: ObservableScopeValue<T>): void;
-    }): void;
-    Unwatch(callback: {
-        (scope: ObservableScopeValue<T>): void;
-    }): void;
-    Destroy(): void;
-}
-export declare class ObservableScope<T> extends ObservableScopeWrapper<T> {
-    constructor(getFunction: {
-        (): T | Promise<T>;
-    });
+interface IStaticObservableScope<T> {
+    type: "static";
+    value: T;
 }
-export interface IObservableScope<T> extends IDestroyable {
-    getFunction: {
-        (): T;
-    };
-    setCallback: EmitterCallback;
+interface IDynamicObservableScope<T> {
+    type: "dynamic";
     async: boolean;
-    value: T;
-    promise: Promise<T> | null;
+    greedy: boolean;
     dirty: boolean;
+    destroyed: boolean;
+    getFunction: () => Promise<T> | T;
+    setCallback: EmitterCallback;
+    value: T;
     emitter: Emitter;
     emitters: (Emitter | null)[];
+    onDestroyed: Emitter | null;
     calcScopes: {
         [id: string]: IObservableScope<unknown> | null;
     } | null;
-    calc: boolean;
-    onDestroyed: Emitter | null;
-    destroyed: boolean;
 }
+export type IObservableScope<T> = IStaticObservableScope<T> | IDynamicObservableScope<T>;
 export declare function CalcScope<T>(callback: () => T, idOverride?: string): T;
 export declare namespace ObservableScope {
     function Create<T>(valueFunction: {
         (): T | Promise<T>;
-    }, calc?: boolean): IObservableScope<T>;
-    function CreateIf<T>(valueFunction: {
-        (): T | Promise<T>;
-    }, greedy?: boolean): [T, IObservableScope<T> | null];
+    }, greedy?: boolean, force?: boolean): IObservableScope<T>;
     function Register(emitter: Emitter): void;
-    function Init<T>(scope: IObservableScope<T>): void;
     function Peek<T>(scope: IObservableScope<T>): T;
     function Value<T>(scope: IObservableScope<T>): T;
     function Touch<T>(scope: IObservableScope<T>): void;
     function Watch<T>(scope: IObservableScope<T>, callback: EmitterCallback<[IObservableScope<T>]>): void;
-    function Unwatch<T>(scope: IObservableScope<T>, callback: EmitterCallback<[IObservableScope<T> | ObservableScopeValue<T>]>): void;
+    function Unwatch<T>(scope: IObservableScope<T>, callback: EmitterCallback<[IObservableScope<T>]>): void;
     function OnDestroyed(scope: IObservableScope<unknown>, callback: EmitterCallback): void;
     function Update(scope: IObservableScope<any>): void;
     function Destroy<T>(scope: IObservableScope<T>): void;
     function DestroyAll(scopes: IObservableScope<unknown>[]): void;
 }
+export {};

package/Store/Tree/observableScope.js

@@ -1,144 +1,222 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObservableScope = exports.ObservableScopeWrapper = exports.ObservableScopeValue = void 0;
+exports.ObservableScope = void 0;
 exports.CalcScope = CalcScope;
 const array_1 = require("../../Utils/array");
 const emitter_1 = require("../../Utils/emitter");
 const functions_1 = require("../../Utils/functions");
-class ObservableScopeValue {
-    get Value() {
-        return ObservableScope.Value(this.scope);
-    }
-    constructor(scope) {
-        this.scope = scope;
-    }
+function CreateDynamicScope(getFunction, greedy, value) {
+    const async = (0, functions_1.IsAsync)(getFunction);
+    const scope = {
+        type: "dynamic",
+        async,
+        greedy: greedy || async,
+        dirty: false,
+        destroyed: false,
+        getFunction,
+        setCallback: function () {
+            return OnSet(scope);
+        },
+        value,
+        emitter: emitter_1.Emitter.Create(),
+        emitters: null,
+        onDestroyed: null,
+        calcScopes: null,
+    };
+    return scope;
+}
+function CreateStaticScope(initialValue) {
+    return {
+        type: "static",
+        value: initialValue,
+    };
 }
-exports.ObservableScopeValue = ObservableScopeValue;
-class ObservableScopeWrapper extends ObservableScopeValue {
-    constructor(scope) {
-        super(scope);
-        if (scope.emitter) {
-            this.scopeEmitter = emitter_1.Emitter.Create();
-            emitter_1.Emitter.On(scope.emitter, () => emitter_1.Emitter.Emit(this.scopeEmitter, this));
+let scopeQueue = [];
+function ProcessScopeQueue() {
+    const queue = scopeQueue;
+    scopeQueue = [];
+    for (let x = 0; x < queue.length; x++) {
+        const scope = queue[x];
+        if (!scope.destroyed) {
+            const value = scope.value;
+            ExecuteScope(scope);
+            if (scope.value !== value)
+                emitter_1.Emitter.Emit(scope.emitter, scope);
         }
     }
-    Scope(callback) {
-        return new ObservableScope(() => callback(this.Value));
-    }
-    Watch(callback) {
-        if (!this.scopeEmitter)
-            return;
-        emitter_1.Emitter.On(this.scopeEmitter, callback);
-        callback(this);
+}
+function OnSetQueued(scope) {
+    if (scopeQueue.length === 0)
+        queueMicrotask(ProcessScopeQueue);
+    scopeQueue.push(scope);
+}
+function OnSet(scope) {
+    if (scope.type === "static" || scope.destroyed)
+        return true;
+    if (scope.dirty)
+        return false;
+    scope.dirty = true;
+    if (scope.greedy) {
+        OnSetQueued(scope);
+        return;
     }
-    Unwatch(callback) {
-        if (!this.scopeEmitter)
-            return;
-        emitter_1.Emitter.Remove(this.scopeEmitter, callback);
+    emitter_1.Emitter.Emit(scope.emitter, scope);
+    return false;
+}
+function RegisterEmitter(emitter) {
+    if (watchState.emitterIds) {
+        if (!watchState.emitterIds.has(emitter[0])) {
+            watchState.emitters.push(emitter);
+            watchState.emitterIds.add(emitter[0]);
+        }
+        return;
     }
-    Destroy() {
-        DestroyScope(this.scope);
-        this.scopeEmitter && emitter_1.Emitter.Clear(this.scopeEmitter);
+    watchState.emitters.push(emitter);
+    if (watchState.emitters.length > 50) {
+        const idSet = (watchState.emitterIds = new Set());
+        let writePos = 0;
+        for (let x = 1; x < watchState.emitters.length; x++) {
+            if (!idSet.has(watchState.emitters[x][0])) {
+                watchState.emitters[++writePos] = watchState.emitters[x];
+                idSet.add(watchState.emitters[x][0]);
+            }
+        }
+        writePos++;
+        if (writePos < watchState.emitters.length)
+            watchState.emitters.splice(writePos);
     }
 }
-exports.ObservableScopeWrapper = ObservableScopeWrapper;
-class ObservableScope extends ObservableScopeWrapper {
-    constructor(getFunction) {
-        super(ObservableScope.Create(getFunction));
-    }
+function RegisterScope(scope) {
+    if (watchState === null || scope.type === "static")
+        return;
+    RegisterEmitter(scope.emitter);
+}
+function GetScopeValue(scope) {
+    if (scope.type === "static" || !scope.dirty || scope.destroyed)
+        return scope.value;
+    ExecuteScope(scope);
+    return scope.value;
 }
-exports.ObservableScope = ObservableScope;
 let watchState = null;
-function WatchScope(scope) {
+function WatchFunction(callback, currentCalc = null) {
     const parent = watchState;
-    watchState = [[], scope.calcScopes, null];
-    const value = scope.getFunction();
-    const emitters = watchState[0];
-    UpdateEmitters(scope, emitters);
-    const calcScopes = watchState[1];
-    if (calcScopes) {
-        const calcScopeValues = Object.values(calcScopes);
-        for (let x = 0; x < calcScopeValues.length; x++)
-            calcScopeValues[x] && ObservableScope.Destroy(calcScopeValues[x]);
-    }
-    scope.calcScopes = watchState[2];
+    watchState = {
+        value: null,
+        emitters: [],
+        emitterIds: null,
+        currentCalc: currentCalc,
+        nextCalc: null,
+    };
+    watchState.value = callback();
+    const resultState = watchState;
     watchState = parent;
-    return value;
+    return resultState;
 }
-function WatchFunction(func, greedy) {
-    const parent = watchState;
-    watchState = [[], null, null];
-    const async = (0, functions_1.IsAsync)(func);
-    const result = func();
-    let scope = null;
-    if (watchState[0].length > 0 || async) {
-        scope = ObservableScope.Create(func, greedy);
-        UpdateEmitters(scope, watchState[0]);
-        scope.calcScopes = watchState[2];
-        UpdateValue(scope, result);
+function ExecuteScope(scope) {
+    scope.dirty = false;
+    const state = WatchFunction(scope.getFunction, scope.calcScopes);
+    UpdateEmitters(scope, state.emitters, !!state.emitterIds);
+    const calcScopes = state.currentCalc;
+    scope.calcScopes = state.nextCalc;
+    for (const key in calcScopes)
+        DestroyScope(calcScopes[key]);
+    if (scope.async)
+        state.value.then(function (result) {
+            scope.value = result;
+            emitter_1.Emitter.Emit(scope.emitter, scope);
+        });
+    else
+        scope.value = state.value;
+}
+function ExecuteFunction(callback, greedy, allowStatic) {
+    const async = (0, functions_1.IsAsync)(callback);
+    const state = WatchFunction(callback);
+    if (!allowStatic || async || state.emitters.length > 0) {
+        const scope = CreateDynamicScope(callback, greedy, async ? null : state.value);
+        scope.calcScopes = state.nextCalc;
+        UpdateEmitters(scope, state.emitters, !!state.emitterIds);
+        if (async)
+            state.value.then(function (result) {
+                scope.value = result;
+                emitter_1.Emitter.Emit(scope.emitter, scope);
+            });
+        return scope;
     }
-    watchState = parent;
-    return [async ? null : result, scope];
+    return CreateStaticScope(state.value);
 }
 function CalcScope(callback, idOverride) {
     if (watchState === null)
         return callback();
-    const nextScopes = (watchState[2] ??= {});
-    const currentScopes = watchState[1];
+    const nextScopes = (watchState.nextCalc ??= {});
     const id = idOverride ?? callback.toString();
-    const currentScope = currentScopes?.[id];
-    if (currentScope) {
+    if (nextScopes[id]) {
+        RegisterScope(nextScopes[id]);
+        return GetScopeValue(nextScopes[id]);
+    }
+    const currentScopes = watchState.currentCalc;
+    nextScopes[id] = currentScopes?.[id] ?? ExecuteFunction(callback, true, true);
+    if (currentScopes?.[id])
         delete currentScopes[id];
-        nextScopes[id] = currentScope;
+    RegisterScope(nextScopes[id]);
+    return GetScopeValue(nextScopes[id]);
+}
+function UpdateEmitters(scope, right, distinct = false) {
+    distinct ? emitter_1.Emitter.Sort(right) : emitter_1.Emitter.Distinct(right);
+    if (scope.emitters === null) {
+        for (let x = 0; x < right.length; x++)
+            emitter_1.Emitter.On(right[x], scope.setCallback);
+        scope.emitters = right;
+        return;
     }
-    else if (!nextScopes[id]) {
-        const scope = ObservableScope.Create(callback, true);
-        nextScopes[id] = scope;
+    if (right.length === 0) {
+        if (scope.emitters.length > 0) {
+            for (let x = 0; x < scope.emitters.length; x++)
+                emitter_1.Emitter.Remove(scope.emitters[x], scope.setCallback);
+            scope.emitters = [];
+        }
+        return;
     }
-    return ObservableScope.Value(nextScopes[id]);
+    (0, array_1.ReconcileSortedEmitters)(scope.emitters, right, function (emitter) {
+        emitter_1.Emitter.On(emitter, scope.setCallback);
+    }, function (emitter) {
+        emitter_1.Emitter.Remove(emitter, scope.setCallback);
+    });
+    scope.emitters = right;
 }
+function DestroyAllScopes(scopes) {
+    for (let x = 0; x < scopes.length; x++)
+        DestroyScope(scopes[x]);
+}
+function DestroyScope(scope) {
+    if (!scope || scope.type === "static")
+        return;
+    emitter_1.Emitter.Clear(scope.emitter);
+    const scopes = scope.calcScopes && Object.values(scope.calcScopes);
+    scopes && DestroyAllScopes(scopes);
+    scope.calcScopes = null;
+    for (let x = 0; x < scope.emitters.length; x++)
+        emitter_1.Emitter.Remove(scope.emitters[x], scope.setCallback);
+    scope.value = undefined;
+    scope.calcScopes = null;
+    scope.emitters = null;
+    scope.emitter = null;
+    scope.getFunction = null;
+    scope.setCallback = null;
+    scope.destroyed = true;
+    scope.onDestroyed && emitter_1.Emitter.Emit(scope.onDestroyed, scope);
+}
+var ObservableScope;
 (function (ObservableScope) {
-    function Create(valueFunction, calc = false) {
-        const scope = {
-            getFunction: valueFunction,
-            value: null,
-            promise: null,
-            async: (0, functions_1.IsAsync)(valueFunction),
-            dirty: true,
-            emitter: emitter_1.Emitter.Create(),
-            emitters: null,
-            calcScopes: null,
-            calc,
-            destroyed: false,
-            onDestroyed: null,
-            setCallback: function () {
-                return OnSet(scope);
-            },
-        };
-        return scope;
+    function Create(valueFunction, greedy = false, force = false) {
+        return ExecuteFunction(valueFunction, greedy, !force);
     }
     ObservableScope.Create = Create;
-    function CreateIf(valueFunction, greedy = false) {
-        return WatchFunction(valueFunction, greedy);
-    }
-    ObservableScope.CreateIf = CreateIf;
     function Register(emitter) {
-        if (watchState === null)
-            return;
-        watchState[0].push(emitter);
+        RegisterEmitter(emitter);
     }
     ObservableScope.Register = Register;
-    function Init(scope) {
-        if (!scope)
-            return;
-        UpdateValue(scope);
-    }
-    ObservableScope.Init = Init;
     function Peek(scope) {
-        if (!scope)
-            return undefined;
-        UpdateValue(scope);
-        return scope.value;
+        return GetScopeValue(scope);
     }
     ObservableScope.Peek = Peek;
     function Value(scope) {
@@ -149,30 +227,32 @@ function CalcScope(callback, idOverride) {
     }
     ObservableScope.Value = Value;
     function Touch(scope) {
-        if (!scope || !scope.emitter)
+        if (!scope)
             return;
-        Register(scope.emitter);
+        RegisterScope(scope);
     }
     ObservableScope.Touch = Touch;
     function Watch(scope, callback) {
-        if (!scope || !scope.emitter)
+        if (!scope || scope.type === "static")
             return;
         emitter_1.Emitter.On(scope.emitter, callback);
     }
     ObservableScope.Watch = Watch;
     function Unwatch(scope, callback) {
-        if (!scope || !scope.emitter)
+        if (!scope || scope.type === "static")
             return;
         emitter_1.Emitter.Remove(scope.emitter, callback);
     }
     ObservableScope.Unwatch = Unwatch;
     function OnDestroyed(scope, callback) {
+        if (scope.type === "static")
+            return;
         scope.onDestroyed ??= emitter_1.Emitter.Create();
         emitter_1.Emitter.On(scope.onDestroyed, callback);
     }
     ObservableScope.OnDestroyed = OnDestroyed;
     function Update(scope) {
-        if (!scope || scope.dirty || scope.destroyed)
+        if (!scope)
             return;
         OnSet(scope);
     }
@@ -182,102 +262,7 @@ function CalcScope(callback, idOverride) {
     }
     ObservableScope.Destroy = Destroy;
     function DestroyAll(scopes) {
-        for (let x = 0; x < scopes.length; x++)
-            Destroy(scopes[x]);
+        DestroyAllScopes(scopes);
     }
     ObservableScope.DestroyAll = DestroyAll;
 })(ObservableScope || (exports.ObservableScope = ObservableScope = {}));
-function DirtyScope(scope) {
-    if (scope.dirty || !scope.getFunction)
-        return;
-    scope.dirty = true;
-    if (scope.async)
-        UpdateValue(scope);
-    else if (scope.calc) {
-        const startValue = scope.value;
-        UpdateValue(scope);
-        startValue !== scope.value && emitter_1.Emitter.Emit(scope.emitter, scope);
-    }
-    else
-        emitter_1.Emitter.Emit(scope.emitter, scope);
-}
-let scopeQueue = [];
-function ProcessScopeQueue() {
-    const scopes = scopeQueue;
-    scopeQueue = [];
-    const distinct = new Set();
-    for (let x = 0; x < scopes.length; x++) {
-        if (!distinct.has(scopes[x])) {
-            distinct.add(scopes[x]);
-            DirtyScope(scopes[x]);
-        }
-    }
-}
-function OnSet(scope) {
-    if (scope.destroyed)
-        return true;
-    if (scope.async || scope.calc) {
-        if (scopeQueue.length === 0)
-            queueMicrotask(ProcessScopeQueue);
-        scopeQueue.push(scope);
-        return;
-    }
-    DirtyScope(scope);
-}
-function UpdateValue(scope, valueOverride = undefined) {
-    if (!scope.dirty)
-        return;
-    scope.dirty = false;
-    const value = valueOverride === undefined ? WatchScope(scope) : valueOverride;
-    if (scope.async) {
-        scope.promise = value.then(function (result) {
-            if (scope.destroyed)
-                return;
-            scope.value = result;
-            emitter_1.Emitter.Emit(scope.emitter, scope);
-            return result;
-        });
-    }
-    else
-        scope.value = value;
-}
-function UpdateEmitters(scope, right) {
-    emitter_1.Emitter.Distinct(right);
-    if (scope.emitters === null) {
-        for (let x = 0; x < right.length; x++)
-            emitter_1.Emitter.On(right[x], scope.setCallback);
-        scope.emitters = right;
-        return;
-    }
-    if (right.length === 0) {
-        if (scope.emitters.length > 0) {
-            for (let x = 0; x < scope.emitters.length; x++)
-                emitter_1.Emitter.Remove(scope.emitters[x], scope.setCallback);
-            scope.emitters = [];
-        }
-        return;
-    }
-    (0, array_1.ReconcileSortedEmitters)(scope.emitters, right, function (emitter) {
-        emitter_1.Emitter.On(emitter, scope.setCallback);
-    }, function (emitter) {
-        emitter_1.Emitter.Remove(emitter, scope.setCallback);
-    });
-    scope.emitters = right;
-}
-function DestroyScope(scope) {
-    if (!scope)
-        return;
-    emitter_1.Emitter.Clear(scope.emitter);
-    const scopes = scope.calcScopes && Object.values(scope.calcScopes);
-    scopes && ObservableScope.DestroyAll(scopes);
-    scope.calcScopes = null;
-    for (let x = 0; x < scope.emitters.length; x++)
-        emitter_1.Emitter.Remove(scope.emitters[x], scope.setCallback);
-    scope.calcScopes = null;
-    scope.emitters = null;
-    scope.emitter = null;
-    scope.getFunction = null;
-    scope.setCallback = null;
-    scope.destroyed = true;
-    scope.onDestroyed && emitter_1.Emitter.Emit(scope.onDestroyed);
-}

package/Utils/decorators.js

@@ -94,7 +94,7 @@ function CreateComputedScope(getter, defaultValue, store) {
         const data = observableScope_1.ObservableScope.Value(scope);
         store.Write(data, "root");
     });
-    observableScope_1.ObservableScope.Init(getterScope);
+    // ObservableScope.Init(getterScope);
     const propertyScope = observableScope_1.ObservableScope.Create(() => store.Get("root", defaultValue));
     observableScope_1.ObservableScope.OnDestroyed(propertyScope, function () {
         observableScope_1.ObservableScope.Destroy(getterScope);
@@ -273,7 +273,7 @@ function Value() {
 function CreateValueScope(tuple) {
     return observableScope_1.ObservableScope.Create(function () {
         return tuple[1];
-    });
+    }, false, true);
 }
 /**
  * Value decorator implementation for creating value properties.
@@ -359,15 +359,21 @@ function WatchDecorator(target, propertyKey, descriptor, scopeFunction) {
         function scopeFunctionWrapper() {
             return scopeFunction(instance);
         }
-        const [value, scope] = observableScope_1.ObservableScope.CreateIf(scopeFunctionWrapper, true);
+        const scope = observableScope_1.ObservableScope.Create(scopeFunctionWrapper, true);
+        const propertyMap = GetScopeMapForInstance(this);
+        propertyMap[propertyKey] = [scope, undefined];
+        observableScope_1.ObservableScope.Watch(scope, function (scope) {
+            instance[propertyKey](observableScope_1.ObservableScope.Value(scope));
+        });
+        /* const [value, scope] = ObservableScope.CreateIf(scopeFunctionWrapper, true);
         if (scope) {
-            const propertyMap = GetScopeMapForInstance(this);
-            propertyMap[propertyKey] = [scope, undefined];
-            observableScope_1.ObservableScope.Watch(scope, function (scope) {
-                instance[propertyKey](observableScope_1.ObservableScope.Value(scope));
-            });
-        }
-        instance[propertyKey](value);
+          const propertyMap = GetScopeMapForInstance(this);
+          propertyMap[propertyKey as string] = [scope, undefined];
+          ObservableScope.Watch(scope, function (scope) {
+            (instance as any)[propertyKey](ObservableScope.Value(scope));
+          });
+        } */
+        instance[propertyKey](observableScope_1.ObservableScope.Value(scope));
         return instance;
     }
     const boundArray = GetBoundArrayForPrototype(target);

package/Utils/emitter.js

@@ -42,17 +42,19 @@ var Emitter;
     function Distinct(emitters) {
         if (emitters.length < 2)
             return;
-        emitters.length < 51 ? DistinctSmall(emitters) : DistinctLarge(emitters);
+        // emitters.length < 51 ? DistinctSmall(emitters) : DistinctLarge(emitters);
+        DistinctSmall(emitters);
     }
     Emitter.Distinct = Distinct;
     function DistinctSmall(emitters) {
         Sort(emitters);
-        let writePos = 1;
+        let writePos = 0;
         for (let x = 1; x < emitters.length; x++) {
-            if (emitters[x][0] !== emitters[writePos - 1][0]) {
-                emitters[writePos++] = emitters[x];
+            if (emitters[x][0] !== emitters[writePos][0]) {
+                emitters[++writePos] = emitters[x];
             }
         }
+        writePos++;
         if (writePos < emitters.length)
             emitters.splice(writePos);
     }

package/Utils/injector.js

@@ -54,6 +54,9 @@ exports.Injector = Injector;
         try {
             return action(...args);
         }
+        catch (err) {
+            console.error("Error evaluating injector scope", err);
+        }
         finally {
             scope = parent;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "j-templates",
-  "version": "7.0.66",
+  "version": "7.0.68",
   "description": "j-templates",
   "license": "MIT",
   "repository": "https://github.com/TypesInCode/jTemplates",