dirvi-lib 0.7.1 → 0.8.0

package/dist/tree-surfer/nav-node/nav-node.types.d.ts

@@ -1,42 +1,70 @@
-import { LeafTreeNode, SerializableKey, TreeNode } from '../tree-node/tree-node.types.js';
-import { FoldNodeRoot } from '../fold-node/fold-node.types.js';
+import { BranchTreeNode, SerializableKey, TreeNode } from '../tree-node/tree-node.types.js';
 import { Cursor } from '../cursor.js';
-/**
- * A navigation entry preserves the original buffer-node properties, but
- * replaces a branch's buffer children with a NavNode.
- */
-export type NavEntry<Id extends SerializableKey, BufferNode extends TreeNode<Id, BufferNode>> = NavLeaf<Id, BufferNode> | NavBranch<Id, BufferNode>;
-export type NavLeaf<Id extends SerializableKey, BufferNode extends TreeNode<Id, BufferNode>> = BufferNode & LeafTreeNode<Id>;
-type ReplaceChildren<Node, Children> = Node extends {
-    children: unknown;
-} ? Omit<Node, 'children'> & {
-    children: Children;
-} : never;
-export type NavBranch<Id extends SerializableKey, BufferNode extends TreeNode<Id, BufferNode>> = ReplaceChildren<BufferNode, NavNode<Id, BufferNode> | null>;
-export declare function isNavBranch<Id extends SerializableKey, BufferNode extends TreeNode<Id, BufferNode>>(entry: NavEntry<Id, BufferNode>): entry is NavBranch<Id, BufferNode>;
-/**
- * The derived tree as navigated: list of visible entries and folded entries.
- */
-export type NavNode<Id extends SerializableKey, BufferNode extends TreeNode<Id, BufferNode>> = {
+import { FoldNode } from '../fold-node/fold-node.types.js';
+export type NavNode<Id extends SerializableKey> = {
     /**
-     * Currently visible entries.
+     * Synthetic UI entry representing folded children.
+     *
+     * It is absent when this directory has no folded children.
      */
-    entries: NavEntry<Id, BufferNode>[];
+    folded: NavFoldEntry<Id> | null;
     /**
-     * Currently loaded entries hidden by this directory's fold.
+     * Loaded entries that are not folded at this directory, corresponding to
+     * navigable rows. Entries retain the order from the TreeNode.
      */
-    foldedEntries: NavEntry<Id, BufferNode>[];
+    entries: NavEntry<Id>[];
 };
-export type NavNodeApi<Id extends SerializableKey, BufferNode extends TreeNode<Id, BufferNode>> = {
-    from(entries: BufferNode[], foldNode: FoldNodeRoot<Id>): NavNode<Id, BufferNode>;
-    getNodeAtPath(navigation: NavNode<Id, BufferNode>, path: Id[]): NavNode<Id, BufferNode> | undefined;
-    getEntryAtPath(navigation: NavNode<Id, BufferNode>, path: Id[]): NavEntry<Id, BufferNode> | undefined;
-    nextCursor(rootNode: NavNode<Id, BufferNode>, cursor: Cursor<Id>): Cursor<Id> | undefined;
-    previousCursor(rootNode: NavNode<Id, BufferNode>, cursor: Cursor<Id>): Cursor<Id> | undefined;
-    cursorAfterFold(rootNode: NavNode<Id, BufferNode>, cursor: Cursor<Id>): Cursor<Id> | undefined;
-    parentCursor(navigation: NavNode<Id, BufferNode>, cursor: Cursor<Id>): Cursor<Id> | undefined;
-    cursors(navigation: NavNode<Id, BufferNode>, parentPath?: Id[]): Cursor<Id>[];
-    visibleLeavesPaths(navigation: NavNode<Id, BufferNode>, parentPath?: Id[]): Id[][];
+export type NavFoldEntry<Id extends SerializableKey> = {
+    /**
+     * Folded entries that are present in the loaded TreeNode.
+     *
+     * This is information for rendering the folded row.
+     */
+    entries: NavEntry<Id>[];
+};
+export type NavEntry<Id extends SerializableKey> = NavLeaf<Id> | NavBranch<Id>;
+export type NavLeaf<Id extends SerializableKey> = {
+    id: Id;
+};
+export type NavBranch<Id extends SerializableKey> = {
+    id: Id;
+    children: NavNode<Id> | null;
+};
+export type NavNodeApi<Id extends SerializableKey, Node extends TreeNode<Id, Node>> = {
+    /**
+     * Tests whether a navigation entry represents a branch.
+     *
+     * A branch is an entry with a `children` property. Its `children` value is
+     * `null` when the corresponding tree branch has not been loaded or opened.
+     */
+    entryIsBranch(entry: NavEntry<Id>): entry is NavBranch<Id>;
+    /**
+     * Creates a navigation projection of the tree node root.
+     *
+     * The root must be a branch node because navigation is rooted at a
+     * directory-like node. The returned navigation entry is always a `NavBranch`.
+     *
+     * The TreeNode is authoritative for:
+     *
+     * - entry identity and order;
+     * - whether the entry is a leaf or branch;
+     * - whether branch children are loaded; and
+     * - the loaded child entries.
+     *
+     * The optional FoldNode is authoritative for folding. When `foldRoot` is
+     * undefined, the projection contains no folded entries.
+     *
+     * A folded entry is omitted from its parent's navigable entries and is
+     * represented by that parent's synthetic `folded` entry instead.
+     */
+    from(root: Node & BranchTreeNode<Id, Node>, foldRoot: FoldNode<Id> | undefined): NavBranch<Id>;
+    getNodeAtPath(navigation: NavNode<Id>, path: readonly Id[]): NavNode<Id> | undefined;
+    getEntryAtPath(navigation: NavNode<Id>, path: readonly Id[]): NavEntry<Id> | undefined;
+    nextCursor(rootNode: NavBranch<Id>, cursor: Cursor<Id>): Cursor<Id> | undefined;
+    previousCursor(rootNode: NavBranch<Id>, cursor: Cursor<Id>): Cursor<Id> | undefined;
+    cursorAfterFold(rootNode: NavBranch<Id>, cursor: Cursor<Id>): Cursor<Id> | undefined;
+    parentCursor(navigation: NavNode<Id>, cursor: Cursor<Id>): Cursor<Id> | undefined;
+    cursors(navigation: NavNode<Id>, parentPath?: Id[]): Cursor<Id>[];
+    visibleLeavesPaths(navigation: NavNode<Id>, parentPath?: readonly Id[]): Id[][];
 };
-export {};
 //# sourceMappingURL=nav-node.types.d.ts.map

package/dist/tree-surfer/nav-node/nav-node.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nav-node.types.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/nav-node/nav-node.types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"nav-node.types.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/nav-node/nav-node.types.ts"],"names":[],"mappings":"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"}

