j-templates 8.2.0 → 9.0.1

package/Node/vNode.js

@@ -312,6 +312,8 @@ function ScheduledAssignment(assign) {
             return;
         scheduled = true;
         NodeConfig.scheduleUpdate(function () {
+            if (ObservableScope.IsDestroyed(scope))
+                return;
             scheduled = false;
             const value = ObservableScope.Peek(scope);
             assign(value);

package/Store/Diff/diffTree.d.ts

@@ -1,22 +1,28 @@
 import { JsonDiffResult } from '../../Utils/json';
 import { IKeyFunc, IRouteDefinitions } from './utils/diffTree.types';
+/**
+ * A tree of JSON state in routes, with projections, that tracks its changes as diffs. The work is
+ * split across `utils/`:
+ * - `homes`: writes, which keep every keyed value at its home
+ * - `state`: reading and writing route state, and snapshots of it
+ * - `routes`: route instances, created from the route definitions
+ * - `projections`: running each route instance's projections
+ * - `paths`: path strings
+ */
 export declare class DiffTree {
-    private keyFunc?;
-    private routeDefinitions;
     private rootState;
-    private rootRoute;
-    private commitedSnapshot;
-    private routeCache;
-    private routeKeyFunc;
-    private resolver;
     private snapshot;
-    private projectionOrder;
-    private routeVersion;
+    private routes;
+    private projections;
+    /** Each root key's snapshot as of the last commit */
+    private commitedSnapshot;
+    private writeContext;
     constructor(keyFunc?: IKeyFunc, routeDefinitions?: IRouteDefinitions);
     WritePath(path: string, value: any): void;
     PatchPath(path: string, patch: any): void;
     PushPath(path: string, items: unknown[]): void;
     SplicePath(path: string, start: number, deleteCount: number, items: any[]): void;
+    private Splice;
     /**
      * Deletes a route: its state, its child routes and projection outputs, and its route
      * instances. The projection order is rebuilt on the next `RunProjections`, so deleting
@@ -30,49 +36,18 @@ export declare class DiffTree {
      * @returns The value, or undefined when any segment of the path doesn't exist
      */
     ReadPath(path: string): any;
-    /**
-     * Runs every projection of every route instance, dependencies first. A projection is skipped
-     * when no route it reads through changed since its last run, when a read's parent is missing,
-     * or when every read value is the same as its last run. Outputs are written as-is to
-     * `$projection_<key>` in their route, without a diff.
-     * @throws When projections depend on each other in a cycle
-     */
+    /** Runs every projection of every route instance; see `Projections.Run` */
     RunProjections(): void;
-    Commit(): JsonDiffResult;
-    Snapshot(path: string): any;
-    /**
-     * Finds the route instance for a route path (the portion of a path before the last `/`), creating it (and any missing
-     * parent instances) from the matching definition on first use.
-     * @returns The deepest route instance matched by a definition, or the root route when none matches
-     */
-    private GetRouteInstance;
-    /**
-     * Whether every route a projection's reads resolved through on its last full read still has
-     * the snapshot it read: a write anywhere under a route clears its cached snapshot, so then no
-     * read can have changed. A wildcard read also needs the same route instances to exist.
-     */
-    private SourcesUnchanged;
     /**
-     * Takes a new snapshot of every source in the route a projection just wrote its output to. The
-     * write cleared that route's snapshot, but nothing the projection read changed between its read
-     * and the write, so without this the next run would read everything again for nothing.
+     * The changes since the last commit. The root is a flat record of keys, so each key's snapshot
+     * is taken and compared on its own, without building a snapshot of the whole root: a key no
+     * write touched has the same cached snapshot as the last commit, and is skipped.
      */
-    private RefreshSources;
-    /**
-     * Snapshots of the values at each path, read through the route's root object so keyed
-     * values resolve through their own copy.
-     * @param sources Filled with what each read resolved through; a read after a missing one is left undefined
-     * @param previous The sources of the last full read, so a wildcard read reuses its unchanged matches
-     * @returns The values, or undefined when any of them is missing
-     */
-    private ReadValues;
-    /** The value at a path, whether it was found, and the route it was read through, when there is one */
-    private ReadValue;
+    Commit(): JsonDiffResult;
     /**
-     * Reads every route a wildcard path matches. While no route instance was added or removed since
-     * the last read, the matches are the same, and a match whose route has the same snapshot keeps
-     * the value it read.
+     * The snapshot of the value at a path. Only the path's first property is snapshotted, not
+     * its whole route.
+     * @returns The snapshot, or undefined when any segment of the path doesn't exist
      */
-    private ReadWildcard;
-    private ReadMatch;
+    Snapshot(path: string): any;
 }