dirvi-lib 0.4.0 → 0.5.0

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

@@ -0,0 +1,117 @@
+import { describe, expect, it } from 'vitest';
+import * as fc from 'fast-check';
+import { createTreeNodeApi } from './tree-node.impl.js';
+import { forestAndPathAndExpectedArb, newBranchesOrNullArb, nodesArrayAndBranchPathArb, } from './tree-node.arb.js';
+const stringNodeApi = createTreeNodeApi();
+describe('tree node API', () => {
+    it('getAtPath returns the node at the generated path', () => {
+        fc.assert(fc.property(forestAndPathAndExpectedArb, ({ entries, path, expected }) => {
+            expect(stringNodeApi.getAtPath(entries, path, (node) => node)).toBe(expected);
+        }));
+    });
+    it('getAtPath applies the selector', () => {
+        const entries = [
+            {
+                id: 'root',
+                children: [{ id: 'child' }],
+            },
+        ];
+        expect(stringNodeApi.getAtPath(entries, ['root', 'child'], (node) => node.id)).toBe('child');
+    });
+    it('getAtPath returns undefined for an empty path', () => {
+        const entries = [{ id: 'root' }];
+        expect(stringNodeApi.getAtPath(entries, [], (node) => node)).toBeUndefined();
+    });
+    it('getAtPath returns undefined through a closed branch', () => {
+        const entries = [
+            {
+                id: 'root',
+                children: null,
+            },
+        ];
+        expect(stringNodeApi.getAtPath(entries, ['root', 'child'], (node) => node)).toBeUndefined();
+    });
+    it('getAtPath returns undefined when the selector returns undefined', () => {
+        const entries = [{ id: 'root' }];
+        expect(stringNodeApi.getAtPath(entries, ['root'], () => undefined)).toBeUndefined();
+    });
+    it('getChildById returns the matching child', () => {
+        const child = { id: 'child' };
+        const root = {
+            id: 'root',
+            children: [child],
+        };
+        expect(stringNodeApi.isOpenBranch(root)).toBe(true);
+        if (!stringNodeApi.isOpenBranch(root)) {
+            return;
+        }
+        expect(stringNodeApi.getChildById(root, 'child')).toBe(child);
+        expect(stringNodeApi.getChildById(root, 'missing')).toBeUndefined();
+    });
+    it('modifyAtPath replaces the generated node', () => {
+        fc.assert(fc.property(forestAndPathAndExpectedArb, ({ entries, path, expected }) => {
+            const replacement = {
+                id: expected.id,
+            };
+            const updatedForest = stringNodeApi.modifyAtPath(entries, path, () => replacement);
+            expect(updatedForest).not.toBeUndefined();
+            if (updatedForest === undefined) {
+                return;
+            }
+            expect(stringNodeApi.getAtPath(updatedForest, path, (node) => node)).toBe(replacement);
+            expect(stringNodeApi.getAtPath(entries, path, (node) => node)).toBe(expected);
+        }));
+    });
+    it('modifyAtPath replaces children at a branch path', () => {
+        fc.assert(fc.property(nodesArrayAndBranchPathArb, newBranchesOrNullArb, ({ entries, path, expected }, newBranches) => {
+            expect(stringNodeApi.isBranch(expected)).toBe(true);
+            const updatedForest = stringNodeApi.modifyAtPath(entries, path, (node) => ({
+                ...node,
+                children: newBranches,
+            }));
+            expect(updatedForest).not.toBeUndefined();
+            if (updatedForest === undefined) {
+                return;
+            }
+            const updatedNode = stringNodeApi.getAtPath(updatedForest, path, (node) => node);
+            expect(updatedNode).not.toBeUndefined();
+            expect(updatedNode).not.toBe(expected);
+            if (updatedNode === undefined ||
+                !stringNodeApi.isBranch(updatedNode) ||
+                (!stringNodeApi.isOpenBranch(updatedNode) && newBranches !== null)) {
+                return;
+            }
+            if (stringNodeApi.isOpenBranch(updatedNode)) {
+                expect([...stringNodeApi.getChildren(updatedNode)]).toStrictEqual(newBranches);
+            }
+            expect(stringNodeApi.getAtPath(entries, path, (node) => node)).toBe(expected);
+        }));
+    });
+    it('modifyAtPath returns undefined when the modifier aborts', () => {
+        const entries = [{ id: 'root' }];
+        expect(stringNodeApi.modifyAtPath(entries, ['root'], () => undefined)).toBeUndefined();
+    });
+    it('modifyAtPath returns undefined for an empty path', () => {
+        const entries = [{ id: 'root' }];
+        expect(stringNodeApi.modifyAtPath(entries, [], (node) => node)).toBeUndefined();
+    });
+    it('modifyAtPath returns undefined for an invalid path', () => {
+        const entries = [
+            {
+                id: 'root',
+                children: [],
+            },
+        ];
+        expect(stringNodeApi.modifyAtPath(entries, ['missing'], (node) => node)).toBeUndefined();
+        expect(stringNodeApi.modifyAtPath(entries, ['root', 'missing'], (node) => node)).toBeUndefined();
+    });
+    it('modifyAtPath cannot traverse a closed branch', () => {
+        const entries = [
+            {
+                id: 'root',
+                children: null,
+            },
+        ];
+        expect(stringNodeApi.modifyAtPath(entries, ['root', 'child'], (node) => node)).toBeUndefined();
+    });
+});

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

