j-templates 8.1.1 → 8.2.0

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

@@ -1,6 +1,6 @@
 import type { JsonDiffResult } from "../../Utils/json";
 /**
- * `type` of the message a `DiffTreeWriter` posts on `Commit()`: the batch's diff results,
+ * `type` of the message a `DiffTreeWriter` posts on `Commit()`: the diff since the last commit,
  * which a `PushStore` applies.
  */
 export declare const DIFF_TREE_EVENT = "DIFF_TREE_EVENT";
@@ -9,82 +9,6 @@ export declare const DIFF_TREE_EVENT = "DIFF_TREE_EVENT";
  * failed, after the `DIFF_TREE_EVENT` carrying the changes that were applied.
  */
 export declare const DIFF_TREE_ERROR = "DIFF_TREE_ERROR";
-/**
- * Interface for diff tree operations.
- */
-export interface IDiffTree {
-    /**
-     * Computes the diff between a new value and the current value at a path.
-     * @param path - Dot-separated path to the value
-     * @param value - The new value to compare
-     * @returns Diff results showing changes
-     */
-    DiffPath(path: string, value: any): JsonDiffResult;
-    PatchPath(path: string, patch: any): JsonDiffResult;
-    SplicePath(path: string, start: number, deleteCount: number | undefined, items: any[]): DiffSpliceResult;
-    PushPath(path: string, items: any[]): JsonDiffResult;
-}
-/**
- * Constructor interface for IDiffTree.
- */
-export interface IDiffTreeConstructor {
-    /**
-     * Creates a new IDiffTree instance.
-     * @param keyFunc - Optional function to extract a key from a value
-     * @param projections - Optional map of derived-value projections, keyed by id
-     */
-    new (keyFunc?: {
-        (val: any): string;
-    }, projections?: DiffTreeProjectionMap): IDiffTree;
-}
-/**
- * A pure function computing a derived value from the current values at `reads`. Called with
- * the resolved read paths (`keys`) first, then each value positionally in the same order as
- * `reads`, so each value parameter can be typed at the call site instead of cast out of a
- * generic read. A trailing wildcard read expands to one key/value pair per matched root key,
- * so `keys` lets the function tell which root each trailing value came from.
- */
-export type DiffTreeProjectionFunc = (keys: string[], ...values: any[]) => any;
-/**
- * A projection's declaration: the dot-separated paths it reads (a plain tree path, an
- * entity's key, or another projection's `$projection_<id>` key for chaining) and the
- * function computing its result from their current values, positionally. Declaring `reads`
- * up front lets the tree topologically sort projections and reject a dependency cycle at
- * construction instead of on first write.
- *
- * The final entry in `reads` may instead be a wildcard root key (e.g. `"user_*"`, no dot
- * nesting) matching every root key with that prefix; each match is read and passed to the
- * projection as its own trailing key/value pair. A wildcard read can't be chained off a
- * projection's `$projection_<id>` key and can't appear anywhere but last.
- */
-export type DiffTreeProjectionDefinition = {
-    reads: string[];
-    projection: DiffTreeProjectionFunc;
-};
-/** A map of projection id to its declaration, keyed by the id used in `$projection_<id>`. */
-export type DiffTreeProjectionMap = {
-    [id: string]: DiffTreeProjectionDefinition;
-};
-/** Reserved key prefix a projection's result is stored under: `$projection_<id>`. */
-export declare const PROJECTION_PREFIX = "$projection_";
-export type DiffSpliceResult<T = unknown> = {
-    /** Array path segments (strings for object keys, numbers for array indices) */
-    path: (string | number)[];
-    /** Required by the splice operation **/
-    start: number;
-    deleteCount: number;
-    items: T[];
-    spliceResult: T[];
-    diffResult: JsonDiffResult;
-};
-export type IDiffMethodBatch = IDiffMethod[];
-export type IDiffMethodBatchResult = ({
-    type: "diff";
-    result: JsonDiffResult;
-} | {
-    type: "splice";
-    result: DiffSpliceResult;
-})[];
 /**
  * A message a `DiffTreeWriter` posts to its `PushStore`. Both arrive as ordinary
  * `"message"` events, so the channel can carry other traffic too; listeners tell them apart
@@ -92,14 +16,16 @@ export type IDiffMethodBatchResult = ({
  */
 export type IDiffPushEvent = {
     type: typeof DIFF_TREE_EVENT;
-    data: IDiffMethodBatchResult;
+    data: JsonDiffResult;
 } | {
     type: typeof DIFF_TREE_ERROR;
     data: any;
 };
