dirvi-lib 0.3.0 → 0.4.0

package/dist/application/user-input-to-intent.test.js

@@ -0,0 +1,125 @@
+import { describe, expect, it } from 'vitest';
+import { userInputToIntent } from './user-input-to-intent.js';
+function normalInputState(normalBuffer = '') {
+  return {
+    inputMode: 'normal',
+    normalBuffer,
+  };
+}
+function commandInputState(commandLine = ':') {
+  return {
+    inputMode: 'command',
+    commandLine,
+  };
+}
+describe('userInputToIntent', () => {
+  describe('normal mode', () => {
+    it.each([
+      ['l', { intentType: 'normalRight' }],
+      ['h', { intentType: 'normalLeft' }],
+      ['j', { intentType: 'normalDown' }],
+      ['k', { intentType: 'normalUp' }],
+      [':', { intentType: 'enterCommandLineMode' }],
+    ])('converts "%s" to the expected intent', (character, expected) => {
+      const userInput = {
+        userInputType: 'character',
+        string: character,
+      };
+      expect(userInputToIntent(userInput, normalInputState())).toEqual(
+        expected,
+      );
+    });
+    it('adds an unrecognized character to the normal buffer', () => {
+      const userInput = {
+        userInputType: 'character',
+        string: 'g',
+      };
+      expect(userInputToIntent(userInput, normalInputState())).toEqual({
+        intentType: 'setNormalBuffer',
+        normalBuffer: 'g',
+      });
+    });
+    it('appends a character to an existing normal buffer', () => {
+      const userInput = {
+        userInputType: 'character',
+        string: 'g',
+      };
+      expect(userInputToIntent(userInput, normalInputState('2'))).toEqual({
+        intentType: 'setNormalBuffer',
+        normalBuffer: '2g',
+      });
+    });
+    it('clears the normal buffer when Escape is pressed', () => {
+      const userInput = {
+        userInputType: 'esc',
+      };
+      expect(userInputToIntent(userInput, normalInputState('gg'))).toEqual({
+        intentType: 'setNormalBuffer',
+        normalBuffer: '',
+      });
+    });
+    it.each([
+      ['rightArrow', 'normalRight'],
+      ['leftArrow', 'normalLeft'],
+      ['downArrow', 'normalDown'],
+      ['upArrow', 'normalUp'],
+    ])('converts %s to %s', (userInputType, intentType) => {
+      const userInput = {
+        userInputType,
+      };
+      expect(userInputToIntent(userInput, normalInputState())).toEqual({
+        intentType,
+      });
+    });
+    it('does not enter command-line mode when the normal buffer is non-empty', () => {
+      const userInput = {
+        userInputType: 'character',
+        string: ':',
+      };
+      expect(userInputToIntent(userInput, normalInputState('g'))).toEqual({
+        intentType: 'setNormalBuffer',
+        normalBuffer: 'g:',
+      });
+    });
+  });
+  describe('command-line mode', () => {
+    it('appends a character to the command line', () => {
+      const userInput = {
+        userInputType: 'character',
+        string: 'w',
+      };
+      expect(userInputToIntent(userInput, commandInputState(':'))).toEqual({
+        intentType: 'setCommandLine',
+        commandLine: ':w',
+      });
+    });
+    it('executes the command line when Enter is pressed', () => {
+      const userInput = {
+        userInputType: 'enter',
+      };
+      expect(userInputToIntent(userInput, commandInputState(':w'))).toEqual({
+        intentType: 'executeCommandLine',
+        commandLine: ':w',
+      });
+    });
+    it('exits command-line mode when Escape is pressed', () => {
+      const userInput = {
+        userInputType: 'esc',
+      };
+      expect(userInputToIntent(userInput, commandInputState(':w'))).toEqual({
+        intentType: 'exitCommandLineMode',
+      });
+    });
+    it.each(['rightArrow', 'leftArrow', 'downArrow', 'upArrow'])(
+      'ignores %s in command-line mode',
+      (userInputType) => {
+        const userInput = {
+          userInputType,
+        };
+        expect(
+          userInputToIntent(userInput, commandInputState()),
+        ).toBeUndefined();
+      },
+    );
+  });
+});

package/dist/domain/cursor.d.ts

@@ -1,17 +1,19 @@
 import { UnixEntryName, UnixEntryPath } from './unix-entry.js';
 import { DisplayRow } from './display-row.js';