@@ -0,0 +1,184 @@
+import { z } from 'zod';
+/**
+ * Runtime schema for IDs that can be safely represented as serializable
+ * primitive values.
+ *
+ * Strings are accepted as-is. Numbers must be finite, so `NaN`, `Infinity`,
+ * and `-Infinity` are rejected.
+ *
+ * Applications should derive a more specific schema when those constraints
+ * are needed.
+ */
+export declare const serializableKeySchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+/**
+ * A serializable primitive suitable for use as a stable tree ID.
+ *
+ * The runtime schema guarantees that numeric values are finite. TypeScript
+ * cannot represent the exclusion of `NaN` and infinities from `number`, so
+ * values from untrusted sources should be validated with
+ * `serializableKeySchema` before being used as IDs.
+ *
+ * For application-specific IDs, define a narrower branded schema and derive
+ * its type with `z.output`.
+ *
+ * @example
+ *
+ * ```ts
+ * const menuIdSchema = z
+ *   .string()
+ *   .min(1)
+ *   .brand<'MenuId'>();
+ *
+ * type MenuId = z.output<typeof menuIdSchema>;
+ *
+ * const menuId = menuIdSchema.parse(input);
+ * // menuId: MenuId
+ *
+ * type MenuNode = TreeNode<MenuId, MenuNode>;
+ * ```
+ */
+export type SerializableKey = string | number;
+/**
+ * A node with no children.
+ */
+export type LeafTreeNode<Id extends SerializableKey> = {
+    id: Id;
+    children?: never;
+};
+/**
+ * A branch whose children have not been loaded.
+ */
+export type ClosedBranchTreeNode<Id extends SerializableKey> = {
+    id: Id;
+    children: null;
+};
+/**
+ * A branch whose children have been loaded.
+ *
+ * TODO Later: Add a dictionary by ID for faster lookup.
+ * Then children will just be an array for keeping order.
+ */
+export type OpenBranchTreeNode<Id extends SerializableKey, ChildNode extends TreeNode<Id, ChildNode>> = {
+    id: Id;
+    children: ChildNode[];
+};
+/**
+ * A tree node that has children, either loaded or unloaded.
+ */
+export type BranchTreeNode<Id extends SerializableKey, ChildNode extends TreeNode<Id, ChildNode>> = OpenBranchTreeNode<Id, ChildNode> | ClosedBranchTreeNode<Id>;
+/**
+ * A node in a tree.
+ *
+ * `ChildNode` is the concrete application-specific node type. It may contain
+ * additional properties, provided that it has the shape of either a leaf or a
+ * branch.
+ */
+export type TreeNode<Id extends SerializableKey, ChildNode extends TreeNode<Id, ChildNode>> = LeafTreeNode<Id> | BranchTreeNode<Id, ChildNode>;
+/**
+ * Selects a value from a node reached by a path.
+ *
+ * The selector is called only when the complete path exists and identifies
+ * a node. Returning `undefined` from the selector is allowed, but is
+ * indistinguishable from an unsuccessful lookup in the return value.
+ */
+export type TreeNodeSelector<ChildNode, Result> = (node: ChildNode) => Result;
+/**
+ * Produces a replacement for a node reached by a path.
+ *
+ * Returning `undefined` aborts the modification and causes `modifyAtPath`
+ * to return `undefined`.
+ */
+export type TreeNodeModifier<ChildNode> = (node: ChildNode) => ChildNode | undefined;
+/**
+ * Fundamental operations for inspecting and immutably updating a tree forest.
+ *
+ * A forest is represented by an array of root-level nodes. A path is an array
+ * of IDs beginning at a root node and continuing through its descendants.
+ *
+ * For example, given tree with IDs:
+ *
+ *   root
+ *   └── child
+ *
+ * the path to `child` is `['root', 'child']`.
+ *
+ * Path traversal and child lookup are performed by this API so that callers
+ * do not depend on the internal child-storage representation or need to
+ * iterate over children themselves.
+ *
+ * An empty path does not identify a node and is invalid for both lookup and
+ * modification operations.
+ */
+export type TreeNodeApi<Id extends SerializableKey, ChildNode extends TreeNode<Id, ChildNode>> = {
+    isLeaf(node: ChildNode): node is ChildNode & LeafTreeNode<Id>;
+    isBranch(node: ChildNode): node is ChildNode & BranchTreeNode<Id, ChildNode>;
+    isClosedBranch(node: BranchTreeNode<Id, ChildNode>): node is ClosedBranchTreeNode<Id>;
+    isOpenBranch(node: BranchTreeNode<Id, ChildNode>): node is OpenBranchTreeNode<Id, ChildNode>;
+    /**
+     * Returns the loaded children of an open branch.
+     *
+     * The returned iterable preserves the branch's sibling order. The method
+     * can only be called after narrowing the branch with `isOpenBranch`.
+     *
+     * The returned children are the existing child nodes; they are not cloned.
+     */
+    getChildren(node: OpenBranchTreeNode<Id, ChildNode>): Iterable<ChildNode>;
+    /**
+     * Returns the child with the supplied ID.
+     *
+     * Returns `undefined` when the branch has no child with that ID.
+     * The returned child is the existing node; it is not cloned.
+     */
+    getChildById(node: OpenBranchTreeNode<Id, ChildNode>, id: Id): ChildNode | undefined;
+    /**
+     * Applies `selector` to the node at `path`.
+     *
+     * The path must:
+     *
+     * - be non-empty;
+     * - begin at one of the supplied forest entries;
+     * - contain only IDs that identify existing entries;
+     * - not traverse through a leaf; and
+     * - not traverse through a closed branch.
+     *
+     * A branch at the end of the path is valid even when it is closed.
+     *
+     * The selector is called only after the complete path has been resolved.
+     * This method does not clone the tree or the selected node.
+     *
+     * Returns `undefined` when the path cannot be resolved, or when the
+     * selector returns `undefined`.
+     */
+    getAtPath<Result>(entries: ChildNode[], path: Id[], selector: TreeNodeSelector<ChildNode, Result>): Result | undefined;
+    /**
+     * Immutably modifies the node at `path`.
+     *
+     * The modifier is called only after the complete path has been resolved.
+     * Its return value replaces the target node. Returning `undefined` aborts
+     * the modification.
+     *
+     * The operation creates new arrays and ancestor nodes along the path.
+     * Nodes and arrays unrelated to the path retain their original object
+     * identity. The input forest and its nodes (as objects) are never modified.
+     *
+     * The path must:
+     *
+     * - be non-empty;
+     * - begin at one of the supplied forest entries;
+     * - contain only IDs that identify existing entries;
+     * - not traverse through a leaf; and
+     * - not traverse through a closed branch.
+     *
+     * A leaf or branch, including a closed branch, may be the final target.
+     *
+     * Returns `undefined` when:
+     *
+     * - `path` is empty;
+     * - the path does not exist;
+     * - an intermediate node is a leaf;
+     * - an intermediate branch is closed; or
+     * - the modifier returns `undefined`.
+     */
+    modifyAtPath(entries: ChildNode[], path: Id[], modifier: TreeNodeModifier<ChildNode>): ChildNode[] | undefined;
+};
+//# sourceMappingURL=tree-node.types.d.ts.map

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

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

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

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+/**
+ * Runtime schema for IDs that can be safely represented as serializable
+ * primitive values.
+ *
+ * Strings are accepted as-is. Numbers must be finite, so `NaN`, `Infinity`,
+ * and `-Infinity` are rejected.
+ *
+ * Applications should derive a more specific schema when those constraints
+ * are needed.
+ */
+export const serializableKeySchema = z.union([z.string(), z.number().finite()]);

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

