dirvi-lib 0.3.0 → 0.5.0

package/dist/domain/posix-node.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { UnixPath } from './unix-path.js';
+import { Cursor, State } from '../tree-surfer/index.js';
+import { FoldNode } from '../tree-surfer/fold-node/fold-node.types.js';
+import { NavNode } from '../tree-surfer/nav-node/nav-node.types.js';
+export declare const PosixNameSchema: z.ZodString;
+export type PosixName = z.output<typeof PosixNameSchema>;
+export type PosixNode = {
+    kind: 'file';
+    id: PosixName;
+} | {
+    kind: 'symlink';
+    id: PosixName;
+    target: UnixPath;
+} | {
+    kind: 'directory';
+    id: PosixName;
+    children: PosixNode[] | null;
+};
+export declare const PosixNodeApi: import("../tree-surfer/index.js").TreeNodeApi<string, PosixNode>;
+export type PosixCursor = Cursor<PosixName>;
+export declare const PosixCursorApi: import("../tree-surfer/cursor.js").CursorApi<string>;
+export type PosixFoldNode = FoldNode<PosixName>;
+export declare const PosixFoldNodeApi: import("../tree-surfer/index.js").FoldNodeApi<string>;
+export type PosixNavNode = NavNode<PosixName, PosixNode>;
+export declare const PosixNavApi: import("../tree-surfer/index.js").NavNodeApi<string, PosixNode>;
+export type PosixState = State<PosixName, PosixNode>;
+export declare const PosixStateApi: import("../tree-surfer/state.js").StateApi<string, PosixNode>;
+//# sourceMappingURL=posix-node.d.ts.map

package/dist/domain/posix-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"posix-node.d.ts","sourceRoot":"","sources":["../../src/domain/posix-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,OAAO,EAAmC,MAAM,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AACzF,OAAO,EAAE,QAAQ,EAAE,MAAM,6CAA6C,CAAC;AAEvE,OAAO,EAAE,OAAO,EAAE,MAAM,2CAA2C,CAAC;AAIpE,eAAO,MAAM,eAAe,aAQxB,CAAC;AAEL,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,eAAe,CAAC,CAAC;AAGzD,MAAM,MAAM,SAAS,GACjB;IACE,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,SAAS,CAAC;CACf,GACD;IACE,IAAI,EAAE,SAAS,CAAC;IAChB,EAAE,EAAE,SAAS,CAAC;IACd,MAAM,EAAE,QAAQ,CAAC;CAClB,GACD;IACE,IAAI,EAAE,WAAW,CAAC;IAClB,EAAE,EAAE,SAAS,CAAC;IACd,QAAQ,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC;CAC9B,CAAC;AAEN,eAAO,MAAM,YAAY,kEAA4C,CAAC;AAStE,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC;AAE5C,eAAO,MAAM,cAAc,sDAA+B,CAAC;AAG3D,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC;AAEhD,eAAO,MAAM,gBAAgB,uDAAiC,CAAC;AAG/D,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;AAEzD,eAAO,MAAM,WAAW,iEAIvB,CAAC;AAGF,MAAM,MAAM,UAAU,GAAG,KAAK,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;AAErD,eAAO,MAAM,aAAa,+DAKzB,CAAC"}

package/dist/domain/posix-node.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { createTreeNodeApi } from '../tree-surfer/tree-node/tree-node.impl.js';
+import { createCursorApi, createStateApi } from '../tree-surfer/index.js';
+import { createFoldNodeApi } from '../tree-surfer/fold-node/fold-node.impl.js';
+import { createNavNodeApi } from '../tree-surfer/nav-node/nav-node.impl.js';
+// Name
+export const PosixNameSchema = z
+    .string()
+    .min(1)
+    .refine((value) => !value.includes('/'), {
+    message: "Entry name must not contain '/'",
+})
+    .refine((value) => value !== '.' && value !== '..', {
+    message: "Entry name cannot be '.' or '..'",
+});
+export const PosixNodeApi = createTreeNodeApi();
+export const PosixCursorApi = createCursorApi();
+export const PosixFoldNodeApi = createFoldNodeApi();
+export const PosixNavApi = createNavNodeApi(PosixNodeApi, PosixFoldNodeApi, PosixCursorApi);
+export const PosixStateApi = createStateApi(PosixNodeApi, PosixFoldNodeApi, PosixCursorApi, PosixNavApi);

