j-templates 5.0.37 → 5.0.39

package/DOM/domNodeConfig.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DOMNodeConfig = void 0;
 const window_1 = require("./window");
 const list_1 = require("../Utils/list");
 const utils_1 = require("./utils");
@@ -10,7 +11,7 @@ function processUpdates() {
     list_1.List.Add(pendingUpdates, null);
     var callback;
     while ((callback = list_1.List.Pop(pendingUpdates)))
-        thread_1.Synch(callback);
+        (0, thread_1.Synch)(callback);
     if (pendingUpdates.size === 0)
         updateScheduled = false;
     else

package/DOM/elements.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.td = exports.tr = exports.th = exports.table = exports.button = exports.style = exports.p = exports.h3 = exports.h2 = exports.h1 = exports.option = exports.select = exports.input = exports.source = exports.video = exports.img = exports.span = exports.b = exports.br = exports.li = exports.ul = exports.a = exports.div = void 0;
 const elementNode_1 = require("../Node/elementNode");
 function div(nodeDef, children) {
     return elementNode_1.ElementNode.Create("div", null, nodeDef, children);

package/DOM/index.js

@@ -1,8 +1,19 @@
 "use strict";
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-__export(require("./elements"));
-__export(require("./svgElements"));
-__export(require("./utils"));
+__exportStar(require("./elements"), exports);
+__exportStar(require("./svgElements"), exports);
+__exportStar(require("./utils"), exports);

package/DOM/svgElements.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.circle = exports.g = exports.svg = void 0;
 const elementNode_1 = require("../Node/elementNode");
 const svgNs = "http://www.w3.org/2000/svg";
 function svg(nodeDef, children) {

package/DOM/utils.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetProperties = void 0;
 function SetValue(target, value) {
     switch (target.nodeName) {
         case "INPUT":

package/DOM/window.js

@@ -1,3 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.wndw = void 0;
 exports.wndw = typeof window !== "undefined" ? window : (new (require("jsdom").JSDOM("")).window);

package/Node/boundNode.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoundNode = void 0;
 const nodeConfig_1 = require("./nodeConfig");
 const observableScope_1 = require("../Store/Tree/observableScope");
 var BoundNode;

package/Node/boundNode.types.d.ts

@@ -1,9 +1,9 @@
 import { NodeRefType } from "./nodeRef";
 import { INodeRefBase } from "./nodeRef.types";
-export declare type FunctionOr<T> = {
+export type FunctionOr<T> = {
     (...args: Array<any>): T | Promise<T>;
 } | T;
-export declare type NodeRefEvents = {
+export type NodeRefEvents = {
     [name: string]: {
         (...args: Array<any>): void;
     };

package/Node/component.d.ts

@@ -27,7 +27,7 @@ export declare namespace Component {
     function Register<D = void, T = void, E = void>(name: string, constructor: ComponentConstructor<D, T, E>): void;
     function Attach(node: Node, nodeRef: NodeRefTypes): void;
 }
-export declare type ComponentConstructor<D, T, E> = {
+export type ComponentConstructor<D, T, E> = {
     new (data: {
         (): D | Promise<D>;
     }, templates: T, nodeRef: INodeRefBase, componentEvents: ComponentNodeEvents<E>): Component<D, T, E>;

package/Node/component.js

@@ -1,17 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Component = void 0;
 const nodeRef_1 = require("./nodeRef");
 const componentNode_1 = require("./componentNode");
 const decorators_1 = require("../Utils/decorators");
 const observableScope_1 = require("../Store/Tree/observableScope");
 class Component {
-    constructor(data, templates, nodeRef, componentEvents) {
-        this.nodeRef = nodeRef;
-        this.componentEvents = componentEvents;
-        this.scope = new observableScope_1.ObservableScope(data);
-        this.templates = templates || {};
-        this.decoratorMap = new Map();
-    }
+    nodeRef;
+    componentEvents;
+    scope;
+    templates;
+    decoratorMap;
     get Injector() {
         return this.nodeRef.injector;
     }
@@ -33,6 +32,13 @@ class Component {
     get Templates() {
         return this.templates;
     }
+    constructor(data, templates, nodeRef, componentEvents) {
+        this.nodeRef = nodeRef;
+        this.componentEvents = componentEvents;
+        this.scope = new observableScope_1.ObservableScope(data);
+        this.templates = templates || {};
+        this.decoratorMap = new Map();
+    }
     Template() {
         return [];
     }

package/Node/componentNode.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentNode = void 0;
 const boundNode_1 = require("./boundNode");
 const nodeRef_1 = require("./nodeRef");
 const nodeConfig_1 = require("./nodeConfig");
@@ -49,15 +50,15 @@ function SetChildren(node) {
 }
 function AddPreReqTemplate(node) {
     return new Promise(resolve => {
-        thread_1.Thread(function () {
+        (0, thread_1.Thread)(function () {
             var preNodes;
             injector_1.Injector.Scope(node.injector, () => preNodes = decorators_1.PreReqTemplate.Get(node.component));
-            thread_1.Schedule(function () {
+            (0, thread_1.Schedule)(function () {
                 if (node.destroyed)
                     return;
                 nodeRef_1.NodeRef.InitAll(preNodes);
             });
-            thread_1.Thread(function () {
+            (0, thread_1.Thread)(function () {
                 if (node.destroyed)
                     return;
                 for (var x = 0; x < preNodes.length; x++)
@@ -80,7 +81,7 @@ function AddPreReqTemplate(node) {
     });
 }
 function AddTemplate(node, init) {
-    thread_1.Thread(function () {
+    (0, thread_1.Thread)(function () {
         if (node.destroyed)
             return;
         var nodes;
@@ -89,10 +90,10 @@ function AddTemplate(node, init) {
         });
         if (!Array.isArray(nodes))
             nodes = [nodes];
-        thread_1.Schedule(function () {
+        (0, thread_1.Schedule)(function () {
             nodeRef_1.NodeRef.InitAll(nodes);
         });
-        thread_1.Thread(function () {
+        (0, thread_1.Thread)(function () {
             if (node.destroyed)
                 return;
             if (init)
@@ -107,7 +108,7 @@ function AddTemplate(node, init) {
                 });
         });
         if (node.component.Bound !== component_1.Component.prototype.Bound)
-            thread_1.After(function () {
+            (0, thread_1.After)(function () {
                 nodeConfig_1.NodeConfig.scheduleUpdate(() => setTimeout(() => node.component.Bound(), 0));
             });
     });

package/Node/componentNode.types.d.ts

@@ -1,7 +1,7 @@
 import { BoundNodeFunctionParam, IBoundNodeBase, NodeDefinition } from "./boundNode.types";
 import { Component, ComponentConstructor } from "./component";
 import { NodeRefType } from "./nodeRef";
-export declare type ComponentNodeEvents<E = void> = {
+export type ComponentNodeEvents<E = void> = {
     [P in keyof E]: {
         (data?: E[P]): void;
     };
@@ -18,7 +18,7 @@ export interface ComponentNodeFunctionParam<D = void, E = void> extends BoundNod
         (): D | Promise<D>;
     };
 }
-export declare type ComponentNodeFunction<D = void, T = void, E = void> = (nodeDef: ComponentNodeFunctionParam<D, E>, templates?: T) => IComponentNode<D, T, E>;
+export type ComponentNodeFunction<D = void, T = void, E = void> = (nodeDef: ComponentNodeFunctionParam<D, E>, templates?: T) => IComponentNode<D, T, E>;
 export interface IComponentNodeBase<D, T, E> extends IBoundNodeBase {
     nodeDef: ComponentNodeFunctionParam<D, E>;
     constructor: ComponentConstructor<D, T, E>;

package/Node/elementNode.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElementNode = void 0;
 const boundNode_1 = require("./boundNode");
 const nodeConfig_1 = require("./nodeConfig");
 const injector_1 = require("../Utils/injector");
@@ -59,18 +60,18 @@ function ScheduleSetData(node, scope) {
     });
 }
 function SetDefaultData(node) {
-    thread_1.Synch(function () {
+    (0, thread_1.Synch)(function () {
         var nodes;
         injector_1.Injector.Scope(node.injector, function () {
             nodes = CreateNodeArray(node.childrenFunc, true);
         });
         if (nodes.length > 0) {
-            thread_1.Schedule(function () {
+            (0, thread_1.Schedule)(function () {
                 if (node.destroyed)
                     return;
                 nodeRef_1.NodeRef.InitAll(nodes);
             });
-            thread_1.Thread(function () {
+            (0, thread_1.Thread)(function () {
                 if (node.destroyed)
                     return;
                 DetachAndAddNodes(node, [], [nodes]);
@@ -79,7 +80,7 @@ function SetDefaultData(node) {
     });
 }
 function SetData(node, value, init = false) {
-    thread_1.Synch(function () {
+    (0, thread_1.Synch)(function () {
         var newNodesMap = new Map();
         var values = value || valueDefault;
         if (!Array.isArray(values))
@@ -99,7 +100,7 @@ function SetData(node, value, init = false) {
                 injector_1.Injector.Scope(node.injector, function () {
                     nodes = CreateNodeArray(node.childrenFunc, value);
                 });
-                thread_1.Schedule(function () {
+                (0, thread_1.Schedule)(function () {
                     if (node.destroyed || newNodesMap.size === 0)
                         return;
                     nodeRef_1.NodeRef.InitAll(nodes);
@@ -117,7 +118,7 @@ function SetData(node, value, init = false) {
             node.nodesMap.clear();
         }
         node.nodesMap = newNodesMap;
-        thread_1.Thread(function () {
+        (0, thread_1.Thread)(function () {
             if (node.destroyed)
                 return;
             if (init)

package/Node/elementNode.types.d.ts

@@ -15,10 +15,10 @@ export interface ElementNodeFunctionParam<T> extends BoundNodeFunctionParam {
         (): T | Array<T> | Promise<Array<T>> | Promise<T>;
     };
 }
-export declare type ElementChildrenFunction<T> = {
+export type ElementChildrenFunction<T> = {
     (data?: T): string | NodeRefTypes | NodeRefTypes[];
 };
-export declare type ElementNodeFunction<T> = {
+export type ElementNodeFunction<T> = {
     (nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunction<T>): INodeRefBase;
 };
 export interface IElementNodeBase<T> extends IBoundNodeBase {

package/Node/nodeConfig.js

@@ -1,4 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeConfig = void 0;
 const domNodeConfig_1 = require("../DOM/domNodeConfig");
 exports.NodeConfig = domNodeConfig_1.DOMNodeConfig;

package/Node/nodeRef.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeRef = exports.NodeRefType = void 0;
 const nodeConfig_1 = require("./nodeConfig");
 const injector_1 = require("../Utils/injector");
 const boundNode_1 = require("./boundNode");

package/Node/nodeRef.types.d.ts

@@ -18,4 +18,4 @@ export interface INodeRefBase {
 export interface INodeRef extends INodeRefBase {
     type: NodeRefType.NodeRef;
 }
-export declare type NodeRefTypes = INodeRef | IBoundNode | IElementNode<any> | IComponentNode<any, any, any>;
+export type NodeRefTypes = INodeRef | IBoundNode | IElementNode<any> | IComponentNode<any, any, any>;

package/Store/Diff/diffAsync.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffAsync = void 0;
 const diffTree_1 = require("./diffTree");
 const workerQueue_1 = require("./workerQueue");
 const diffWorker_1 = require("./diffWorker");
-const diffCnstr = diffTree_1.DiffTreeScope();
+const diffCnstr = (0, diffTree_1.DiffTreeScope)();
 class DiffAsync {
+    workerQueue;
     constructor(keyFunc) {
         this.workerQueue = new workerQueue_1.WorkerQueue(diffWorker_1.DiffWorker.Create());
         this.workerQueue.Push({ method: "create", arguments: [keyFunc.toString()] });

package/Store/Diff/diffSync.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffSync = void 0;
 const diffTree_1 = require("./diffTree");
-const diffCnstr = diffTree_1.DiffTreeScope();
+const diffCnstr = (0, diffTree_1.DiffTreeScope)();
 class DiffSync {
+    diffTree;
     constructor(keyFunc) {
         this.diffTree = new diffCnstr(keyFunc);
     }

package/Store/Diff/diffTree.d.ts

@@ -2,7 +2,7 @@ export interface IDiffMethod {
     method: "create" | "diffpath" | "diffbatch" | "updatepath" | "getpath";
     arguments: Array<any>;
 }
-export declare type IDiffResponse = {
+export type IDiffResponse = {
     path: string;
     value: any;
 }[];

package/Store/Diff/diffTree.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffTreeScope = void 0;
 function DiffTreeScope(worker) {
     const ctx = this;
     if (ctx && worker) {
@@ -38,9 +39,10 @@ function DiffTreeScope(worker) {
         return !(jsonConstructor === value.constructor || Array.isArray(value));
     }
     class DiffTree {
+        keyFunc;
+        rootStateMap = new Map();
         constructor(keyFunc) {
             this.keyFunc = keyFunc;
-            this.rootStateMap = new Map();
         }
         static GetKeyRef(key) {
             return `___DiffTreeKeyRef.${key}`;

package/Store/Diff/diffWorker.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffWorker = void 0;
 const diffTree_1 = require("./diffTree");
 var DiffWorker;
 (function (DiffWorker) {

package/Store/Diff/workerQueue.js

@@ -1,7 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerQueue = void 0;
 const list_1 = require("../../Utils/list");
 class WorkerQueue {
+    callbacks;
+    worker;
     constructor(worker) {
         this.worker = worker;
         this.callbacks = list_1.List.Create();

package/Store/Store/store.js

@@ -1,21 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Store = void 0;
 const observableTree_1 = require("../Tree/observableTree");
 const storeWriter_1 = require("./storeWriter");
 class Store {
+    observableTree = new observableTree_1.ObservableTree();
+    storeWriter = new storeWriter_1.StoreWriter(this.observableTree);
+    rootScope = this.observableTree.Scope("ROOT", root => root);
+    get Root() {
+        return this.rootScope;
+    }
     constructor(init) {
-        this.observableTree = new observableTree_1.ObservableTree();
-        this.storeWriter = new storeWriter_1.StoreWriter(this.observableTree);
-        this.rootScope = this.observableTree.Scope("ROOT", root => root);
         if (init)
             this.Write(init);
     }
-    get Root() {
-        return this.rootScope;
-    }
     Action(action) {
-        var node = this.observableTree.GetNode("ROOT");
-        action(node.Proxy, this.storeWriter);
+        var proxy = this.observableTree.Get("ROOT");
+        action(proxy, this.storeWriter);
     }
     Write(data) {
         this.Action((root, writer) => writer.Write(root, data));
@@ -25,7 +26,6 @@ class Store {
     }
     Destroy() {
         this.rootScope.Destroy();
-        this.observableTree.Destroy();
     }
 }
 exports.Store = Store;

package/Store/Store/storeAsync.d.ts

@@ -10,7 +10,7 @@ export declare class StoreAsync {
     }, init?: any);
     Scope<T, R>(id: string, func: {
         (val: T): R;
-    }): import("..").ObservableScope<R>;
+    }): import("..").ObservableScope<T | R>;
     Action<T>(id: string, action: {
         (val: T, writer: StoreAsyncWriter): Promise<void>;
     }): Promise<void>;

package/Store/Store/storeAsync.js

@@ -1,10 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.StoreAsync = void 0;
 const observableTree_1 = require("../Tree/observableTree");
 const diffAsync_1 = require("../Diff/diffAsync");
 const storeAsyncWriter_1 = require("./storeAsyncWriter");
 const asyncQueue_1 = require("../../Utils/asyncQueue");
 class StoreAsync {
+    idFunc;
+    diffAsync;
+    observableTree;
+    asyncWriter;
+    asyncQueue;
     constructor(idFunc, init) {
         this.idFunc = idFunc;
         this.diffAsync = new diffAsync_1.DiffAsync(this.idFunc);
@@ -22,10 +28,7 @@ class StoreAsync {
     }
     async Action(id, action) {
         await this.asyncQueue.Next(async () => {
-            var node;
-            if (id)
-                node = this.observableTree.GetNode(id);
-            await action(node && node.Proxy, this.asyncWriter);
+            await action(id && this.observableTree.Get(id), this.asyncWriter);
         });
     }
     async Write(data) {
@@ -41,7 +44,6 @@ class StoreAsync {
     Destroy() {
         this.asyncQueue.Stop();
         this.diffAsync.Destroy();
-        this.observableTree.Destroy();
     }
 }
 exports.StoreAsync = StoreAsync;

package/Store/Store/storeAsyncWriter.d.ts

@@ -1,6 +1,5 @@
 import { DiffAsync } from "../Diff/diffAsync";
 import { ObservableTree } from "../Tree/observableTree";
-import { ObservableProxy } from "../Tree/observableProxy";
 export declare class StoreAsyncWriter {
     private idFunc;
     private diffAsync;
@@ -8,9 +7,9 @@ export declare class StoreAsyncWriter {
     constructor(idFunc: {
         (val: any): string;
     }, diffAsync: DiffAsync, observableTree: ObservableTree);
-    Write<T>(source: T | ObservableProxy, data: any): Promise<void>;
-    Merge<T>(source: T | ObservableProxy, data: Partial<T>): Promise<void>;
-    Push<T>(source: Array<T> | ObservableProxy, data: T): Promise<void>;
-    Splice<T>(source: Array<T> | ObservableProxy, start: number, deleteCount?: number, ...items: Array<T>): Promise<void>;
+    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,44 +1,44 @@
 "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) {
-        var path;
+        let path;
         if (source) {
-            var proxy = source;
-            path = proxy.___node.Path;
+            path = this.observableTree.GetPathOf(source);
         }
         else {
             path = this.idFunc(data);
             if (!path)
                 throw new Error("data must have an id");
         }
-        var diff = await this.diffAsync.DiffPath(path, data);
+        let diff = await this.diffAsync.DiffPath(path, data);
         this.ApplyChanges(diff);
     }
     async Merge(source, data) {
-        var proxy = source;
-        var rootPath = proxy.___node.Path;
-        var keys = Object.keys(data);
-        var message = keys.map(key => ({ path: `${rootPath}.${key}`, value: data[key] }));
-        var diff = await this.diffAsync.DiffBatch(message);
+        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) {
-        var proxy = source;
-        var rootPath = proxy.___node.Path;
+        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 proxy = source;
-        var rootPath = proxy.___node.Path;
+        var rootPath = this.observableTree.GetPathOf(source);
         var array = await this.diffAsync.GetPath(rootPath);
         array = array.slice();
         array.splice(start, deleteCount, ...items);

package/Store/Store/storeSync.js

@@ -1,23 +1,24 @@
 "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) {
-        this.diffSync = new diffSync_1.DiffSync();
-        this.observableTree = new observableTree_1.ObservableTree();
-        this.storeWriter = new storeSyncWriter_1.StoreSyncWriter(this.diffSync, this.observableTree);
-        this.rootScope = this.observableTree.Scope("ROOT", root => root);
         if (init)
             this.Write(init);
     }
-    get Root() {
-        return this.rootScope;
-    }
     Action(action) {
-        var node = this.observableTree.GetNode("ROOT");
-        action(node.Proxy, this.storeWriter);
+        var proxy = this.observableTree.Get("ROOT");
+        action(proxy, this.storeWriter);
     }
     Write(data) {
         this.Action((root, writer) => writer.Write(root, data));
@@ -27,7 +28,6 @@ class StoreSync {
     }
     Destroy() {
         this.rootScope.Destroy();
-        this.observableTree.Destroy();
     }
 }
 exports.StoreSync = StoreSync;

package/Store/Store/storeSyncWriter.d.ts

@@ -1,13 +1,12 @@
 import { ObservableTree } from "../Tree/observableTree";
-import { ObservableProxy } from "../Tree/observableProxy";
 import { DiffSync } from "../Diff/diffSync";
 export declare class StoreSyncWriter {
     private diffSync;
     private observableTree;
     constructor(diffSync: DiffSync, observableTree: ObservableTree);
-    Write<T>(source: T | ObservableProxy, data: any): void;
-    Merge<T>(source: T | ObservableProxy, data: Partial<T>): void;
-    Push<T>(source: Array<T> | ObservableProxy, data: T): void;
-    Splice<T>(source: Array<T> | ObservableProxy, start: number, deleteCount?: number, ...items: Array<T>): any[];
+    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;
 }