j-templates 5.0.51 → 5.0.52

package/Store/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObservableScope = exports.StoreAsync = exports.StoreSync = exports.Store = void 0;
+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");
@@ -9,3 +9,7 @@ var storeAsync_1 = require("./Store/storeAsync");
 Object.defineProperty(exports, "StoreAsync", { enumerable: true, get: function () { return storeAsync_1.StoreAsync; } });
 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/decorators.d.ts

@@ -22,7 +22,9 @@ export declare namespace Destroy {
 declare function DestroyDecorator<T extends Component<any, any, any> & Record<K, IDestroyable>, K extends string>(target: T, propertyKey: K): any;
 export declare function PreReqTemplate(template: {
     (): NodeRefTypes | NodeRefTypes[];
-}): <T extends Component<any, any, any>>(target: new (...args: Array<any>) => T) => any;
+}): <T extends Component<any, any, any>>(target: {
+    new (...args: Array<any>): T;
+}) => any;
 export declare namespace PreReqTemplate {
     function Get(value: any): NodeRefTypes[];
 }

package/Utils/decorators.js

@@ -1,70 +1,75 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PreReq = exports.PreReqTemplate = exports.Destroy = exports.Inject = exports.ComputedAsync = exports.Computed = exports.DestroyScope = exports.Scope = exports.StateAsync = exports.StateSync = exports.State = void 0;
-const store_1 = require("../Store/Store/store");
+exports.State = State;
+exports.StateSync = StateSync;
+exports.StateAsync = StateAsync;
+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");
 function State() {
     return StateDecorator;
 }
-exports.State = State;
 function StateDecorator(target, propertyKey) {
     const propKey = `StoreDecorator_${propertyKey}`;
-    DestroyDecorator(target, propKey);
     return {
         configurable: false,
         enumerable: true,
         get: function () {
-            var map = this.DecoratorMap;
-            var store = map.get(propKey);
-            const value = store && store.Root.Value;
-            if (observableScope_1.ObservableScope.Watching())
-                return value;
-            return observableTree_1.ObservableTree.UnwrapProxyValues(value);
+            const map = this.DecoratorMap;
+            const node = map.get(propKey);
+            return node;
         },
         set: function (val) {
-            var map = this.DecoratorMap;
-            var store = map.get(propKey);
-            if (!store)
-                map.set(propKey, new store_1.Store(val));
-            else
-                store.Merge(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]];
+            }
         }
     };
 }
 function StateSync() {
     return StateSyncDecorator;
 }
-exports.StateSync = StateSync;
 function StateSyncDecorator(target, propertyKey) {
     const propKey = `StoreSyncDecorator_${propertyKey}`;
-    DestroyDecorator(target, propKey);
     return {
         configurable: false,
         enumerable: true,
         get: function () {
-            var map = this.DecoratorMap;
-            var store = map.get(propKey);
-            const value = store && store.Root.Value;
-            if (observableScope_1.ObservableScope.Watching())
-                return value;
-            return observableTree_1.ObservableTree.UnwrapProxyValues(value);
+            const map = this.DecoratorMap;
+            const node = map.get(propKey);
+            return node;
         },
         set: function (val) {
-            var map = this.DecoratorMap;
-            var store = map.get(propKey);
-            if (!store)
-                map.set(propKey, new Store_1.StoreSync(val));
-            else
-                store.Merge(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]];
+            }
         }
     };
 }
 function StateAsync() {
     return StateAsyncDecorator;
 }