+/** A `DiffTree` method call sent to a worker connected with `ConnectWorkerToDiffTree` */
 export interface IDiffMethod {
     /** The method to call */
-    method: "diffpath" | "splicepath" | "pushpath" | "patchpath";
+    method: "writepath" | "patchpath" | "pushpath" | "splicepath";
     /** Arguments for the method call */
     arguments: Array<any>;
 }
+export type IDiffMethodBatch = IDiffMethod[];

package/Store/Diff/diffTree.types.js

@@ -1,5 +1,5 @@
 /**
- * `type` of the message a `DiffTreeWriter` posts on `Commit()`: the batch's diff results,
+ * `type` of the message a `DiffTreeWriter` posts on `Commit()`: the diff since the last commit,
  * which a `PushStore` applies.
  */
 export const DIFF_TREE_EVENT = "DIFF_TREE_EVENT";
@@ -8,5 +8,3 @@ export const DIFF_TREE_EVENT = "DIFF_TREE_EVENT";
  * failed, after the `DIFF_TREE_EVENT` carrying the changes that were applied.
  */
 export const DIFF_TREE_ERROR = "DIFF_TREE_ERROR";
-/** Reserved key prefix a projection's result is stored under: `$projection_<id>`. */
-export const PROJECTION_PREFIX = "$projection_";

package/Store/Diff/diffTreeWorker.d.ts

@@ -1,2 +1,6 @@
 import { DiffTree } from "./diffTree";
+/**
+ * Runs each batch of method calls a `StoreAsync` sends on the tree, then its projections, and
+ * posts back the tree's `Commit()` diff for the store to apply.
+ */
 export declare function ConnectWorkerToDiffTree(diffTree: DiffTree, worker: Worker): void;

package/Store/Diff/diffTreeWorker.js

@@ -1,44 +1,22 @@
+/**
+ * Runs each batch of method calls a `StoreAsync` sends on the tree, then its projections, and
+ * posts back the tree's `Commit()` diff for the store to apply.
+ */
 export function ConnectWorkerToDiffTree(diffTree, worker) {
     worker.onmessage = function (event) {
         const data = event.data;
-        const result = new Array(data.length + 1);
-        for (let x = 0; x < data.length; x++) {
-            const call = data[x];
-            switch (call.method) {
-                case "diffpath": {
-                    result[x] = {
-                        type: "diff",
-                        result: diffTree.DiffPath(call.arguments[0], call.arguments[1])
-                    };
-                    break;
-                }
-                case "splicepath": {
-                    result[x] = {
-                        type: "splice",
-                        result: diffTree.SplicePath(call.arguments[0], call.arguments[1], call.arguments[2], call.arguments[3])
-                    };
-                    break;
-                }
-                case "pushpath": {
-                    result[x] = {
-                        type: "diff",
-                        result: diffTree.PushPath(call.arguments[0], call.arguments[1])
-                    };
-                    break;
-                }
-                case "patchpath": {
-                    result[x] = {
-                        type: "diff",
-                        result: diffTree.PatchPath(call.arguments[0], call.arguments[1])
-                    };
-                    break;
-                }
-            }
-        }
-        result[result.length - 1] = {
-            type: "diff",
-            result: diffTree.RunProjections()
-        };
-        worker.postMessage(result);
+        for (let x = 0; x < data.length; x++)
+            RunMethod(diffTree, data[x]);
+        diffTree.RunProjections();
+        worker.postMessage(diffTree.Commit());
     };
 }
+function RunMethod(diffTree, call) {
+    const args = call.arguments;
+    switch (call.method) {
+        case "writepath": return diffTree.WritePath(args[0], args[1]);
+        case "splicepath": return diffTree.SplicePath(args[0], args[1], args[2], args[3]);
+        case "pushpath": return diffTree.PushPath(args[0], args[1]);
+        case "patchpath": return diffTree.PatchPath(args[0], args[1]);
+    }
+}

package/Store/Diff/diffTreeWriter.d.ts

@@ -1,14 +1,14 @@
 import { JsonDiffResult } from "../../Utils/json";
 import { DiffTree } from "./diffTree";
