dirvi-lib 0.7.1 → 0.8.0

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

@@ -1,70 +1,193 @@
-import { SerializableKey } from '../tree-node/tree-node.types.js';
+import { SerializableKey, TreeNodeApi } from '../tree-node/tree-node.types.js';
 /**
- * The whole fold state for a tree-node tree.
+ * A node in the fold-state tree.
  *
- * The root has no ID because it represents the fold at the root.
- * Its `children` contain the fold nodes for the forest's root entries.
+ * @remarks
  *
- * `folds` contains the IDs folded at this root. Fold order is not
- * represented here; the buffer tree determines entry order.
+ * A fold-state tree is a sparse projection of a buffer tree. Apart from its
+ * root, it stores only nodes that are folded or that have fold information
+ * somewhere below them. It does not contain buffer entries or buffer-specific
+ * properties.
+ *
+ * The `id` identifies the corresponding buffer entry among its siblings.
+ *
+ * `children` contains fold-state nodes for direct buffer entries that are not
+ * folded at this node but have fold information below them.
+ *
+ * `foldedChildren` contains fold-state nodes for direct buffer entries whose contents
+ * are folded at this node. Each folded entry is represented by a complete
+ * `FoldNode`, allowing fold state within a folded entry to be preserved
+ * recursively.
+ *
+ * A direct buffer entry with no fold state at or below it is omitted from both
+ * collections. Consequently, the union of `children` and `foldedChildren` does not
+ * need to contain every direct buffer child.
+ *
+ * The following invariant holds for every fold-state node:
+ *
+ *  - no ID occurs more than once in `children`;
+ *  - no ID occurs more than once in `foldedChildren`;
+ *  - no ID occurs in both collections;
+ *  - every ID in either collection identifies a direct child in the
+ *    corresponding buffer-tree node.
+ *
+ * Every fold node is an open branch from the perspective of `TreeNodeApi`.
+ * Missing paths may nevertheless be created lazily by `FoldNodeService`.
+ *
+ * @typeParam Id - The type of IDs in the actual tree nodes.
+ *
+ * @example
+ *
+ * ```ts
+ * type FileId = string;
+ * type FileFoldNode = FoldNode<FileId>;
+ *
+ * const root: FileFoldNode = {
+ *   id: '/',
+ *   children: [],
+ *   foldedChildren: [],
+ * };
+ * ```
  */