-export type Cursor = {
-    kind: 'entry';
-    parentPath: UnixEntryPath;
-    entryName: UnixEntryName;
-} | {
-    kind: 'fold';
-    parentPath: UnixEntryPath;
-};
+export type Cursor =
+  | {
+      kind: 'entry';
+      parentPath: UnixEntryPath;
+      entryName: UnixEntryName;
+    }
+  | {
+      kind: 'fold';
+      parentPath: UnixEntryPath;
+    };
 export declare const Cursor: {
-    equal(left: Cursor, right: Cursor): boolean;
-    matchesDisplayRow(cursor: Cursor, row: DisplayRow): boolean;
-    fromDisplayRow(row: DisplayRow): Cursor;
-    getPath(cursor: Cursor): UnixEntryPath | undefined;
+  equal(left: Cursor, right: Cursor): boolean;
+  matchesDisplayRow(cursor: Cursor, row: DisplayRow): boolean;
+  fromDisplayRow(row: DisplayRow): Cursor;
+  getPath(cursor: Cursor): UnixEntryPath | undefined;
 };
-//# sourceMappingURL=cursor.d.ts.map
+//# sourceMappingURL=cursor.d.ts.map

package/dist/domain/cursor.js

@@ -1,44 +1,46 @@
 import { UnixEntryPath } from './unix-entry.js';
 export const Cursor = {
-    equal(left, right) {
-        if (left.kind !== right.kind) {
-            return false;
-        }
-        if (!UnixEntryPath.equal(left.parentPath, right.parentPath)) {
-            return false;
-        }
-        if (left.kind === 'entry' && right.kind === 'entry') {
-            return left.entryName === right.entryName;
-        }
-        return true;
-    },
-    matchesDisplayRow(cursor, row) {
-        if (cursor.kind === 'entry' && row.kind === 'entry') {
-            return (UnixEntryPath.equal(cursor.parentPath, row.parentPath) &&
-                cursor.entryName === row.entry.name);
-        }
-        if (cursor.kind === 'fold' && row.kind === 'fold') {
-            return UnixEntryPath.equal(cursor.parentPath, row.parentPath);
-        }
-        return false;
-    },
-    fromDisplayRow(row) {
-        if (row.kind === 'entry') {
-            return {
-                kind: 'entry',
-                parentPath: row.parentPath,
-                entryName: row.entry.name,
-            };
-        }
-        return {
-            kind: 'fold',
-            parentPath: row.parentPath,
-        };
-    },
-    getPath(cursor) {
-        if (cursor.kind === 'fold') {
-            return undefined;
-        }
-        return [...cursor.parentPath, cursor.entryName];
-    },
+  equal(left, right) {
+    if (left.kind !== right.kind) {
+      return false;
+    }
+    if (!UnixEntryPath.equal(left.parentPath, right.parentPath)) {
+      return false;
+    }
+    if (left.kind === 'entry' && right.kind === 'entry') {
+      return left.entryName === right.entryName;
+    }
+    return true;
+  },
+  matchesDisplayRow(cursor, row) {
+    if (cursor.kind === 'entry' && row.kind === 'entry') {
+      return (
+        UnixEntryPath.equal(cursor.parentPath, row.parentPath) &&
+        cursor.entryName === row.entry.name
+      );
+    }
+    if (cursor.kind === 'fold' && row.kind === 'fold') {
+      return UnixEntryPath.equal(cursor.parentPath, row.parentPath);
+    }
+    return false;
+  },
+  fromDisplayRow(row) {
+    if (row.kind === 'entry') {
+      return {
+        kind: 'entry',
+        parentPath: row.parentPath,
+        entryName: row.entry.name,
+      };
+    }
+    return {
+      kind: 'fold',
+      parentPath: row.parentPath,
+    };
+  },
+  getPath(cursor) {
+    if (cursor.kind === 'fold') {
+      return undefined;
+    }
+    return [...cursor.parentPath, cursor.entryName];
+  },
 };

package/dist/domain/display-row.d.ts

@@ -1,29 +1,34 @@
 import { UnixEntry, UnixEntryName, UnixEntryPath } from './unix-entry.js';
 import type { UnixPath } from './unix-path.js';
