j-templates 8.1.2 → 9.0.0

package/Store/Diff/utils/state.js

@@ -0,0 +1,155 @@
+import { JsonType } from "../../../Utils/json";
+import { Snapshot } from "../../Tree/snapshot";
+import { PROP_DELIMETER, ROUTE_DELIMETER, RouteAndProperty, SplitRouteAndPath, WILDCARD } from "./paths";
+/**
+ * The raw state of a DiffTree's routes. A route's state hangs off its parent route's state under
+ * `ROUTE_STATE`, keyed by segment, so `Object.keys` of a route's state lists only its own values.
+ */
+export const ROUTE_STATE = Symbol("ROUTE_STATE");
+/**
+ * A route's state object, e.g. `/channel/1/`'s; `""` and `/` are the root.
+ * @param create Creates the route's state, and its parents', when missing
+ * @returns The state, or undefined when it's missing and `create` isn't set
+ */
+export function RouteState(root, route, create = false) {
+    let state = root;
+    for (let start = 1; state !== undefined && state !== null && start < route.length;) {
+        const end = route.indexOf(ROUTE_DELIMETER, start);
+        const segment = route.slice(start, end);
+        if (create && !Object.hasOwn(state, ROUTE_STATE))
+            Object.defineProperty(state, ROUTE_STATE, { value: {} });
+        state = create ? state[ROUTE_STATE][segment] ??= {} : state[ROUTE_STATE]?.[segment];
+        start = end + 1;
+    }
+    return state;
+}
+/**
+ * Writes a value to a path as it is, without diffing it or keeping keyed values at their homes,
+ * creating the path's route when missing. A path to a route (`/channel/1/`) only creates it.
+ * @throws When the path's parent doesn't exist
+ */
+export function WritePath(snapshot, root, path, value) {
+    const [route, property] = RouteAndProperty(path);
+    const state = RouteState(root, route, true);
+    if (property === "")
+        return;
+    const parts = property.split(PROP_DELIMETER);
+    const parent = ReadPathParts(state, parts, parts.length - 1);
+    if (!parent)
+        throw new Error("Unable to write value to path: " + path);
+    Assign(snapshot, parent, parts[parts.length - 1], value);
+}
+/** The value at a path, or undefined when any segment of it doesn't exist; see ReadPathFound */
+export function ReadPath(root, path) {
+    return ReadPathFound(root, path)[0];
+}
+/**
+ * The value at a path, and whether its parent was found: a property missing from an existing
+ * parent is found as undefined.
+ */
+export function ReadPathFound(root, path) {
+    const [route, property] = RouteAndProperty(path);
+    const state = RouteState(root, route);
+    if (property === "")
+        return [state, !!state];
+    const parts = property.split(PROP_DELIMETER);
+    const parent = ReadPathParts(state, parts, parts.length - 1);
+    return [parent?.[parts[parts.length - 1]], !!parent];
+}
+/** The value at the first `depth` parts of a property path */
+export function ReadPathParts(value, parts, depth) {
+    let curr = value;
+    for (let x = 0; curr !== undefined && curr !== null && x < depth; x++)
+        curr = curr[parts[x]];
+    return curr;
+}
+/**
+ * The snapshot of the value at a path, whether it was found, and the route it was read through,
+ * when there is one. A property path is read from the snapshot of its first segment alone, not of
+ * the whole route, so a write to the route's other keys neither rebuilds what it reads nor changes it.
+ */
+export function ReadSnapshot(snapshot, root, path) {
+    const [route, property] = SplitRouteAndPath(path);
+    const routeState = RouteState(root, route);
+    if (!routeState)
+        return [undefined, false, undefined];
+    if (property === "") {
+        const routeSnapshot = Snapshot.Get(snapshot, routeState);
+        return [routeSnapshot, !!routeSnapshot, { route, state: routeState, snapshot: routeSnapshot }];
+    }
+    const dot = property.indexOf(PROP_DELIMETER);
+    const key = dot < 0 ? property : property.slice(0, dot);
+    const keySnapshot = Snapshot.Child(snapshot, routeState, key);
+    const source = { route, state: routeState, key, snapshot: keySnapshot };
+    if (dot < 0)
+        return [keySnapshot, true, source];
+    const [value, valueFound] = ReadPathFound(keySnapshot, property.slice(dot + 1));
+    return [value, valueFound, source];
+}
+/**
+ * Whether a key's value still has the snapshot taken of it, told by a cache lookup without
+ * taking a new one. A primitive value has no snapshot of its own and is compared as it is. A
+ * value with no cached snapshot was written since, even where the snapshot was undefined.
+ */
+export function KeyUnchanged(snapshot, state, key, keySnapshot) {
+    const value = state[key];
+    if (JsonType(value) === "value")
+        return value === keySnapshot;
+    const cached = Snapshot.Peek(snapshot, value);
+    return cached !== undefined && cached === keySnapshot;
+}
+// Removing or replacing a value changes its parent, not the value: its snapshot stays valid. That
+// matters for a slot, whose value is a home still held, and read, elsewhere.
+export function Remove(snapshot, parent, prop) {
+    delete parent[prop];
+    Snapshot.Invalidate(snapshot, parent);
+}
+export function Assign(snapshot, parent, prop, value) {
+    parent[prop] = value;
+    Snapshot.Invalidate(snapshot, parent);
+}
+/**
+ * Deletes a route's state, child routes included, from its parent route. Every cached snapshot
+ * that embedded a value from it, such as one reading a keyed value through its home in the
+ * route, is invalidated.
+ * @param route A non-root route path, e.g. `/channel/1/`
+ */
+export function DeleteRouteState(snapshot, root, route) {
+    const parentRoute = route.slice(0, route.lastIndexOf(ROUTE_DELIMETER, route.length - 2) + 1);
+    const segment = route.slice(parentRoute.length, -1);
+    const routeStates = RouteState(root, parentRoute)?.[ROUTE_STATE];
+    if (!routeStates || !Object.hasOwn(routeStates, segment))
+        return;
+    InvalidateState(snapshot, routeStates[segment]);
+    delete routeStates[segment];
+}
+function InvalidateState(snapshot, value) {
+    if (JsonType(value) === "value")
+        return;
+    Snapshot.Invalidate(snapshot, value);
+    const keys = Object.keys(value);
+    for (let x = 0; x < keys.length; x++)
+        InvalidateState(snapshot, value[keys[x]]);
+    const routeStates = value[ROUTE_STATE];
+    for (const segment in routeStates)
+        InvalidateState(snapshot, routeStates[segment]);
+}
+/**
+ * Expands a wildcard path's route against the route state under `root`.
+ * @returns Each matching path, keyed by the segment the wildcard matched
+ */
+export function ExpandWildcardPath(root, path) {
+    const [route, property] = SplitRouteAndPath(path);
+    const parts = route.split(ROUTE_DELIMETER);
+    const index = parts.findIndex(part => part.endsWith(WILDCARD));
+    const prefix = parts[index].slice(0, -1);
+    const parent = RouteState(root, parts.slice(0, index).join(ROUTE_DELIMETER) + ROUTE_DELIMETER);
+    const children = parent?.[ROUTE_STATE] ?? {};
+    const paths = {};
+    for (const segment of Object.keys(children))
+        if (segment.startsWith(prefix)) {
+            parts[index] = segment;
+            paths[segment] = parts.join(ROUTE_DELIMETER) + property;
+        }
+    return paths;
+}

