dirvi-lib 0.7.0 → 0.8.0

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

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

@@ -0,0 +1,7 @@
+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/nav-node.types.js';
+import { StateApi } from './state.types.js';
+export declare function createStateApi<Id extends SerializableKey, Node extends TreeNode<Id, Node>>(treeNodeApi: TreeNodeApi<Id, Node>, foldNodeApi: FoldNodeApi<Id>, cursorApi: CursorApi<Id>, navNodeApi: NavNodeApi<Id, Node>): StateApi<Id, Node>;
+//# sourceMappingURL=state.impl.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,89 @@
+export function createStateApi(treeNodeApi, foldNodeApi, cursorApi, navNodeApi) {
+    /**
+     * 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(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 oldRoot.children) {
+            if (!treeNodeApi.isBranch(oldEntry) ||
+                !treeNodeApi.isOpenBranch(oldEntry)) {
+                continue;
+            }
+            const oldChildFoldNode = oldFoldNode === undefined
+                ? undefined
+                : foldNodeApi.getChildById(oldFoldNode, oldEntry.id);
+            const entryPath = [...parentPath, oldEntry.id];
+            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.root.children,
+                };
+            });
+            if (updatedRoot !== undefined && treeNodeApi.isOpenBranch(updatedRoot)) {
+                newRoot = updatedRoot;
+            }
+        }
+        return {
+            root: newRoot,
+            foldRoot: newFoldNode,
+        };
+    }
+    /**
+     * Currently the cursor just goes to root.
+     *
+     * TODO: Cursor policy:
+     * 1. Keep the exact cursor if it survives,
+     * 2. Otherwise, choose the deepest surviving ancestor entry,
+     * 3. Otherwise, choose the nearest preceding old cursor that still survives,
+     * 4. Otherwise, choose the first new cursor.
+     * 5. If no cursor exists, use the root fold cursor.
+     */
+    function resyncCursor(oldState, newRoot, newFoldNode) {
+        return [];
+    }
+    return {
+        getNodeAtCursor(state) {
+            const path = cursorApi.getPath(state.cursor);
+            return treeNodeApi.getAtPath(state.root, path, (node) => node);
+        },
+        async resync(oldState, 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.
+             *
+             * The fallback expresses the State invariant while satisfying the
+             * optional return type needed by recursive child reloads.
+             */
+            const foldRoot = reloaded.foldRoot ?? oldState.foldRoot;
+            const cursor = resyncCursor(oldState, reloaded.root, foldRoot) ?? [];
+            const root = reloaded.root;
+            return {
+                ...oldState,
+                root,
+                foldRoot,
+                cursor,
+            };
+        },
+    };
+}

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

@@ -0,0 +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>>(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

@@ -0,0 +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,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

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

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

@@ -0,0 +1,21 @@
+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>> = {
+    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'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>>;
+};
+//# sourceMappingURL=state.types.d.ts.map

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

@@ -0,0 +1 @@
+{"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/state/state.types.js

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