package/dist/tree-surfer/nav-node/nav-node.types.js

@@ -1,3 +1 @@
-export function isNavBranch(entry) {
-    return 'children' in entry;
-}
+export {};

package/dist/tree-surfer/state/state.impl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state.impl.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/state/state.impl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACzF,OAAO,EAAY,WAAW,EAAgB,MAAM,iCAAiC,CAAC;AACtF,OAAO,EAAU,SAAS,EAAc,MAAM,cAAc,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,EAAE,QAAQ,EAAS,MAAM,kBAAkB,CAAC;AAEnD,wBAAgB,cAAc,CAC5B,EAAE,SAAS,eAAe,EAC1B,IAAI,SAAS,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC,EAE/B,WAAW,EAAE,WAAW,CAAC,EAAE,EAAE,IAAI,CAAC,EAClC,WAAW,EAAE,WAAW,CAAC,EAAE,CAAC,EAC5B,SAAS,EAAE,SAAS,CAAC,EAAE,CAAC,EACxB,UAAU,EAAE,UAAU,CAAC,EAAE,EAAE,IAAI,CAAC,GAC/B,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC,CA6IpB"}
+{"version":3,"file":"state.impl.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/state/state.impl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,eAAe,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACzG,OAAO,EAAY,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACxE,OAAO,EAAU,SAAS,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,EAAE,QAAQ,EAAS,MAAM,kBAAkB,CAAC;AAEnD,wBAAgB,cAAc,CAC5B,EAAE,SAAS,eAAe,EAC1B,IAAI,SAAS,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC,EAE/B,WAAW,EAAE,WAAW,CAAC,EAAE,EAAE,IAAI,CAAC,EAClC,WAAW,EAAE,WAAW,CAAC,EAAE,CAAC,EAC5B,SAAS,EAAE,SAAS,CAAC,EAAE,CAAC,EACxB,UAAU,EAAE,UAAU,CAAC,EAAE,EAAE,IAAI,CAAC,GAC/B,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC,CAoIpB"}

package/dist/tree-surfer/state/state.impl.js

