j-templates 5.0.37 → 5.0.38

package/Store/Tree/observableNode.d.ts

@@ -1,32 +0,0 @@
-import { ObservableTree } from "./observableTree";
-import { Type } from "./observableProxy";
-export declare class ObservableNode {
-    private tree;
-    private key;
-    private parent;
-    private valuePathResolver;
-    private destroyed;
-    private children;
-    private path;
-    private scope;
-    private arrayScope;
-    get Key(): string;
-    get Path(): string;
-    get Value(): any;
-    get Type(): Type;
-    get Self(): ObservableNode;
-    get Proxy(): any;
-    get ProxyArray(): any[];
-    get Parent(): ObservableNode;
-    get Children(): Map<string, ObservableNode>;
-    constructor(tree: ObservableTree, key: string, parent: ObservableNode, valuePathResolver: {
-        (value: string): string;
-    });
-    UpdateKey(newKey: string): void;
-    EnsureChild(key: string): ObservableNode;
-    Update(): void;
-    ArrayUpdate(): void;
-    Destroy(): void;
-    Push(data: any): number;
-    Splice(start: number, deleteCount?: number, ...items: Array<any>): any[];
-}

package/Store/Tree/observableNode.js

@@ -1,148 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const observableProxy_1 = require("./observableProxy");
-const observableScope_1 = require("./observableScope");
-class ObservableNode {
-    constructor(tree, key, parent, valuePathResolver) {
-        this.tree = tree;
-        this.key = key;
-        this.parent = parent;
-        this.valuePathResolver = valuePathResolver;
-        this.destroyed = false;
-        this.children = new Map();
-        this.path = undefined;
-        this.scope = observableScope_1.ObservableScope.Create(() => {
-            var value = this.tree.Get(this.Path);
-            var type = observableProxy_1.ObservableProxy.TypeOf(value);
-            var resolvedPath = this.valuePathResolver && type === observableProxy_1.Type.Value && typeof value === 'string' ? this.valuePathResolver(value) || this.Path : this.Path;
-            var self = this.Path === resolvedPath ? this : this.tree.GetNode(resolvedPath);
-            var proxy = this === self ?
-                type === observableProxy_1.Type.Value ?
-                    value :
-                    observableProxy_1.ObservableProxy.CreateFrom(this, type) :
-                self.Proxy;
-            return {
-                value: value,
-                type: observableProxy_1.ObservableProxy.TypeOf(value),
-                self: self,
-                proxy: proxy
-            };
-        });
-    }
-    get Key() {
-        return this.key;
-    }
-    get Path() {
-        if (this.path === undefined)
-            this.path = (this.parent ? this.parent.Path + "." : "") + this.key;
-        return this.path;
-    }
-    get Value() {
-        return observableScope_1.ObservableScope.Value(this.scope).value;
-    }
-    get Type() {
-        return observableScope_1.ObservableScope.Value(this.scope).type;
-    }
-    get Self() {
-        return observableScope_1.ObservableScope.Value(this.scope).self;
-    }
-    get Proxy() {
-        return observableScope_1.ObservableScope.Value(this.scope).proxy;
-    }
-    get ProxyArray() {
-        if (this.Type !== observableProxy_1.Type.Array) {
-            this.arrayScope && this.arrayScope.Destroy();
-            this.arrayScope = null;
-            return null;
-        }
-        this.arrayScope = this.arrayScope || observableScope_1.ObservableScope.Create(() => this.Value.map((c, i) => this.EnsureChild(i.toString()).Proxy));
-        return observableScope_1.ObservableScope.Value(this.arrayScope);
-    }
-    get Parent() {
-        return this.parent;
-    }
-    get Children() {
-        return this.children;
-    }
-    UpdateKey(newKey) {
-        if (!this.parent)
-            return;
-        this.parent.children.delete(this.key);
-        this.parent.children.set(newKey, this);
-        this.key = newKey;
-        this.path = undefined;
-    }
-    EnsureChild(key) {
-        var child = this.children.get(key);
-        if (!child) {
-            child = new ObservableNode(this.tree, key, this, this.valuePathResolver);
-            this.children.set(key, child);
-        }
-        return child;
-    }
-    Update() {
-        this.children.clear();
-        observableScope_1.ObservableScope.Update(this.scope);
-    }
-    ArrayUpdate() {
-        observableScope_1.ObservableScope.Update(this.arrayScope);
-        var lengthNode = this.children.get('length');
-        if (lengthNode)
-            lengthNode.Update();
-        observableScope_1.ObservableScope.Emit(this.scope);
-    }
-    Destroy() {
-        this.destroyed = true;
-        this.parent && !this.parent.destroyed && this.parent.Children.delete(this.key);
-        this.children.forEach(c => c.Destroy());
-        observableScope_1.ObservableScope.Destroy(this.scope);
-        observableScope_1.ObservableScope.Destroy(this.arrayScope);
-    }
-    Push(data) {
-        var array = this.Value;
-        if (!Array.isArray(array))
-            throw new Error("Node value is not an array.");
-        var ret = array.push(data);
-        this.ArrayUpdate();
-        return ret;
-    }
-    Splice(start, deleteCount, ...items) {
-        deleteCount = deleteCount || 0;
-        var array = this.Value;
-        if (!Array.isArray(array))
-            throw new Error("Node value is not an array.");
-        var startLength = array.length;
-        var ret = array.splice(start, deleteCount, ...items);
-        var x = start;
-        var key = null;
-        var newKey = null;
-        var child = null;
-        for (; x < (start + deleteCount); x++) {
-            key = x.toString();
-            child = this.Children.get(key);
-            if (child)
-                child.Destroy();
-        }
-        if (startLength < array.length)
-            for (var y = startLength - 1; y >= x; y--) {
-                key = y.toString();
-                child = this.Children.get(key);
-                if (child) {
-                    newKey = (y - deleteCount + items.length).toString();
-                    child.UpdateKey(newKey);
-                }
-            }
-        else
-            for (; x < startLength; x++) {
-                key = x.toString();
-                child = this.Children.get(key);
-                if (child) {
-                    newKey = (x - deleteCount + items.length).toString();
-                    child.UpdateKey(newKey);
-                }
-            }
-        this.ArrayUpdate();
-        return ret;
-    }
-}
-exports.ObservableNode = ObservableNode;