-import { DiffSpliceResult, DiffTreeProjectionMap } from "./diffTree.types";
+import { IKeyFunc, IRouteDefinitions } from "./utils/diffTree.types";
 /**
  * A `DiffTree` that pushes its changes to a `PushStore` instead of answering a store's
  * requests. Use it inside a worker that produces data itself (for example, the result of a
  * computation it runs): write with the usual `DiffTree` methods, then call `Commit()` to run
  * projections and post everything since the last commit as one message.
  *
- * - Push only: don't pass a `DiffTreeWriter` to `ConnectWorkerToDiffTree`. It would record
- *   the request/response batches too and send them again on the next `Commit()`.
+ * - Push only: don't pass a `DiffTreeWriter` to `ConnectWorkerToDiffTree`, which commits
+ *   every batch itself and would post it to the wrong place.
  * - After a change fails, every later change before `Commit()` throws that same error. The
  *   changes made before the failure are already in the tree, so `Commit()` still sends them,
  *   followed by a `DIFF_TREE_ERROR` message. Projections aren't run for that batch; the next
@@ -18,8 +18,8 @@ import { DiffSpliceResult, DiffTreeProjectionMap } from "./diffTree.types";
  *
  * @example
  * // engine-worker.ts
- * const tree = new DiffTreeWriter(self, undefined, projections);
- * tree.DiffPath("results", computeResults());
+ * const tree = new DiffTreeWriter(self, undefined, { "/": { projections } });
+ * tree.WritePath("results", computeResults());
  * tree.Commit();
  *
  * // main thread
@@ -30,64 +30,51 @@ import { DiffSpliceResult, DiffTreeProjectionMap } from "./diffTree.types";
 export declare class DiffTreeWriter extends DiffTree {
     private worker;
     private uncommittedError;
-    private uncommitted;
     /**
      * Creates a DiffTreeWriter.
      * @param worker Where `Commit()` posts its messages: the worker's `self`, or a `MessagePort`.
      *   On the same thread as the store, anything whose `postMessage` dispatches a `"message"`
-     *   event on the store's `EventTarget`; post copies, or construct the store with `cloneData`.
+     *   event on the store's `EventTarget`. The store clones every value it applies, so it never
+     *   shares objects with the writer's tree.
      * @param keyFunc Optional function to extract a key from objects. Pass the same key logic to
      *   the `PushStore` that receives the changes.
-     * @param projections Optional map of derived-value projections, keyed by id. They run once
-     *   per `Commit()`, after the batch's changes.
+     * @param routes Optional route definitions. Projections run once per `Commit()`, after the
+     *   batch's changes.
      */
     constructor(worker: {
         postMessage(message: unknown): void;
-    }, keyFunc?: {
-        (val: any): string;
-    }, projections?: DiffTreeProjectionMap);
+    }, keyFunc?: IKeyFunc, routes?: IRouteDefinitions);
     /**
      * Not available on a DiffTreeWriter: `Commit()` runs projections once per batch, after its
      * changes. Running them earlier would push a projection result computed from part of a batch.
      * @throws Always.
      */
-    RunProjections(): JsonDiffResult;
+    RunProjections(): void;
     /**
-     * Computes the diff between a new value and the current value at a path, and records it
-     * for the next `Commit()`.
-     * @param path - Dot-separated path to the value
-     * @param value - The new value to compare
-     * @returns Diff results showing changes
+     * Writes a value at a path.
      * @throws The change's error, or an earlier uncommitted change's error.
      */
-    DiffPath(path: string, value: any): JsonDiffResult;
+    WritePath(path: string, value: any): void;
     /**
-     * Merges a patch into the current value at a path, and records the diff for the next
-     * `Commit()`.
-     * @param path - Dot-separated path to the value
-     * @param patch - The value to merge into the current value
-     * @returns Diff results showing changes
+     * Merges a patch into the current value at a path.
      * @throws The change's error, or an earlier uncommitted change's error.
      */
-    PatchPath(path: string, patch: any): JsonDiffResult;
+    PatchPath(path: string, patch: any): void;
     /**
-     * Appends items to the array at a path, and records the diff for the next `Commit()`.
-     * @param path - Dot-separated path to the array
-     * @param items - The items to append
-     * @returns Diff results showing changes
+     * Appends items to the array at a path.
      * @throws The change's error, or an earlier uncommitted change's error.
      */
-    PushPath(path: string, items: unknown[]): JsonDiffResult;
+    PushPath(path: string, items: unknown[]): void;
     /**
-     * Splices the array at a path, and records the splice for the next `Commit()`.
-     * @param path - Dot-separated path to the array
-     * @param start - The position at which to start changing the array
-     * @param deleteCount - The number of elements to delete
-     * @param items - The elements to insert
-     * @returns The splice and its diff results
+     * Splices the array at a path.
      * @throws The change's error, or an earlier uncommitted change's error.
      */