@@ -1,50 +1,55 @@
-import { CursorKind } from '../cursor.js';
 export function createStateApi(treeNodeApi, foldNodeApi, cursorApi, navNodeApi) {
     /**
-     * Create a new buffer and fold node at a level.
+     * Create a new root and fold root.
      *
      * Works on fold root and descendant fold nodes using the generic.
+     *
+     * TODO: Later: Filter the fold node
      */
-    async function reload(oldBuffer, oldFoldNode, parentPath, loadBranches) {
-        let newBuffer = await loadBranches(parentPath);
+    async function reload(oldRoot, oldFoldNode, parentPath, loadBranches) {
+        // Do not load a branch that was already closed.
+        if (!treeNodeApi.isOpenBranch(oldRoot)) {
+            return {
+                root: oldRoot,
+                foldRoot: oldFoldNode,
+            };
+        }
+        const newChildren = await loadBranches(parentPath);
+        let newRoot = {
+            ...oldRoot,
+            children: newChildren,
+        };
         let newFoldNode = oldFoldNode; // Start with assumption of no changes
-        for (const oldEntry of oldBuffer) {
+        for (const oldEntry of oldRoot.children) {
             if (!treeNodeApi.isBranch(oldEntry) ||
                 !treeNodeApi.isOpenBranch(oldEntry)) {
                 continue;
             }
-            const newEntry = treeNodeApi.getAtPath(newBuffer, [oldEntry.id], (entry) => entry);
-            if (newEntry === undefined || !treeNodeApi.isBranch(newEntry)) {
-                continue;
-            }
             const oldChildFoldNode = oldFoldNode === undefined
                 ? undefined
                 : foldNodeApi.getChildById(oldFoldNode, oldEntry.id);
             const entryPath = [...parentPath, oldEntry.id];
-            const reloadedChild = await reload([...treeNodeApi.getChildren(oldEntry)], oldChildFoldNode, entryPath, loadBranches);
-            const updatedBuffer = treeNodeApi.modifyAtPath(newBuffer, [oldEntry.id], (entry) => {
-                // The entry may be closed: loadBranches normally returns branches
-                // with `branches: null`. We are turning it back into an open branch.
+            const reloadedChild = await reload(oldEntry, oldChildFoldNode, entryPath, loadBranches);
+            const updatedRoot = treeNodeApi.modifyAtPath(newRoot, [oldEntry.id], (entry) => {
                 if (!treeNodeApi.isBranch(entry)) {
                     return undefined;
                 }
                 return {
                     ...entry,
-                    children: reloadedChild.buffer,
+                    children: reloadedChild.root.children,
                 };
             });
-            if (updatedBuffer !== undefined) {
-                newBuffer = updatedBuffer;
+            if (updatedRoot !== undefined && treeNodeApi.isOpenBranch(updatedRoot)) {
+                newRoot = updatedRoot;
             }
         }
         return {
-            buffer: newBuffer,
-            foldNode: newFoldNode,
+            root: newRoot,
+            foldRoot: newFoldNode,
         };
     }
     /**
-     * Currently the cursor just goes to the first entry at root if
-     * not all root entries are folded, otherwise the fold.
+     * Currently the cursor just goes to root.
      *
      * TODO: Cursor policy:
      * 1. Keep the exact cursor if it survives,
@@ -53,21 +58,16 @@ export function createStateApi(treeNodeApi, foldNodeApi, cursorApi, navNodeApi)
      * 4. Otherwise, choose the first new cursor.
      * 5. If no cursor exists, use the root fold cursor.
      */
-    function resyncCursor(oldState, newBuffer, newFoldNode) {
-        const navigation = navNodeApi.from(newBuffer, newFoldNode);
-        return navNodeApi.cursors(navigation)[0];
+    function resyncCursor(oldState, newRoot, newFoldNode) {
+        return [];
     }
     return {
         getNodeAtCursor(state) {
             const path = cursorApi.getPath(state.cursor);
-            if (path === undefined) {
-                // The cursor is positioned on a fold rather than an entry.
-                return undefined;
-            }
-            return treeNodeApi.getAtPath(state.buffer, path, (node) => node);
+            return treeNodeApi.getAtPath(state.root, path, (node) => node);
         },
         async resync(oldState, loadChildren) {
-            const reloaded = await reload(oldState.buffer, oldState.foldNode, [], loadChildren);
+            const reloaded = await reload(oldState.root, oldState.foldRoot, [], loadChildren);
             /*
              * `oldState.foldNode` is always present. At the root reload starts with
              * that node, so `reloaded.foldNode` should also always be present.
@@ -75,15 +75,13 @@ export function createStateApi(treeNodeApi, foldNodeApi, cursorApi, navNodeApi)
              * The fallback expresses the State invariant while satisfying the
              * optional return type needed by recursive child reloads.
              */
-            const foldNode = reloaded.foldNode ?? oldState.foldNode;
-            const cursor = resyncCursor(oldState, reloaded.buffer, foldNode) ?? {
-                kind: CursorKind.Fold,
-                parentPath: [],
-            };
+            const foldRoot = reloaded.foldRoot ?? oldState.foldRoot;
+            const cursor = resyncCursor(oldState, reloaded.root, foldRoot) ?? [];
+            const root = reloaded.root;
             return {
                 ...oldState,
-                buffer: reloaded.buffer,
-                foldNode,
+                root,
+                foldRoot,
                 cursor,
             };
         },

package/dist/tree-surfer/state/state.schemas.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 import { SerializableKey, TreeNode } from '../tree-node/tree-node.types.js';
 import { State } from './state.types.js';
-export declare function createStateSchema<Id extends SerializableKey, Node extends TreeNode<Id, Node>>(bufferNodeSchema: z.ZodType<Node>, foldNodeRootSchema: z.ZodType<State<Id, Node>['foldNode']>, cursorSchema: z.ZodType<State<Id, Node>['cursor']>): z.ZodObject<{
-    buffer: z.ZodArray<z.ZodType<Node, unknown, z.core.$ZodTypeInternals<Node, unknown>>>;
-    foldNode: z.ZodType<import("../index.js").FoldNodeRoot<Id>, unknown, z.core.$ZodTypeInternals<import("../index.js").FoldNodeRoot<Id>, unknown>>;
+export declare function createStateSchema<Id extends SerializableKey, Node extends TreeNode<Id, Node>>(rootSchema: z.ZodType<State<Id, Node>['root']>, foldNodeRootSchema: z.ZodType<State<Id, Node>['foldRoot']>, cursorSchema: z.ZodType<State<Id, Node>['cursor']>): z.ZodObject<{
+    root: z.ZodType<Node & import("../tree-node/tree-node.types.js").BranchTreeNode<Id, Node>, unknown, z.core.$ZodTypeInternals<Node & import("../tree-node/tree-node.types.js").BranchTreeNode<Id, Node>, unknown>>;
+    foldRoot: z.ZodType<import("../index.js").FoldNode<Id>, unknown, z.core.$ZodTypeInternals<import("../index.js").FoldNode<Id>, unknown>>;
     cursor: z.ZodType<import("../cursor.js").Cursor<Id>, unknown, z.core.$ZodTypeInternals<import("../cursor.js").Cursor<Id>, unknown>>;
 }, z.core.$strip>;
 //# sourceMappingURL=state.schemas.d.ts.map

package/dist/tree-surfer/state/state.schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state.schemas.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/state/state.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAC5E,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEzC,wBAAgB,iBAAiB,CAC/B,EAAE,SAAS,eAAe,EAC1B,IAAI,SAAS,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC,EAE/B,gBAAgB,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EACjC,kBAAkB,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC,UAAU,CAAC,CAAC,EAC1D,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC;;;;kBAOnD"}
+{"version":3,"file":"state.schemas.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/state/state.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAC5E,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEzC,wBAAgB,iBAAiB,CAC/B,EAAE,SAAS,eAAe,EAC1B,IAAI,SAAS,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC,EAE/B,UAAU,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,EAC9C,kBAAkB,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC,UAAU,CAAC,CAAC,EAC1D,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC;;;;kBAOnD"}

package/dist/tree-surfer/state/state.schemas.js

@@ -1,8 +1,8 @@
 import { z } from 'zod';
-export function createStateSchema(bufferNodeSchema, foldNodeRootSchema, cursorSchema) {
+export function createStateSchema(rootSchema, foldNodeRootSchema, cursorSchema) {
     return z.object({
-        buffer: z.array(bufferNodeSchema),
-        foldNode: foldNodeRootSchema,
+        root: rootSchema,
+        foldRoot: foldNodeRootSchema,
         cursor: cursorSchema,
     });
 }

package/dist/tree-surfer/state/state.types.d.ts

@@ -1,16 +1,20 @@
-import { Cursor } from '../cursor.js';
-import { SerializableKey, TreeNode } from '../tree-node/tree-node.types.js';
-import { FoldNodeRoot } from '../fold-node/fold-node.types.js';
+import type { Cursor } from '../cursor.js';
+import { BranchTreeNode, SerializableKey, TreeNode } from '../tree-node/tree-node.types.js';
+import type { FoldNode } from '../fold-node/fold-node.types.js';
 export type State<Id extends SerializableKey, Node extends TreeNode<Id, Node>> = {
-    buffer: Node[];
-    foldNode: FoldNodeRoot<Id>;
+    root: Node & BranchTreeNode<Id, Node>;
+    foldRoot: FoldNode<Id>;
     cursor: Cursor<Id>;
 };
 export type StateApi<Id extends SerializableKey, Node extends TreeNode<Id, Node>> = {
     getNodeAtCursor(state: State<Id, Node>): Node | undefined;
     /**
-     * Reloads the root and all descendant branches that were loaded in the
-     * previous state.
+     * Reloads the root's children and all descendant branches that were loaded in
+     * the previous state.
+     *
+     * `loadBranches([])` loads the root's direct children.
+     * `loadBranches(['src'])` loads the children of `src`, where 'src' is the
+     * id of a root's child.
      */
     resync(oldState: State<Id, Node>, loadBranches: (path: Id[]) => Promise<Node[]>): Promise<State<Id, Node>>;
 };

package/dist/tree-surfer/state/state.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state.types.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/state/state.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACtC,OAAO,EACL,eAAe,EACf,QAAQ,EACT,MAAM,iCAAiC,CAAC;AACzC,OAAO,EACL,YAAY,EACb,MAAM,iCAAiC,CAAC;AAEzC,MAAM,MAAM,KAAK,CACf,EAAE,SAAS,eAAe,EAC1B,IAAI,SAAS,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC,IAC7B;IACF,MAAM,EAAE,IAAI,EAAE,CAAC;IACf,QAAQ,EAAE,YAAY,CAAC,EAAE,CAAC,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,QAAQ,CAClB,EAAE,SAAS,eAAe,EAC1B,IAAI,SAAS,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC,IAC7B;IACF,eAAe,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,IAAI,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC;IAE1D;;;OAGG;IACH,MAAM,CACJ,QAAQ,EAAE,KAAK,CAAC,EAAE,EAAE,IAAI,CAAC,EACzB,YAAY,EAAE,CAAC,IAAI,EAAE,EAAE,EAAE,KAAK,OAAO,CAAC,IAAI,EAAE,CAAC,GAC5C,OAAO,CAAC,KAAK,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC;CAC7B,CAAC"}
+{"version":3,"file":"state.types.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/state/state.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,EACL,cAAc,EACd,eAAe,EACf,QAAQ,EACT,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAEhE,MAAM,MAAM,KAAK,CACf,EAAE,SAAS,eAAe,EAC1B,IAAI,SAAS,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC,IAC7B;IACF,IAAI,EAAE,IAAI,GAAG,cAAc,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;IACtC,QAAQ,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,QAAQ,CAAC,EAAE,SAAS,eAAe,EAAE,IAAI,SAAS,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC,IAAI;IAClF,eAAe,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,IAAI,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC;IAE1D;;;;;;;OAOG;IACH,MAAM,CACJ,QAAQ,EAAE,KAAK,CAAC,EAAE,EAAE,IAAI,CAAC,EACzB,YAAY,EAAE,CAAC,IAAI,EAAE,EAAE,EAAE,KAAK,OAAO,CAAC,IAAI,EAAE,CAAC,GAC5C,OAAO,CAAC,KAAK,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC;CAC7B,CAAC"}

package/dist/tree-surfer/tree-node/tree-node.arb.d.ts

@@ -42,11 +42,9 @@ export declare const generatedClosedBranchNodeArb: fc.Arbitrary<NodeWithReachabl
  */
 export declare const generatedNodeArb: fc.Arbitrary<NodeWithReachableNodes>;
 /**
- * Generates an array of generated nodes with unique IDs suitable for use as
- * the root of a forest.
+ * Generates an array of generated nodes with unique sibling IDs.
  *
- * Root IDs must be unique because paths begin by looking up an ID in this
- * array.
+ * The result is suitable for use as the loaded children of an open branch.
  */
 export declare const generatedNodesArrayArb: fc.Arbitrary<NodeWithReachableNodes[]>;
 /**
@@ -56,8 +54,8 @@ export declare const generatedNodesArrayArb: fc.Arbitrary<NodeWithReachableNodes
  * Paths through closed branches stop at the closed branch because its
  * descendants are not loaded.
  */
-export declare const nodesArrayAndPathsArb: fc.Arbitrary<{
-    entries: any[];
+export declare const nodeAndPathsArb: fc.Arbitrary<{
+    root: any;
     pathEntries: NodeAtPath[];
 }>;
 /**
@@ -66,8 +64,8 @@ export declare const nodesArrayAndPathsArb: fc.Arbitrary<{
  * Every generated path is valid for `getAtPath`; unreachable paths are not
  * included.
  */
-export declare const nodesArrayAndPathAndExpectedArb: fc.Arbitrary<{
-    entries: any[];
+export declare const nodeAndPathAndExpectedArb: fc.Arbitrary<{
+    root: any;
     path: Path;
     expected: any;
 }>;
@@ -78,7 +76,7 @@ export declare const nodesArrayAndPathAndExpectedArb: fc.Arbitrary<{
  * valid, but a path through a closed branch cannot reach any descendants.
  */
 export declare const nodesArrayAndBranchPathArb: fc.Arbitrary<{
-    entries: any[];
+    root: any;
     path: Path;
     expected: any;
 }>;

package/dist/tree-surfer/tree-node/tree-node.arb.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tree-node.arb.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/tree-node/tree-node.arb.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAErD;;;;GAIG;AACH,KAAK,UAAU,GAAG,MAAM,CAAC;AASzB;;;GAGG;AACH,eAAO,MAAM,SAAS,sBAIpB,CAAC;AAEH;;GAEG;AAEH,MAAM,MAAM,UAAU,GAAG,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;AAC1D,KAAK,IAAI,GAAG,UAAU,EAAE,CAAC;AAEzB,KAAK,UAAU,GAAG;IAChB,IAAI,EAAE,IAAI,CAAC;IACX,IAAI,EAAE,UAAU,CAAC;CAClB,CAAC;AAEF,KAAK,sBAAsB,GAAG;IAC5B,IAAI,EAAE,UAAU,CAAC;IACjB,cAAc,EAAE,UAAU,EAAE,CAAC;CAC9B,CAAC;AAyEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,sCAEhC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,4BAA4B,sCAExC,CAAC;AAaF;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,EAAE,EAAE,CAAC,SAAS,CAAC,sBAAsB,CA0C5D,CAAC;AAEP;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,wCAIjC,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB;;;EAOjC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,+BAA+B;;;;EAQzC,CAAC;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B;;;;EAcpC,CAAC;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,cAAc,qBAE1B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,4BAGhC,CAAC"}
+{"version":3,"file":"tree-node.arb.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/tree-node/tree-node.arb.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAErD;;;;GAIG;AACH,KAAK,UAAU,GAAG,MAAM,CAAC;AASzB;;;GAGG;AACH,eAAO,MAAM,SAAS,sBAIpB,CAAC;AAEH;;GAEG;AAEH,MAAM,MAAM,UAAU,GAAG,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;AAC1D,KAAK,IAAI,GAAG,UAAU,EAAE,CAAC;AAEzB,KAAK,UAAU,GAAG;IAChB,IAAI,EAAE,IAAI,CAAC;IACX,IAAI,EAAE,UAAU,CAAC;CAClB,CAAC;AAEF,KAAK,sBAAsB,GAAG;IAC5B,IAAI,EAAE,UAAU,CAAC;IACjB,cAAc,EAAE,UAAU,EAAE,CAAC;CAC9B,CAAC;AAqEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,sCAEhC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,4BAA4B,sCAExC,CAAC;AAaF;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,EAAE,EAAE,CAAC,SAAS,CAAC,sBAAsB,CA0C5D,CAAC;AAEP;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,wCAIjC,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,eAAe;;;EAK3B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB;;;;EAQnC,CAAC;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B;;;;EAYpC,CAAC;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,cAAc,qBAE1B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,4BAGhC,CAAC"}

package/dist/tree-surfer/tree-node/tree-node.arb.debug.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tree-node.arb.debug.test.d.ts.map

package/dist/tree-surfer/tree-node/tree-node.arb.debug.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-node.arb.debug.test.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/tree-node/tree-node.arb.debug.test.ts"],"names":[],"mappings":""}

package/dist/tree-surfer/tree-node/tree-node.arb.js

@@ -22,7 +22,7 @@ const generatedLeafNodeWithReachableNodes = (id) => {
     const node = { id };
     return {
         node,
-        reachableNodes: [{ path: [id], node }],
+        reachableNodes: [{ path: [], node }],
     };
 };
 /**
@@ -41,7 +41,7 @@ const generatedClosedBranchWithReachableNodes = (id) => {
     };
     return {
         node,
-        reachableNodes: [{ path: [id], node }],
+        reachableNodes: [{ path: [], node }],
     };
 };
 /**
@@ -56,16 +56,13 @@ const generatedOpenBranchWithReachableNodes = (id, children) => {
         id,
         children: children.map(({ node }) => node),
     };
-    const descendantNodes = children.flatMap(({ reachableNodes }) => reachableNodes.map(({ path, node }) => ({
-        path: [id, ...path],
+    const descendantNodes = children.flatMap(({ node: child, reachableNodes }) => reachableNodes.map(({ path, node }) => ({
+        path: [child.id, ...path],
         node,
     })));
     return {
         node,
-        reachableNodes: [
-            { path: [id], node },
-            ...descendantNodes,
-        ],
+        reachableNodes: [{ path: [], node }, ...descendantNodes],
     };
 };
 /**
@@ -125,11 +122,9 @@ export const generatedNodeArb = fc.letrec((tie) => {
     };
 }).node;
 /**
- * Generates an array of generated nodes with unique IDs suitable for use as
- * the root of a forest.
+ * Generates an array of generated nodes with unique sibling IDs.
  *
- * Root IDs must be unique because paths begin by looking up an ID in this
- * array.
+ * The result is suitable for use as the loaded children of an open branch.
  */
 export const generatedNodesArrayArb = fc.uniqueArray(generatedNodeArb, {
     minLength: 0,
@@ -143,9 +138,9 @@ export const generatedNodesArrayArb = fc.uniqueArray(generatedNodeArb, {
  * Paths through closed branches stop at the closed branch because its
  * descendants are not loaded.
  */
-export const nodesArrayAndPathsArb = generatedNodesArrayArb.map((generatedNodes) => ({
-    entries: generatedNodes.map(({ node }) => node),
-    pathEntries: generatedNodes.flatMap(({ reachableNodes }) => reachableNodes),
+export const nodeAndPathsArb = generatedNodeArb.map(({ node: root, reachableNodes }) => ({
+    root,
+    pathEntries: reachableNodes,
 }));
 /**
  * Generates root-level nodes and a path to one of their reachable nodes.
@@ -153,10 +148,10 @@ export const nodesArrayAndPathsArb = generatedNodesArrayArb.map((generatedNodes)
  * Every generated path is valid for `getAtPath`; unreachable paths are not
  * included.
  */
-export const nodesArrayAndPathAndExpectedArb = nodesArrayAndPathsArb
+export const nodeAndPathAndExpectedArb = nodeAndPathsArb
     .filter(({ pathEntries }) => pathEntries.length > 0)
-    .chain(({ entries, pathEntries }) => fc.constantFrom(...pathEntries).map(({ path, node }) => ({
-    entries,
+    .chain(({ root, pathEntries }) => fc.constantFrom(...pathEntries).map(({ path, node }) => ({
+    root,
     path,
     expected: node,
 })));
@@ -166,14 +161,14 @@ export const nodesArrayAndPathAndExpectedArb = nodesArrayAndPathsArb
  * Both open and closed branches are included. A path to a closed branch is
  * valid, but a path through a closed branch cannot reach any descendants.
  */
-export const nodesArrayAndBranchPathArb = nodesArrayAndPathsArb
-    .map(({ entries, pathEntries }) => ({
-    entries,
+export const nodesArrayAndBranchPathArb = nodeAndPathsArb
+    .map(({ root, pathEntries }) => ({
+    root,
     branchPathEntries: pathEntries.filter(({ node }) => 'children' in node),
 }))
     .filter(({ branchPathEntries }) => branchPathEntries.length > 0)
-    .chain(({ entries, branchPathEntries }) => fc.constantFrom(...branchPathEntries).map(({ path, node }) => ({
-    entries,
+    .chain(({ root, branchPathEntries }) => fc.constantFrom(...branchPathEntries).map(({ path, node }) => ({
+    root,
     path,
     expected: node,
 })));

package/dist/tree-surfer/tree-node/tree-node.impl.d.ts

@@ -10,5 +10,5 @@ import type { SerializableKey, TreeNode, TreeNodeApi } from './tree-node.types.j
  * Node IDs are compared using JavaScript value equality. Sibling IDs
  * should be unique.
  */
-export declare function createTreeNodeApi<Id extends SerializableKey, ChildNode extends TreeNode<Id, ChildNode>>(): TreeNodeApi<Id, ChildNode>;
+export declare function createTreeNodeApi<Id extends SerializableKey, Node extends TreeNode<Id, Node>>(): TreeNodeApi<Id, Node>;
 //# sourceMappingURL=tree-node.impl.d.ts.map

package/dist/tree-surfer/tree-node/tree-node.impl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tree-node.impl.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/tree-node/tree-node.impl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAKV,eAAe,EACf,QAAQ,EACR,WAAW,EACZ,MAAM,sBAAsB,CAAC;AAE9B;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,EAAE,SAAS,eAAe,EAC1B,SAAS,SAAS,QAAQ,CAAC,EAAE,EAAE,SAAS,CAAC,KACtC,WAAW,CAAC,EAAE,EAAE,SAAS,CAAC,CA0G9B"}
+{"version":3,"file":"tree-node.impl.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/tree-node/tree-node.impl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAKV,eAAe,EACf,QAAQ,EACR,WAAW,EACZ,MAAM,sBAAsB,CAAC;AAE9B;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,EAAE,SAAS,eAAe,EAC1B,IAAI,SAAS,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC,KAC5B,WAAW,CAAC,EAAE,EAAE,IAAI,CAAC,CAqGzB"}

package/dist/tree-surfer/tree-node/tree-node.impl.js

@@ -11,7 +11,6 @@
  */
 export function createTreeNodeApi() {
     const treeNodeApi = {
-        // Type Narrowers:
         isLeaf(node) {
             return !('children' in node);
         },
@@ -30,60 +29,54 @@ export function createTreeNodeApi() {
         getChildById(node, id) {
             return node.children.find((child) => child.id === id);
         },
-        getAtPath(entries, path, selector) {
-            if (path.length === 0) {
-                return undefined;
-            }
-            // Accumulator
-            let node = entries.find((candidate) => candidate.id === path[0]);
-            for (let index = 1; node !== undefined && index < path.length; index += 1) {
-                if (treeNodeApi.isOpenBranch(node)) {
-                    node = treeNodeApi.getChildById(node, path[index]);
+        getAtPath(root, path, selector) {
+            let node = root;
+            for (const id of path) {
+                if (!treeNodeApi.isBranch(node) || !treeNodeApi.isOpenBranch(node)) {
+                    return undefined;
                 }
-                else {
-                    node = undefined;
+                const child = treeNodeApi.getChildById(node, id);
+                if (child === undefined) {
+                    return undefined;
                 }
+                node = child;
             }
-            return node === undefined ? undefined : selector(node);
+            return selector(node);
         },
-        modifyAtPath(entries, path, modifier) {
+        modifyAtPath(root, path, modifier) {
             if (path.length === 0) {
-                return undefined;
+                return modifier(root);
             }
-            // Only cloned arrays/nodes are modified below.
-            const updatedEntries = [...entries];
-            let currentEntries = updatedEntries;
-            for (let index = 0; index < path.length; index += 1) {
-                const id = path[index];
-                const childIndex = currentEntries.findIndex((candidate) => candidate.id === id);
-                if (childIndex === -1) {
-                    return undefined;
-                }
-                const child = currentEntries[childIndex];
-                if (index === path.length - 1) {
-                    const replacement = modifier(child);
-                    if (replacement === undefined) {
-                        return undefined;
-                    }
-                    currentEntries[childIndex] = replacement;
-                    return updatedEntries;
-                }
-                if (!treeNodeApi.isBranch(child) || !treeNodeApi.isOpenBranch(child)) {
-                    // The path cannot continue through a leaf or closed branch.
-                    return undefined;
-                }
-                // Clone the child array before modifying it.
-                const updatedChildren = [...treeNodeApi.getChildren(child)];
-                // Clone the ancestor node and attach the cloned child array.
-                currentEntries[childIndex] = {
-                    ...child,
-                    children: updatedChildren,
-                };
-                // Continue traversal through the cloned children.
-                currentEntries = updatedChildren;
-            }
-            return undefined;
+            return modifyChildAtPath(root, path, modifier);
         },
     };
+    function modifyChildAtPath(node, path, modifier) {
+        const childId = path[0];
+        if (childId === undefined ||
+            !treeNodeApi.isBranch(node) ||
+            !treeNodeApi.isOpenBranch(node)) {
+            return undefined;
+        }
+        const childIndex = node.children.findIndex((child) => child.id === childId);
+        if (childIndex === -1) {
+            return undefined;
+        }
+        const child = node.children[childIndex];
+        if (child === undefined) {
+            return undefined;
+        }
+        const updatedChild = path.length === 1
+            ? modifier(child)
+            : modifyChildAtPath(child, path.slice(1), modifier);
+        if (updatedChild === undefined) {
+            return undefined;
+        }
+        const children = [...node.children];
+        children[childIndex] = updatedChild;
+        return {
+            ...node,
+            children,
+        };
+    }
     return treeNodeApi;
 }

package/dist/tree-surfer/tree-node/tree-node.schemas.d.ts

@@ -16,7 +16,7 @@ export declare const serializableKeySchema: z.ZodUnion<readonly [z.ZodString, z.
  *
  * The concrete application can extend these schemas with additional fields.
  */
-export declare function createTreeNodeSchemas<Id extends SerializableKey, ChildNode extends TreeNode<Id, ChildNode>>(idSchema: z.ZodType<Id>, childSchema: z.ZodType<ChildNode>): {
+export declare function createTreeNodeSchemas<Id extends SerializableKey, Node extends TreeNode<Id, Node>>(idSchema: z.ZodType<Id>, nodeSchema: z.ZodType<Node>): {
     leafSchema: z.ZodObject<{
         id: z.ZodType<Id, unknown, z.core.$ZodTypeInternals<Id, unknown>>;
     }, z.core.$strip>;
@@ -26,7 +26,7 @@ export declare function createTreeNodeSchemas<Id extends SerializableKey, ChildN
     }, z.core.$strip>;
     openBranchSchema: z.ZodObject<{
         id: z.ZodType<Id, unknown, z.core.$ZodTypeInternals<Id, unknown>>;
-        children: z.ZodArray<z.ZodType<ChildNode, unknown, z.core.$ZodTypeInternals<ChildNode, unknown>>>;
+        children: z.ZodArray<z.ZodType<Node, unknown, z.core.$ZodTypeInternals<Node, unknown>>>;
     }, z.core.$strip>;
 };
 //# sourceMappingURL=tree-node.schemas.d.ts.map