package/Store/Tree/observableProxy.d.ts

@@ -1,17 +0,0 @@
-import { ObservableNode } from "./observableNode";
-export declare enum Type {
-    Value = 0,
-    Object = 1,
-    Array = 2
-}
-export interface ObservableProxy {
-    ___storeProxy: boolean;
-    ___type: Type;
-    ___node: ObservableNode;
-    toJSON(): any;
-}
-export declare namespace ObservableProxy {
-    function TypeOf(value: any): Type;
-    function CreateFrom(node: ObservableNode, type: Type): any;
-    function CopyValue<T>(value: T): T;
-}

package/Store/Tree/observableProxy.js

@@ -1,119 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var Type;
-(function (Type) {
-    Type[Type["Value"] = 0] = "Value";
-    Type[Type["Object"] = 1] = "Object";
-    Type[Type["Array"] = 2] = "Array";
-})(Type = exports.Type || (exports.Type = {}));
-var ObservableProxy;
-(function (ObservableProxy) {
-    function TypeOf(value) {
-        if (!value)
-            return Type.Value;
-        if (Array.isArray(value))
-            return Type.Array;
-        else if (typeof value === 'object')
-            return Type.Object;
-        return Type.Value;
-    }
-    ObservableProxy.TypeOf = TypeOf;
-    function CreateFrom(node, type) {
-        switch (type) {
-            case Type.Array:
-                return CreateArrayProxy(node);
-            case Type.Object:
-                return CreateObjectProxy(node);
-            default:
-                throw new Error("Can't create proxy from Value type");
-        }
-    }
-    ObservableProxy.CreateFrom = CreateFrom;
-    function CopyValue(value) {
-        var type = TypeOf(value);
-        if (type === Type.Value)
-            return value;
-        if (typeof value.toJSON === 'function')
-            return value.toJSON();
-        if (type === Type.Array)
-            return value.map(v => CopyValue(v));
-        else if (type === Type.Object) {
-            var ret = {};
-            for (var key in value)
-                ret[key] = CopyValue(value[key]);
-            return ret;
-        }
-        return null;
-    }
-    ObservableProxy.CopyValue = CopyValue;
-})(ObservableProxy = exports.ObservableProxy || (exports.ObservableProxy = {}));
-function CreateArrayProxy(node) {
-    return new Proxy([], {
-        get: (obj, prop) => {
-            switch (prop) {
-                case '___type':
-                    return Type.Array;
-                case '___storeProxy':
-                    return true;
-                case '___node':
-                    return node;
-                case 'toJSON':
-                    return () => {
-                        return CopyNode(node);
-                    };
-                case 'length':
-                    return node.EnsureChild(prop).Value;
-                default:
-                    if (typeof (prop) === 'symbol')
-                        return node.ProxyArray[prop];
-                    if (!isNaN(parseInt(prop)))
-                        return node.EnsureChild(prop).Proxy;
-                    var func = obj[prop];
-                    return func && func.bind(node.ProxyArray);
-            }
-        },
-        ownKeys: () => {
-            return Reflect.ownKeys(node.Value);
-        }
-    });
-}
-function CreateObjectProxy(node) {
-    return new Proxy({}, {
-        get: (obj, prop) => {
-            switch (prop) {
-                case '___type':
-                    return Type.Object;
-                case '___storeProxy':
-                    return true;
-                case '___node':
-                    return node;
-                case 'toJSON':
-                    return () => {
-                        return CopyNode(node);
-                    };
-                default:
-                    if (typeof (prop) !== 'symbol')
-                        return node.EnsureChild(prop).Proxy;
-                    return obj[prop];
-            }
-        },
-        ownKeys: () => {
-            return Reflect.ownKeys(node.Value);
-        }
-    });
-}
-function CopyNode(node) {
-    if (node.Type === Type.Value)
-        return node.Value;
-    var ret = null;
-    if (node.Type === Type.Array)
-        ret = node.Value.map((v, i) => CopyNode(node.Self.EnsureChild(i.toString()).Self));
-    else {
-        ret = {};
-        for (var key in node.Value) {
-            var child = node.Self.EnsureChild(key);
-            ret[key] = CopyNode(child.Self);
-        }
-    }
-    return ret;
-}