-export type DisplayEntry = {
-    kind: 'file';
-    name: UnixEntryName;
-} | {
-    kind: 'symlink';
-    name: UnixEntryName;
-    target: UnixPath;
-} | {
-    kind: 'directory';
-    name: UnixEntryName;
-};
+export type DisplayEntry =
+  | {
+      kind: 'file';
+      name: UnixEntryName;
+    }
+  | {
+      kind: 'symlink';
+      name: UnixEntryName;
+      target: UnixPath;
+    }
+  | {
+      kind: 'directory';
+      name: UnixEntryName;
+    };
 export declare const DisplayEntry: {
-    fromUnixEntry(entry: UnixEntry): DisplayEntry;
-};
-export type DisplayRow = {
-    kind: 'entry';
-    parentPath: UnixEntryPath;
-    entry: DisplayEntry;
-} | {
-    kind: 'fold';
-    parentPath: UnixEntryPath;
-    entryNames: UnixEntryName[];
+  fromUnixEntry(entry: UnixEntry): DisplayEntry;
 };
+export type DisplayRow =
+  | {
+      kind: 'entry';
+      parentPath: UnixEntryPath;
+      entry: DisplayEntry;
+    }
+  | {
+      kind: 'fold';
+      parentPath: UnixEntryPath;
+      entryNames: UnixEntryName[];
+    };
 export declare const DisplayRow: {
-    equal(firstRow: DisplayRow, secondRow: DisplayRow): boolean;
+  equal(firstRow: DisplayRow, secondRow: DisplayRow): boolean;
 };
-//# sourceMappingURL=display-row.d.ts.map
+//# sourceMappingURL=display-row.d.ts.map

