j-templates 7.0.65 → 7.0.67

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) {
-    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);
-        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;
+    for (const key in calcScopes)
+        DestroyScope(calcScopes[key]);
+    scope.calcScopes = state.nextCalc;
+    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) {
-        return WatchFunction(valueFunction);
-    }
-    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/animation.d.ts

@@ -1,8 +1,14 @@
 import { IDestroyable } from "./utils.types";
+/**
+ * Supported animation functions.
+ */
 export declare enum AnimationType {
     Linear = 0,
     EaseIn = 1
 }
+/**
+ * Class for handling interpolation for basic animations.
+ */
 export declare class Animation implements IDestroyable {
     private type;
     private running;
@@ -13,16 +19,53 @@ export declare class Animation implements IDestroyable {
     private animationDuration;
     private animationUpdate;
     private animationRun;
+    /**
+     * Is the animation currently running.
+     */
     get Running(): boolean;
+    /**
+     * The starting value of the current animation.
+     */
     get Start(): number;
+    /**
+     * The ending value of the current animation.
+     */
     get End(): number;
+    /**
+     * Is this animation enabled.
+     */
     get Enabled(): boolean;
+    /**
+     * @param type Interpolation function
+     * @param duration The duration of the Animation
+     * @param update Callback invoked during the animation with the next value
+     */
     constructor(type: AnimationType, duration: number, update: {
         (next: number): void;
     });
+    /**
+     * Start an animation. Calls the passed `update` callback for each animation frame
+     * with interpolated values based on the passed `AnimationType`.
+     *
+     * @param start initial animation value
+     * @param end ending animation value
+     * @returns Promise<void> that resolves once the animation is complete
+     */
     Animate(start: number, end: number): Promise<void>;
+    /**
+     * Disables the Animation. Cancels the animation if it is running.
+     */
     Disable(): void;
+    /**
+     * Enables the Animation.
+     */
     Enable(): void;
+    /**
+     * Cancels the Animation if it is running by clearing any sheduled timeout events.
+     */
     Cancel(): void;
+    /**
+     * IDestroyable. Cancels the animation.
+     */
     Destroy(): void;
 }

package/Utils/animation.js

@@ -20,24 +20,47 @@ var StepFunctions;
     }
     StepFunctions.Linear = Linear;
 })(StepFunctions || (StepFunctions = {}));
+/**
+ * Supported animation functions.
+ */
 var AnimationType;
 (function (AnimationType) {
     AnimationType[AnimationType["Linear"] = 0] = "Linear";
     AnimationType[AnimationType["EaseIn"] = 1] = "EaseIn";
 })(AnimationType || (exports.AnimationType = AnimationType = {}));
+/**
+ * Class for handling interpolation for basic animations.
+ */
 class Animation {
+    /**
+     * Is the animation currently running.
+     */
     get Running() {
         return this.running;
     }
+    /**
+     * The starting value of the current animation.
+     */
     get Start() {
         return this.start;
     }
+    /**
+     * The ending value of the current animation.
+     */
     get End() {
         return this.end;
     }
+    /**
+     * Is this animation enabled.
+     */
     get Enabled() {
         return this.enabled;
     }
+    /**
+     * @param type Interpolation function
+     * @param duration The duration of the Animation
+     * @param update Callback invoked during the animation with the next value
+     */
     constructor(type, duration, update) {
         this.animationStart = 0;
         this.animationRun = null;
@@ -49,13 +72,23 @@ class Animation {
         this.animationDuration = duration;
         this.animationUpdate = nodeConfig_1.NodeConfig.wrapPriorityUpdates(update);
     }
+    /**
+     * Start an animation. Calls the passed `update` callback for each animation frame
+     * with interpolated values based on the passed `AnimationType`.
+     *
+     * @param start initial animation value
+     * @param end ending animation value
+     * @returns Promise<void> that resolves once the animation is complete
+     */
     Animate(start, end) {
         if (!this.enabled)
             return;
+        this.Cancel();
         const diff = end - start;
-        if (diff === 0)
+        if (diff === 0) {
+            this.animationUpdate(end);
             return;
-        this.Cancel();
+        }
         this.animationStart = Date.now();
         this.running = true;
         this.start = start;
@@ -63,8 +96,10 @@ class Animation {
         return new Promise((resolve) => {
             const stepFunc = StepFunctions[AnimationType[this.type]];
             const animationRun = () => {
-                if (this.animationRun !== animationRun)
+                if (this.animationRun !== animationRun) {
+                    resolve();
                     return;
+                }
                 const percent = stepFunc(this.animationStart, this.animationDuration);
                 const step = percent * diff;
                 const next = this.start + step;
@@ -81,19 +116,31 @@ class Animation {
             this.Cancel();
         });
     }
+    /**
+     * Disables the Animation. Cancels the animation if it is running.
+     */
     Disable() {
         this.Cancel();
         this.enabled = false;
     }
+    /**
+     * Enables the Animation.
+     */
     Enable() {
         this.enabled = true;
     }
+    /**
+     * Cancels the Animation if it is running by clearing any sheduled timeout events.
+     */
     Cancel() {
         this.running = false;
         this.start = null;
         this.end = null;
         this.animationRun = null;
     }
+    /**
+     * IDestroyable. Cancels the animation.
+     */
     Destroy() {
         this.Disable();
     }