dirvi-lib 0.7.0 → 0.8.0

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

@@ -1,70 +1,193 @@
-import { TreeNodeModifier, TreeNodeSelector } 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 PropertyKey> = {
+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
+ *
+ * This API is `TreeNodeApi` specialized for `FoldNode`. It provides structural
+ * tree operations such as node lookup and immutable path updates.
+ *
+ * Paths are relative to the supplied root node:
+ *
+ *  - `[]` identifies the root;
+ *  - `['child']` identifies a direct child of the root;
+ *  - `['child', 'grandchild']` identifies a descendant.
  *
- * 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.
+ * 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 `folds` set contains the IDs of entries folded at this node. Fold
- * order is not represented here; the buffer tree determines entry order.
+ * 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`.
  *
- * The type is structurally compatible with `TreeNode`, allowing the shared
- * `TreeNodeApi` to be used for path traversal and immutable updates.
+ * @typeParam Id - The type of IDs in the actual tree nodes.
  */
-export type FoldNode<Id extends PropertyKey> = 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.
  *
- * 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`.
+ * Paths are relative to the supplied root node:
+ *
+ *  - `[]` 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 PropertyKey> = {
+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: TreeNodeSelector<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: TreeNodeModifier<FoldNode<Id>>): 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 PropertyKey> = {
-    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,EACL,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,iCAAiC,CAAC;AAEzC;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,CAAC,EAAE,SAAS,WAAW,IAAI;IACjD,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,WAAW,IAAI,YAAY,CAAC,EAAE,CAAC,GAAG;IAChE,EAAE,EAAE,EAAE,CAAC;CACR,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,CAAC,EAAE,SAAS,WAAW,IAAI;IAChD;;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,gBAAgB,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,GAC/C,MAAM,GAAG,SAAS,CAAC;IAEtB;;OAEG;IACH,YAAY,CACV,QAAQ,EAAE,YAAY,CAAC,EAAE,CAAC,EAC1B,IAAI,EAAE,EAAE,EAAE,EACV,QAAQ,EAAE,gBAAgB,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,GACvC,YAAY,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC;CACjC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,eAAe,CAAC,EAAE,SAAS,WAAW,IAAI;IACpD,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/index.d.ts

@@ -7,5 +7,7 @@ export * from './tree-node/tree-node.impl.js';
 export * from './tree-node/tree-node.schemas.js';
 export * from './tree-node/tree-node.types.js';
 export * from './cursor.js';
-export * from './state.js';
+export * from './state/state.impl.js';
+export * from './state/state.schemas.js';
+export * from './state/state.types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/tree-surfer/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tree-surfer/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAE/C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAE7C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AACjD,cAAc,gCAAgC,CAAC;AAE/C,cAAc,aAAa,CAAC;AAE5B,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tree-surfer/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAE/C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAE7C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AACjD,cAAc,gCAAgC,CAAC;AAE/C,cAAc,aAAa,CAAC;AAE5B,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC"}

package/dist/tree-surfer/index.js

@@ -7,4 +7,6 @@ export * from './tree-node/tree-node.impl.js';
 export * from './tree-node/tree-node.schemas.js';
 export * from './tree-node/tree-node.types.js';
 export * from './cursor.js';
-export * from './state.js';
+export * from './state/state.impl.js';
+export * from './state/state.schemas.js';
+export * from './state/state.types.js';

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"}