-    SplicePath(path: string, start: number, deleteCount: number, items: any[]): DiffSpliceResult<unknown>;
+    SplicePath(path: string, start: number, deleteCount: number, items: any[]): void;
+    /**
+     * Deletes a route, its child routes and its route instances.
+     * @throws The change's error, or an earlier uncommitted change's error.
+     */
+    DeleteRoute(routePath: string): void;
     /**
      * Runs projections and posts every change since the last commit as one `DIFF_TREE_EVENT`
      * message, which a `PushStore` applies as a unit. Posts nothing when nothing changed.
@@ -97,7 +84,9 @@ export declare class DiffTreeWriter extends DiffTree {
      * throw, since the failed change already did. If a projection throws, the batch's changes
      * and the error are posted the same way, then `Commit()` rethrows. Either way the next batch
      * starts clean.
+     * @returns The diff that was posted.
      * @throws A projection's error.
      */
-    Commit(): void;
+    Commit(): JsonDiffResult;
+    private Guard;
 }

package/Store/Diff/diffTreeWriter.js

@@ -6,8 +6,8 @@ import { DIFF_TREE_ERROR, DIFF_TREE_EVENT } from "./diffTree.types";
  * computation it runs): write with the usual `DiffTree` methods, then call `Commit()` to run
  * projections and post everything since the last commit as one message.
  *
- * - Push only: don't pass a `DiffTreeWriter` to `ConnectWorkerToDiffTree`. It would record
- *   the request/response batches too and send them again on the next `Commit()`.
+ * - Push only: don't pass a `DiffTreeWriter` to `ConnectWorkerToDiffTree`, which commits
+ *   every batch itself and would post it to the wrong place.
  * - After a change fails, every later change before `Commit()` throws that same error. The
  *   changes made before the failure are already in the tree, so `Commit()` still sends them,
  *   followed by a `DIFF_TREE_ERROR` message. Projections aren't run for that batch; the next
@@ -17,8 +17,8 @@ import { DIFF_TREE_ERROR, DIFF_TREE_EVENT } from "./diffTree.types";
  *
  * @example
  * // engine-worker.ts
- * const tree = new DiffTreeWriter(self, undefined, projections);
- * tree.DiffPath("results", computeResults());
+ * const tree = new DiffTreeWriter(self, undefined, { "/": { projections } });
+ * tree.WritePath("results", computeResults());
  * tree.Commit();
  *
  * // main thread