package/dist/index.d.ts

@@ -1,10 +1,10 @@
-export * from './domain/cursor.js';
-export * from './domain/display-row.js';
-export * from './domain/fold-node.js';
-export * from './domain/navigation-node.js';
-export * from './domain/state.js';
-export * from './domain/unix-entry.js';
+export * from './tree-surfer-ui/application/user-input-to-intent.js';
+export * from './tree-surfer-ui/application/intent-to-effect.js';
+export * from './tree-surfer-ui/domain/effect.js';
+export * from './tree-surfer-ui/domain/input-state.js';
+export * from './tree-surfer-ui/domain/intent.js';
+export * from './tree-surfer-ui/domain/user-input.js';
+export * from './tree-surfer/index.js';
+export * from './domain/posix-node.js';
 export * from './domain/unix-path.js';
-export * from './infrastructure/get-cwd.js';
-export * from './infrastructure/get-dir-lazy-entries.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AAEtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0CAA0C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,sDAAsD,CAAC;AACrE,cAAc,kDAAkD,CAAC;AAEjE,cAAc,mCAAmC,CAAC;AAClD,cAAc,wCAAwC,CAAC;AACvD,cAAc,mCAAmC,CAAC;AAClD,cAAc,uCAAuC,CAAC;AAEtD,cAAc,wBAAwB,CAAC;AAEvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC"}

package/dist/index.js

@@ -1,9 +1,9 @@
-export * from './domain/cursor.js';
-export * from './domain/display-row.js';
-export * from './domain/fold-node.js';
-export * from './domain/navigation-node.js';
-export * from './domain/state.js';
-export * from './domain/unix-entry.js';
+export * from './tree-surfer-ui/application/user-input-to-intent.js';
+export * from './tree-surfer-ui/application/intent-to-effect.js';
+export * from './tree-surfer-ui/domain/effect.js';
+export * from './tree-surfer-ui/domain/input-state.js';
+export * from './tree-surfer-ui/domain/intent.js';
+export * from './tree-surfer-ui/domain/user-input.js';
+export * from './tree-surfer/index.js';
+export * from './domain/posix-node.js';
 export * from './domain/unix-path.js';
-export * from './infrastructure/get-cwd.js';
-export * from './infrastructure/get-dir-lazy-entries.js';

package/dist/tree-surfer/cursor.d.ts

