j-templates 8.1.2 → 8.2.0

package/Store/Diff/utils/diffTree.utils.d.ts

@@ -0,0 +1,79 @@
+import { JsonDiffResult } from "../../../Utils/json";
+import { ISnapshotState, SnapshotPath, SnapshotResolver } from "../../Tree/snapshot";
+export declare const ROOT_ROUTE = "/";
+export declare const PROJECTION_PREFIX = "$projection_";
+export declare const ROUTE_STATE: unique symbol;
+type KeyFunc = {
+    (value: any): string | undefined;
+};
+/** Returns the keyFunc for a route path (`/channel/1/`, or `""`/`/` for the root) */
+export type RouteKeyFunc = {
+    (route: string): KeyFunc | undefined;
+};
+/**
+ * The path a keyed value lives at: its key joined to the route it was found in. A key
+ * starting with `/` is a route path from the root.
+ * @returns The path, or undefined when the value isn't keyed
+ */
+export declare function ResolveKey(keyFunc: KeyFunc | undefined, route: string, value: any): string;
+export declare function ExpandKeyedDiffFromValue(route: string, path: string, keyFunc: KeyFunc, value: any, keyedDiff: {
+    path: string;
+    value: any;
+}[]): void;
+/**
+ * Applies a diff to `diffRoot`, then each keyed value and rebased row it produced, until none are
+ * left. Each rebase moves a row past one keyed value, so the rows run out.
+ */
+export declare function ApplyDiff(snapshot: ISnapshotState, treeRootState: any, routeKeyFunc: RouteKeyFunc, route: string, diffRoot: any, diff: JsonDiffResult): void;
+export declare function ApplyPathValues(snapshot: ISnapshotState, root: any, pathValues: {
+    path: string;
+    value: any;
+}[]): void;
+/**
+ * A snapshot resolver reading each keyed child through the path it lives at, keyed with the
+ * keyFunc of the route the snapshot walk is in.
+ */
+export declare function CreateKeyResolver(root: any, routeKeyFunc: RouteKeyFunc): SnapshotResolver;
+export declare function ApplyValueToPath(snapshot: ISnapshotState, root: any, routeKeyFunc: RouteKeyFunc, basePath: string, path: string, value: any): void;
+/**
+ * Converts a route path to the snapshot path of the value it names, following how
+ * `WritePath` stores route state: `/channel/1/item.v` is `[ROUTE_STATE, "channel", ROUTE_STATE, "1", "item", "v"]`.
+ */
+export declare function ToSnapshotPath(path: string): SnapshotPath;
+/** The route path a snapshot path is in: each segment following a `ROUTE_STATE`, e.g. `/channel/1/` */
+export declare function SnapshotPathRoute(path: Readonly<SnapshotPath>): string;
+export declare function WritePath(snapshot: ISnapshotState, root: any, path: string, value: any, guardPath?: boolean, pathIndex?: number): void;
+export declare function ReadPath(root: any, path: string, pathIndex?: number): any;
+export declare function ReadPathFound(root: any, path: string, pathIndex?: number): any[];
+export declare function SplitRouteAndPath(path: string): readonly [string, string];
+export declare function GetKeyedPath(root: any, dotPath: string, keyFunc?: (data: any) => string): string;
+/**
+ * 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 declare function DeleteRouteState(snapshot: ISnapshotState, root: any, route: string): void;
+/** Whether a path's route has a wildcard segment, e.g. a `row_*` segment */
+export declare function IsWildcardPath(path: string): boolean;
+/**
+ * Whether a route matches a route pattern segment by segment. A pattern segment ending in `*`
+ * matches any segment starting with the text before it: a `row_*` segment matches `row_1`.
+ */
+export declare function RouteMatches(pattern: string, route: string): boolean;
+/**
+ * Expands a wildcard path's route against the route state under `root`.
+ * @returns Each matching path, keyed by the segment the wildcard matched
+ */
+export declare function ExpandWildcardPath(root: any, path: string): {
+    [segment: string]: string;
+};
+/**
+ * Throws when a read path's wildcard is invalid: more than one wildcard segment, a `*` that
+ * doesn't end its segment, or a `*` in the property path.
+ */
+export declare function ValidateWildcardPath(path: string): void;
+/** Whether `path` is `basePath` or a property below it: `/a.b` is within `/a`, `/ab` isn't */
+export declare function IsPathWithin(path: string, basePath: string): boolean;
+export declare function JoinPaths(basePath: string, targetPath: string): string;
+export {};

