dirvi-lib 0.3.0 → 0.4.0

package/dist/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/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/application/intent-to-effect-no-state.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,178 @@
+import { describe, expect, it } from 'vitest';
+import { intentToEffect } from './intent-to-effect.js';
+const state = {};
+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'],
+    ])(
+      '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/application/intent-to-effect.d.ts

@@ -0,0 +1,8 @@
+import { Effect } from '../domain/effect.js';
+import { State } from '../domain/state.js';
+import { Intent } from '../domain/intent.js';
+export declare function intentToEffect(
+  intent: Intent,
+  state: State,
+): Effect | undefined;
+//# sourceMappingURL=intent-to-effect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"intent-to-effect.d.ts","sourceRoot":"","sources":["../../src/application/intent-to-effect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAgB,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,KAAK,EAAQ,MAAM,oBAAoB,CAAC;AAEjD,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAU7C,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,KAAK,GACX,MAAM,GAAG,SAAS,CAgEpB"}

package/dist/application/intent-to-effect.js

@@ -0,0 +1,142 @@
+import { View } from '../domain/state.js';
+import { Cursor } from '../domain/cursor.js';
+function dispatchAction(action) {
+  return {
+    effectType: 'dispatchEffectAction',
+    action,
+  };
+}
+// Effect derived from intent and the state.
+export function intentToEffect(intent, state) {
+  switch (intent.intentType) {
+    case 'setNormalBuffer':
+      return normalBufferToEffectResult(intent.normalBuffer);
+    case 'normalRight':
+      return normalInteractRightToEffect(state);
+    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: '',
+        },
+      };
+  }
+}
+// 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) {
+  const currentEntry = View.getEntryAtCursor(state);
+  if (currentEntry === undefined) {
+    return undefined;
+  }
+  const path = Cursor.getPath(state.cursor);
+  if (path === undefined) {
+    return undefined;
+  }
+  if (currentEntry.kind === 'directory') {
+    if (currentEntry.entries === undefined) {
+      return {
+        effectType: 'loadDir',
+        path,
+      };
+    } else {
+      return dispatchAction({
+        effectActionType: 'updateDir',
+        path,
+        entries: undefined,
+      });
+    }
+  }
+  if (currentEntry.kind === 'file') {
+    return {
+      effectType: 'printFile',
+      path,
+    };
+  }
+  // TODO Later: Peeking on folds
+  return undefined;
+}
+function normalInteractLeftToEffect(state) {
+  if (state.cursor.parentPath.length === 0) {
+    return undefined;
+  }
+  return dispatchAction({
+    effectActionType: 'outDir',
+  });
+}

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

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

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

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

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

@@ -0,0 +1,178 @@
+import { describe, expect, it } from 'vitest';
+import { intentToEffect } from './intent-to-effect.js';
+const state = {};
+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'],
+    ])(
+      '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/application/user-input-to-intent.d.ts

@@ -0,0 +1,8 @@
+import { UserInput } from '../domain/user-input.js';
+import { InputState } from '../domain/input-state.js';
+import { Intent } from '../domain/intent.js';
+export declare function userInputToIntent(
+  userInput: UserInput,
+  inputState: InputState,
+): Intent | undefined;
+//# sourceMappingURL=user-input-to-intent.d.ts.map

package/dist/application/user-input-to-intent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-input-to-intent.d.ts","sourceRoot":"","sources":["../../src/application/user-input-to-intent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAG7C,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,SAAS,EACpB,UAAU,EAAE,UAAU,GACrB,MAAM,GAAG,SAAS,CAQpB"}

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

@@ -0,0 +1,98 @@
+// Derive the intent from the user input and the current input state.
+export function userInputToIntent(userInput, inputState) {
+  switch (inputState.inputMode) {
+    case 'normal':
+      return normalUserInputToIntent(userInput, inputState.normalBuffer);
+    case 'command':
+      return commandUserInputToIntent(userInput, inputState.commandLine);
+  }
+}
+function normalUserInputToIntent(userInput, normalBuffer) {
+  if (userInput.userInputType === 'esc') {
+    return {
+      intentType: 'setNormalBuffer',
+      normalBuffer: '',
+    };
+  }
+  if (userInput.userInputType === 'character') {
+    return normalCharacterToIntent(userInput.string, normalBuffer);
+  }
+  switch (userInput.userInputType) {
+    case 'rightArrow':
+      return {
+        intentType: 'normalRight',
+      };
+    case 'leftArrow':
+      return {
+        intentType: 'normalLeft',
+      };
+    case 'downArrow':
+      return {
+        intentType: 'normalDown',
+      };
+    case 'upArrow':
+      return {
+        intentType: 'normalUp',
+      };
+  }
+}
+function normalCharacterToIntent(character, normalBuffer) {
+  if (normalBuffer === '') {
+    switch (character) {
+      case 'l':
+        return {
+          intentType: 'normalRight',
+        };
+      case 'h':
+        return {
+          intentType: 'normalLeft',
+        };
+      case 'j':
+        return {
+          intentType: 'normalDown',
+        };
+      case 'k':
+        return {
+          intentType: 'normalUp',
+        };
+      case ':':
+        return {
+          intentType: 'enterCommandLineMode',
+        };
+    }
+  }
+  return {
+    intentType: 'setNormalBuffer',
+    normalBuffer: normalBuffer + character,
+  };
+}
+function commandUserInputToIntent(userInput, commandLine) {
+  if (userInput.userInputType === 'esc') {
+    return {
+      intentType: 'exitCommandLineMode',
+    };
+  }
+  if (userInput.userInputType === 'enter') {
+    return {
+      intentType: 'executeCommandLine',
+      commandLine: commandLine,
+    };
+  }
+  if (userInput.userInputType === 'backspace') {
+    if (commandLine.length < 2) {
+      return {
+        intentType: 'exitCommandLineMode',
+      };
+    }
+    return {
+      intentType: 'setCommandLine',
+      commandLine: commandLine.slice(0, -1),
+    };
+  }
+  if (userInput.userInputType === 'character') {
+    return {
+      intentType: 'setCommandLine',
+      commandLine: commandLine + userInput.string,
+    };
+  }
+}

package/dist/application/user-input-to-intent.test.d.ts

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

package/dist/application/user-input-to-intent.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-input-to-intent.test.d.ts","sourceRoot":"","sources":["../../src/application/user-input-to-intent.test.ts"],"names":[],"mappings":""}