j-templates 5.0.54 → 6.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "j-templates",
-  "version": "5.0.54",
+  "version": "6.0.1",
   "description": "j-templates",
   "license": "MIT",
   "repository": "https://github.com/TypesInCode/jTemplates",

package/web.export.d.ts

@@ -1,4 +1,4 @@
 export * from "./index";
 export * from "./Utils";
-export { ObservableScope, Store, StoreAsync, ObservableNode, ObservableComputed } from "./Store";
+export { ObservableScope, ObservableNode } from "./Store";
 export * from "./DOM";

package/web.export.js

@@ -14,13 +14,10 @@ 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 });
-exports.ObservableComputed = exports.ObservableNode = exports.StoreAsync = exports.Store = exports.ObservableScope = void 0;
+exports.ObservableNode = exports.ObservableScope = void 0;
 __exportStar(require("./index"), exports);
 __exportStar(require("./Utils"), exports);
 var Store_1 = require("./Store");
 Object.defineProperty(exports, "ObservableScope", { enumerable: true, get: function () { return Store_1.ObservableScope; } });
-Object.defineProperty(exports, "Store", { enumerable: true, get: function () { return Store_1.Store; } });
-Object.defineProperty(exports, "StoreAsync", { enumerable: true, get: function () { return Store_1.StoreAsync; } });
 Object.defineProperty(exports, "ObservableNode", { enumerable: true, get: function () { return Store_1.ObservableNode; } });
-Object.defineProperty(exports, "ObservableComputed", { enumerable: true, get: function () { return Store_1.ObservableComputed; } });
 __exportStar(require("./DOM"), exports);

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/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;