j-templates 5.0.53 → 6.0.0

package/Store/Store/storeAsyncWriter.d.ts

@@ -1,15 +0,0 @@
-import { DiffAsync } from "../Diff/diffAsync";
-import { ObservableTree } from "../Tree/observableTree";
-export declare class StoreAsyncWriter {
-    private idFunc;
-    private diffAsync;
-    private observableTree;
-    constructor(idFunc: {
-        (val: any): string;
-    }, diffAsync: DiffAsync, observableTree: ObservableTree);
-    Write<T>(source: T, data: any): Promise<void>;
-    Merge<T>(source: T, data: Partial<T>): Promise<void>;
-    Push<T>(source: Array<T>, data: T): Promise<void>;
-    Splice<T>(source: Array<T>, start: number, deleteCount?: number, ...items: Array<T>): Promise<void>;
-    private ApplyChanges;
-}

package/Store/Store/storeAsyncWriter.js

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StoreAsyncWriter = void 0;
-class StoreAsyncWriter {
-    idFunc;
-    diffAsync;
-    observableTree;
-    constructor(idFunc, diffAsync, observableTree) {
-        this.idFunc = idFunc;
-        this.diffAsync = diffAsync;
-        this.observableTree = observableTree;
-    }
-    async Write(source, data) {
-        let path;
-        if (source) {
-            path = this.observableTree.GetPathOf(source);
-        }
-        else {
-            path = this.idFunc(data);
-            if (!path)
-                throw new Error("data must have an id");
-        }
-        let diff = await this.diffAsync.DiffPath(path, data);
-        this.ApplyChanges(diff);
-    }
-    async Merge(source, data) {
-        const rootPath = this.observableTree.GetPathOf(source);
-        const keys = Object.keys(data);
-        const message = keys.map(key => ({ path: `${rootPath}.${key}`, value: data[key] }));
-        const diff = await this.diffAsync.DiffBatch(message);
-        this.ApplyChanges(diff);
-    }
-    async Push(source, data) {
-        const rootPath = this.observableTree.GetPathOf(source);
-        var lengthPath = `${rootPath}.length`;
-        var length = await this.diffAsync.GetPath(lengthPath);
-        var diff = await this.diffAsync.DiffPath(`${rootPath}.${length}`, data);
-        this.ApplyChanges(diff);
-    }
-    async Splice(source, start, deleteCount, ...items) {
-        var rootPath = this.observableTree.GetPathOf(source);
-        var array = await this.diffAsync.GetPath(rootPath);
-        array = array.slice();
-        array.splice(start, deleteCount, ...items);
-        var diff = await this.diffAsync.DiffPath(rootPath, array);
-        this.ApplyChanges(diff);
-    }
-    ApplyChanges(diff) {
-        this.observableTree.WriteAll(diff);
-    }
-}
-exports.StoreAsyncWriter = StoreAsyncWriter;

package/Store/Store/storeSync.d.ts

@@ -1,15 +0,0 @@
-import { StoreSyncWriter } from "./storeSyncWriter";
-export declare class StoreSync<T> {
-    private diffSync;
-    private observableTree;
-    private storeWriter;
-    private rootScope;
-    get Root(): import("..").ObservableScope<T>;
-    constructor(init?: T);
-    Action(action: {
-        (root: T, writer: StoreSyncWriter): void;
-    }): void;
-    Write(data: T): void;
-    Merge(data: Partial<T>): void;
-    Destroy(): void;
-}

package/Store/Store/storeSync.js

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

package/Store/Store/storeSyncWriter.d.ts

@@ -1,12 +0,0 @@
-import { ObservableTree } from "../Tree/observableTree";
-import { DiffSync } from "../Diff/diffSync";
-export declare class StoreSyncWriter {
-    private diffSync;
-    private observableTree;
-    constructor(diffSync: DiffSync, observableTree: ObservableTree);
-    Write<T>(source: T, data: any): void;
-    Merge<T>(source: T, data: Partial<T>): void;
-    Push<T>(source: Array<T>, data: T): void;
-    Splice<T>(source: Array<T>, start: number, deleteCount?: number, ...items: Array<T>): void;
-    private ApplyChanges;
-}