package/Store/Diff/utils/diffTree.utils.js

@@ -0,0 +1,398 @@
+import { JsonApplyDiff, JsonDeepClone, JsonDiff, JsonType } from "../../../Utils/json";
+import { Snapshot } from "../../Tree/snapshot";
+export const ROOT_ROUTE = "/";
+export const PROJECTION_PREFIX = "$projection_";
+export const ROUTE_STATE = Symbol("ROUTE_STATE");
+const ROUTE_DELIMETER = "/";
+const PROP_DELIMETER = ".";
+const WILDCARD = "*";
+/**
+ * The path a keyed value lives at: its key joined to the route it was found in. A key
+ * starting with `/` is a route path from the root.
+ * @returns The path, or undefined when the value isn't keyed
+ */
+export function ResolveKey(keyFunc, route, value) {
+    const key = keyFunc?.(value);
+    return key ? JoinPaths(route, key) : undefined;
+}
+export function ExpandKeyedDiffFromValue(route, path, keyFunc, value, keyedDiff) {
+    const type = JsonType(value);
+    if (type === 'value')
+        return;
+    const filterPrefix = JoinPaths(route, path);
+    const key = keyFunc(value);
+    if (key) {
+        const [keyRoute] = SplitRouteAndPath(key);
+        const invalidKeyRoute = keyRoute && !keyRoute.startsWith('/') && route.endsWith(keyRoute);
+        const fullKeyPath = JoinPaths(route, key);
+        if (!invalidKeyRoute && fullKeyPath && !IsPathWithin(fullKeyPath, filterPrefix))
+            keyedDiff.push({
+                path: fullKeyPath,
+                value: value
+            });
+    }
+    const keys = type === "array" ? undefined : Object.keys(value);
+    const length = keys ? keys.length : value.length;
+    for (let x = 0; x < length; x++) {
+        const child = value[keys ? keys[x] : x];
+        ExpandKeyedDiffFromValue(route, path, keyFunc, child, keyedDiff);
+    }
+}
+/**
+ * Applies a diff to `diffRoot`, then each keyed value and rebased row it produced, until none are
+ * left. Each rebase moves a row past one keyed value, so the rows run out.
+ */
+export function ApplyDiff(snapshot, treeRootState, routeKeyFunc, route, diffRoot, diff) {
+    const keyFunc = routeKeyFunc(route);
+    const fixupDiff = [];
+    for (let x = 0; keyFunc && x < diff.length; x++) {
+        const row = diff[x];
+        const path = row.path;
+        let curr = diffRoot;
+        let key = null;
+        let keyIndex = -1;
+        let y = 0;
+        for (; curr && y < path.length; y++) {
+            const currKey = keyFunc(curr);
+            if (currKey) {
+                key = currKey;
+                keyIndex = y;
+            }
+            curr = curr[path[y]];
+        }
+        if (y < path.length && key) {
+            const joinedKey = JoinPaths(route, key);
+            const keyedValue = ReadPath(treeRootState, joinedKey);
+            if (keyedValue) {
+                const write = {
+                    type: "write",
+                    value: keyedValue,
+                    path: path.slice(0, keyIndex)
+                };
+                fixupDiff.push(write);
+            }
+        }
+    }
+    JsonApplyDiff(diffRoot, fixupDiff, function (parent, prop, value) {
+        parent[prop] = value;
+        Snapshot.Invalidate(snapshot, parent);
+    });
+    // The raw value can be a stale copy missing paths the diff's snapshot has; the rebased rows
+    // below write those to the value's home
+    JsonApplyDiff(diffRoot, diff, function (parent, prop, value) {
+        parent[prop] = value;
+        Snapshot.Invalidate(snapshot, parent);
+    });
+    if (!keyFunc)
+        return;
+    const rebasedRouteMap = {};
+    const keyedWrites = [];
+    for (let x = 0; x < diff.length; x++) {
+        const diffRow = diff[x];
+        const path = diffRow.path;
+        const pathStr = path.join('.');
+        const routeAndPath = JoinPaths(route, pathStr);
+        if (diffRow.type === "write")
+            ExpandKeyedDiffFromValue(route, pathStr, keyFunc, diffRow.value, keyedWrites);
+        let curr = diffRoot;
+        let key = null;
+        let keyIndex = -1;
+        let keyCurr = null;
+        for (let y = 0; curr && y < path.length; y++) {
+            const currKey = keyFunc(curr);
+            if (currKey) {
+                key = currKey;
+                keyIndex = y;
+                keyCurr = curr;
+            }
+            curr = curr[path[y]];
+        }
+        if (key) {
+            const joinedPath = JoinPaths(route, key);
+            if (!IsPathWithin(routeAndPath, joinedPath)) {
+                const exists = !!ReadPath(treeRootState, joinedPath);
+                const [targetRoute, targetPath] = SplitRouteAndPath(joinedPath);
+                rebasedRouteMap[targetRoute] ??= [];
+                if (!exists) {
+                    rebasedRouteMap[targetRoute].push({
+                        type: 'write',
+                        path: targetPath.split('.'),
+                        value: keyCurr
+                    });
+                }
+                else {
+                    const rebasedDiffRow = diffRow.type === "move" ? {
+                        ...diffRow,
+                        path: targetPath.split('.').concat(diffRow.path.slice(keyIndex))
+                    } : {
+                        ...diffRow,
+                        path: targetPath.split('.').concat(diffRow.path.slice(keyIndex))
+                    };
+                    if (rebasedDiffRow.type === "move" || rebasedDiffRow.value !== ReadPath(treeRootState, JoinPaths(targetRoute, rebasedDiffRow.path.join('.'))))
+                        rebasedRouteMap[targetRoute].push(rebasedDiffRow);
+                }
+            }
+        }
+    }
+    for (let x = 0; x < keyedWrites.length; x++) {
+        const [keyedRoute, keyedPath] = SplitRouteAndPath(keyedWrites[x].path);
+        ApplyValueToPath(snapshot, treeRootState, routeKeyFunc, keyedRoute, keyedPath, keyedWrites[x].value);
+    }
+    for (const rebasedRoute in rebasedRouteMap) {
+        const rebasedRoot = ReadPath(treeRootState, rebasedRoute);
+        ApplyDiff(snapshot, treeRootState, routeKeyFunc, rebasedRoute, rebasedRoot, rebasedRouteMap[rebasedRoute]);
+    }
+}
+export function ApplyPathValues(snapshot, root, pathValues) {
+    for (let x = 0; x < pathValues.length; x++)
+        WritePath(snapshot, root, pathValues[x].path, JsonDeepClone(pathValues[x].value));
+}
+/**
+ * A snapshot resolver reading each keyed child through the path it lives at, keyed with the
+ * keyFunc of the route the snapshot walk is in.
+ */
+export function CreateKeyResolver(root, routeKeyFunc) {
+    return function (child, snapshotPath) {
+        const route = SnapshotPathRoute(snapshotPath);
+        const keyedPath = ResolveKey(routeKeyFunc(route), route, child);
+        if (!keyedPath)
+            return undefined;
+        const value = ReadPath(root, keyedPath);
+        return value === undefined ? undefined : { value, path: ToSnapshotPath(keyedPath) };
+    };
+}
+/**
+ * The snapshot of `routeRoot[property]`, read through its home value when it's keyed, as a
+ * snapshot of the whole route would hold it.
+ */
+function ResolvedSnapshot(snapshot, root, routeKeyFunc, routeRoot, route, property) {
+    const value = routeRoot[property];
+    if (JsonType(value) === "value")
+        return value;
+    const resolver = CreateKeyResolver(root, routeKeyFunc);
+    const path = ToSnapshotPath(JoinPaths(route, property));
+    const resolved = resolver(value, path);
+    return resolved ? Snapshot.Get(snapshot, resolved.value, resolver, resolved.path) : Snapshot.Get(snapshot, value, resolver, path);
+}
+export function ApplyValueToPath(snapshot, root, routeKeyFunc, basePath, path, value) {
+    const [route, property] = SplitRouteAndPath(path);
+    if (!property)
+        throw new Error("Unable to write to root path");
+    let combinedRoute = JoinPaths(basePath, route);
+    let diffRoot = ReadPath(root, combinedRoute);
+    if (diffRoot === undefined) {
+        WritePath(snapshot, root, combinedRoute, undefined);
+        diffRoot = ReadPath(root, combinedRoute);
+    }
+    // Only the written value is snapshotted. A snapshot of the whole route would cache values that
+    // embed keys whose home values this apply hasn't written yet, and nothing would update them.
+    const propertyIndex = property.indexOf(PROP_DELIMETER);
+    const rootProperty = propertyIndex < 0 ? property : property.slice(0, propertyIndex);
+    const currentValue = ReadPath(ResolvedSnapshot(snapshot, root, routeKeyFunc, diffRoot, combinedRoute, rootProperty), propertyIndex < 0 ? "" : property.slice(propertyIndex + 1));
+    const diff = JsonDiff(value, currentValue, property);
+    ApplyDiff(snapshot, root, routeKeyFunc, combinedRoute, diffRoot, diff);
+}
+/**
+ * Converts a route path to the snapshot path of the value it names, following how
+ * `WritePath` stores route state: `/channel/1/item.v` is `[ROUTE_STATE, "channel", ROUTE_STATE, "1", "item", "v"]`.
+ */
+export function ToSnapshotPath(path) {
+    const snapshotPath = [];
+    const [route, dotPath] = SplitRouteAndPath(path);
+    const routeParts = route.split(ROUTE_DELIMETER);
+    for (let x = 0; x < routeParts.length; x++)
+        routeParts[x] !== "" && snapshotPath.push(ROUTE_STATE, routeParts[x]);
+    if (dotPath !== "")
+        snapshotPath.push(...dotPath.split(PROP_DELIMETER));
+    return snapshotPath;
+}
+/** The route path a snapshot path is in: each segment following a `ROUTE_STATE`, e.g. `/channel/1/` */
+export function SnapshotPathRoute(path) {
+    let route = ROUTE_DELIMETER;
+    for (let x = 0; x < path.length - 1; x++)
+        if (path[x] === ROUTE_STATE)
+            route += `${String(path[x + 1])}${ROUTE_DELIMETER}`;
+    return route;
+}
+export function WritePath(snapshot, root, path, value, guardPath = true, pathIndex = 0) {
+    const startingSlash = path[pathIndex] === ROUTE_DELIMETER;
+    if (startingSlash && path.includes(ROUTE_DELIMETER, pathIndex + 1)) {
+        const routeKey = path.slice(pathIndex + 1, path.indexOf(ROUTE_DELIMETER, pathIndex + 1));
+        if (!Object.hasOwn(root, ROUTE_STATE))
+            Object.defineProperty(root, ROUTE_STATE, {
+                value: {}
+            });
+        root[ROUTE_STATE][routeKey] ??= {};
+        WritePath(snapshot, root[ROUTE_STATE][routeKey], path, value, guardPath, pathIndex + routeKey.length + 1);
+        return;
+    }
+    const sliceIndex = startingSlash ? pathIndex + 1 : pathIndex;
+    const dotPath = path.slice(sliceIndex);
+    if (guardPath && dotPath.startsWith(PROJECTION_PREFIX))
+        throw new Error(`Cannot write to ${path}: ${PROJECTION_PREFIX} keys are reserved for projection results.`);
+    if (dotPath === '')
+        return;
+    const parts = dotPath.split(PROP_DELIMETER);
+    let curr = root;
+    let x = 0;
+    for (; curr && x < parts.length - 1; x++)
+        curr = curr[parts[x]];
+    if (!curr)
+        throw new Error("Unable to write value to path: " + path);
+    if (curr[parts[x]])
+        Snapshot.Invalidate(snapshot, curr[parts[x]]);
+    curr[parts[x]] = value;
+    Snapshot.Invalidate(snapshot, curr);
+}
+export function ReadPath(root, path, pathIndex = 0) {
+    if (root === undefined)
+        return undefined;
+    if (path === '')
+        return root;
+    const startingSlash = path[pathIndex] === ROUTE_DELIMETER;
+    if (startingSlash && pathIndex === path.length - 1)
+        return root;
+    if (startingSlash && path.includes(ROUTE_DELIMETER, pathIndex + 1)) {
+        const routeKey = path.slice(pathIndex + 1, path.indexOf(ROUTE_DELIMETER, pathIndex + 1));
+        const nextRoot = root[ROUTE_STATE]?.[routeKey];
+        return ReadPath(nextRoot, path, pathIndex + routeKey.length + 1);
+    }
+    const sliceIndex = startingSlash ? pathIndex + 1 : pathIndex;
+    const dotPath = path.slice(sliceIndex);
+    const parts = dotPath.split(PROP_DELIMETER);
+    let curr = root;
+    let x = 0;
+    for (; curr && x < parts.length - 1; x++)
+        curr = curr[parts[x]];
+    return curr?.[parts[x]];
+}
+export function ReadPathFound(root, path, pathIndex = 0) {
+    if (root === undefined)
+        return [undefined, false];
+    if (path === '')
+        return [root, !!root];
+    const startingSlash = path[pathIndex] === ROUTE_DELIMETER;
+    if (startingSlash && pathIndex === path.length - 1)
+        return [root, !!root];
+    if (startingSlash && path.includes(ROUTE_DELIMETER, pathIndex + 1)) {
+        const routeKey = path.slice(pathIndex + 1, path.indexOf(ROUTE_DELIMETER, pathIndex + 1));
+        const nextRoot = root[ROUTE_STATE]?.[routeKey];
+        return ReadPathFound(nextRoot, path, pathIndex + routeKey.length + 1);
+    }
+    const sliceIndex = startingSlash ? pathIndex + 1 : pathIndex;
+    const dotPath = path.slice(sliceIndex);
+    const parts = dotPath.split(PROP_DELIMETER);
+    let curr = root;
+    let x = 0;
+    for (; curr && x < parts.length - 1; x++)
+        curr = curr[parts[x]];
+    return [curr?.[parts[x]], !!curr];
+}
+export function SplitRouteAndPath(path) {
+    const lastSlash = path.lastIndexOf(ROUTE_DELIMETER);
+    const route = path.slice(0, lastSlash + 1);
+    const propertyPath = path.slice(lastSlash + 1);
+    return [route, propertyPath];
+}
+export function GetKeyedPath(root, dotPath, keyFunc) {
+    if (!keyFunc)
+        return undefined;
+    const parts = dotPath.split(PROP_DELIMETER);
+    let keyPath = keyFunc(root);
+    let curr = root;
+    for (let x = 0; curr && x < parts.length - 1; x++) {
+        curr = curr[parts[x]];
+        keyPath = keyFunc(root) ?? keyPath;
+    }
+    return keyPath;
+}
+/**
+ * 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 = ReadPath(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]);
+}
+/** Whether a path's route has a wildcard segment, e.g. a `row_*` segment */
+export function IsWildcardPath(path) {
+    return SplitRouteAndPath(path)[0].includes(WILDCARD);
+}
+/**
+ * Whether a route matches a route pattern segment by segment. A pattern segment ending in `*`
+ * matches any segment starting with the text before it: a `row_*` segment matches `row_1`.
+ */
+export function RouteMatches(pattern, route) {
+    if (pattern === route)
+        return true;
+    // Every route but a few fails on the text before the wildcard, so that's checked before splitting
+    const wildcard = pattern.indexOf(WILDCARD);
+    if (wildcard < 0 || !route.startsWith(pattern.slice(0, wildcard)))
+        return false;
+    const patternParts = pattern.split(ROUTE_DELIMETER);
+    const routeParts = route.split(ROUTE_DELIMETER);
+    if (patternParts.length !== routeParts.length)
+        return false;
+    for (let x = 0; x < patternParts.length; x++)
+        if (patternParts[x].endsWith(WILDCARD) ? !routeParts[x].startsWith(patternParts[x].slice(0, -1)) : patternParts[x] !== routeParts[x])
+            return false;
+    return true;
+}
+/**
+ * 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 = ReadPath(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;
+}
+/**
+ * Throws when a read path's wildcard is invalid: more than one wildcard segment, a `*` that
+ * doesn't end its segment, or a `*` in the property path.
+ */
+export function ValidateWildcardPath(path) {
+    const [route, property] = SplitRouteAndPath(path);
+    const wildcards = route.split(ROUTE_DELIMETER).filter(part => part.includes(WILDCARD));
+    if (property.includes(WILDCARD) || wildcards.length > 1 || wildcards.some(part => part.indexOf(WILDCARD) !== part.length - 1))
+        throw new Error(`Invalid wildcard read ${path}: only one route segment may end in ${WILDCARD}.`);
+}
+/** Whether `path` is `basePath` or a property below it: `/a.b` is within `/a`, `/ab` isn't */
+export function IsPathWithin(path, basePath) {
+    return path === basePath || path.startsWith(basePath + PROP_DELIMETER);
+}
+export function JoinPaths(basePath, targetPath) {
+    if (targetPath.startsWith(ROUTE_DELIMETER))
+        return targetPath;
+    if (basePath === '')
+        return `/${targetPath}`;
+    return basePath.concat(targetPath);
+}

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
@@ -40,7 +39,6 @@ export declare abstract class ReadStore {
      * @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 +60,5 @@ 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;
 }

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)
@@ -61,10 +62,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 +73,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);
     }
 }
 /**

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