@@ -0,0 +1,24 @@
+export declare const CursorKind: {
+    readonly Entry: "entry";
+    readonly Fold: "fold";
+};
+export type CursorKind = (typeof CursorKind)[keyof typeof CursorKind];
+export type CursorEntry<Id> = {
+    kind: typeof CursorKind.Entry;
+    parentPath: readonly Id[];
+    entryId: Id;
+};
+export type CursorFold<Id> = {
+    kind: typeof CursorKind.Fold;
+    parentPath: readonly Id[];
+};
+export type Cursor<Id> = CursorEntry<Id> | CursorFold<Id>;
+export type CursorApi<Id> = {
+    isEntry(cursor: Cursor<Id>): cursor is CursorEntry<Id>;
+    isFold(cursor: Cursor<Id>): cursor is CursorFold<Id>;
+    equal(left: Cursor<Id>, right: Cursor<Id>): boolean;
+    getPath(cursor: Cursor<Id>): Id[] | undefined;
+    cursorBelongsToSubtree(cursor: Cursor<Id>, entryPath: readonly Id[]): boolean;
+};
+export declare function createCursorApi<Id>(): CursorApi<Id>;
+//# sourceMappingURL=cursor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cursor.d.ts","sourceRoot":"","sources":["../../src/tree-surfer/cursor.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU;;;CAGb,CAAC;AAEX,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,OAAO,UAAU,CAAC,CAAC;AAEtE,MAAM,MAAM,WAAW,CAAC,EAAE,IAAI;IAC5B,IAAI,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;IAC9B,UAAU,EAAE,SAAS,EAAE,EAAE,CAAC;IAC1B,OAAO,EAAE,EAAE,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,UAAU,CAAC,EAAE,IAAI;IAC3B,IAAI,EAAE,OAAO,UAAU,CAAC,IAAI,CAAC;IAC7B,UAAU,EAAE,SAAS,EAAE,EAAE,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,MAAM,CAAC,EAAE,IAAI,WAAW,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,EAAE,CAAC,CAAC;AAE1D,MAAM,MAAM,SAAS,CAAC,EAAE,IAAI;IAC1B,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,GAAG,MAAM,IAAI,WAAW,CAAC,EAAE,CAAC,CAAC;IAEvD,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,GAAG,MAAM,IAAI,UAAU,CAAC,EAAE,CAAC,CAAC;IAErD,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC;IAEpD,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,GAAG,SAAS,CAAC;IAE9C,sBAAsB,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,EAAE,SAAS,EAAE,SAAS,EAAE,EAAE,GAAG,OAAO,CAAC;CAC/E,CAAC;AAEF,wBAAgB,eAAe,CAAC,EAAE,KAAK,SAAS,CAAC,EAAE,CAAC,CA0CnD"}

package/dist/tree-surfer/cursor.js

