j-templates 5.0.53 → 6.0.0

package/Store/Tree/observableScope.js

@@ -37,7 +37,7 @@ class ObservableScopeWrapper extends ObservableScopeValue {
     }
     Destroy() {
         DestroyScope(this.scope);
-        this.scopeEmitter && this.scopeEmitter.clear();
+        this.scopeEmitter && emitter_1.Emitter.Clear(this.scopeEmitter);
     }
 }
 exports.ObservableScopeWrapper = ObservableScopeWrapper;
@@ -62,19 +62,23 @@ function WatchAction(action) {
 }
 (function (ObservableScope) {
     function Create(valueFunction, dependencies) {
-        const hasFunction = typeof valueFunction === 'function';
+        const hasFunction = typeof valueFunction === "function";
         const scope = {
             getFunction: hasFunction ? valueFunction : null,
             value: hasFunction ? null : valueFunction,
-            async: hasFunction ? valueFunction[Symbol.toStringTag] === 'AsyncFunction' : false,
+            async: hasFunction
+                ? valueFunction[Symbol.toStringTag] === "AsyncFunction"
+                : false,
             dirty: hasFunction,
             emitter: hasFunction ? emitter_1.Emitter.Create() : null,
             emitters: null,
             destroyed: false,
-            setCallback: hasFunction ? function () {
-                return OnSet(scope);
-            } : null,
-            dependencies
+            setCallback: hasFunction
+                ? function () {
+                    return OnSet(scope);
+                }
+                : null,
+            dependencies,
         };
         return scope;
     }
@@ -137,9 +141,9 @@ function UpdateValue(scope) {
         return;
     scope.dirty = false;
     let value = null;
-    const emitters = scope.getFunction && WatchAction(() => value = scope.getFunction());
+    const emitters = scope.getFunction && WatchAction(() => (value = scope.getFunction()));
     if (scope.async)
-        Promise.resolve(value).then(val => {
+        Promise.resolve(value).then((val) => {
             scope.value = val;
             emitter_1.Emitter.Emit(scope.emitter, scope);
         });
@@ -154,19 +158,19 @@ function DestroyScope(scope) {
         for (let x = 0; x < scope.dependencies.length; x++)
             DestroyScope(scope.dependencies[x]);
     scope.emitters && scope.emitters.clear();
-    scope.emitter && scope.emitter.clear();
+    scope.emitter && emitter_1.Emitter.Clear(scope.emitter);
     scope.getFunction = null;
     scope.setCallback = null;
     scope.destroyed = true;
 }
 function UpdateEmitters(scope, newEmitters) {
     if (newEmitters) {
-        newEmitters.forEach(e => {
+        newEmitters.forEach((e) => {
             if (!scope.emitters?.delete(e))
                 emitter_1.Emitter.On(e, scope.setCallback);
         });
     }
     if (scope.emitters)
-        scope.emitters.forEach(e => emitter_1.Emitter.Remove(e, scope.setCallback));
+        scope.emitters.forEach((e) => emitter_1.Emitter.Remove(e, scope.setCallback));
     scope.emitters = newEmitters;
 }

package/Store/index.d.ts

@@ -1,6 +1,2 @@
-export { Store } from "./Store/store";
-export { StoreSync } from "./Store/storeSync";
-export { StoreAsync } from "./Store/storeAsync";
 export { ObservableScope } from "./Tree/observableScope";
 export { ObservableNode } from "./Tree/observableNode";
-export { ObservableComputed } from './Tree/observableComputed';

package/Store/index.js

@@ -1,15 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObservableComputed = exports.ObservableNode = exports.ObservableScope = exports.StoreAsync = exports.StoreSync = exports.Store = void 0;
-var store_1 = require("./Store/store");
-Object.defineProperty(exports, "Store", { enumerable: true, get: function () { return store_1.Store; } });
-var storeSync_1 = require("./Store/storeSync");
-Object.defineProperty(exports, "StoreSync", { enumerable: true, get: function () { return storeSync_1.StoreSync; } });
-var storeAsync_1 = require("./Store/storeAsync");
-Object.defineProperty(exports, "StoreAsync", { enumerable: true, get: function () { return storeAsync_1.StoreAsync; } });
+exports.ObservableNode = exports.ObservableScope = void 0;
 var observableScope_1 = require("./Tree/observableScope");
 Object.defineProperty(exports, "ObservableScope", { enumerable: true, get: function () { return observableScope_1.ObservableScope; } });
 var observableNode_1 = require("./Tree/observableNode");
 Object.defineProperty(exports, "ObservableNode", { enumerable: true, get: function () { return observableNode_1.ObservableNode; } });
-var observableComputed_1 = require("./Tree/observableComputed");
-Object.defineProperty(exports, "ObservableComputed", { enumerable: true, get: function () { return observableComputed_1.ObservableComputed; } });

package/Utils/array.d.ts

@@ -0,0 +1 @@
+export declare function RemoveNulls(array: (unknown | null)[], startIndex?: number): void;

package/Utils/array.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoveNulls = RemoveNulls;
+function RemoveNulls(array, startIndex = 0) {
+    let nullIndex = startIndex;
+    for (; nullIndex < array.length && array[nullIndex] !== null; nullIndex++) { }
+    let notNullIndex = nullIndex + 1;
+    while (notNullIndex < array.length) {
+        for (; notNullIndex < array.length && array[notNullIndex] === null; notNullIndex++) { }
+        array[nullIndex] = array[notNullIndex];
+        nullIndex++;
+        notNullIndex++;
+    }
+    array.splice(nullIndex);
+}

package/Utils/decorators.d.ts

@@ -2,16 +2,16 @@ import { Component } from "../Node/component";
 import { IDestroyable } from "./utils.types";
 import { NodeRefTypes } from "../Node/nodeRef.types";
 export declare function State(): any;
-export declare function StateSync(): any;
-export declare function StateAsync(): any;
+export declare function Value(): any;
+export declare function StateAsync(defaultValue: any, keyFunc?: (val: any) => string): any;
+export declare function StateAsyncDecorator<T extends Component<any, any, any>, K extends string>(defaultValue: any, keyFunc: ((val: any) => string) | undefined, target: T, propertyKey: K): {
+    configurable: boolean;
+    enumerable: boolean;
+    get: (this: T) => any;
+    set: (this: T, val: any) => void;
+};
 export declare function Scope(): typeof ScopeDecorator;
 declare function ScopeDecorator<T extends Component<any, any, any>, K extends string>(target: T, propertyKey: K, descriptor: PropertyDescriptor): PropertyDescriptor;
-export declare function DestroyScope(): typeof DestroyScopeDecorator;
-declare function DestroyScopeDecorator<T extends Component<any, any, any> & Record<K, IDestroyable>, K extends string>(target: T, propertyKey: K, descriptor: PropertyDescriptor): PropertyDescriptor;
-export declare function Computed(): <T extends Component<any, any, any>, K extends string>(target: T, propertyKey: K, descriptor: PropertyDescriptor) => any;
-export declare function ComputedAsync(idFunc?: {
-    (val: any): string;
-}): <T extends Component<any, any, any>, K extends string>(target: T, propertyKey: K, descriptor: PropertyDescriptor) => any;
 export declare function Inject<I>(type: {
     new (...args: Array<any>): I;
 }): <F extends I, T extends Component<any, any, any> & Record<K, F>, K extends string>(target: T, propertyKey: K, descriptor?: PropertyDescriptor) => any;

package/Utils/decorators.js

@@ -1,35 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.State = State;
-exports.StateSync = StateSync;
+exports.Value = Value;
 exports.StateAsync = StateAsync;
+exports.StateAsyncDecorator = StateAsyncDecorator;
 exports.Scope = Scope;
-exports.DestroyScope = DestroyScope;
-exports.Computed = Computed;
-exports.ComputedAsync = ComputedAsync;
 exports.Inject = Inject;
 exports.Destroy = Destroy;
 exports.PreReqTemplate = PreReqTemplate;
 exports.PreReq = PreReq;
-const Store_1 = require("../Store");
 const observableScope_1 = require("../Store/Tree/observableScope");
-const observableTree_1 = require("../Store/Tree/observableTree");
 const observableNode_1 = require("../Store/Tree/observableNode");
+const diffAsync_1 = require("../Store/Diff/diffAsync");
+const json_1 = require("./json");
+const decoratorInstanceMap = new WeakMap();
+const valueInstanceMap = new WeakMap();
+function GetDecoratorMapForInstance(instance) {
+    const map = decoratorInstanceMap.get(instance) ?? new Map();
+    decoratorInstanceMap.set(instance, map);
+    return map;
+}
+function GetValueMapForInstance(instance) {
+    const map = valueInstanceMap.get(instance) ?? new Map();
+    valueInstanceMap.set(instance, map);
+    return map;
+}
 function State() {
     return StateDecorator;
 }
 function StateDecorator(target, propertyKey) {
-    const propKey = `StoreDecorator_${propertyKey}`;
+    const propKey = `StateDecorator_${propertyKey}`;
     return {
         configurable: false,
         enumerable: true,
         get: function () {
-            const map = this.DecoratorMap;
+            const map = GetDecoratorMapForInstance(this);
             const node = map.get(propKey);
             return node;
         },
         set: function (val) {
-            const map = this.DecoratorMap;
+            const map = GetDecoratorMapForInstance(this);
             const node = map.get(propKey);
             if (!node)
                 map.set(propKey, observableNode_1.ObservableNode.Create(val));
@@ -38,65 +48,77 @@ function StateDecorator(target, propertyKey) {
                 for (let x = 0; x < keys.length; x++)
                     node[keys[x]] = val[keys[x]];
             }
-        }
+        },
     };
 }
-function StateSync() {
-    return StateSyncDecorator;
+function Value() {
+    return ValueDecorator;
 }
-function StateSyncDecorator(target, propertyKey) {
-    const propKey = `StoreSyncDecorator_${propertyKey}`;
+function ValueDecorator(target, propertyKey) {
+    const propKey = `ValueDecorator_${propertyKey}`;
     return {
         configurable: false,
         enumerable: true,
         get: function () {
-            const map = this.DecoratorMap;
-            const node = map.get(propKey);
-            return node;
+            const map = GetDecoratorMapForInstance(this);
+            const scope = map.get(propKey);
+            return observableScope_1.ObservableScope.Value(scope);
         },
         set: function (val) {
-            const map = this.DecoratorMap;
-            const node = map.get(propKey);
-            if (!node)
-                map.set(propKey, observableNode_1.ObservableNode.Create(val));
-            else {
-                const keys = Object.keys(val);
-                for (let x = 0; x < keys.length; x++)
-                    node[keys[x]] = val[keys[x]];
+            const valueMap = GetValueMapForInstance(this);
+            if (valueMap.get(propKey) === val)
+                return;
+            valueMap.set(propKey, val);
+            const map = GetDecoratorMapForInstance(this);
+            let scope = map.get(propKey);
+            if (scope === undefined) {
+                scope = observableScope_1.ObservableScope.Create(function () {
+                    return valueMap.get(propKey);
+                });
+                map.set(propKey, scope);
             }
-        }
+            else
+                observableScope_1.ObservableScope.Update(scope);
+        },
     };
 }
-function StateAsync() {
-    return StateAsyncDecorator;
+function StateAsync(defaultValue, keyFunc) {
+    return StateAsyncDecorator.bind(null, defaultValue, keyFunc);
 }
-function StateAsyncDecorator(target, propertyKey) {
-    const propKey = `StoreAsyncDecorator_${propertyKey}`;
-    const scopeKey = `StoreAsyncDecorator_Scope_${propertyKey}`;
-    DestroyDecorator(target, propKey);
-    DestroyDecorator(target, scopeKey);
+function StateAsyncDecorator(defaultValue, keyFunc, target, propertyKey) {
+    const propKey = `ValueDecorator_${propertyKey}`;
+    const treeKey = `ValueDecoratorTree_${propertyKey}`;
     return {
         configurable: false,
         enumerable: true,
         get: function () {
-            var map = this.DecoratorMap;
-            var scope = map.get(scopeKey);
-            const value = scope && scope.Value;
-            if (observableScope_1.ObservableScope.Watching())
-                return value;
-            return observableTree_1.ObservableTree.UnwrapProxyValues(value);
+            const map = GetDecoratorMapForInstance(this);
+            const node = map.get(propKey);
+            return node?.root;
         },
         set: function (val) {
-            var map = this.DecoratorMap;
-            var store = map.get(propKey);
-            if (!store) {
-                store = new Store_1.StoreAsync((val) => val.___id, { ___id: "ROOT", data: val });
-                map.set(propKey, store);
-                map.set(scopeKey, store.Scope("ROOT", val => val.data));
+            const map = GetDecoratorMapForInstance(this);
+            const node = map.get(propKey);
+            if (!node) {
+                const newNode = observableNode_1.ObservableNode.Create({ root: defaultValue });
+                map.set(propKey, newNode);
+                const newTree = new diffAsync_1.DiffAsync(keyFunc);
+                map.set(treeKey, newTree);
+                newTree.DiffPath("", val).then((result) => {
+                    observableNode_1.ObservableNode.EnableDiff(false);
+                    (0, json_1.ApplyDiff)(newNode, result);
+                    observableNode_1.ObservableNode.EnableDiff(true);
+                });
             }
-            else
-                store.Action("ROOT", async (root, writer) => await writer.Merge(root.data, val));
-        }
+            else {
+                const tree = map.get(treeKey);
+                tree.DiffPath("", val).then((result) => {
+                    observableNode_1.ObservableNode.EnableDiff(false);
+                    (0, json_1.ApplyDiff)(node, result);
+                    observableNode_1.ObservableNode.EnableDiff(true);
+                });
+            }
+        },
     };
 }
 function Scope() {
@@ -113,122 +135,15 @@ function ScopeDecorator(target, propertyKey, descriptor) {
         configurable: false,
         enumerable: true,
         get: function () {
-            var map = this.DecoratorMap;
-            var scope = map.get(propKey);
-            if (!scope) {
-                const getter = descriptor.get.bind(this);
-                scope = new observableScope_1.ObservableScope(getter);
-                map.set(propKey, scope);
-            }
-            return scope.Value;
-        }
-    };
-}
-function DestroyScope() {
-    return DestroyScopeDecorator;
-}
-function DestroyScopeDecorator(target, propertyKey, descriptor) {
-    if (!(descriptor && descriptor.get))
-        throw "Destroy Scope decorator requires a getter";
-    if (descriptor && descriptor.set)
-        throw "Destroy Scope decorator does not support setters";
-    const propKey = `ScopeDecorator_${propertyKey}`;
-    DestroyDecorator(target, propKey);
-    const valKey = `ScopeDecorator_${propertyKey}_Value`;
-    DestroyDecorator(target, valKey);
-    return {
-        configurable: false,
-        enumerable: true,
-        get: function () {
-            var map = this.DecoratorMap;
+            var map = GetDecoratorMapForInstance(this);
             var scope = map.get(propKey);
             if (!scope) {
                 const getter = descriptor.get.bind(this);
                 scope = new observableScope_1.ObservableScope(getter);
                 map.set(propKey, scope);
-                scope.Watch(scope => {
-                    var lastValue = map.get(valKey);
-                    lastValue && lastValue.Destroy();
-                    map.set(valKey, scope.Value);
-                });
             }
             return scope.Value;
-        }
-    };
-}
-function Computed() {
-    return ComputedDecorator;
-}
-function ComputedDecorator(target, propertyKey, descriptor) {
-    if (!(descriptor && descriptor.get))
-        throw "Computed decorator requires a getter";
-    if (descriptor && descriptor.set)
-        throw "Computed decorator does not support setters";
-    const scopeKey = `ComputedDecorator_Scope_${propertyKey}`;
-    const storeKey = `ComputedDecorator_Store_${propertyKey}`;
-    DestroyDecorator(target, scopeKey);
-    DestroyDecorator(target, storeKey);
-    return {
-        configurable: false,
-        enumerable: true,
-        get: function () {
-            var map = this.DecoratorMap;
-            var store = map.get(storeKey);
-            if (!store) {
-                const getter = descriptor.get.bind(this);
-                const scope = new observableScope_1.ObservableScope(getter);
-                store = new Store_1.StoreSync(scope.Value);
-                scope.Watch(scope => {
-                    if (!this.Destroyed)
-                        store.Write(scope.Value);
-                });
-                map.set(scopeKey, scope);
-                map.set(storeKey, store);
-            }
-            return store.Root.Value;
-        }
-    };
-}
-function ComputedAsync(idFunc) {
-    return ComputedAsyncDecorator.bind(null, idFunc);
-}
-function ComputedAsyncDecorator(idFunc, target, propertyKey, descriptor) {
-    if (!(descriptor && descriptor.get))
-        throw "ComputedAsync decorator requires a getter";
-    if (descriptor && descriptor.set)
-        throw "ComputedAsync decorator does not support setters";
-    const scopeKey = `ComputedDecorator_Scope_${propertyKey}`;
-    const storeKey = `ComputedDecorator_Store_${propertyKey}`;
-    const storeScopeKey = `ComputedDecorator_StoreScope_${propertyKey}`;
-    DestroyDecorator(target, scopeKey);
-    DestroyDecorator(target, storeKey);
-    DestroyDecorator(target, storeScopeKey);
-    return {
-        configurable: false,
-        enumerable: true,
-        get: function () {
-            var map = this.DecoratorMap;
-            var storeScope = map.get(storeScopeKey);
-            if (!storeScope) {
-                const getter = descriptor.get.bind(this);
-                const scope = new observableScope_1.ObservableScope(() => {
-                    var value = getter();
-                    if (value && typeof value.toJSON === 'function')
-                        value = value.toJSON();
-                    return value;
-                });
-                const store = new Store_1.StoreAsync((val) => val._id, { _id: "ROOT", data: scope.Value });
-                scope.Watch(scope => {
-                    if (!this.Destroyed)
-                        store.Write({ _id: "ROOT", data: scope.Value });
-                });
-                storeScope = store.Scope("ROOT", (val) => val.data);
-                map.set(storeScopeKey, storeScope);
-                map.set(scopeKey, scope);
-                map.set(storeKey, store);
-            }
-            return storeScope.Value;
-        }
+        },
     };
 }
 function Inject(type) {
@@ -243,7 +158,7 @@ function InjectorDecorator(type, target, propertyKey, descriptor) {
         },
         set: function (val) {
             this.Injector.Set(type, val);
-        }
+        },
     };
 }
 function Destroy() {
@@ -251,13 +166,9 @@ function Destroy() {
 }
 (function (Destroy) {
     function Get(value) {
-        return value && value.DestroyDecorator_Destroys || [];
+        return (value && value.DestroyDecorator_Destroys) || [];
     }
     function All(value) {
-        var arr = Get(value);
-        arr.map(prop => (value[prop] || value.DecoratorMap.get(prop)))
-            .filter(o => !!o)
-            .forEach(o => o.Destroy());
     }
     Destroy.All = All;
 })(Destroy || (exports.Destroy = Destroy = {}));
@@ -288,10 +199,11 @@ function PreReq() {
 }
 (function (PreReq) {
     function Get(value) {
-        return value && value.PreReqDecorator_PreReqs || [];
+        return (value && value.PreReqDecorator_PreReqs) || [];
     }
     function All(value) {
-        var arr = Get(value).map((prop) => (value[prop] && value[prop].Init) || Promise.resolve());
+        var arr = Get(value).map((prop) => (value[prop] && value[prop].Init) ||
+            Promise.resolve());
         return Promise.all(arr);
     }
     PreReq.All = All;

package/Utils/emitter.d.ts

@@ -1,8 +1,9 @@
 export type EmitterCallback<T extends readonly any[] = any[]> = (...args: T) => boolean | void;
-export type Emitter = Set<EmitterCallback>;
+export type Emitter = Array<EmitterCallback>;
 export declare namespace Emitter {
     function Create(): Emitter;
     function On(emitter: Emitter, callback: EmitterCallback): void;
     function Emit(emitter: Emitter, ...args: any[]): void;
     function Remove(emitter: Emitter, callback: EmitterCallback): void;
+    function Clear(emitter: Emitter): void;
 }

package/Utils/emitter.js

@@ -1,31 +1,40 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Emitter = void 0;
+const array_1 = require("./array");
 var Emitter;
 (function (Emitter) {
     function Create() {
-        return new Set();
+        return [];
     }
     Emitter.Create = Create;
     function On(emitter, callback) {
-        emitter.add(callback);
+        emitter.push(callback);
     }
     Emitter.On = On;
     function Emit(emitter, ...args) {
-        let cleanup;
-        emitter.forEach(function (cb) {
-            const result = cb(...args);
+        let removed = false;
+        for (let x = 0; x < emitter.length; x++) {
+            const result = emitter[x]?.(...args);
             if (result === true) {
-                cleanup ??= [];
-                cleanup.push(cb);
+                removed = true;
+                emitter[x] = null;
             }
-        });
-        for (let x = 0; cleanup !== undefined && x < cleanup.length; x++)
-            Remove(emitter, cleanup[x]);
+        }
+        if (removed)
+            (0, array_1.RemoveNulls)(emitter);
     }
     Emitter.Emit = Emit;
     function Remove(emitter, callback) {
-        emitter.delete(callback);
+        const index = emitter.indexOf(callback);
+        if (index >= 0) {
+            emitter[index] = null;
+            (0, array_1.RemoveNulls)(emitter, index);
+        }
     }
     Emitter.Remove = Remove;
+    function Clear(emitter) {
+        emitter.splice(0);
+    }
+    Emitter.Clear = Clear;
 })(Emitter || (exports.Emitter = Emitter = {}));

package/Utils/json.d.ts

@@ -2,6 +2,11 @@ export type JsonDiffResult<T = unknown> = {
     path: (string | number)[];
     value: unknown;
 }[];
-export declare function JsonType(value: any): "value" | "array" | "object";
-export declare function JsonDeepClone<T>(value: T): T;
-export declare function JsonDiff<T>(newValue: T, oldValue: T): JsonDiffResult<T>;
+export type JsonDiffFactoryResult = ReturnType<typeof JsonDiffFactory>;
+export declare function ApplyDiff(root: any, diffResult: JsonDiffResult): void;
+export declare function JsonDiffFactory(): {
+    JsonType: (value: any) => "value" | "array" | "object";
+    JsonDiff: <T>(newValue: T, oldValue: T, rootPath?: string, initResult?: JsonDiffResult<T>) => JsonDiffResult<T>;
+};
+export declare const JsonDiff: <T>(newValue: T, oldValue: T, rootPath?: string, initResult?: JsonDiffResult<T>) => JsonDiffResult<T>;
+export declare const JsonType: (value: any) => "value" | "array" | "object";