@@ -0,0 +1,3 @@
+export * from './intent-to-effect.js';
+export * from './user-input-to-intent.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer-ui/application/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC"}

package/dist/tree-surfer-ui/application/index.js

@@ -0,0 +1,2 @@
+export * from './intent-to-effect.js';
+export * from './user-input-to-intent.js';

package/dist/tree-surfer-ui/application/intent-to-effect-no-state.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=intent-to-effect-no-state.test.d.ts.map

package/dist/tree-surfer-ui/application/intent-to-effect-no-state.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intent-to-effect-no-state.test.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer-ui/application/intent-to-effect-no-state.test.ts"],"names":[],"mappings":""}

package/dist/tree-surfer-ui/application/intent-to-effect-no-state.test.js

@@ -0,0 +1,192 @@
+export {};
+// import { describe, expect, it } from 'vitest';
+//
+// import type { PosixState } from '../../domain/posix-node.js';
+// import { intentToEffect } from './intent-to-effect.js';
+//
+// const state = {} as PosixState;
+//
+// describe('intentToEffectNoState', () => {
+//   describe('normal mode buffer', () => {
+//     it('stores z as a possible command prefix', () => {
+//       expect(
+//         intentToEffect(
+//           {
+//             intentType: 'setNormalBuffer',
+//             normalBuffer: 'z',
+//           },
+//           state,
+//         ),
+//       ).toEqual({
+//         effectType: 'setInputState',
+//         inputState: {
+//           inputMode: 'normal',
+//           normalBuffer: 'z',
+//         },
+//       });
+//     });
+//
+//     it.each([
+//       ['za', 'toggleFold'],
+//       ['zc', 'fold'],
+//       ['zo', 'unfold'],
+//     ] as const)(
+//       'converts %s into a %s effect action',
+//       (normalBuffer, effectActionType) => {
+//         expect(
+//           intentToEffect(
+//             {
+//               intentType: 'setNormalBuffer',
+//               normalBuffer,
+//             },
+//             state,
+//           ),
+//         ).toEqual({
+//           effectType: 'dispatchEffectAction',
+//           action: {
+//             effectActionType,
+//           },
+//         });
+//       },
+//     );
+//
+//     it('clears the normal buffer when the input is not a known command', () => {
+//       expect(
+//         intentToEffect(
+//           {
+//             intentType: 'setNormalBuffer',
+//             normalBuffer: 'x',
+//           },
+//           state,
+//         ),
+//       ).toEqual({
+//         effectType: 'setInputState',
+//         inputState: {
+//           inputMode: 'normal',
+//           normalBuffer: '',
+//         },
+//       });
+//     });
+//   });
+//
+//   describe('normal mode navigation', () => {
+//     it('moves to the next entry', () => {
+//       expect(
+//         intentToEffect(
+//           {
+//             intentType: 'normalDown',
+//           },
+//           state,
+//         ),
+//       ).toEqual({
+//         effectType: 'dispatchEffectAction',
+//         action: {
+//           effectActionType: 'nextEntry',
+//         },
+//       });
+//     });
+//
+//     it('moves to the previous entry', () => {
+//       expect(
+//         intentToEffect(
+//           {
+//             intentType: 'normalUp',
+//           },
+//           state,
+//         ),
+//       ).toEqual({
+//         effectType: 'dispatchEffectAction',
+//         action: {
+//           effectActionType: 'prevEntry',
+//         },
+//       });
+//     });
+//   });
+//
+//   describe('command-line mode', () => {
+//     it('enters command-line mode', () => {
+//       expect(
+//         intentToEffect(
+//           {
+//             intentType: 'enterCommandLineMode',
+//           },
+//           state,
+//         ),
+//       ).toEqual({
+//         effectType: 'setInputState',
+//         inputState: {
+//           inputMode: 'command',
+//           commandLine: ':',
+//         },
+//       });
+//     });
+//
+//     it('updates the command line', () => {
+//       expect(
+//         intentToEffect(
+//           {
+//             intentType: 'setCommandLine',
+//             commandLine: ':w',
+//           },
+//           state,
+//         ),
+//       ).toEqual({
+//         effectType: 'setInputState',
+//         inputState: {
+//           inputMode: 'command',
+//           commandLine: ':w',
+//         },
+//       });
+//     });
+//
+//     it('exits command-line mode', () => {
+//       expect(
+//         intentToEffect(
+//           {
+//             intentType: 'exitCommandLineMode',
+//           },
+//           state,
+//         ),
+//       ).toEqual({
+//         effectType: 'setInputState',
+//         inputState: {
+//           inputMode: 'normal',
+//           normalBuffer: '',
+//         },
+//       });
+//     });
+//
+//     it('returns to normal mode after executing a gibberish command line', () => {
+//       expect(
+//         intentToEffect(
+//           {
+//             intentType: 'executeCommandLine',
+//             commandLine: ':sijbas',
+//           },
+//           state,
+//         ),
+//       ).toEqual({
+//         effectType: 'setInputState',
+//         inputState: {
+//           inputMode: 'normal',
+//           normalBuffer: '',
+//         },
+//       });
+//     });
+//
+//     it('quits when the :q command is executed', () => {
+//       expect(
+//         intentToEffect(
+//           {
+//             intentType: 'executeCommandLine',
+//             commandLine: ':q',
+//           },
+//           state,
+//         ),
+//       ).toEqual({
+//         effectType: 'quit',
+//         exitMessage: '',
+//       });
+//     });
+//   });
+// });