-export type FoldNodeRoot<Id extends SerializableKey> = {
+export type FoldNode<Id extends SerializableKey> = {
+    id: Id;
     children: FoldNode<Id>[];
-    folds: ReadonlySet<Id>;
+    foldedChildren: FoldNode<Id>[];
 };
 /**
- * Fold state associated with a node in the buffer tree.
+ * Operations for inspecting and immutably updating a fold-state tree.
+ *
+ * @remarks
  *
- * A fold node has the shape of an open tree node: its children are always
- * represented by an array, and an empty `children` array means that no child
- * fold nodes are currently represented.
+ * This API is `TreeNodeApi` specialized for `FoldNode`. It provides structural
+ * tree operations such as node lookup and immutable path updates.
  *
- * The `folds` set contains the IDs of entries folded at this node. Fold
- * order is not represented here; the buffer tree determines entry order.
+ * Paths are relative to the supplied root node:
  *
- * The type is structurally compatible with `TreeNode`, allowing the shared
- * `TreeNodeApi` to be used for path traversal and immutable updates.
+ *  - `[]` identifies the root;
+ *  - `['child']` identifies a direct child of the root;
+ *  - `['child', 'grandchild']` identifies a descendant.
+ *
+ * Path operations are strict. They operate only on nodes that already exist
+ * in the fold-state tree. Use `FoldNodeService` when missing fold-state nodes
+ * should be automatically created.
+ *
+ * The API does not interpret the `foldedChildren` collection. It only navigates and
+ * updates the structural `children` tree. The semantic operations for adding
+ * and removing foldedChildren belong to `FoldNodeService`.
+ *
+ * @typeParam Id - The type of IDs in the actual tree nodes.
  */
-export type FoldNode<Id extends SerializableKey> = FoldNodeRoot<Id> & {
-    id: Id;
-};
+export type FoldNodeApi<Id extends SerializableKey> = TreeNodeApi<Id, FoldNode<Id>>;
 /**
- * Operations for navigating and immutably updating fold-tree structure.
+ * Semantic operations for managing fold state.
+ *
+ * @remarks
+ *
+ * `FoldNodeService` provides operations in terms of folded buffer entries
+ * rather than generic tree-node updates.
+ *
+ * Paths are relative to the supplied root node:
  *
- * This API is a projection of `TreeNodeApi` onto the fold-tree
- * representation. Path operations are strict: they only operate on
- * paths that already exist. Creation of missing fold paths belongs to
- * `FoldNodeService`.
+ *  - `[]` addresses the root
+ *  - `['child']` addresses a direct child of the root;
+ *  - `['child', 'grandchild']` addresses a descendant.
+ *
+ * Lookup and removal operations are strict and return `undefined` when the
+ * requested path does not exist. Adding a folded entry may create missing
+ * fold-state nodes along the requested path.
+ *
+ * @typeParam Id - The type of IDs in the actual tree nodes.
  */
-export type FoldNodeApi<Id extends SerializableKey> = {
+export type FoldNodeService<Id extends SerializableKey> = {
     /**
-     * Returns the children of either the fold root or a fold node.
+     * Creates an empty fold-state node.
+     *
+     * It has no structural children and no folded entries.
+     *
+     * @returns A new empty fold-state node.
      */
-    getChildren(node: FoldNodeRoot<Id> | FoldNode<Id>): Iterable<FoldNode<Id>>;
+    createEmptyNode(id: Id): FoldNode<Id>;
     /**
-     * Returns a direct child by ID.
+     * Tests whether a node is folded.
+     *
+     * The path identifies the node whose `foldedChildren` collection is inspected. An
+     * empty path selects the root.
+     *
+     * This operation does not create missing fold-state nodes, or otherwise
+     * mutate the `rootNode`.
+     *
+     * @param rootNode - The root of the fold-state tree.
+     * @param path - A path relative to `rootNode`.
+     * @param entryId - The ID of the direct buffer entry to test.
+     * @returns `true` when the entry is folded at the resolved node;
+     * otherwise `false`. Missing paths also return `false`.
      */
-    getChildById(node: FoldNodeRoot<Id> | FoldNode<Id>, id: Id): FoldNode<Id> | undefined;
+    getIfEntryFoldedAtPath(rootNode: FoldNode<Id>, path: readonly Id[], entryId: Id): boolean;
     /**
-     * Selects a fold node at a path below the root.
+     * Returns the IDs of folded entries at the node at the path.
+     *
+     * Returns undefined if path has no fold node.
      */
-    getAtPath<Result>(rootNode: FoldNodeRoot<Id>, path: Id[], selector: (node: FoldNode<Id>) => Result): Result | undefined;
+    foldedEntriesAtPath(rootNode: FoldNode<Id>, path: readonly Id[]): Id[] | undefined;
     /**
-     * Immutably modifies a fold node at a path below the root.
+     * Marks a direct buffer entry as folded at a node.
+     *
+     * Missing fold-state nodes along the path are created. If the entry is
+     * already folded, the existing fold-state tree is returned unchanged.
+     * If the entry is currently in `children`, it is moved to `foldedChildren` while
+     * preserving its nested fold state.
+     *
+     * Moving an entry preserves its nested `children` and `foldedChildren`, so fold
+     * state below the newly folded entry is not lost.
+     *
+     * @param rootNode - The root of the fold-state tree.
+     * @param path - A path relative to `rootNode`. An empty path selects the
+     * root.
+     * @param entryId - The ID of the direct buffer entry to fold.
+     * @returns A new root containing the fold, or `undefined` when the path
+     * cannot be updated.
      */
-    modifyAtPath(rootNode: FoldNodeRoot<Id>, path: Id[], modifier: (node: FoldNode<Id>) => FoldNode<Id> | undefined): FoldNodeRoot<Id> | undefined;
-};
-/**
- * Semantic operations for managing folded buffer entries.
- *
- * Unlike `FoldNodeApi`, the service may create missing fold paths when
- * adding a fold. This allows an empty root to be populated lazily.
- */
-export type FoldNodeService<Id extends SerializableKey> = {
-    createEmptyRoot(): FoldNodeRoot<Id>;
-    getIfEntryFoldedAtPath(rootNode: FoldNodeRoot<Id>, path: Id[], entryId: Id): boolean;
-    addFoldedEntryAtPath(rootNode: FoldNodeRoot<Id>, path: Id[], entryId: Id): FoldNodeRoot<Id> | undefined;
-    removeFoldedEntryAtPath(rootNode: FoldNodeRoot<Id>, path: Id[], entryId: Id): FoldNodeRoot<Id> | undefined;
-    clearFoldedEntriesAtPath(rootNode: FoldNodeRoot<Id>, path: Id[]): FoldNodeRoot<Id> | undefined;
+    addFoldedEntryAtPath(rootNode: FoldNode<Id>, path: readonly Id[], entryId: Id): FoldNode<Id> | undefined;
+    /**
+     * Removes the folded state for a direct buffer entry at a node.
+     *
+     * The entry is removed from `foldedChildren`. If the entry contains nested fold
+     * state in either its `children` or `foldedChildren` collections, it is moved to
+     * `children` so that the nested state is preserved. If it has no nested
+     * fold state, it is omitted from both collections.
+     *
+     * This operation does not create missing fold-state nodes. If the entry is
+     * not currently folded, the existing fold-state tree is returned unchanged.
+     *
+     * @param rootNode - The root of the fold-state tree.
+     * @param path - A path relative to `rootNode`. An empty path selects the
+     * root.
+     * @param entryId - The ID of the direct buffer entry to unfold.
+     * @returns A new root without the fold, or `undefined` when the path does
+     * not exist.
+     */
+    removeFoldedEntryAtPath(rootNode: FoldNode<Id>, path: readonly Id[], entryId: Id): FoldNode<Id> | undefined;
+    /**
+     * Removes the folded state for all direct buffer entries at a node.
+     *
+     * Each entry is removed from `foldedChildren`. Entries that contain nested
+     * fold state in either their `children` or `foldedChildren` collections are
+     * moved to `children` so that their nested fold state is preserved. Entries
+     * with no nested fold state are omitted from both collections.
+     *
+     * This operation does not create missing fold-state nodes. If the path does
+     * not exist, the existing fold-state tree cannot be updated and `undefined`
+     * is returned. When the resolved node has no folded entries, the existing
+     * fold-state tree is returned unchanged.
+     *
+     * @param rootNode - The root of the fold-state tree.
+     * @param path - A path relative to `rootNode`. An empty path selects the
+     * root.
+     * @returns A new root without the folds at the resolved node, or
+     * `undefined` when the path does not exist.
+     */
+    clearFoldedEntriesAtPath(rootNode: FoldNode<Id>, path: readonly Id[]): FoldNode<Id> | undefined;
+    clearFoldedEntriesAtPath(rootNode: FoldNode<Id>, path: readonly Id[]): FoldNode<Id> | undefined;
 };
 //# sourceMappingURL=fold-node.types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"fold-node.types.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/fold-node/fold-node.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAElE;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,CAAC,EAAE,SAAS,eAAe,IAAI;IACrD,QAAQ,EAAE,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC;IACzB,KAAK,EAAE,WAAW,CAAC,EAAE,CAAC,CAAC;CACxB,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,QAAQ,CAAC,EAAE,SAAS,eAAe,IAAI,YAAY,CAAC,EAAE,CAAC,GAAG;IACpE,EAAE,EAAE,EAAE,CAAC;CACR,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,CAAC,EAAE,SAAS,eAAe,IAAI;IACpD;;OAEG;IACH,WAAW,CAAC,IAAI,EAAE,YAAY,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC;IAE3E;;OAEG;IACH,YAAY,CACV,IAAI,EAAE,YAAY,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,EAAE,CAAC,EACrC,EAAE,EAAE,EAAE,GACL,QAAQ,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC;IAE5B;;OAEG;IACH,SAAS,CAAC,MAAM,EACd,QAAQ,EAAE,YAAY,CAAC,EAAE,CAAC,EAC1B,IAAI,EAAE,EAAE,EAAE,EACV,QAAQ,EAAE,CAAC,IAAI,EAAE,QAAQ,CAAC,EAAE,CAAC,KAAK,MAAM,GACvC,MAAM,GAAG,SAAS,CAAC;IAEtB;;OAEG;IACH,YAAY,CACV,QAAQ,EAAE,YAAY,CAAC,EAAE,CAAC,EAC1B,IAAI,EAAE,EAAE,EAAE,EACV,QAAQ,EAAE,CAAC,IAAI,EAAE,QAAQ,CAAC,EAAE,CAAC,KAAK,QAAQ,CAAC,EAAE,CAAC,GAAG,SAAS,GACzD,YAAY,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC;CACjC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,eAAe,CAAC,EAAE,SAAS,eAAe,IAAI;IACxD,eAAe,IAAI,YAAY,CAAC,EAAE,CAAC,CAAC;IAEpC,sBAAsB,CACpB,QAAQ,EAAE,YAAY,CAAC,EAAE,CAAC,EAC1B,IAAI,EAAE,EAAE,EAAE,EACV,OAAO,EAAE,EAAE,GACV,OAAO,CAAC;IAEX,oBAAoB,CAClB,QAAQ,EAAE,YAAY,CAAC,EAAE,CAAC,EAC1B,IAAI,EAAE,EAAE,EAAE,EACV,OAAO,EAAE,EAAE,GACV,YAAY,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC;IAEhC,uBAAuB,CACrB,QAAQ,EAAE,YAAY,CAAC,EAAE,CAAC,EAC1B,IAAI,EAAE,EAAE,EAAE,EACV,OAAO,EAAE,EAAE,GACV,YAAY,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC;IAEhC,wBAAwB,CACtB,QAAQ,EAAE,YAAY,CAAC,EAAE,CAAC,EAC1B,IAAI,EAAE,EAAE,EAAE,GACT,YAAY,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC;CACjC,CAAC"}
+{"version":3,"file":"fold-node.types.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/fold-node/fold-node.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAE/E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,MAAM,MAAM,QAAQ,CAAC,EAAE,SAAS,eAAe,IAAI;IACjD,EAAE,EAAE,EAAE,CAAC;IACP,QAAQ,EAAE,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC;IACzB,cAAc,EAAE,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC;CAChC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,MAAM,WAAW,CAAC,EAAE,SAAS,eAAe,IAAI,WAAW,CAAC,EAAE,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC;AAEpF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,eAAe,CAAC,EAAE,SAAS,eAAe,IAAI;IACxD;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,EAAE,EAAE,GAAG,QAAQ,CAAC,EAAE,CAAC,CAAC;IAEtC;;;;;;;;;;;;;;OAcG;IACH,sBAAsB,CACpB,QAAQ,EAAE,QAAQ,CAAC,EAAE,CAAC,EACtB,IAAI,EAAE,SAAS,EAAE,EAAE,EACnB,OAAO,EAAE,EAAE,GACV,OAAO,CAAC;IAEX;;;;OAIG;IACH,mBAAmB,CACjB,QAAQ,EAAE,QAAQ,CAAC,EAAE,CAAC,EACtB,IAAI,EAAE,SAAS,EAAE,EAAE,GAClB,EAAE,EAAE,GAAG,SAAS,CAAC;IAEpB;;;;;;;;;;;;;;;;;OAiBG;IACH,oBAAoB,CAClB,QAAQ,EAAE,QAAQ,CAAC,EAAE,CAAC,EACtB,IAAI,EAAE,SAAS,EAAE,EAAE,EACnB,OAAO,EAAE,EAAE,GACV,QAAQ,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC;IAE5B;;;;;;;;;;;;;;;;;OAiBG;IACH,uBAAuB,CACrB,QAAQ,EAAE,QAAQ,CAAC,EAAE,CAAC,EACtB,IAAI,EAAE,SAAS,EAAE,EAAE,EACnB,OAAO,EAAE,EAAE,GACV,QAAQ,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC;IAE5B;;;;;;;;;;;;;;;;;;OAkBG;IACH,wBAAwB,CACtB,QAAQ,EAAE,QAAQ,CAAC,EAAE,CAAC,EACtB,IAAI,EAAE,SAAS,EAAE,EAAE,GAClB,QAAQ,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC;IAC5B,wBAAwB,CACtB,QAAQ,EAAE,QAAQ,CAAC,EAAE,CAAC,EACtB,IAAI,EAAE,SAAS,EAAE,EAAE,GAClB,QAAQ,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC;CAC7B,CAAC"}

package/dist/tree-surfer/fold-node/tree-node.test.d.ts

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

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

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

package/dist/tree-surfer/fold-node/tree-node.test.js

@@ -0,0 +1,90 @@
+import { describe, expect, it } from 'vitest';
+import { createTreeNodeApi } from '../tree-node/tree-node.impl.js';
+import { createFoldNodeService } from './fold-node.impl.js';
+const foldNodeApi = createTreeNodeApi();
+const service = createFoldNodeService(foldNodeApi);
+describe('createFoldNodeService', () => {
+    it('UT: adds a new entry to foldedChildren', () => {
+        const root = service.createEmptyNode(0);
+        const updated = service.addFoldedEntryAtPath(root, [], 0);
+        expect(updated).toStrictEqual({
+            id: 0,
+            children: [],
+            foldedChildren: [
+                {
+                    id: 0,
+                    children: [],
+                    foldedChildren: [],
+                },
+            ],
+        });
+    });
+    it('UT: moves an existing structural entry to foldedChildren', () => {
+        const child = {
+            id: 1,
+            children: [],
+            foldedChildren: [],
+        };
+        const root = {
+            id: 0,
+            children: [child],
+            foldedChildren: [],
+        };
+        const updated = service.addFoldedEntryAtPath(root, [], 1);
+        expect(updated).toStrictEqual({
+            id: 0,
+            children: [],
+            foldedChildren: [child],
+        });
+    });
+    it('UT: preserves nested fold state when moving an entry', () => {
+        const nestedChild = {
+            id: 2,
+            children: [],
+            foldedChildren: [],
+        };
+        const child = {
+            id: 1,
+            children: [],
+            foldedChildren: [nestedChild],
+        };
+        const root = {
+            id: 0,
+            children: [child],
+            foldedChildren: [],
+        };
+        const updated = service.addFoldedEntryAtPath(root, [], 1);
+        expect(updated).toStrictEqual({
+            id: 0,
+            children: [],
+            foldedChildren: [
+                {
+                    id: 1,
+                    children: [],
+                    foldedChildren: [nestedChild],
+                },
+            ],
+        });
+        expect(updated?.foldedChildren[0]).toBe(child);
+        expect(updated?.foldedChildren[0]?.foldedChildren[0]).toBe(nestedChild);
+    });
+    it('UT: rejects a path through a folded entry', () => {
+        const foldedChild = {
+            id: 1,
+            children: [],
+            foldedChildren: [],
+        };
+        const root = {
+            id: 0,
+            children: [],
+            foldedChildren: [foldedChild],
+        };
+        const updated = service.addFoldedEntryAtPath(root, [1], 2);
+        expect(updated).toBeUndefined();
+        expect(root).toStrictEqual({
+            id: 0,
+            children: [],
+            foldedChildren: [foldedChild],
+        });
+    });
+});

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

@@ -1,6 +1,6 @@
-import { SerializableKey, TreeNode, TreeNodeApi } from '../tree-node/tree-node.types.js';
-import { FoldNodeApi } from '../fold-node/fold-node.types.js';
-import { CursorApi } from '../cursor.js';
-import { NavNodeApi } from './nav-node.types.js';
-export declare function createNavNodeApi<Id extends SerializableKey, BufferNode extends TreeNode<Id, BufferNode>>(treeNodeApi: TreeNodeApi<Id, BufferNode>, foldNodeApi: FoldNodeApi<Id>, cursorApi: CursorApi<Id>): NavNodeApi<Id, BufferNode>;
+import type { SerializableKey, TreeNode, TreeNodeApi } from '../tree-node/tree-node.types.js';
+import type { FoldNodeService } from '../fold-node/fold-node.types.js';
+import type { CursorApi } from '../cursor.js';
+import type { NavNodeApi } from './nav-node.types.js';
+export declare function createNavNodeApi<Id extends SerializableKey, Node extends TreeNode<Id, Node>>(treeNodeApi: TreeNodeApi<Id, Node>, foldNodeService: FoldNodeService<Id>, cursorApi: CursorApi<Id>): NavNodeApi<Id, Node>;
 //# sourceMappingURL=nav-node.impl.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"nav-node.impl.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/nav-node/nav-node.impl.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,eAAe,EACf,QAAQ,EACR,WAAW,EACZ,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,WAAW,EAAgB,MAAM,iCAAiC,CAAC;AAC5E,OAAO,EAAU,SAAS,EAAc,MAAM,cAAc,CAAC;AAC7D,OAAO,EAKL,UAAU,EACX,MAAM,qBAAqB,CAAC;AAE7B,wBAAgB,gBAAgB,CAC9B,EAAE,SAAS,eAAe,EAC1B,UAAU,SAAS,QAAQ,CAAC,EAAE,EAAE,UAAU,CAAC,EAE3C,WAAW,EAAE,WAAW,CAAC,EAAE,EAAE,UAAU,CAAC,EACxC,WAAW,EAAE,WAAW,CAAC,EAAE,CAAC,EAC5B,SAAS,EAAE,SAAS,CAAC,EAAE,CAAC,GACvB,UAAU,CAAC,EAAE,EAAE,UAAU,CAAC,CAqP5B"}
+{"version":3,"file":"nav-node.impl.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/nav-node/nav-node.impl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,QAAQ,EACR,WAAW,EACZ,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAY,eAAe,EAAE,MAAM,iCAAiC,CAAC;AACjF,OAAO,KAAK,EAAU,SAAS,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,KAAK,EAIV,UAAU,EACX,MAAM,qBAAqB,CAAC;AAE7B,wBAAgB,gBAAgB,CAC9B,EAAE,SAAS,eAAe,EAC1B,IAAI,SAAS,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC,EAE/B,WAAW,EAAE,WAAW,CAAC,EAAE,EAAE,IAAI,CAAC,EAClC,eAAe,EAAE,eAAe,CAAC,EAAE,CAAC,EACpC,SAAS,EAAE,SAAS,CAAC,EAAE,CAAC,GACvB,UAAU,CAAC,EAAE,EAAE,IAAI,CAAC,CA2RtB"}

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

@@ -1,44 +1,76 @@
-import { CursorKind } from '../cursor.js';
-import { isNavBranch, } from './nav-node.types.js';
-export function createNavNodeApi(treeNodeApi, foldNodeApi, cursorApi) {
-    const navNodeApi = {
-        // Return a nav node from the BufferNode tree and FoldNode tree.
-        from(entries, foldNode) {
-            const visibleEntriesSoFar = [];
-            const foldedEntriesSoFar = [];
-            for (const entry of entries) {
-                // Find the node
-                let navigationEntry;
-                if (treeNodeApi.isBranch(entry)) {
-                    // If fold node does not have children (recursively no folds),
-                    // then just use empty.
-                    const childFoldNode = foldNodeApi.getChildById(foldNode, entry.id) ??
-                        createEmptyFoldNode();
-                    navigationEntry = {
-                        ...entry,
-                        children: entry.children === null
-                            ? null
-                            : navNodeApi.from(entry.children, childFoldNode),
-                    };
-                }
-                else if (treeNodeApi.isLeaf(entry)) {
-                    navigationEntry = entry;
-                }
-                else {
-                    // This should be unreachable if BufferNode correctly extends TreeNode.
-                    throw new Error('Unsupported tree node');
-                }
-                if (foldNode.folds.has(entry.id)) {
-                    foldedEntriesSoFar.push(navigationEntry);
-                }
-                else {
-                    visibleEntriesSoFar.push(navigationEntry);
-                }
+export function createNavNodeApi(treeNodeApi, foldNodeService, cursorApi) {
+    function entryIsBranch(entry) {
+        return 'children' in entry;
+    }
+    function createNavNode(entries, foldRoot, parentPath) {
+        const visibleEntries = [];
+        const foldedEntries = [];
+        const foldedEntryIds = foldRoot === undefined
+            ? undefined
+            : foldNodeService.foldedEntriesAtPath(foldRoot, parentPath);
+        for (const entry of entries) {
+            const entryPath = [...parentPath, entry.id];
+            const isFolded = foldRoot !== undefined &&
+                foldNodeService.getIfEntryFoldedAtPath(foldRoot, parentPath, entry.id);
+            const navigationEntry = createNavEntry(entry, foldRoot, entryPath);
+            if (isFolded) {
+                foldedEntries.push(navigationEntry);
+            }
+            else {
+                visibleEntries.push(navigationEntry);
             }
+        }
+        return {
+            entries: visibleEntries,
+            folded: foldedEntryIds === undefined || foldedEntryIds.length === 0
+                ? null
+                : {
+                    entries: foldedEntries,
+                },
+        };
+    }
+    function createNavEntry(entry, foldRoot, entryPath) {
+        if (treeNodeApi.isLeaf(entry)) {
             return {
-                entries: visibleEntriesSoFar,
-                foldedEntries: foldedEntriesSoFar,
+                id: entry.id,
             };
+        }
+        return createNavBranch(entry, foldRoot, entryPath);
+    }
+    function createNavBranch(entry, foldRoot, entryPath) {
+        if (!treeNodeApi.isBranch(entry)) {
+            throw new Error('Navigation root must be a branch');
+        }
+        return {
+            id: entry.id,
+            children: entry.children === null
+                ? null
+                : createNavNode(entry.children, foldRoot, entryPath),
+        };
+    }
+    function rootCursors(rootNode) {
+        if (rootNode.children === null) {
+            return [[]];
+        }
+        return [[], ...cursorsInNode(rootNode.children, [])];
+    }
+    function cursorsInNode(node, parentPath) {
+        const cursors = [];
+        for (const entry of node.entries) {
+            const entryPath = [...parentPath, entry.id];
+            cursors.push(entryPath);
+            if (!entryIsBranch(entry) || entry.children === null) {
+                continue;
+            }
+            cursors.push(...cursorsInNode(entry.children, entryPath));
+        }
+        return cursors;
+    }
+    const navNodeApi = {
+        entryIsBranch,
+        // Return a nav node from the TreeNode and FoldNode trees.
+        from(root, foldRoot) {
+            return createNavBranch(root, foldRoot, []);
         },
         getNodeAtPath(navigation, path) {
             const [currentId, ...remainingPath] = path;
@@ -46,11 +78,11 @@ export function createNavNodeApi(treeNodeApi, foldNodeApi, cursorApi) {
             if (currentId === undefined) {
                 return navigation;
             }
-            const entry = [...navigation.entries, ...navigation.foldedEntries].find((candidate) => candidate.id === currentId);
+            const entry = navigation.entries.find((candidate) => candidate.id === currentId);
             if (entry === undefined) {
                 return undefined;
             }
-            if (!isNavBranch(entry)) {
+            if (!entryIsBranch(entry)) {
                 return undefined;
             }
             // The directory has not been loaded/opened.
@@ -64,20 +96,20 @@ export function createNavNodeApi(treeNodeApi, foldNodeApi, cursorApi) {
             if (currentId === undefined) {
                 return undefined;
             }
-            const entry = [...navigation.entries, ...navigation.foldedEntries].find((candidate) => candidate.id === currentId);
+            const entry = navigation.entries.find((candidate) => candidate.id === currentId);
             if (entry === undefined) {
                 return undefined;
             }
             if (remainingPath.length === 0) {
                 return entry;
             }
-            if (!isNavBranch(entry) || entry.children === null) {
+            if (!entryIsBranch(entry) || entry.children === null) {
                 return undefined;
             }
             return navNodeApi.getEntryAtPath(entry.children, remainingPath);
         },
         nextCursor(rootNode, cursor) {
-            const cursors = cursorsInNode(rootNode, []);
+            const cursors = rootCursors(rootNode);
             const currentIndex = cursors.findIndex((candidate) => cursorApi.equal(candidate, cursor));
             if (currentIndex === -1 || currentIndex === cursors.length - 1) {
                 return undefined;
@@ -85,7 +117,7 @@ export function createNavNodeApi(treeNodeApi, foldNodeApi, cursorApi) {
             return cursors[currentIndex + 1];
         },
         previousCursor(rootNode, cursor) {
-            const cursors = cursorsInNode(rootNode, []);
+            const cursors = rootCursors(rootNode);
             const currentIndex = cursors.findIndex((candidate) => cursorApi.equal(candidate, cursor));
             if (currentIndex <= 0) {
                 return undefined;
@@ -93,52 +125,32 @@ export function createNavNodeApi(treeNodeApi, foldNodeApi, cursorApi) {
             return cursors[currentIndex - 1];
         },
         cursorAfterFold(rootNode, cursor) {
-            if (cursorApi.isFold(cursor)) {
+            if (cursor.length === 0) {
                 return undefined;
             }
-            const cursors = cursorsInNode(rootNode, []);
+            const cursors = rootCursors(rootNode);
             const currentIndex = cursors.findIndex((candidate) => cursorApi.equal(candidate, cursor));
             if (currentIndex === -1) {
                 return undefined;
             }
-            const foldedPath = [...cursor.parentPath, cursor.entryId];
             for (let index = currentIndex + 1; index < cursors.length; index += 1) {
                 const candidate = cursors[index];
                 if (candidate === undefined) {
                     continue;
                 }
-                if (cursorApi.cursorBelongsToSubtree(candidate, foldedPath)) {
+                if (cursorApi.cursorBelongsToSubtree(candidate, cursor)) {
                     continue;
                 }
                 return candidate;
             }
             // The fold row will be created at the end of this directory.
-            return {
-                kind: CursorKind.Fold,
-                parentPath: cursor.parentPath,
-            };
+            return [...cursor];
         },
-        parentCursor(navigation, cursor) {
-            const parentPath = cursor.parentPath;
-            // The cursor is already in the root directory.
-            if (parentPath.length === 0) {
-                return undefined;
-            }
-            const entryId = parentPath.at(-1);
-            if (entryId === undefined) {
-                return undefined;
-            }
-            const containingPath = parentPath.slice(0, -1);
-            const entry = navNodeApi.getEntryAtPath(navigation, [...parentPath]);
-            // The parent path must identify a navigable branch.
-            if (entry === undefined || !isNavBranch(entry)) {
+        parentCursor(_navigation, cursor) {
+            if (cursor.length === 0) {
                 return undefined;
             }
-            return {
-                kind: CursorKind.Entry,
-                parentPath: containingPath,
-                entryId: entryId,
-            };
+            return cursor.slice(0, -1);
         },
         cursors(navigation, parentPath = []) {
             return cursorsInNode(navigation, parentPath);
@@ -147,7 +159,7 @@ export function createNavNodeApi(treeNodeApi, foldNodeApi, cursorApi) {
             const paths = [];
             for (const entry of navigation.entries) {
                 const entryPath = [...parentPath, entry.id];
-                if (isNavBranch(entry)) {
+                if (entryIsBranch(entry)) {
                     // A null children value means that the directory has not been
                     // loaded/opened, so there are no visible descendant files.
                     if (entry.children !== null) {
@@ -162,30 +174,3 @@ export function createNavNodeApi(treeNodeApi, foldNodeApi, cursorApi) {
     };
     return navNodeApi;
 }
-function createEmptyFoldNode() {
-    return {
-        children: [],
-        folds: new Set(),
-    };
-}
-function cursorsInNode(node, parentPath) {
-    const cursors = [];
-    for (const entry of node.entries) {
-        cursors.push({
-            kind: CursorKind.Entry,
-            parentPath,
-            entryId: entry.id,
-        });
-        if (!isNavBranch(entry) || entry.children === null) {
-            continue;
-        }
-        cursors.push(...cursorsInNode(entry.children, [...parentPath, entry.id]));
-    }
-    if (node.foldedEntries.length > 0) {
-        cursors.push({
-            kind: CursorKind.Fold,
-            parentPath,
-        });
-    }
-    return cursors;
-}