package/Store/Store/pushStore.d.ts

@@ -43,12 +43,8 @@ export declare class PushStore extends ReadStore {
      * @param keyFunc Optional function to generate a key for a given data value, used to
      *   resolve root objects. Pass the same key logic the `DiffTreeWriter` was constructed
      *   with, if any.
-     * @param cloneData Whether to deep-clone the values the store adopts (false by default).
-     *   A `Worker` or `MessagePort` already delivers a structured-clone copy of every message.
-     *   A same-thread `EventTarget` delivers the writer's own objects, so either the writer
-     *   posts copies or this is true; otherwise the store and the writer's tree share objects.
      */
-    constructor(eventTarget: EventTarget, keyFunc?: (value: any) => string | undefined, cloneData?: boolean);
+    constructor(eventTarget: EventTarget, keyFunc?: (value: any) => string | undefined);
     /**
      * Stops listening to the source and destroys the error scope. The source stays open (a
      * worker keeps running); closing or terminating it is up to its owner.

package/Store/Store/pushStore.js

@@ -43,35 +43,16 @@ export class PushStore extends ReadStore {
      * @param keyFunc Optional function to generate a key for a given data value, used to
      *   resolve root objects. Pass the same key logic the `DiffTreeWriter` was constructed
      *   with, if any.
-     * @param cloneData Whether to deep-clone the values the store adopts (false by default).
-     *   A `Worker` or `MessagePort` already delivers a structured-clone copy of every message.
-     *   A same-thread `EventTarget` delivers the writer's own objects, so either the writer
-     *   posts copies or this is true; otherwise the store and the writer's tree share objects.
      */
-    constructor(eventTarget, keyFunc, cloneData = false) {
-        super(keyFunc, cloneData);
+    constructor(eventTarget, keyFunc) {
+        super(keyFunc);
         this.eventTarget = eventTarget;
         this.error = null;
         this.errorScope = ObservableScope.Basic(() => this.error);
         this.messageHandler = (event) => {
             const messageData = event.data;
             if (messageData && messageData.type === DIFF_TREE_EVENT) {
-                const data = messageData.data;
-                for (let x = 0; x < data.length; x++) {
-                    const result = data[x];
-                    switch (result.type) {
-                        case "diff": {
-                            this.UpdateRootMap(result.result);
-                            break;
-                        }
-                        case "splice": {
-                            const spliceResult = result.result;
-                            this.UpdateRootMap(spliceResult.diffResult);
-                            this.SpliceRootObject(spliceResult.path[0], spliceResult.start, spliceResult.deleteCount, spliceResult.items);
-                            break;
-                        }
-                    }
-                }
+                this.UpdateRootMap(messageData.data);
                 if (this.error !== null) {
                     this.error = null;
                     ObservableScope.Update(this.errorScope);

package/Store/Store/store.d.ts

@@ -9,7 +9,6 @@ import { JsonDiffResult } from "../../Utils/json";
  */
 export declare abstract class ReadStore {
     protected keyFunc?: (value: any) => string | undefined;
-    private cloneData;
     private rootMap;
     private createNode;
     /**
@@ -17,7 +16,7 @@ export declare abstract class ReadStore {
      * @param keyFunc Optional function to generate a key for a given data value.
      * When provided, enables alias functionality where values can reference other root objects.
      */
-    constructor(keyFunc?: (value: any) => string | undefined, cloneData?: boolean);
+    constructor(keyFunc?: (value: any) => string | undefined);
     /**
      * Retrieves a value from the store by id.
      * @template O - The type of the value to retrieve
@@ -34,13 +33,18 @@ export declare abstract class ReadStore {
      */
     Get<O>(id: string, defaultValue: O): O;
     Has(id: string): boolean;
+    /**
+     * Whether the store holds the root a path is in: its key, before the first `.`. Push, Splice
+     * and Patch take a path into a root, e.g. `rows.t_1`.
+     * @param path The path, e.g. `user.items`.
+     */
+    protected HasRootOf(path: string): boolean;
     /**
      * Updates the root map with diff results by grouping changes by root path.
      * @param results - Array of diff results to apply
      * @protected
      */
     protected UpdateRootMap(results: JsonDiffResult): void;
-    protected SpliceRootObject(rootPath: string | number, start: number, deleteCount: number, items: any[]): void;
     /**
      * Updates a specific root object with diff results.
      * Creates the root object if it doesn't exist.
@@ -62,5 +66,7 @@ export declare abstract class Store extends ReadStore {
     abstract Write(data: unknown, key?: string): Promise<void> | void;
     abstract Patch(key: string, patch: unknown): Promise<void> | void;
     abstract Push(key: string, ...data: unknown[]): Promise<void> | void;
-    abstract Splice(key: string, start: number, deleteCount?: number, ...items: unknown[]): Promise<any[]> | any[];
+    abstract Splice(key: string, start: number, deleteCount?: number, ...items: unknown[]): Promise<void> | void;
 }
+/** The root key a path is in: its text before the first `.` */
+export declare function RootOf(path: string): string;

package/Store/Store/store.js

@@ -14,14 +14,15 @@ export class ReadStore {
      * @param keyFunc Optional function to generate a key for a given data value.
      * When provided, enables alias functionality where values can reference other root objects.
      */
-    constructor(keyFunc, cloneData = true) {
+    constructor(keyFunc) {
         this.keyFunc = keyFunc;
-        this.cloneData = cloneData;
         this.rootMap = new Map();
         const aliasFunc = keyFunc &&
             ((value, reactive = true) => {
                 const key = keyFunc(value);
-                if (key === undefined)
+                // A route key names an entity in a DiffTree route instance, which never reaches the
+                // store: read the embedded copy
+                if (key === undefined || key.startsWith("/"))
                     return undefined;
                 const rootObject = this.rootMap.get(key);
                 if (rootObject === undefined)
@@ -46,6 +47,14 @@ export class ReadStore {
     Has(id) {
         return this.rootMap.has(id);
     }
+    /**
+     * Whether the store holds the root a path is in: its key, before the first `.`. Push, Splice
+     * and Patch take a path into a root, e.g. `rows.t_1`.
+     * @param path The path, e.g. `user.items`.
+     */
+    HasRootOf(path) {
+        return this.Has(RootOf(path));
+    }
     /**
      * Updates the root map with diff results by grouping changes by root path.
      * @param results - Array of diff results to apply
@@ -61,10 +70,6 @@ export class ReadStore {
             this.UpdateRootObject(rootGroup[0].path[0], rootGroup);
         }
     }
-    SpliceRootObject(rootPath, start, deleteCount, items) {
-        const rootObject = this.rootMap.get(rootPath);
-        ObservableNode.ApplySplice(rootObject[rootPath], start, deleteCount, items, this.cloneData);
-    }
     /**
      * Updates a specific root object with diff results.
      * Creates the root object if it doesn't exist.
@@ -76,14 +81,18 @@ export class ReadStore {
     UpdateRootObject(rootPath, results) {
         const rootObject = this.rootMap.get(rootPath);
         if (rootObject === undefined) {
-            if (results.length > 1 || results[0].path.length > 1)
-                throw `Unable to initialize root path ${rootPath} with ${results.length} results and initial path ${results[0].path}`;
-            const rootData = this.cloneData ? JsonDeepClone(results[0].value) : results[0].value;
+            if (results[0].type !== "write" || results[0].path.length > 1)
+                throw `Unable to initialize root path ${rootPath} with initial path ${results[0].path}`;
+            const rootData = JsonDeepClone(results[0].value);
             const newRootObject = this.createNode({ [rootPath]: rootData }, false);
             this.rootMap.set(rootPath, newRootObject);
+            // Later entries for the same root (e.g. route summaries written one instance at a time)
+            // apply to the root just created
+            if (results.length > 1)
+                ObservableNode.ApplyDiff(newRootObject, results.slice(1));
             return;
         }
-        ObservableNode.ApplyDiff(rootObject, results, this.cloneData);
+        ObservableNode.ApplyDiff(rootObject, results);
     }
 }
 /**
@@ -95,3 +104,8 @@ export class ReadStore {
  */
 export class Store extends ReadStore {
 }
+/** The root key a path is in: its text before the first `.` */
+export function RootOf(path) {
+    const dot = path.indexOf(".");
+    return dot < 0 ? path : path.slice(0, dot);
+}

package/Store/Store/storeAsync.d.ts

@@ -24,7 +24,7 @@ import { Store } from "./store";
  * await store.Push("users", { id: 1 }, { id: 2 });
  *
  * // Splicing an array asynchronously
- * const deletedItems = await store.Splice("users", 0, 1, { id: 3 });
+ * await store.Splice("users", 0, 1, { id: 3 });
  *
  * // Cleaning up resources
  * store.Destroy();
@@ -41,7 +41,7 @@ export declare class StoreAsync extends Store {
     /**
      * Creates an instance of StoreAsync.
      * @param diffWorker A `Worker` running a `DiffTree` connected via `ConnectWorkerToDiffTree`
-     *   (e.g. a bundled `defaultDiffTreeWorker` entry). Any `keyFunc`/projections the diff needs
+     *   (e.g. a bundled `defaultDiffTreeWorker` entry). Any `keyFunc`/routes the diff needs
      *   must be baked into that worker's own entry file.
      * @param keyFunc Optional function to generate a key for a given data value, used locally by
      *   this store to resolve root objects. Pass the same key logic the worker's `DiffTree` was
@@ -88,12 +88,11 @@ export declare class StoreAsync extends Store {
      * @param start The position at which to start changing the array.
      * @param deleteCount Optional number of elements to delete. If not provided, all elements from start to end will be deleted.
      * @param items Optional elements to insert into the array.
-     * @returns A promise that resolves to the array of deleted elements once the splice has been
-     *   applied to the store.
+     * @returns A promise that resolves once the splice has been applied to the store.
      * @throws Will throw if the key isn't in the store and has no pending Write, or reject with
      *   the original error if an earlier change failed.
      */
-    Splice(key: string, start: number, deleteCount?: number, ...items: unknown[]): Promise<any[]>;
+    Splice(key: string, start: number, deleteCount?: number, ...items: unknown[]): Promise<void>;
     /**
      * Returns a promise that resolves once every change made before this call has been applied
      * to the store. Changes made after this call are sent in a later batch, so they aren't

package/Store/Store/storeAsync.js

@@ -1,6 +1,6 @@
 import { AsyncQueue } from "../../Utils/asyncQueue";
 import { WorkerQueue } from "../Diff/workerQueue";
-import { Store } from "./store";
+import { RootOf, Store } from "./store";
 /**
  * StoreAsync class extends the base Store class to provide asynchronous data management operations.
  * This class handles writing, patching, pushing, and splicing data in an asynchronous manner.
@@ -26,7 +26,7 @@ import { Store } from "./store";
  * await store.Push("users", { id: 1 }, { id: 2 });
  *
  * // Splicing an array asynchronously
- * const deletedItems = await store.Splice("users", 0, 1, { id: 3 });
+ * await store.Splice("users", 0, 1, { id: 3 });
  *
  * // Cleaning up resources
  * store.Destroy();
@@ -38,17 +38,17 @@ export class StoreAsync extends Store {
     /**
      * Creates an instance of StoreAsync.
      * @param diffWorker A `Worker` running a `DiffTree` connected via `ConnectWorkerToDiffTree`
-     *   (e.g. a bundled `defaultDiffTreeWorker` entry). Any `keyFunc`/projections the diff needs
+     *   (e.g. a bundled `defaultDiffTreeWorker` entry). Any `keyFunc`/routes the diff needs
      *   must be baked into that worker's own entry file.
      * @param keyFunc Optional function to generate a key for a given data value, used locally by
      *   this store to resolve root objects. Pass the same key logic the worker's `DiffTree` was
      *   constructed with, if any.
      */
     constructor(diffWorker, keyFunc) {
-        super(keyFunc, false);
+        super(keyFunc);
         this.writeKeySet = new Set();
         this.currentBatch = [];
-        this.currentBatchPromise = Promise.resolve([]);
+        this.currentBatchPromise = Promise.resolve();
         this.workerQueue = new WorkerQueue(diffWorker);
         this.asyncQueue = new AsyncQueue(true);
     }
@@ -59,29 +59,13 @@ export class StoreAsync extends Store {
                 await Promise.resolve();
                 if (batch === this.currentBatch)
                     this.currentBatch = [];
-                const results = await this.workerQueue.Push(batch);
-                for (let x = 0; x < results.length; x++) {
-                    const result = results[x];
-                    switch (result.type) {
-                        case "diff": {
-                            this.UpdateRootMap(result.result);
-                            break;
-                        }
-                        case "splice": {
-                            const spliceResult = result.result;
-                            this.UpdateRootMap(spliceResult.diffResult);
-                            this.SpliceRootObject(spliceResult.path[0], spliceResult.start, spliceResult.deleteCount, spliceResult.items);
-                            break;
-                        }
-                    }
-                }
-                return results;
+                // The worker's Commit() diff covers every change in the batch
+                const diff = await this.workerQueue.Push(batch);
+                this.UpdateRootMap(diff);
             });
         }
-        const batchIndex = this.currentBatch.length;
         this.currentBatch.push(method);
-        const batchResult = await this.currentBatchPromise;
-        return batchResult[batchIndex].result;
+        await this.currentBatchPromise;
     }
     /**
      * Writes data to the store asynchronously.
@@ -98,12 +82,13 @@ export class StoreAsync extends Store {
         key = key || this.keyFunc?.(data);
         if (!key)
             throw new Error("No key provided for data");
-        this.writeKeySet.add(key);
+        // Pending writes by root, so a change to a path in a root being written isn't refused
+        this.writeKeySet.add(RootOf(key));
         await this.Schedule({
-            method: "diffpath",
+            method: "writepath",
             arguments: [key, data]
         });
-        this.writeKeySet.delete(key);
+        this.writeKeySet.delete(RootOf(key));
     }
     /**
      * Patches an existing value in the store with new data asynchronously.
@@ -116,7 +101,7 @@ export class StoreAsync extends Store {
      *   the original error if an earlier change failed.
      */
     async Patch(key, patch) {
-        if (!this.Has(key) && !this.writeKeySet.has(key))
+        if (!this.HasRootOf(key) && !this.writeKeySet.has(RootOf(key)))
             throw "Key not found in store";
         await this.Schedule({
             method: "patchpath",
@@ -132,7 +117,7 @@ export class StoreAsync extends Store {
      *   the original error if an earlier change failed.
      */
     async Push(key, ...data) {
-        if (!this.Has(key) && !this.writeKeySet.has(key))
+        if (!this.HasRootOf(key) && !this.writeKeySet.has(RootOf(key)))
             throw "Key not found in store";
         await this.Schedule({
             method: "pushpath",
@@ -146,19 +131,17 @@ export class StoreAsync extends Store {
      * @param start The position at which to start changing the array.
      * @param deleteCount Optional number of elements to delete. If not provided, all elements from start to end will be deleted.
      * @param items Optional elements to insert into the array.
-     * @returns A promise that resolves to the array of deleted elements once the splice has been
-     *   applied to the store.
+     * @returns A promise that resolves once the splice has been applied to the store.
      * @throws Will throw if the key isn't in the store and has no pending Write, or reject with
      *   the original error if an earlier change failed.
      */
     async Splice(key, start, deleteCount, ...items) {
-        if (!this.Has(key) && !this.writeKeySet.has(key))
+        if (!this.HasRootOf(key) && !this.writeKeySet.has(RootOf(key)))
             throw "Key not found in store";
-        const spliceResult = await this.Schedule({
+        await this.Schedule({
             method: "splicepath",
-            arguments: [key, start, deleteCount, items]
+            arguments: [key, start, deleteCount ?? Infinity, items]
         });
-        return spliceResult.spliceResult;
     }
     /**
      * Returns a promise that resolves once every change made before this call has been applied

package/Store/Store/storeSync.d.ts

@@ -1,4 +1,4 @@
-import { DiffTreeProjectionMap } from "../Diff/diffTree.types";
+import { IRouteDefinitions } from "../Diff/utils/diffTree.types";
 import { Store } from "./store";
 /**
  * StoreSync class extends the base Store class to provide synchronous data management operations.
@@ -22,25 +22,26 @@ import { Store } from "./store";
  * store.Push("user.array", { id: 1 }, { id: 2 });
  *
  * // Splicing an array
- * const deletedItems = store.Splice("user.array", 0, 1, { id: 3 });
+ * store.Splice("user.array", 0, 1, { id: 3 });
  *
  * @see Store
  * @see StoreAsync
- * @see DiffSync
+ * @see DiffTree
  */
 export declare class StoreSync extends Store {
     /**
-     * The diff instance used to compute differences between current and new data states.
+     * The tree each change is applied to. Its `Commit()` diff keeps the store in sync.
      * @private
      */
     private diff;
     /**
      * Creates an instance of StoreSync.
      * @param keyFunc Optional function to generate a key for a given data value.
-     * @param projections Optional map of derived-value projections, keyed by id. A
-     * projection's result is readable through `Get` at `$projection_<id>`.
+     * @param routes Optional route definitions. A projection in the root route (`"/"`) is
+     * readable through `Get` at `$projection_<key>`.
+     * @throws When projections depend on each other in a cycle.
      */
-    constructor(keyFunc?: (value: any) => string | undefined, projections?: DiffTreeProjectionMap);
+    constructor(keyFunc?: (value: any) => string | undefined, routes?: IRouteDefinitions);
     /**
      * Writes data to the store synchronously.
      * @param data The data to be written. Can be of any type.
@@ -68,7 +69,11 @@ export declare class StoreSync extends Store {
      * @param start The position at which to start changing the array.
      * @param deleteCount Optional number of elements to delete. If not provided, all elements from start to end will be deleted.
      * @param items Optional elements to insert into the array.
-     * @returns The array of deleted elements.
      */
-    Splice(key: string, start: number, deleteCount?: number, ...items: unknown[]): unknown[];
+    Splice(key: string, start: number, deleteCount?: number, ...items: unknown[]): void;
+    /**
+     * Runs projections and applies everything changed since the last sync to the store.
+     * @private
+     */
+    private Sync;
 }

package/Store/Store/storeSync.js

@@ -1,5 +1,4 @@
-import { JsonDeepClone } from "../../Utils/json";
-import { DiffSync } from "../Diff/diffSync";
+import { DiffTree } from "../Diff/diffTree";
 import { Store } from "./store";
 /**
  * StoreSync class extends the base Store class to provide synchronous data management operations.
@@ -23,22 +22,23 @@ import { Store } from "./store";
  * store.Push("user.array", { id: 1 }, { id: 2 });
  *
  * // Splicing an array
- * const deletedItems = store.Splice("user.array", 0, 1, { id: 3 });
+ * store.Splice("user.array", 0, 1, { id: 3 });
  *
  * @see Store
  * @see StoreAsync
- * @see DiffSync
+ * @see DiffTree
  */
 export class StoreSync extends Store {
     /**
      * Creates an instance of StoreSync.
      * @param keyFunc Optional function to generate a key for a given data value.
-     * @param projections Optional map of derived-value projections, keyed by id. A
-     * projection's result is readable through `Get` at `$projection_<id>`.
+     * @param routes Optional route definitions. A projection in the root route (`"/"`) is
+     * readable through `Get` at `$projection_<key>`.
+     * @throws When projections depend on each other in a cycle.
      */
-    constructor(keyFunc, projections) {
+    constructor(keyFunc, routes) {
         super(keyFunc);
-        this.diff = new DiffSync(keyFunc, projections);
+        this.diff = new DiffTree(keyFunc, routes);
     }
     /**
      * Writes data to the store synchronously.
@@ -50,8 +50,8 @@ export class StoreSync extends Store {
         key = key || this.keyFunc?.(data);
         if (!key)
             throw "No key provided for data";
-        const diffResult = this.diff.DiffPath(key, data);
-        this.UpdateRootMap(diffResult);
+        this.diff.WritePath(key, data);
+        this.Sync();
     }
     /**
      * Patches an existing value in the store with new data synchronously.
@@ -60,10 +60,10 @@ export class StoreSync extends Store {
      * @throws Will throw an error if the value to be patched is undefined.
      */
     Patch(key, patch) {
-        if (!this.Has(key))
+        if (!this.HasRootOf(key))
             throw "Key not found in store";
-        const diffResult = this.diff.PatchPath(key, patch);
-        this.UpdateRootMap(diffResult);
+        this.diff.PatchPath(key, patch);
+        this.Sync();
     }
     /**
      * Pushes data into an array stored at the specified key synchronously.
@@ -71,10 +71,10 @@ export class StoreSync extends Store {
      * @param data The data items to be pushed into the array.
      */
     Push(key, ...data) {
-        if (!this.Has(key))
+        if (!this.HasRootOf(key))
             throw "Key not found in store";
-        const diffResult = this.diff.PushPath(key, data);
-        this.UpdateRootMap(diffResult);
+        this.diff.PushPath(key, data);
+        this.Sync();
     }
     /**
      * Splices an array stored at the specified key with new data synchronously.
@@ -83,14 +83,19 @@ export class StoreSync extends Store {
      * @param start The position at which to start changing the array.
      * @param deleteCount Optional number of elements to delete. If not provided, all elements from start to end will be deleted.
      * @param items Optional elements to insert into the array.
-     * @returns The array of deleted elements.
      */
     Splice(key, start, deleteCount, ...items) {
-        if (!this.Has(key))
+        if (!this.HasRootOf(key))
             throw "Key not found in store";
-        const spliceResult = this.diff.SplicePath(key, start, deleteCount, items);
-        this.UpdateRootMap(spliceResult.diffResult);
-        this.SpliceRootObject(spliceResult.path[0], spliceResult.start, spliceResult.deleteCount, items);
-        return JsonDeepClone(spliceResult.spliceResult);
+        this.diff.SplicePath(key, start, deleteCount ?? Infinity, items);
+        this.Sync();
+    }
+    /**
+     * Runs projections and applies everything changed since the last sync to the store.
+     * @private
+     */
+    Sync() {
+        this.diff.RunProjections();
+        this.UpdateRootMap(this.diff.Commit());
     }
 }