@@ -31,17 +31,17 @@ export class DiffTreeWriter extends DiffTree {
      * Creates a DiffTreeWriter.
      * @param worker Where `Commit()` posts its messages: the worker's `self`, or a `MessagePort`.
      *   On the same thread as the store, anything whose `postMessage` dispatches a `"message"`
-     *   event on the store's `EventTarget`; post copies, or construct the store with `cloneData`.
+     *   event on the store's `EventTarget`. The store clones every value it applies, so it never
+     *   shares objects with the writer's tree.
      * @param keyFunc Optional function to extract a key from objects. Pass the same key logic to
      *   the `PushStore` that receives the changes.
-     * @param projections Optional map of derived-value projections, keyed by id. They run once
-     *   per `Commit()`, after the batch's changes.
+     * @param routes Optional route definitions. Projections run once per `Commit()`, after the
+     *   batch's changes.
      */
-    constructor(worker, keyFunc, projections) {
-        super(keyFunc, projections);
+    constructor(worker, keyFunc, routes) {
+        super(keyFunc, routes);
         this.worker = worker;
         this.uncommittedError = null;
-        this.uncommitted = [];
     }
     /**
      * Not available on a DiffTreeWriter: `Commit()` runs projections once per batch, after its
@@ -52,100 +52,39 @@ export class DiffTreeWriter extends DiffTree {
         throw new Error("RunProjections is called during Commit()");
     }
     /**
-     * Computes the diff between a new value and the current value at a path, and records it
-     * for the next `Commit()`.
-     * @param path - Dot-separated path to the value
-     * @param value - The new value to compare
-     * @returns Diff results showing changes
+     * Writes a value at a path.
      * @throws The change's error, or an earlier uncommitted change's error.
      */
-    DiffPath(path, value) {
-        if (this.uncommittedError)
-            throw this.uncommittedError;
-        try {
-            const result = super.DiffPath(path, value);
-            result.length > 0 && this.uncommitted.push({
-                type: "diff",
-                result
-            });
-            return result;
-        }
-        catch (err) {
-            this.uncommittedError = err;
-            throw err;
-        }
+    WritePath(path, value) {
+        this.Guard(() => super.WritePath(path, value));
     }
     /**
-     * Merges a patch into the current value at a path, and records the diff for the next
-     * `Commit()`.
-     * @param path - Dot-separated path to the value
-     * @param patch - The value to merge into the current value
-     * @returns Diff results showing changes
+     * Merges a patch into the current value at a path.
      * @throws The change's error, or an earlier uncommitted change's error.
      */
     PatchPath(path, patch) {
-        if (this.uncommittedError)
-            throw this.uncommittedError;
-        try {
-            const result = super.PatchPath(path, patch);
-            result.length > 0 && this.uncommitted.push({
-                type: "diff",
-                result
-            });
-            return result;
-        }
-        catch (err) {
-            this.uncommittedError = err;
-            throw err;
-        }
+        this.Guard(() => super.PatchPath(path, patch));
     }
     /**
-     * Appends items to the array at a path, and records the diff for the next `Commit()`.
-     * @param path - Dot-separated path to the array
-     * @param items - The items to append
-     * @returns Diff results showing changes
+     * Appends items to the array at a path.
      * @throws The change's error, or an earlier uncommitted change's error.
      */
     PushPath(path, items) {
-        if (this.uncommittedError)
-            throw this.uncommittedError;
-        try {
-            const result = super.PushPath(path, items);
-            result.length > 0 && this.uncommitted.push({
-                type: "diff",
-                result
-            });
-            return result;
-        }
-        catch (err) {
-            this.uncommittedError = err;
-            throw err;
-        }
+        this.Guard(() => super.PushPath(path, items));
     }
     /**
-     * Splices the array at a path, and records the splice for the next `Commit()`.
-     * @param path - Dot-separated path to the array
-     * @param start - The position at which to start changing the array
-     * @param deleteCount - The number of elements to delete
-     * @param items - The elements to insert
-     * @returns The splice and its diff results
+     * Splices the array at a path.
      * @throws The change's error, or an earlier uncommitted change's error.
      */
     SplicePath(path, start, deleteCount, items) {
-        if (this.uncommittedError)
-            throw this.uncommittedError;
-        try {
-            const result = super.SplicePath(path, start, deleteCount, items);
-            this.uncommitted.push({
-                type: "splice",
-                result
-            });
-            return result;
-        }
-        catch (err) {
-            this.uncommittedError = err;
-            throw err;
-        }
+        this.Guard(() => super.SplicePath(path, start, deleteCount, items));
+    }
+    /**
+     * Deletes a route, its child routes and its route instances.
+     * @throws The change's error, or an earlier uncommitted change's error.
+     */
+    DeleteRoute(routePath) {
+        this.Guard(() => super.DeleteRoute(routePath));
     }
     /**
      * Runs projections and posts every change since the last commit as one `DIFF_TREE_EVENT`
@@ -156,24 +95,23 @@ export class DiffTreeWriter extends DiffTree {
      * throw, since the failed change already did. If a projection throws, the batch's changes
      * and the error are posted the same way, then `Commit()` rethrows. Either way the next batch
      * starts clean.
+     * @returns The diff that was posted.
      * @throws A projection's error.
      */
     Commit() {
+        let diff = [];
         try {
-            const result = !this.uncommittedError ? super.RunProjections() : [];
-            result.length > 0 && this.uncommitted.push({
-                type: "diff",
-                result
-            });
+            !this.uncommittedError && super.RunProjections();
         }
         catch (err) {
             this.uncommittedError = err;
             throw err;
         }
         finally {
-            this.uncommitted.length > 0 && this.worker.postMessage({
+            diff = super.Commit();
+            diff.length > 0 && this.worker.postMessage({
                 type: DIFF_TREE_EVENT,
-                data: this.uncommitted
+                data: diff
             });
             if (this.uncommittedError) {
                 this.worker.postMessage({
@@ -181,8 +119,19 @@ export class DiffTreeWriter extends DiffTree {
                     data: this.uncommittedError
                 });
             }
-            this.uncommitted = [];
             this.uncommittedError = null;
         }
+        return diff;
+    }
+    Guard(change) {
+        if (this.uncommittedError)
+            throw this.uncommittedError;
+        try {
+            change();
+        }
+        catch (err) {
+            this.uncommittedError = err;
+            throw err;
+        }
     }
 }

package/Store/Diff/index.d.ts

@@ -1 +1,2 @@
 export * from "./diffTree.types";
+export * from "./utils/diffTree.types";

package/Store/Diff/index.js

@@ -1 +1,2 @@
 export * from "./diffTree.types";
+export * from "./utils/diffTree.types";

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

@@ -0,0 +1,108 @@
+/** A projection of the values at one or more paths, rerun when any of them changes */
+export type IReadsProjectionDefinition = {
+    /**
+     * Paths relative to the route, or from the root when starting with `/`. One route segment may
+     * end in `*` to read every matching route, e.g. `child/row_*` + `/name`, which passes an object
+     * keyed by matched segment.
+     */
+    reads: string[];
+    projection: {
+        (...reads: any): any;
+    };
+};
+/**
+ * A projection of each entry of one keyed record, by key. Its output is a record with the same
+ * keys: an entry whose value is the same as on the last run keeps its output without a call, and
+ * an entry the projection returns undefined for is left out.
+ */
+export type IKeyedProjectionDefinition = {
+    reads?: never;
+    /**
+     * The record, relative to the route or from the root when starting with `/`; no wildcard. When
+     * left out, the route's own state, without its projections' outputs. A missing record reads as
+     * an empty one.
+     */
+    read?: string;
+    projection: {
+        (entry: any, key: string): any;
+    };
+};
+export type IProjectionDefinition = IReadsProjectionDefinition | IKeyedProjectionDefinition;
+export type IProjectionDefinitions = {
+    [key: string]: IProjectionDefinition;
+};
+/**
+ * A keyed projection's state: each key's value and output from its last run, kept for a key
+ * left out of the output too, so it isn't called again while its value is the same.
+ */
+export type IKeyedState = {
+    entries: Map<string, {
+        value: any;
+        output: any;
+    }>;
+    /** Whether it reads its route's own state, which leaves out the route's projection outputs */
+    routeState: boolean;
+};
+/** A route a read resolved through on its last full read: its path, raw state and the snapshot read from it */
+export type IRouteSource = {
+    route: string;
+    state: object;
+    snapshot: any;
+};
+/** A route a wildcard read matched: the segment, the path read in it, and what was read */
+export type IWildcardMatch = IRouteSource & {
+    segment: string;
+    path: string;
+    value: any;
+    found: boolean;
+};
+/** A wildcard read's matches, and the tree's route version, which changes when a route instance may have been added or removed */
+export type IWildcardSource = {
+    version: number;
+    matches: IWildcardMatch[];
+};
+/** What a read resolved through on its last full read */
+export type IReadSource = IRouteSource | IWildcardSource;
+export type IProjection = {
+    key: string;
+    reads: string[];
+    projection: {
+        (...reads: any): any;
+    };
+    /** Where the output is written: `$projection_<key>` in the route, e.g. `/channel/1/$projection_count` */
+    output: string;
+    /** Whether a read covers the projection's own output, e.g. a read of the route's root object */
+    readsOutput: boolean;
+    /** The read values from the last run, compared by reference to skip the next one */
+    values?: any[];
+    /**
+     * What each read resolved through on the last full read; undefined for a read that didn't
+     * resolve. While every route still has the same cached snapshot, no read can have changed.
+     */
+    sources?: (IReadSource | undefined)[];
+    /** Set for a keyed projection, whose one read is the record it maps */
+    keyed?: IKeyedState;
+};
+export type IKeyFunc = {
+    (val: any): string | undefined;
+};
+export type IRouteDefinition = {
+    projections: IProjectionDefinitions;
+    keyFunc?: IKeyFunc;
+    routes?: IRouteDefinitions;
+};
+export type IRouteDefinitions = {
+    [route: string]: IRouteDefinition;
+};
+export type IRoute = {
+    /** The instance's full route path from the tree root, e.g. `/channel/1/` */
+    path: string;
+    parts: string[];
+    projections: IProjection[];
+    /** Child instances by their own segments joined with `/`, e.g. `channel/1`, in creation order */
+    childRoutes: Map<string, IRoute>;
+    /** How many segments each child definition's pattern spans, in definition order, without repeats */
+    childPartCounts: number[];
+    keyFunc?: IKeyFunc;
+    routeDefinitions?: IRouteDefinitions;
+};

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

@@ -0,0 +1 @@
+export {};