-exports.StateAsync = StateAsync;
 function StateAsyncDecorator(target, propertyKey) {
     const propKey = `StoreAsyncDecorator_${propertyKey}`;
     const scopeKey = `StoreAsyncDecorator_Scope_${propertyKey}`;
@@ -97,7 +102,6 @@ function StateAsyncDecorator(target, propertyKey) {
 function Scope() {
     return ScopeDecorator;
 }
-exports.Scope = Scope;
 function ScopeDecorator(target, propertyKey, descriptor) {
     if (!(descriptor && descriptor.get))
         throw "Scope decorator requires a getter";
@@ -123,7 +127,6 @@ function ScopeDecorator(target, propertyKey, descriptor) {
 function DestroyScope() {
     return DestroyScopeDecorator;
 }
-exports.DestroyScope = DestroyScope;
 function DestroyScopeDecorator(target, propertyKey, descriptor) {
     if (!(descriptor && descriptor.get))
         throw "Destroy Scope decorator requires a getter";
@@ -156,7 +159,6 @@ function DestroyScopeDecorator(target, propertyKey, descriptor) {
 function Computed() {
     return ComputedDecorator;
 }
-exports.Computed = Computed;
 function ComputedDecorator(target, propertyKey, descriptor) {
     if (!(descriptor && descriptor.get))
         throw "Computed decorator requires a getter";
@@ -190,7 +192,6 @@ function ComputedDecorator(target, propertyKey, descriptor) {
 function ComputedAsync(idFunc) {
     return ComputedAsyncDecorator.bind(null, idFunc);
 }
-exports.ComputedAsync = ComputedAsync;
 function ComputedAsyncDecorator(idFunc, target, propertyKey, descriptor) {
     if (!(descriptor && descriptor.get))
         throw "ComputedAsync decorator requires a getter";
@@ -233,7 +234,6 @@ function ComputedAsyncDecorator(idFunc, target, propertyKey, descriptor) {
 function Inject(type) {
     return InjectorDecorator.bind(null, type);
 }
-exports.Inject = Inject;
 function InjectorDecorator(type, target, propertyKey, descriptor) {
     return {
         configurable: false,
@@ -249,7 +249,6 @@ function InjectorDecorator(type, target, propertyKey, descriptor) {
 function Destroy() {
     return DestroyDecorator;
 }
-exports.Destroy = Destroy;
 (function (Destroy) {
     function Get(value) {
         return value && value.DestroyDecorator_Destroys || [];
@@ -270,7 +269,6 @@ function DestroyDecorator(target, propertyKey) {
 function PreReqTemplate(template) {
     return PreReqTemplateDecorator.bind(null, template);
 }
-exports.PreReqTemplate = PreReqTemplate;
 (function (PreReqTemplate) {
     function Get(value) {
         var func = value && value.PreReqTemplateDecorator_Template;
@@ -288,7 +286,6 @@ function PreReqTemplateDecorator(template, target) {
 function PreReq() {
     return PreReqDecorator;
 }
-exports.PreReq = PreReq;
 (function (PreReq) {
     function Get(value) {
         return value && value.PreReqDecorator_PreReqs || [];

package/Utils/emitter.d.ts

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

package/Utils/emitter.js

@@ -12,9 +12,16 @@ var Emitter;
     }
     Emitter.On = On;
     function Emit(emitter, ...args) {
+        let cleanup;
         emitter.forEach(function (cb) {
-            cb(...args);
+            const result = cb(...args);
+            if (result === true) {
+                cleanup ??= [];
+                cleanup.push(cb);
+            }
         });
+        for (let x = 0; cleanup !== undefined && x < cleanup.length; x++)
+            Remove(emitter, cleanup[x]);
     }
     Emitter.Emit = Emit;
     function Remove(emitter, callback) {

package/Utils/json.d.ts

@@ -0,0 +1,7 @@
+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>;

package/Utils/json.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonType = JsonType;
+exports.JsonDeepClone = JsonDeepClone;
+exports.JsonDiff = JsonDiff;
+const jsonProto = Object.getPrototypeOf({});
+function JsonType(value) {
+    if (value === null || value === undefined)
+        return 'value';
+    if (Array.isArray(value))
+        return 'array';
+    if (jsonProto === Object.getPrototypeOf(value))
+        return 'object';
+    return 'value';
+}
+function JsonDeepClone(value) {
+    const type = JsonType(value);
+    switch (type) {
+        case 'array':
+            return value.map(JsonDeepClone);
+        case 'object': {
+            const ret = {};
+            const keys = Object.keys(value);
+            for (let x = 0; x < keys.length; x++)
+                ret[keys[x]] = JsonDeepClone(value[keys[x]]);
+            return ret;
+        }
+        default:
+            return value;
+    }
+}
+function JsonDiff(newValue, oldValue) {
+    const result = [];
+    JsonDiffRecursive([], newValue, oldValue, result);
+    return result;
+}
+function JsonDiffRecursive(path, newValue, oldValue, resp) {
+    if (newValue === oldValue)
+        return false;
+    const newType = JsonType(newValue);
+    const oldType = JsonType(oldValue);
+    const changedPathLength = resp.length;
+    let allChildrenChanged = true;
+    if (newType === oldType)
+        switch (newType) {
+            case 'array': {
+                allChildrenChanged = JsonDiffArrays(path, newValue, oldValue, resp);
+                break;
+            }
+            case 'object': {
+                allChildrenChanged = JsonDiffObjects(path, newValue, oldValue, resp);
+                break;
+            }
+        }
+    if (allChildrenChanged) {
+        resp.splice(changedPathLength);
+        resp.push({
+            path,
+            value: newValue
+        });
+        return true;
+    }
+    return false;
+}
+function JsonDiffArrays(path, newValue, oldValue, resp) {
+    let allChildrenChanged = true;
+    if (newValue.length !== oldValue.length)
+        resp.push({
+            path: path.concat('length'),
+            value: newValue.length
+        });
+    if (newValue.length > 0 || oldValue.length > 0) {
+        for (let y = 0; y < newValue.length; y++) {
+            const arrayPath = path.concat(y);
+            const oldValueElem = oldValue[y];
+            allChildrenChanged = JsonDiffRecursive(arrayPath, newValue[y], oldValueElem, resp) && allChildrenChanged;
+        }
+    }
+    else
+        allChildrenChanged = false;
+    return allChildrenChanged;
+}
+function JsonDiffObjects(path, newValue, oldValue, resp) {
+    const newKeys = Object.keys(newValue).sort();
+    const oldKeys = Object.keys(oldValue).sort();
+    if (newKeys.length === 0 && oldKeys.length === 0)
+        return false;
+    if (newKeys.length < oldKeys.length)
+        return true;
+    let newKeyIndex = 0;
+    let oldKeyIndex = 0;
+    while (newKeyIndex < newKeys.length) {
+        const childPath = path.concat(newKeys[newKeyIndex]);
+        if (oldKeyIndex < oldKeys.length && newKeys[newKeyIndex] === oldKeys[oldKeyIndex]) {
+            JsonDiffRecursive(childPath, newValue[newKeys[newKeyIndex]], oldValue[oldKeys[oldKeyIndex]], resp);
+            oldKeyIndex++;
+        }
+        else if (newValue[newKeys[newKeyIndex]] !== undefined) {
+            resp.push({
+                path: childPath,
+                value: newValue[newKeys[newKeyIndex]]
+            });
+        }
+        newKeyIndex++;
+    }
+    if (oldKeyIndex < oldKeys.length)
+        return true;
+    return false;
+}

package/Utils/list.js

@@ -18,7 +18,7 @@ var List;
     }
     List.Clear = Clear;
     function Push(list, data) {
-        var node = { previous: null, next: null, data: data };
+        const node = { previous: null, next: null, data: data };
         if (list.size === 0) {
             list.head = node;
             list.tail = node;
@@ -36,7 +36,7 @@ var List;
     function Pop(list) {
         if (list.size === 0)
             return null;
-        var node = list.head;
+        const node = list.head;
         list.head = node.next;
         if (list.head)
             list.head.previous = null;
@@ -69,8 +69,8 @@ var List;
     function AddBefore(list, node, data) {
         if (!node)
             return List.Add(list, data);
-        var newNode = { previous: null, next: null, data: data };
-        var prevNode = node.previous;
+        const newNode = { previous: null, next: null, data: data };
+        const prevNode = node.previous;
         newNode.next = node;
         node.previous = newNode;
         if (list.head === node)
@@ -86,8 +86,8 @@ var List;
     function AddAfter(list, node, data) {
         if (!node)
             return List.Push(list, data);
-        var newNode = { previous: null, next: null, data: data };
-        var nextNode = node.next;
+        const newNode = { previous: null, next: null, data: data };
+        const nextNode = node.next;
         node.next = newNode;
         newNode.previous = node;
         if (list.tail === node)
@@ -133,7 +133,7 @@ var List;
     }
     List.RemoveNode = RemoveNode;
     function ForEach(list, callback) {
-        var node = list.head;
+        let node = list.head;
         while (node) {
             callback(node.data);
             node = node.next;

package/Utils/thread.d.ts

@@ -1,16 +1,10 @@
-export declare function Schedule(callback: {
-    (): void;
-}): void;
-export declare function After(callback: {
-    (): void;
-}): void;
+type ThreadCallback = {
+    (async: boolean): void;
+};
+export declare function Schedule(callback: ThreadCallback): void;
+export declare function After(callback: ThreadCallback): void;
 export declare function Callback<A = void, B = void, C = void, D = void>(callback: (a: A, b: B, c: C, d: D) => void): (a?: A, b?: B, c?: C, d?: D) => void;
-export declare function Synch(callback: {
-    (): void;
-}): void;
-export declare function Thread(callback: {
-    (): void;
-}): void;
-export declare function ThreadAsync(callback: {
-    (): void;
-}): Promise<void>;
+export declare function Synch(callback: ThreadCallback): void;
+export declare function Thread(callback: ThreadCallback): void;
+export declare function ThreadAsync(callback: ThreadCallback): Promise<boolean>;
+export {};

package/Utils/thread.js

@@ -1,18 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ThreadAsync = exports.Thread = exports.Synch = exports.Callback = exports.After = exports.Schedule = void 0;
+exports.Schedule = Schedule;
+exports.After = After;
+exports.Callback = Callback;
+exports.Synch = Synch;
+exports.Thread = Thread;
+exports.ThreadAsync = ThreadAsync;
 const list_1 = require("./list");
 const workTimeMs = 16;
 const contextQueue = list_1.List.Create();
-var threadContext = null;
-var timeoutRunning = false;
-function ProcessQueue() {
-    var workEndTime = Date.now() + workTimeMs;
-    var ctx;
-    while (Date.now() < workEndTime && (ctx = list_1.List.Pop(contextQueue)))
-        DoWork(ctx, workEndTime);
+let threadContext = null;
+let timeoutRunning = false;
+const scheduleCallback = setTimeout;
+function timeRemaining() {
+    return this.end - Date.now();
+}
+function createDeadline() {
+    return {
+        end: Date.now() + workTimeMs,
+        timeRemaining
+    };
+}
+function ProcessQueue(deadline = createDeadline()) {
+    let ctx;
+    while (deadline.timeRemaining() > 0 && (ctx = list_1.List.Pop(contextQueue)))
+        DoWork(ctx, deadline);
     if (contextQueue.size > 0)
-        setTimeout(ProcessQueue);
+        scheduleCallback(ProcessQueue);
     else
         timeoutRunning = false;
 }
@@ -21,20 +35,20 @@ function ScheduleWork(ctx) {
     if (timeoutRunning)
         return;
     timeoutRunning = true;
-    setTimeout(ProcessQueue);
+    scheduleCallback(ProcessQueue);
 }
 function Invoke(ctx, callback) {
-    var parent = ctx.workEndNode;
+    const parent = ctx.workEndNode;
     ctx.workEndNode = ctx.workList.head;
-    callback();
+    callback(true);
     ctx.workEndNode = parent;
 }
-function DoWork(ctx, workEndTime = Date.now() + workTimeMs) {
-    var parentContext = threadContext;
+function DoWork(ctx, deadline = createDeadline()) {
+    const parentContext = threadContext;
     threadContext = ctx;
-    var async = ctx.async;
-    var callback;
-    while (async === ctx.async && Date.now() < workEndTime && (callback = list_1.List.Pop(ctx.workList)))
+    const async = ctx.async;
+    let callback;
+    while (async === ctx.async && deadline.timeRemaining() > 0 && (callback = list_1.List.Pop(ctx.workList)))
         Invoke(ctx, callback);
     if (ctx.workList.size > 0)
         ScheduleWork(ctx);
@@ -58,51 +72,44 @@ function ScheduleCallback(callback, before, async) {
         threadContext.workEndNode = list_1.List.Add(threadContext.workList, callback);
 }
 function SynchWithoutThread(callback) {
-    var workEndTime = Date.now() + workTimeMs;
-    callback();
+    callback(false);
     if (threadContext)
         if (threadContext.async)
             ScheduleWork(threadContext);
         else
-            DoWork(threadContext, workEndTime);
+            DoWork(threadContext);
     threadContext = null;
 }
 function Schedule(callback) {
     ScheduleCallback(callback, true, true);
 }
-exports.Schedule = Schedule;
 function After(callback) {
     ScheduleCallback(callback, false, false);
 }
-exports.After = After;
 function Callback(callback) {
     return function (a, b, c, d) {
         Schedule(function () { callback(a, b, c, d); });
     };
 }
-exports.Callback = Callback;
 var inSynchCallback = false;
 function Synch(callback) {
     if (threadContext || inSynchCallback)
-        callback();
+        callback(false);
     else {
         inSynchCallback = true;
         SynchWithoutThread(callback);
         inSynchCallback = false;
     }
 }
-exports.Synch = Synch;
 function Thread(callback) {
     if (threadContext)
         ScheduleCallback(callback, true, false);
     else
         Synch(callback);
 }
-exports.Thread = Thread;
 function ThreadAsync(callback) {
-    return new Promise(resolve => Thread(function () {
-        callback();
+    return new Promise(resolve => Thread(function (async) {
+        callback(async);
         Thread(resolve);
     }));
 }
-exports.ThreadAsync = ThreadAsync;