package/dist/tree-surfer-ui/application/intent-to-effect.d.ts

@@ -0,0 +1,6 @@
+import { SerializableKey, TreeNode, TreeNodeApi } from '../../tree-surfer/tree-node/tree-node.types.js';
+import { Effect, Intent } from '../domain/index.js';
+import { CursorApi, State, StateApi } from '../../tree-surfer/index.js';
+export type IntentToEffect<Id extends SerializableKey, BufferNode extends TreeNode<Id, BufferNode>> = (intent: Intent, state: State<Id, BufferNode>) => Effect<Id, BufferNode> | undefined;
+export declare function createIntentToEffect<Id extends SerializableKey, BufferNode extends TreeNode<Id, BufferNode>>(stateApi: StateApi<Id, BufferNode>, cursorApi: CursorApi<Id>, treeNodeApi: TreeNodeApi<Id, BufferNode>): IntentToEffect<Id, BufferNode>;
+//# sourceMappingURL=intent-to-effect.d.ts.map

package/dist/tree-surfer-ui/application/intent-to-effect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intent-to-effect.d.ts","sourceRoot":"","sources":["../../../src/tree-surfer-ui/application/intent-to-effect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,gDAAgD,CAAC;AACxG,OAAO,EAAE,MAAM,EAAgB,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAClE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAGxE,MAAM,MAAM,cAAc,CACxB,EAAE,SAAS,eAAe,EAC1B,UAAU,SAAS,QAAQ,CAAC,EAAE,EAAE,UAAU,CAAC,IACzC,CACF,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,UAAU,CAAC,KACzB,MAAM,CAAC,EAAE,EAAE,UAAU,CAAC,GAAG,SAAS,CAAC;AAGxC,wBAAgB,oBAAoB,CAClC,EAAE,SAAS,eAAe,EAC1B,UAAU,SAAS,QAAQ,CAAC,EAAE,EAAE,UAAU,CAAC,EAE3C,QAAQ,EAAE,QAAQ,CAAC,EAAE,EAAE,UAAU,CAAC,EAClC,SAAS,EAAE,SAAS,CAAC,EAAE,CAAC,EACxB,WAAW,EAAE,WAAW,CAAC,EAAE,EAAE,UAAU,CAAC,GACvC,cAAc,CAAC,EAAE,EAAE,UAAU,CAAC,CAyEhC"}