package/Store/Store/storeSyncWriter.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StoreSyncWriter = void 0;
-class StoreSyncWriter {
-    diffSync;
-    observableTree;
-    constructor(diffSync, observableTree) {
-        this.diffSync = diffSync;
-        this.observableTree = observableTree;
-    }
-    Write(source, data) {
-        var rootPath = source && this.observableTree.GetPathOf(source) || "ROOT";
-        var diff = this.diffSync.DiffPath(rootPath, data);
-        this.ApplyChanges(diff);
-    }
-    Merge(source, data) {
-        var rootPath = this.observableTree.GetPathOf(source);
-        var keys = Object.keys(data);
-        var message = keys.map(key => ({ path: `${rootPath}.${key}`, value: data[key] }));
-        var diff = this.diffSync.DiffBatch(message);
-        this.ApplyChanges(diff);
-    }
-    Push(source, data) {
-        var rootPath = this.observableTree.GetPathOf(source);
-        var length = source.length;
-        this.diffSync.UpdatePath(`${rootPath}.${length}`, data);
-        this.observableTree.Write(`${rootPath}.${length}`, data);
-    }
-    Splice(source, start, deleteCount, ...items) {
-        var rootPath = this.observableTree.GetPathOf(source);
-        var proxy = this.observableTree.Get(rootPath);
-        const array = proxy.toJSON().slice();
-        array.splice(start, deleteCount, ...items);
-        this.diffSync.UpdatePath(rootPath, array);
-        this.observableTree.Write(rootPath, array);
-    }
-    ApplyChanges(diff) {
-        this.observableTree.WriteAll(diff);
-    }
-}
-exports.StoreSyncWriter = StoreSyncWriter;

package/Store/Store/storeWriter.d.ts

@@ -1,9 +0,0 @@
-import { ObservableTree } from "../Tree/observableTree";
-export declare class StoreWriter {
-    private observableTree;
-    constructor(observableTree: ObservableTree);
-    Write<T>(source: T, data: any): void;
-    Merge<T>(source: T, data: Partial<T>): void;
-    Push<T>(source: Array<T>, data: T): void;
-    Splice<T>(source: Array<T>, start: number, deleteCount?: number, ...items: Array<T>): void;
-}

package/Store/Store/storeWriter.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StoreWriter = void 0;
-class StoreWriter {
-    observableTree;
-    constructor(observableTree) {
-        this.observableTree = observableTree;
-    }
-    Write(source, data) {
-        const rootPath = source && this.observableTree.GetPathOf(source) || "ROOT";
-        this.observableTree.Write(rootPath, data);
-    }
-    Merge(source, data) {
-        const rootPath = this.observableTree.GetPathOf(source);
-        for (const key in data)
-            this.observableTree.Write(`${rootPath}.${key}`, data[key]);
-    }
-    Push(source, data) {
-        const rootPath = this.observableTree.GetPathOf(source);
-        this.observableTree.Write(`${rootPath}.${source.length}`, data);
-    }
-    Splice(source, start, deleteCount, ...items) {
-        const json = source.toJSON();
-        const copy = json.slice();
-        copy.splice(start, deleteCount, ...items);
-        const rootPath = this.observableTree.GetPathOf(source);
-        this.observableTree.Write(rootPath, copy);
-    }
-}
-exports.StoreWriter = StoreWriter;

package/Store/Tree/observableComputed.d.ts

@@ -1,4 +0,0 @@
-import { IObservableScope } from "./observableScope";
-export declare namespace ObservableComputed {
-    function Create<T>(compute: () => T): IObservableScope<any>;
-}

package/Store/Tree/observableComputed.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObservableComputed = void 0;
-const json_1 = require("../../Utils/json");
-const list_1 = require("../../Utils/list");
-const observableNode_1 = require("./observableNode");
-const observableScope_1 = require("./observableScope");
-const scheduleNodes = new Set();
-const computedQueue = list_1.List.Create();
-function updateNode({ node, scope }) {
-    const value = observableScope_1.ObservableScope.Value(scope);
-    node.data = (0, json_1.JsonDeepClone)(value);
-}
-let computing = false;
-function scheduleComputed(node, scope) {
-    if (scheduleNodes.has(node))
-        return;
-    scheduleNodes.add(node);
-    list_1.List.Add(computedQueue, { node, scope });
-    if (!computing) {
-        computing = true;
-        queueMicrotask(function () {
-            computing = false;
-            scheduleNodes.clear();
-            list_1.List.ForEach(computedQueue, updateNode);
-            list_1.List.Clear(computedQueue);
-        });
-    }
-}
-function CreateComputed(compute) {
-    const scope = observableScope_1.ObservableScope.Create(compute);
-    const node = observableNode_1.ObservableNode.Create({ data: null });
-    observableScope_1.ObservableScope.Watch(scope, function (scope) {
-        scheduleComputed(node, scope);
-    });
-    node.data = observableScope_1.ObservableScope.Value(scope);
-    return observableScope_1.ObservableScope.Create(function () { return node.data; }, [scope]);
-}
-var ObservableComputed;
-(function (ObservableComputed) {
-    function Create(compute) {
-        return CreateComputed(compute);
-    }
-    ObservableComputed.Create = Create;
-})(ObservableComputed || (exports.ObservableComputed = ObservableComputed = {}));