package/dist/domain/display-row.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"display-row.d.ts","sourceRoot":"","sources":["../../src/domain/display-row.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAE1E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,MAAM,MAAM,YAAY,GACpB;IACE,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,aAAa,CAAC;CACrB,GACD;IACE,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,aAAa,CAAC;IACpB,MAAM,EAAE,QAAQ,CAAC;CAClB,GACD;IACE,IAAI,EAAE,WAAW,CAAC;IAClB,IAAI,EAAE,aAAa,CAAC;CACrB,CAAC;AAEN,eAAO,MAAM,YAAY;yBACF,SAAS,GAAG,YAAY;CAU9C,CAAA;AAED,MAAM,MAAM,UAAU,GAClB;IACE,IAAI,EAAE,OAAO,CAAC;IACd,UAAU,EAAE,aAAa,CAAC;IAC1B,KAAK,EAAE,YAAY,CAAC;CACrB,GACD;IACE,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,aAAa,CAAC;IAC1B,UAAU,EAAE,aAAa,EAAE,CAAC;CAC7B,CAAC;AAEN,eAAO,MAAM,UAAU;oBACL,UAAU,aAAa,UAAU,GAAG,OAAO;CAqB5D,CAAC"}
+{"version":3,"file":"display-row.d.ts","sourceRoot":"","sources":["../../src/domain/display-row.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAE1E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,MAAM,MAAM,YAAY,GACpB;IACE,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,aAAa,CAAC;CACrB,GACD;IACE,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,aAAa,CAAC;IACpB,MAAM,EAAE,QAAQ,CAAC;CAClB,GACD;IACE,IAAI,EAAE,WAAW,CAAC;IAClB,IAAI,EAAE,aAAa,CAAC;CACrB,CAAC;AAEN,eAAO,MAAM,YAAY;yBACF,SAAS,GAAG,YAAY;CAU9C,CAAC;AAEF,MAAM,MAAM,UAAU,GAClB;IACE,IAAI,EAAE,OAAO,CAAC;IACd,UAAU,EAAE,aAAa,CAAC;IAC1B,KAAK,EAAE,YAAY,CAAC;CACrB,GACD;IACE,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,aAAa,CAAC;IAC1B,UAAU,EAAE,aAAa,EAAE,CAAC;CAC7B,CAAC;AAEN,eAAO,MAAM,UAAU;oBACL,UAAU,aAAa,UAAU,GAAG,OAAO;CAqB5D,CAAC"}

package/dist/domain/display-row.js

@@ -1,29 +1,33 @@
 import { UnixEntryPath } from './unix-entry.js';
 import { entryNamesEqual } from './unix-entry.js';
 export const DisplayEntry = {
-    fromUnixEntry(entry) {
-        if (entry.kind === 'directory') {
-            return {
-                kind: 'directory',
-                name: entry.name,
-            };
-        }
-        return entry;
+  fromUnixEntry(entry) {
+    if (entry.kind === 'directory') {
+      return {
+        kind: 'directory',
+        name: entry.name,
+      };
     }
+    return entry;
+  },
 };
 export const DisplayRow = {
-    equal(firstRow, secondRow) {
-        if (firstRow.kind !== secondRow.kind) {
-            return false;
-        }
-        if (firstRow.kind === 'fold' && secondRow.kind === 'fold') {
-            return (UnixEntryPath.equal(firstRow.parentPath, secondRow.parentPath) &&
-                entryNamesEqual(firstRow.entryNames, secondRow.entryNames));
-        }
-        if (firstRow.kind === 'entry' && secondRow.kind === 'entry') {
-            return (UnixEntryPath.equal(firstRow.parentPath, secondRow.parentPath) &&
-                firstRow.entry.name === secondRow.entry.name);
-        }
-        return false;
-    },
+  equal(firstRow, secondRow) {
+    if (firstRow.kind !== secondRow.kind) {
+      return false;
+    }
+    if (firstRow.kind === 'fold' && secondRow.kind === 'fold') {
+      return (
+        UnixEntryPath.equal(firstRow.parentPath, secondRow.parentPath) &&
+        entryNamesEqual(firstRow.entryNames, secondRow.entryNames)
+      );
+    }
+    if (firstRow.kind === 'entry' && secondRow.kind === 'entry') {
+      return (
+        UnixEntryPath.equal(firstRow.parentPath, secondRow.parentPath) &&
+        firstRow.entry.name === secondRow.entry.name
+      );
+    }
+    return false;
+  },
 };

package/dist/domain/effect.d.ts

@@ -0,0 +1,48 @@
+import { UnixEntry, UnixEntryPath } from './unix-entry.js';
+import { InputState } from './input-state.js';
+export type Effect =
+  | {
+      effectType: 'dispatchEffectAction';
+      action: EffectAction;
+    }
+  | {
+      effectType: 'loadDir';
+      path: UnixEntryPath;
+    }
+  | {
+      effectType: 'printFile';
+      path: UnixEntryPath;
+    }
+  | {
+      effectType: 'quit';
+      exitMessage: string;
+    }
+  | {
+      effectType: 'setInputState';
+      inputState: InputState;
+    };
+export type EffectAction =
+  | {
+      effectActionType: 'nextEntry';
+    }
+  | {
+      effectActionType: 'prevEntry';
+    }
+  | {
+      effectActionType: 'updateDir';
+      path: UnixEntryPath;
+      entries: UnixEntry[] | undefined;
+    }
+  | {
+      effectActionType: 'outDir';
+    }
+  | {
+      effectActionType: 'fold';
+    }
+  | {
+      effectActionType: 'unfold';
+    }
+  | {
+      effectActionType: 'toggleFold';
+    };
+//# sourceMappingURL=effect.d.ts.map

package/dist/domain/effect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect.d.ts","sourceRoot":"","sources":["../../src/domain/effect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAG9C,MAAM,MAAM,MAAM,GACd;IACE,UAAU,EAAE,sBAAsB,CAAC;IACnC,MAAM,EAAE,YAAY,CAAC;CACtB,GACD;IACE,UAAU,EAAE,SAAS,CAAC;IACtB,IAAI,EAAE,aAAa,CAAC;CACrB,GACD;IACE,UAAU,EAAE,WAAW,CAAC;IACxB,IAAI,EAAE,aAAa,CAAC;CACrB,GACD;IACE,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;CACrB,GACD;IACE,UAAU,EAAE,eAAe,CAAC;IAC5B,UAAU,EAAE,UAAU,CAAC;CACxB,CAAC;AAGN,MAAM,MAAM,YAAY,GACpB;IACE,gBAAgB,EAAE,WAAW,CAAC;CAC/B,GACD;IACE,gBAAgB,EAAE,WAAW,CAAC;CAC/B,GACD;IACE,gBAAgB,EAAE,WAAW,CAAC;IAC9B,IAAI,EAAE,aAAa,CAAC;IACpB,OAAO,EAAE,SAAS,EAAE,GAAG,SAAS,CAAC;CAClC,GACD;IACE,gBAAgB,EAAE,QAAQ,CAAC;CAC5B,GACD;IACE,gBAAgB,EAAE,MAAM,CAAC;CAC1B,GACD;IACE,gBAAgB,EAAE,QAAQ,CAAC;CAC5B,GACD;IACE,gBAAgB,EAAE,YAAY,CAAC;CAChC,CAAC"}

package/dist/domain/effect.js

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

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

@@ -1,17 +1,25 @@
 import { UnixEntry, UnixEntryName, UnixEntryPath } from './unix-entry.js';
 export type FoldNode = {
-    children: Record<UnixEntryName, FoldNode>;
-    folds: UnixEntryName[];
+  children: Record<UnixEntryName, FoldNode>;
+  folds: UnixEntryName[];
 };
 export declare const FoldNode: {
-    getAtPath(rootNode: FoldNode, path: UnixEntryPath): FoldNode | undefined;
-    getIfEntryFolded(node: FoldNode | undefined, entry: UnixEntry): boolean;
-    modifyAtPath(rootNode: FoldNode, path: UnixEntryName[], modifier: (targetNode: FoldNode) => FoldNode): FoldNode;
-    addFoldedEntry(node: FoldNode, entry: UnixEntry): FoldNode;
-    addFoldedEntryAtPath(rootNode: FoldNode, path: UnixEntryName[], entry: UnixEntry): FoldNode;
-    createEmpty(): FoldNode;
-    setFoldedEntries(node: FoldNode, entries: UnixEntry[]): FoldNode;
-    removeFoldedEntry(node: FoldNode, entry: UnixEntry): FoldNode;
-    clearFoldedEntries(node: FoldNode): FoldNode;
+  getAtPath(rootNode: FoldNode, path: UnixEntryPath): FoldNode | undefined;
+  getIfEntryFolded(node: FoldNode | undefined, entry: UnixEntry): boolean;
+  modifyAtPath(
+    rootNode: FoldNode,
+    path: UnixEntryName[],
+    modifier: (targetNode: FoldNode) => FoldNode,
+  ): FoldNode;
+  addFoldedEntry(node: FoldNode, entry: UnixEntry): FoldNode;
+  addFoldedEntryAtPath(
+    rootNode: FoldNode,
+    path: UnixEntryName[],
+    entry: UnixEntry,
+  ): FoldNode;
+  createEmpty(): FoldNode;
+  setFoldedEntries(node: FoldNode, entries: UnixEntry[]): FoldNode;
+  removeFoldedEntry(node: FoldNode, entry: UnixEntry): FoldNode;
+  clearFoldedEntries(node: FoldNode): FoldNode;
 };
-//# sourceMappingURL=fold-node.d.ts.map
+//# sourceMappingURL=fold-node.d.ts.map

package/dist/domain/fold-node.js

@@ -1,81 +1,93 @@
 export const FoldNode = {
-    // Query-Like
-    getAtPath(rootNode, path) {
-        const [currentName, ...remainingPath] = path;
-        if (currentName === undefined) {
-            return rootNode;
-        }
-        const childNode = rootNode.children[currentName];
-        if (childNode === undefined) {
-            return undefined;
-        }
-        return FoldNode.getAtPath(childNode, remainingPath);
-    },
-    getIfEntryFolded(node, entry) {
-        return node !== undefined && hasFoldedEntryNamed(node, entry.name);
-    },
-    // Command/Modifer-Like
-    modifyAtPath(rootNode, path, modifier) {
-        const [currentName, ...remainingPath] = path;
-        // Base case
-        if (currentName === undefined) {
-            return modifier(rootNode);
-        }
-        // Create childNode to create path in tree to the needed node
-        const childNode = rootNode.children[currentName] ?? FoldNode.createEmpty();
-        return {
-            ...rootNode,
-            children: {
-                ...rootNode.children,
-                [currentName]: FoldNode.modifyAtPath(childNode, remainingPath, modifier),
-            },
-        };
-    },
-    addFoldedEntry(node, entry) {
-        // Avoid duplicates
-        if (hasFoldedEntryNamed(node, entry.name)) {
-            return node;
-        }
-        return setFoldedEntriesNamed(node, [...node.folds, entry.name]);
-    },
-    addFoldedEntryAtPath(rootNode, path, entry) {
-        return FoldNode.modifyAtPath(rootNode, path, (node) => FoldNode.addFoldedEntry(node, entry));
-    },
-    createEmpty() {
-        return {
-            children: Object.create(null),
-            folds: [],
-        };
-    },
-    setFoldedEntries(node, entries) {
-        return setFoldedEntriesNamed(node, entries.map((entry) => entry.name));
-    },
-    removeFoldedEntry(node, entry) {
-        if (!hasFoldedEntryNamed(node, entry.name)) {
-            return node;
-        }
-        return setFoldedEntriesNamed(node, node.folds.filter((entryName) => entryName !== entry.name));
-    },
-    clearFoldedEntries(node) {
-        if (node.folds.length === 0) {
-            return node;
-        }
-        return setFoldedEntriesNamed(node, []);
-    },
+  // Query-Like
+  getAtPath(rootNode, path) {
+    const [currentName, ...remainingPath] = path;
+    if (currentName === undefined) {
+      return rootNode;
+    }
+    const childNode = rootNode.children[currentName];
+    if (childNode === undefined) {
+      return undefined;
+    }
+    return FoldNode.getAtPath(childNode, remainingPath);
+  },
+  getIfEntryFolded(node, entry) {
+    return node !== undefined && hasFoldedEntryNamed(node, entry.name);
+  },
+  // Command/Modifer-Like
+  modifyAtPath(rootNode, path, modifier) {
+    const [currentName, ...remainingPath] = path;
+    // Base case
+    if (currentName === undefined) {
+      return modifier(rootNode);
+    }
+    // Create childNode to create path in tree to the needed node
+    const childNode = rootNode.children[currentName] ?? FoldNode.createEmpty();
+    return {
+      ...rootNode,
+      children: {
+        ...rootNode.children,
+        [currentName]: FoldNode.modifyAtPath(
+          childNode,
+          remainingPath,
+          modifier,
+        ),
+      },
+    };
+  },
+  addFoldedEntry(node, entry) {
+    // Avoid duplicates
+    if (hasFoldedEntryNamed(node, entry.name)) {
+      return node;
+    }
+    return setFoldedEntriesNamed(node, [...node.folds, entry.name]);
+  },
+  addFoldedEntryAtPath(rootNode, path, entry) {
+    return FoldNode.modifyAtPath(rootNode, path, (node) =>
+      FoldNode.addFoldedEntry(node, entry),
+    );
+  },
+  createEmpty() {
+    return {
+      children: Object.create(null),
+      folds: [],
+    };
+  },
+  setFoldedEntries(node, entries) {
+    return setFoldedEntriesNamed(
+      node,
+      entries.map((entry) => entry.name),
+    );
+  },
+  removeFoldedEntry(node, entry) {
+    if (!hasFoldedEntryNamed(node, entry.name)) {
+      return node;
+    }
+    return setFoldedEntriesNamed(
+      node,
+      node.folds.filter((entryName) => entryName !== entry.name),
+    );
+  },
+  clearFoldedEntries(node) {
+    if (node.folds.length === 0) {
+      return node;
+    }
+    return setFoldedEntriesNamed(node, []);
+  },
 };
 // PRIVATE HELPERS
 // Queries
 function hasFoldedEntryNamed(node, entryName) {
-    return node.folds.includes(entryName);
+  return node.folds.includes(entryName);
 }
 function uniqueEntryNames(entryNames) {
-    return [...new Set(entryNames)];
+  return [...new Set(entryNames)];
 }
 // Adding
 function setFoldedEntriesNamed(node, entryNames) {
-    const uniqueNames = uniqueEntryNames(entryNames);
-    return {
-        ...node,
-        folds: uniqueNames,
-    };
+  const uniqueNames = uniqueEntryNames(entryNames);
+  return {
+    ...node,
+    folds: uniqueNames,
+  };
 }

package/dist/domain/input-state.d.ts

@@ -0,0 +1,10 @@
+export type InputState =
+  | {
+      inputMode: 'normal';
+      normalBuffer: string;
+    }
+  | {
+      inputMode: 'command';
+      commandLine: string;
+    };
+//# sourceMappingURL=input-state.d.ts.map

package/dist/domain/input-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-state.d.ts","sourceRoot":"","sources":["../../src/domain/input-state.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAClB;IACE,SAAS,EAAE,QAAQ,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;CACtB,GACD;IACE,SAAS,EAAE,SAAS,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC"}

package/dist/domain/input-state.js

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