package/dist/tree-surfer-ui/application/intent-to-effect.js

@@ -0,0 +1,137 @@
+// Factory method, since Apis are needed to derive intent
+export function createIntentToEffect(stateApi, cursorApi, treeNodeApi) {
+    return (intent, state) => {
+        switch (intent.intentType) {
+            case 'setNormalBuffer':
+                return normalBufferToEffectResult(intent.normalBuffer);
+            case 'normalRight':
+                return normalInteractRightToEffect(state, stateApi, cursorApi, treeNodeApi);
+            case 'normalLeft':
+                return normalInteractLeftToEffect(state);
+            case 'normalDown':
+                return dispatchAction({
+                    effectActionType: 'nextEntry',
+                });
+            case 'normalUp':
+                return dispatchAction({
+                    effectActionType: 'prevEntry',
+                });
+            case 'enterCommandLineMode':
+                return {
+                    effectType: 'setInputState',
+                    inputState: {
+                        inputMode: 'command',
+                        commandLine: ':',
+                    },
+                };
+            case 'setCommandLine':
+                return {
+                    effectType: 'setInputState',
+                    inputState: {
+                        inputMode: 'command',
+                        commandLine: intent.commandLine,
+                    },
+                };
+            case 'exitCommandLineMode':
+                return {
+                    effectType: 'setInputState',
+                    inputState: {
+                        inputMode: 'normal',
+                        normalBuffer: '',
+                    },
+                };
+            case 'executeCommandLine':
+                if (intent.commandLine === ':q') {
+                    return {
+                        effectType: 'quit',
+                        exitMessage: '',
+                    };
+                }
+                return {
+                    effectType: 'setInputState',
+                    inputState: {
+                        inputMode: 'normal',
+                        normalBuffer: '',
+                    },
+                };
+        }
+    };
+}
+function dispatchAction(action) {
+    return {
+        effectType: 'dispatchEffectAction',
+        action,
+    };
+}
+// Sets the buffer. Three possibilities:
+// - New command buffer is recognized as a motion, this dispatches the
+// "effect action". Consumer will know to reset the input state.
+// - Prefix of a possible motion, updates normal buffer.
+// - Not a prefix, clears the buffer.
+function normalBufferToEffectResult(updatedNormalBuffer) {
+    switch (updatedNormalBuffer) {
+        case 'z':
+            return {
+                effectType: 'setInputState',
+                inputState: {
+                    inputMode: 'normal',
+                    normalBuffer: updatedNormalBuffer,
+                },
+            };
+        case 'za':
+            return dispatchAction({
+                effectActionType: 'toggleFold',
+            });
+        case 'zc':
+            return dispatchAction({
+                effectActionType: 'fold',
+            });
+        case 'zo':
+            return dispatchAction({
+                effectActionType: 'unfold',
+            });
+        default:
+            return {
+                effectType: 'setInputState',
+                inputState: {
+                    inputMode: 'normal',
+                    normalBuffer: '',
+                },
+            };
+    }
+}
+function normalInteractRightToEffect(state, stateApi, cursorApi, treeNodeApi) {
+    const currentEntry = stateApi.getNodeAtCursor(state);
+    if (currentEntry === undefined) {
+        return undefined;
+    }
+    const path = cursorApi.getPath(state.cursor);
+    if (path === undefined) {
+        return undefined;
+    }
+    if (treeNodeApi.isBranch(currentEntry)) {
+        if (currentEntry.children === null) {
+            return {
+                effectType: 'loadBranchEntries',
+                path,
+            };
+        }
+        return dispatchAction({
+            effectActionType: 'setBranchEntries',
+            path,
+            entries: null,
+        });
+    }
+    return {
+        effectType: 'emitPath',
+        path,
+    };
+}
+function normalInteractLeftToEffect(state) {
+    if (state.cursor.parentPath.length === 0) {
+        return undefined;
+    }
+    return dispatchAction({
+        effectActionType: 'navigateToParent',
+    });
+}