package/Store/Tree/observableNode.d.ts

@@ -1,3 +1,5 @@
 export declare namespace ObservableNode {
     function Create<T>(value: T): T;
+    function EnableDiff(value: boolean): void;
+    function CreateFactory(alias?: (value: any) => any | undefined): <T>(value: T) => T;
 }

package/Store/Tree/observableNode.js

@@ -3,20 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObservableNode = void 0;
 const json_1 = require("../../Utils/json");
 const observableScope_1 = require("./observableScope");
+const IS_OBSERVABLE_NODE = "____observableNode";
 const proxyCache = new WeakMap();
 const scopeCache = new WeakMap();
 function getOwnPropertyDescriptor(target, prop) {
     const descriptor = Object.getOwnPropertyDescriptor(target, prop);
     return {
         ...descriptor,
-        configurable: true
+        configurable: true,
     };
 }
 function getOwnPropertyDescriptorArray(target, prop) {
     const descriptor = Object.getOwnPropertyDescriptor(target, prop);
     return {
         ...descriptor,
-        configurable: true
+        configurable: true,
     };
 }
 function has(value, prop) {
@@ -32,164 +33,218 @@ function ownKeysArray(value) {
     return Object.keys(value);
 }
 function UnwrapProxy(value) {
-    if (!value)
+    const type = (0, json_1.JsonType)(value);
+    if (type === "value")
         return value;
-    if (value.toJSON && typeof value.toJSON === 'function')
+    if (value[IS_OBSERVABLE_NODE] === true)
         return value.toJSON();
-    const type = (0, json_1.JsonType)(value);
     switch (type) {
-        case 'object': {
+        case "object": {
             const keys = Object.keys(value);
             for (let x = 0; x < keys.length; x++)
                 value[keys[x]] = UnwrapProxy(value[keys[x]]);
         }
-        case 'array': {
+        case "array": {
             for (let x = 0; x < value.length; x++)
                 value[x] = UnwrapProxy(value[x]);
         }
     }
     return value;
 }
-function CreateArrayProxy(value) {
-    const scope = observableScope_1.ObservableScope.Create(() => value);
-    const proxy = new Proxy(value, {
-        get: ArrayProxyGetter,
-        set: ArrayProxySetter,
-        has: hasArray,
-        ownKeys: ownKeysArray,
-        getOwnPropertyDescriptor: getOwnPropertyDescriptorArray
-    });
-    scopeCache.set(value, scope);
-    proxyCache.set(value, proxy);
-    return proxy;
-}
-function CreateObjectProxy(value) {
-    const scope = observableScope_1.ObservableScope.Create(() => value);
-    const proxy = new Proxy(value, {
-        get: ObjectProxyGetter,
-        set: ObjectProxySetter,
-        has,
-        ownKeys,
-        getOwnPropertyDescriptor
-    });
-    scopeCache.set(value, scope);
-    proxyCache.set(value, proxy);
-    return proxy;
-}
-function ArrayProxySetter(array, prop, value) {
-    value = UnwrapProxy(value);
-    array[prop] = value;
-    const scope = scopeCache.get(array);
-    observableScope_1.ObservableScope.Update(scope);
-    return true;
-}
-function ArrayProxyGetter(array, prop) {
-    const scope = scopeCache.get(array);
-    array = observableScope_1.ObservableScope.Value(scope);
-    switch (prop) {
-        case "toJSON":
-            return function () {
-                return array;
-            };
-        default: {
-            const arrayValue = array[prop];
-            if (typeof prop === 'symbol')
-                return arrayValue;
-            if (typeof arrayValue === 'function')
-                return function ArrayFunction(...args) {
-                    const proxyArray = array.slice();
-                    for (let x = 0; x < proxyArray.length; x++)
-                        proxyArray[x] = proxyCache.get(proxyArray[x]) ?? CreateProxy(proxyArray[x]);
-                    let result = proxyArray[prop](...args);
-                    switch (prop) {
-                        case 'push':
-                        case 'unshift':
-                        case 'splice':
-                        case 'pop':
-                        case 'shift':
-                        case 'sort':
-                        case 'reverse':
-                            array.length = proxyArray.length;
-                            for (let x = 0; x < proxyArray.length; x++)
-                                array[x] = UnwrapProxy(proxyArray[x]);
-                            observableScope_1.ObservableScope.Update(scope);
-                            break;
-                    }
-                    return result;
-                };
-            const proxy = CreateProxy(arrayValue);
-            return proxy;
+let applyingDiff = false;
+function CreateProxyFactory(alias) {
+    function ToJsonCopy(value) {
+        const type = (0, json_1.JsonType)(value);
+        switch (type) {
+            case "array": {
+                const typedValue = value;
+                return typedValue.map(ToJsonCopy);
+                break;
+            }
+            case "object": {
+                const typedValue = alias(value) ?? value;
+                const keys = Object.keys(typedValue);
+                const copy = {};
+                for (let x = 0; x < keys.length; x++)
+                    copy[keys[x]] = ToJsonCopy(typedValue[keys[x]]);
+                return copy;
+            }
+            default:
+                return value;
         }
     }
-}
-let applyingDiff = false;
-function ObjectProxySetter(object, prop, value) {
-    const scope = scopeCache.get(object);
-    value = UnwrapProxy(value);
-    if (applyingDiff) {
-        object[prop] = value;
+    function ToJsonDefault(value) {
+        return value;
+    }
+    const ToJson = alias !== undefined ? ToJsonCopy : ToJsonDefault;
+    function CreateArrayProxy(value) {
+        const scope = observableScope_1.ObservableScope.Create(() => value);
+        const proxy = new Proxy(value, {
+            get: ArrayProxyGetter,
+            set: ArrayProxySetter,
+            has: hasArray,
+            ownKeys: ownKeysArray,
+            getOwnPropertyDescriptor: getOwnPropertyDescriptorArray,
+        });
+        scopeCache.set(value, scope);
+        proxyCache.set(value, proxy);
+        return proxy;
+    }
+    function CreateObjectProxy(value) {
+        const scope = observableScope_1.ObservableScope.Create(() => value);
+        const proxy = new Proxy(value, {
+            get: ObjectProxyGetter,
+            set: ObjectProxySetter,
+            has,
+            ownKeys,
+            getOwnPropertyDescriptor,
+        });
+        scopeCache.set(value, scope);
+        proxyCache.set(value, proxy);
+        return proxy;
+    }
+    function ArrayProxySetter(array, prop, value) {
+        if (prop === IS_OBSERVABLE_NODE)
+            throw `Cannot assign read-only property: ${IS_OBSERVABLE_NODE}`;
+        value = UnwrapProxy(value);
+        array[prop] = value;
+        const scope = scopeCache.get(array);
         observableScope_1.ObservableScope.Update(scope);
+        return true;
     }
-    else {
-        applyingDiff = true;
-        const proxy = proxyCache.get(object);
-        const json = proxy.toJSON();
-        const diff = (0, json_1.JsonDiff)(value, json[prop]);
-        for (let x = 0; x < diff.length; x++) {
-            if (diff[x].path.length === 0) {
-                proxy[prop] = diff[x].value;
-            }
-            else {
-                const path = diff[x].path;
-                let curr = proxy[prop];
-                let y = 0;
-                for (; y < path.length - 1; y++)
-                    curr = curr[path[y]];
-                curr[path[y]] = diff[x].value;
+    function ArrayProxyGetter(array, prop) {
+        if (prop === IS_OBSERVABLE_NODE)
+            return true;
+        const scope = scopeCache.get(array);
+        array = observableScope_1.ObservableScope.Value(scope);
+        switch (prop) {
+            case "toJSON":
+                return function () {
+                    return ToJson(array);
+                };
+            default: {
+                const arrayValue = array[prop];
+                if (typeof prop === "symbol")
+                    return arrayValue;
+                if (typeof arrayValue === "function")
+                    return function ArrayFunction(...args) {
+                        const proxyArray = array.slice();
+                        for (let x = 0; x < proxyArray.length; x++)
+                            proxyArray[x] =
+                                proxyCache.get(proxyArray[x]) ??
+                                    CreateProxyFromValue(proxyArray[x]);
+                        let result = proxyArray[prop](...args);
+                        switch (prop) {
+                            case "push":
+                            case "unshift":
+                            case "splice":
+                            case "pop":
+                            case "shift":
+                            case "sort":
+                            case "reverse":
+                                array.length = proxyArray.length;
+                                for (let x = 0; x < proxyArray.length; x++)
+                                    array[x] = UnwrapProxy(proxyArray[x]);
+                                observableScope_1.ObservableScope.Update(scope);
+                                break;
+                        }
+                        return result;
+                    };
+                const proxy = CreateProxyFromValue(arrayValue);
+                return proxy;
             }
         }
-        applyingDiff = false;
     }
-    return true;
-}
-function ObjectProxyGetter(object, prop) {
-    const scope = scopeCache.get(object);
-    object = observableScope_1.ObservableScope.Value(scope);
-    switch (prop) {
-        case "toJSON":
-            return function () {
-                return object;
-            };
-        default: {
-            const proxyValue = object[prop];
-            if (typeof prop === 'symbol')
-                return proxyValue;
-            const proxy = CreateProxy(proxyValue);
-            return proxy;
+    function ObjectProxySetter(object, prop, value) {
+        if (prop === IS_OBSERVABLE_NODE)
+            throw `Cannot assign read-only property: ${IS_OBSERVABLE_NODE}`;
+        const scope = scopeCache.get(object);
+        value = UnwrapProxy(value);
+        if (applyingDiff) {
+            object[prop] = value;
+            observableScope_1.ObservableScope.Update(scope);
         }
+        else {
+            applyingDiff = true;
+            const diff = (0, json_1.JsonDiff)(value, object[prop]);
+            for (let x = 0; x < diff.length; x++) {
+                if (diff[x].path.length === 0) {
+                    const proxy = proxyCache.get(object);
+                    proxy[prop] = diff[x].value;
+                }
+                else {
+                    const path = diff[x].path;
+                    let curr = object[prop];
+                    let y = 0;
+                    for (; y < path.length - 1; y++)
+                        curr = curr[path[y]];
+                    const target = proxyCache.get(curr) ?? curr;
+                    target[path[y]] = diff[x].value;
+                }
+            }
+            applyingDiff = false;
+        }
+        return true;
     }
-}
-function CreateProxy(value) {
-    const type = (0, json_1.JsonType)(value);
-    switch (type) {
-        case 'object': {
-            const proxy = proxyCache.get(value) ?? CreateObjectProxy(value);
-            return proxy;
+    function ObjectProxyGetter(object, prop) {
+        if (prop === IS_OBSERVABLE_NODE)
+            return true;
+        const scope = scopeCache.get(object);
+        object = observableScope_1.ObservableScope.Value(scope);
+        switch (prop) {
+            case "toJSON":
+                return function () {
+                    return ToJson(object);
+                };
+            default: {
+                const proxyValue = object[prop];
+                if (typeof prop === "symbol")
+                    return proxyValue;
+                const proxy = CreateProxyFromValue(proxyValue);
+                return proxy;
+            }
         }
-        case 'array': {
-            const proxy = proxyCache.get(value) ?? CreateArrayProxy(value);
-            observableScope_1.ObservableScope.Touch(scopeCache.get(value));
-            return proxy;
+    }
+    function CreateProxyFromValue(value) {
+        const type = (0, json_1.JsonType)(value);
+        switch (type) {
+            case "object": {
+                let proxy = proxyCache.get(value) ?? CreateObjectProxy(value);
+                if (alias !== undefined) {
+                    const aliasValue = alias(proxy);
+                    if (aliasValue !== undefined)
+                        proxy = proxyCache.get(aliasValue) ?? CreateObjectProxy(aliasValue);
+                }
+                return proxy;
+            }
+            case "array": {
+                const proxy = proxyCache.get(value) ?? CreateArrayProxy(value);
+                observableScope_1.ObservableScope.Touch(scopeCache.get(value));
+                return proxy;
+            }
+            default:
+                return value;
         }
-        default:
-            return value;
     }
+    function CreateProxy(value) {
+        value = UnwrapProxy(value);
+        return CreateProxyFromValue(value);
+    }
+    return CreateProxy;
 }
+const DefaultCreateProxy = CreateProxyFactory();
 var ObservableNode;
 (function (ObservableNode) {
     function Create(value) {
-        value = UnwrapProxy(value);
-        return CreateProxy(value);
+        return DefaultCreateProxy(value);
     }
     ObservableNode.Create = Create;
+    function EnableDiff(value) {
+        applyingDiff = value;
+    }
+    ObservableNode.EnableDiff = EnableDiff;
+    function CreateFactory(alias) {
+        return CreateProxyFactory(alias);
+    }
+    ObservableNode.CreateFactory = CreateFactory;
 })(ObservableNode || (exports.ObservableNode = ObservableNode = {}));