@@ -0,0 +1,65 @@
+export const CursorKind = {
+    Entry: 'entry',
+    Fold: 'fold',
+};
+export function createCursorApi() {
+    const cursorApi = {
+        isEntry(cursor) {
+            return cursor.kind === CursorKind.Entry;
+        },
+        isFold(cursor) {
+            return cursor.kind === CursorKind.Fold;
+        },
+        equal(left, right) {
+            if (!idPathEqual(left.parentPath, right.parentPath)) {
+                return false;
+            }
+            if (cursorApi.isFold(left)) {
+                return cursorApi.isFold(right);
+            }
+            return cursorApi.isEntry(right) && left.entryId === right.entryId;
+        },
+        getPath(cursor) {
+            if (cursorApi.isFold(cursor)) {
+                return undefined;
+            }
+            return [...cursor.parentPath, cursor.entryId];
+        },
+        cursorBelongsToSubtree(cursor, entryPath) {
+            if (cursorApi.isFold(cursor)) {
+                return isStrictPathPrefix(entryPath, cursor.parentPath);
+            }
+            const cursorPath = [...cursor.parentPath, cursor.entryId];
+            return isStrictPathPrefix(entryPath, cursorPath);
+        },
+    };
+    return cursorApi;
+}
+/**
+ * Returns true when both paths contain the same IDs in the same order.
+ */
+function idPathEqual(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    for (let index = 0; index < left.length; index += 1) {
+        if (left[index] !== right[index]) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Returns true when `prefix` is a strict prefix of `path`.
+ */
+function isStrictPathPrefix(prefix, path) {
+    if (prefix.length >= path.length) {
+        return false;
+    }
+    for (let index = 0; index < prefix.length; index += 1) {
+        if (prefix[index] !== path[index]) {
+            return false;
+        }
+    }
+    return true;
+}

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

@@ -0,0 +1,5 @@
+import { FoldNode, FoldNodeApi, FoldNodeService } from './fold-node.types.js';
+import { SerializableKey } from '../tree-node/tree-node.types.js';
+export declare function createFoldNodeApi<Id extends SerializableKey>(): FoldNodeApi<Id>;
+export declare function createFoldNodeService<Id extends SerializableKey>(foldNodeApi: FoldNodeApi<Id>, createChild: (id: Id) => FoldNode<Id>): FoldNodeService<Id>;
+//# sourceMappingURL=fold-node.impl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fold-node.impl.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/fold-node/fold-node.impl.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EACR,WAAW,EAEX,eAAe,EAChB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAElE,wBAAgB,iBAAiB,CAAC,EAAE,SAAS,eAAe,KAAK,WAAW,CAAC,EAAE,CAAC,CAiC/E;AAED,wBAAgB,qBAAqB,CAAC,EAAE,SAAS,eAAe,EAC9D,WAAW,EAAE,WAAW,CAAC,EAAE,CAAC,EAC5B,WAAW,EAAE,CAAC,EAAE,EAAE,EAAE,KAAK,QAAQ,CAAC,EAAE,CAAC,GACpC,eAAe,CAAC,EAAE,CAAC,CAiLrB"}

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

@@ -0,0 +1,143 @@
+import { createTreeNodeApi } from '../tree-node/tree-node.impl.js';
+export function createFoldNodeApi() {
+    const treeNodeApi = createTreeNodeApi();
+    return {
+        getChildren(node) {
+            return node.children;
+        },
+        getChildById(node, id) {
+            return node.children.find((child) => child.id === id);
+        },
+        getAtPath(rootNode, path, selector) {
+            return treeNodeApi.getAtPath(rootNode.children, path, selector);
+        },
+        modifyAtPath(rootNode, path, modifier) {
+            const children = treeNodeApi.modifyAtPath(rootNode.children, path, modifier);
+            if (children === undefined) {
+                return undefined;
+            }
+            return {
+                ...rootNode,
+                children,
+            };
+        },
+    };
+}
+export function createFoldNodeService(foldNodeApi, createChild) {
+    return {
+        createEmptyRoot() {
+            return {
+                children: [],
+                folds: new Set(),
+            };
+        },
+        getIfEntryFoldedAtPath(rootNode, path, entryId) {
+            if (path.length === 0) {
+                return rootNode.folds.has(entryId);
+            }
+            const node = foldNodeApi.getAtPath(rootNode, path, (candidate) => candidate);
+            return node !== undefined && node.folds.has(entryId);
+        },
+        addFoldedEntryAtPath(rootNode, path, entryId) {
+            const ensuredRoot = ensurePath(rootNode, path);
+            if (path.length === 0) {
+                return addFoldedEntry(ensuredRoot, entryId);
+            }
+            return foldNodeApi.modifyAtPath(ensuredRoot, path, (node) => addFoldedEntry(node, entryId));
+        },
+        removeFoldedEntryAtPath(rootNode, path, entryId) {
+            if (path.length === 0) {
+                return removeFoldedEntry(rootNode, entryId);
+            }
+            return foldNodeApi.modifyAtPath(rootNode, path, (node) => removeFoldedEntry(node, entryId));
+        },
+        clearFoldedEntriesAtPath(rootNode, path) {
+            if (path.length === 0) {
+                return clearFoldedEntries(rootNode);
+            }
+            return foldNodeApi.modifyAtPath(rootNode, path, clearFoldedEntries);
+        },
+    };
+    // Helpers:
+    // `Node extends FoldNodeRoot<Id> | FoldNode<Id>` is used to create two
+    // versions of functions: one for the root and one for the children.
+    // "Flat" functions
+    //
+    // Adds entry name to the given node.
+    function addFoldedEntry(node, entryId) {
+        if (node.folds.has(entryId)) {
+            return node;
+        }
+        const folds = new Set(node.folds);
+        folds.add(entryId);
+        return {
+            ...node,
+            folds,
+        };
+    }
+    function removeFoldedEntry(node, entryId) {
+        if (!node.folds.has(entryId)) {
+            return node;
+        }
+        const folds = new Set(node.folds);
+        folds.delete(entryId);
+        return {
+            ...node,
+            folds,
+        };
+    }
+    function clearFoldedEntries(node) {
+        if (node.folds.size === 0) {
+            return node;
+        }
+        return {
+            ...node,
+            folds: new Set(),
+        };
+    }
+    /**
+     * Ensures that the requested path exists in the fold-state tree.
+     *
+     * This creates fold nodes only; it does not modify the buffer tree.
+     */
+    function ensurePath(rootNode, path) {
+        if (path.length === 0) {
+            return rootNode;
+        }
+        const children = ensureChildPath(rootNode.children, path, 0);
+        if (children === rootNode.children) {
+            return rootNode;
+        }
+        return {
+            ...rootNode,
+            children,
+        };
+    }
+    function ensureChildPath(children, path, pathIndex) {
+        const id = path[pathIndex];
+        if (id === undefined) {
+            return children;
+        }
+        const childIndex = children.findIndex((child) => child.id === id);
+        const child = childIndex === -1 ? createChild(id) : children[childIndex];
+        let updatedChild = child;
+        if (pathIndex < path.length - 1) {
+            const updatedChildren = ensureChildPath(child.children, path, pathIndex + 1);
+            if (updatedChildren !== child.children) {
+                updatedChild = {
+                    ...child,
+                    children: updatedChildren,
+                };
+            }
+        }
+        if (childIndex === -1) {
+            return [...children, updatedChild];
+        }
+        if (updatedChild === child) {
+            return children;
+        }
+        const result = [...children];
+        result[childIndex] = updatedChild;
+        return result;
+    }
+}

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

@@ -0,0 +1,70 @@
+import { TreeNodeModifier, TreeNodeSelector } from '../tree-node/tree-node.types.js';
+/**
+ * The whole fold state for a tree-node 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.
+ *
+ * `folds` contains the IDs folded at this root. Fold order is not
+ * represented here; the buffer tree determines entry order.
+ */
+export type FoldNodeRoot<Id extends PropertyKey> = {
+    children: FoldNode<Id>[];
+    folds: ReadonlySet<Id>;
+};
+/**
+ * Fold state associated with a node in the buffer tree.
+ *
+ * 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.
+ *
+ * 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 type is structurally compatible with `TreeNode`, allowing the shared
+ * `TreeNodeApi` to be used for path traversal and immutable updates.
+ */
+export type FoldNode<Id extends PropertyKey> = FoldNodeRoot<Id> & {
+    id: Id;
+};
+/**
+ * Operations for navigating and immutably updating fold-tree structure.
+ *
+ * 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`.
+ */
+export type FoldNodeApi<Id extends PropertyKey> = {
+    /**
+     * Returns the children of either the fold root or a fold node.
+     */
+    getChildren(node: FoldNodeRoot<Id> | FoldNode<Id>): Iterable<FoldNode<Id>>;
+    /**
+     * Returns a direct child by ID.
+     */
+    getChildById(node: FoldNodeRoot<Id> | FoldNode<Id>, id: Id): FoldNode<Id> | undefined;
+    /**
+     * Selects a fold node at a path below the root.
+     */
+    getAtPath<Result>(rootNode: FoldNodeRoot<Id>, path: Id[], selector: TreeNodeSelector<FoldNode<Id>, Result>): Result | undefined;
+    /**
+     * Immutably modifies a fold node at a path below the root.
+     */
+    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;
+};
+//# sourceMappingURL=fold-node.types.d.ts.map

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

@@ -0,0 +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,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAErF;;;;;;;;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,CACzB,EAAE,SAAS,WAAW,IACpB;IACF,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"}

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

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

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

@@ -0,0 +1,9 @@
+export * from './fold-node/fold-node.impl.js';
+export * from './fold-node/fold-node.types.js';
+export * from './nav-node/nav-node.impl.js';
+export * from './nav-node/nav-node.types.js';
+export * from './tree-node/tree-node.impl.js';
+export * from './tree-node/tree-node.types.js';
+export * from './cursor.js';
+export * from './state.js';
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/tree-surfer/index.js

@@ -0,0 +1,8 @@
+export * from './fold-node/fold-node.impl.js';
+export * from './fold-node/fold-node.types.js';
+export * from './nav-node/nav-node.impl.js';
+export * from './nav-node/nav-node.types.js';
+export * from './tree-node/tree-node.impl.js';
+export * from './tree-node/tree-node.types.js';
+export * from './cursor.js';
+export * from './state.js';

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

@@ -0,0 +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>;
+//# sourceMappingURL=nav-node.impl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nav-node.impl.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer/nav-node/nav-node.impl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,eAAe,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACvG,OAAO,EAAE,WAAW,EAAgB,MAAM,iCAAiC,CAAC;AAC5E,OAAO,EAAU,SAAS,EAAc,MAAM,cAAc,CAAC;AAC7D,OAAO,EAA6C,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAE5F,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"}

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

@@ -0,0 +1,191 @@
+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);
+                }
+            }
+            return {
+                entries: visibleEntriesSoFar,
+                foldedEntries: foldedEntriesSoFar,
+            };
+        },
+        getNodeAtPath(navigation, path) {
+            const [currentId, ...remainingPath] = path;
+            // An empty path identifies the current node.
+            if (currentId === undefined) {
+                return navigation;
+            }
+            const entry = [...navigation.entries, ...navigation.foldedEntries].find((candidate) => candidate.id === currentId);
+            if (entry === undefined) {
+                return undefined;
+            }
+            if (!isNavBranch(entry)) {
+                return undefined;
+            }
+            // The directory has not been loaded/opened.
+            if (entry.children === null) {
+                return undefined;
+            }
+            return navNodeApi.getNodeAtPath(entry.children, remainingPath);
+        },
+        getEntryAtPath(navigation, path) {
+            const [currentId, ...remainingPath] = path;
+            if (currentId === undefined) {
+                return undefined;
+            }
+            const entry = [...navigation.entries, ...navigation.foldedEntries].find((candidate) => candidate.id === currentId);
+            if (entry === undefined) {
+                return undefined;
+            }
+            if (remainingPath.length === 0) {
+                return entry;
+            }
+            if (!isNavBranch(entry) || entry.children === null) {
+                return undefined;
+            }
+            return navNodeApi.getEntryAtPath(entry.children, remainingPath);
+        },
+        nextCursor(rootNode, cursor) {
+            const cursors = cursorsInNode(rootNode, []);
+            const currentIndex = cursors.findIndex((candidate) => cursorApi.equal(candidate, cursor));
+            if (currentIndex === -1 || currentIndex === cursors.length - 1) {
+                return undefined;
+            }
+            return cursors[currentIndex + 1];
+        },
+        previousCursor(rootNode, cursor) {
+            const cursors = cursorsInNode(rootNode, []);
+            const currentIndex = cursors.findIndex((candidate) => cursorApi.equal(candidate, cursor));
+            if (currentIndex <= 0) {
+                return undefined;
+            }
+            return cursors[currentIndex - 1];
+        },
+        cursorAfterFold(rootNode, cursor) {
+            if (cursorApi.isFold(cursor)) {
+                return undefined;
+            }
+            const cursors = cursorsInNode(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)) {
+                    continue;
+                }
+                return candidate;
+            }
+            // The fold row will be created at the end of this directory.
+            return {
+                kind: CursorKind.Fold,
+                parentPath: cursor.parentPath,
+            };
+        },
+        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)) {
+                return undefined;
+            }
+            return {
+                kind: CursorKind.Entry,
+                parentPath: containingPath,
+                entryId: entryId,
+            };
+        },
+        cursors(navigation, parentPath = []) {
+            return cursorsInNode(navigation, parentPath);
+        },
+        visibleLeavesPaths(navigation, parentPath = []) {
+            const paths = [];
+            for (const entry of navigation.entries) {
+                const entryPath = [...parentPath, entry.id];
+                if (isNavBranch(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) {
+                        paths.push(...navNodeApi.visibleLeavesPaths(entry.children, entryPath));
+                    }
+                    continue;
+                }
+                paths.push(entryPath);
+            }
+            return paths;
+        },
+    };
+    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;
+}