epiq 0.0.1 → 0.0.3

package/dist/cli.d.ts

@@ -1,2 +1,3 @@
 #!/usr/bin/env node
-export declare const main: () => void;
+import './debug-logger.js';
+export declare let triggerRender: () => void;

package/dist/cli.js

@@ -3,11 +3,14 @@ import { render } from 'ink';
 import meow from 'meow';
 import React from 'react';
 import App from './app.js';
-import { BoardActions } from './board/actions/board-action-map.js';
+import { Hints } from './board/hints/hints.js';
 import { board } from './board/mock/board.js';
-import { buildDefaultActions } from './navigation/actions/default-actions-routes.js';
+import { ContextualActionMap } from './navigation/actions/board-action-map.js';
+import { inputActions } from './navigation/actions/input/input-actions.js';
+import { DefaultActions } from './navigation/actions/default/default-actions.js';
 import { navigate } from './navigation/navigation.js';
-import { setState } from './navigation/state/state.js';
+import { patchState, updateState } from './navigation/state/state.js';
+import './debug-logger.js';
 const cli = meow(`
 	Usage
 	  $ epiq
@@ -27,31 +30,51 @@ const cli = meow(`
     },
 });
 cli;
-export const main = () => {
+(() => {
     console.clear();
+    const onBeforeRender = () => {
+        updateState(state => {
+            const { currentNode, mode } = state;
+            const hints = (currentNode && Hints[currentNode.actionContext + mode]) ??
+                (currentNode && Hints[currentNode.actionContext]) ?? [''];
+            return {
+                ...state,
+                availableHints: hints,
+            };
+        });
+    };
     navigate({
         index: 0,
         breadCrumb: [board],
         callbacks: {
             render: () => {
+                onBeforeRender();
                 render(React.createElement(App, { board: board }));
             },
             onSelectChange: (selected, breadCrumb) => {
-                if (!selected)
-                    return;
-                const type = selected
-                    .actionContext; // Fix so that we can infer this type
-                setState(state => ({
-                    ...state,
-                    currentNode: selected,
+                // container is the "list" we are navigating in (board → swimlanes, swimlane → tickets, etc)
+                const container = breadCrumb.at(-1);
+                // still remember which *child* is selected for rendering
+                const currentNode = selected ?? container;
+                // but build actions from the container type, not the selected child
+                const containerType = container
+                    .actionContext;
+                patchState({
+                    currentNode,
                     breadCrumb,
-                    availableActions: [...buildDefaultActions(), ...BoardActions[type]],
-                }));
+                    availableActions: [
+                        ...DefaultActions,
+                        ...ContextualActionMap[containerType],
+                        ...inputActions,
+                    ],
+                });
             },
         },
     });
+})();
+export let triggerRender = () => {
+    render(React.createElement(App, { board: board }));
 };
-main();
 process.stdout.on('resize', () => {
     render(React.createElement(App, { board: board }));
 });

package/dist/debug-logger.d.ts

@@ -0,0 +1,2 @@
+export declare function bug(...args: any[]): void;
+export {};

package/dist/debug-logger.js

@@ -0,0 +1,15 @@
+import fs from 'fs';
+import path from 'path';
+import util from 'util';
+const DEFAULT_PATH = path.resolve(process.cwd(), 'debug.log');
+export function bug(...args) {
+    const timestamp = new Date().toISOString();
+    const message = util.format(...args);
+    const line = `[${timestamp}] ${message}\n`;
+    // Ensure parent directory exists
+    fs.mkdirSync(path.dirname(DEFAULT_PATH), { recursive: true });
+    // appendFileSync creates the file if it does not exist
+    fs.appendFileSync(DEFAULT_PATH, line, 'utf8');
+}
+// make it global
+globalThis.bug = bug;

package/dist/navigation/actions/add/add-actions.d.ts

@@ -0,0 +1,2 @@
+import { ActionEntry } from '../../model/action-map.model.js';
+export declare const AddItemActions: ActionEntry[];

package/dist/navigation/actions/add/add-actions.js

@@ -0,0 +1,25 @@
+import { board } from '../../../board/mock/board.js';
+import { triggerRender } from '../../../cli.js';
+import { Mode } from '../../model/action-map.model.js';
+import { KeyIntent } from '../../utils/key-intent.js';
+export const AddItemActions = [
+    {
+        intent: KeyIntent.AddItem,
+        mode: Mode.DEFAULT,
+        description: '[A] Add item',
+        action: () => {
+            const newItem = {
+                id: `item-${Date.now()}`,
+                name: 'New Item',
+                actionContext: 'SWIMLANE',
+                children: [],
+                isSelected: false,
+                childrenRenderAxis: 'vertical',
+                enableChildNavigationAcrossContainers: true,
+                description: '',
+            };
+            board.children.push(newItem);
+            triggerRender();
+        },
+    },
+];

package/dist/navigation/actions/add/add-item-actions.d.ts

@@ -0,0 +1,2 @@
+import { ActionEntry } from '../../model/action-map.model.js';
+export declare const AddItemActions: ActionEntry[];

package/dist/navigation/actions/add/add-item-actions.js

@@ -0,0 +1,25 @@
+import { board } from '../../../board/mock/board.js';
+import { triggerRender } from '../../../cli.js';
+import { Mode } from '../../model/action-map.model.js';
+import { KeyIntent } from '../../utils/key-intent.js';
+export const AddItemActions = [
+    {
+        intent: KeyIntent.AddItem,
+        mode: Mode.DEFAULT,
+        description: '[A] Add item',
+        action: () => {
+            const newItem = {
+                id: `item-${Date.now()}`,
+                name: 'New Item',
+                actionContext: 'SWIMLANE',
+                children: [],
+                isSelected: false,
+                childrenRenderAxis: 'vertical',
+                enableChildNavigationAcrossContainers: true,
+                description: '',
+            };
+            board.children.push(newItem);
+            triggerRender();
+        },
+    },
+];

package/dist/navigation/actions/add-item/add-item-actions.d.ts

@@ -0,0 +1,3 @@
+import { CommandLineActionEntry } from '../../model/action-map.model.js';
+export declare const addSwimlaneAction: NonNullable<CommandLineActionEntry['action']>;
+export declare const addTicketAction: NonNullable<CommandLineActionEntry['action']>;

package/dist/navigation/actions/add-item/add-item-actions.js

@@ -0,0 +1,35 @@
+import { BoardItemTypes, } from '../../../board/model/board.model.js';
+export const addSwimlaneAction = async (ctx, _, { value }) => {
+    const newItem = {
+        id: `${Date.now()}`,
+        name: value || 'New lane',
+        description: '...',
+        actionContext: BoardItemTypes.SWIMLANE,
+        children: [],
+        isSelected: false,
+        childrenRenderAxis: 'vertical',
+        enableChildNavigationAcrossContainers: true,
+    };
+    const parent = ctx.navigationNode;
+    parent.children ?? (parent.children = []);
+    const newItemIndex = parent.children.length;
+    parent.children.push(newItem);
+    ctx.updateSelection(newItemIndex);
+};
+export const addTicketAction = async (ctx, _, { value }) => {
+    const newItem = {
+        id: `asdf${Date.now()}`,
+        name: value || 'New issue',
+        actionContext: BoardItemTypes.TICKET_LIST_ITEM,
+        children: [],
+        isSelected: false,
+        childrenRenderAxis: 'vertical',
+        enableChildNavigationAcrossContainers: true,
+        description: '',
+    };
+    const parent = ctx.navigationNode;
+    parent.children ?? (parent.children = []);
+    const newItemIndex = parent.children.length;
+    parent.children.push(newItem);
+    ctx.updateSelection(newItemIndex);
+};

package/dist/navigation/actions/board-action-map.d.ts

@@ -0,0 +1,10 @@
+import { BoardItemTypes } from '../../board/model/board.model.js';
+import { ActionEntry, ActionMap } from '../model/action-map.model.js';
+type BoardActionMap = ActionMap<{
+    [BoardItemTypes.BOARD]: ActionEntry[];
+    [BoardItemTypes.SWIMLANE]: ActionEntry[];
+    [BoardItemTypes.TICKET_LIST_ITEM]: ActionEntry[];
+    [BoardItemTypes.TICKET]: ActionEntry[];
+}>;
+export declare const ContextualActionMap: BoardActionMap;
+export {};

package/dist/navigation/actions/board-action-map.js

@@ -0,0 +1,12 @@
+import { BoardItemTypes } from '../../board/model/board.model.js';
+import { moveAcrossParents, moveWithinParent, toggleMoveMode, } from './move/move-actions.js';
+export const ContextualActionMap = {
+    [BoardItemTypes.BOARD]: [],
+    [BoardItemTypes.SWIMLANE]: [...toggleMoveMode, ...moveWithinParent],
+    [BoardItemTypes.TICKET_LIST_ITEM]: [
+        ...toggleMoveMode,
+        ...moveWithinParent,
+        ...moveAcrossParents,
+    ],
+    [BoardItemTypes.TICKET]: [],
+};

package/dist/{lib/utils/default-actions.d.ts → navigation/actions/default/default-action-utils.d.ts}

@@ -1,7 +1,7 @@
-import { NavigateCtx } from '../navigation-context.js';
+import { NavigateCtx } from '../../model/navigation-ctx.model.js';
 export declare const navigateToNextItem: (ctx: NavigateCtx) => void;
 export declare const navigateToPreviousItem: (ctx: NavigateCtx) => void;
 export declare const navigateToNextContainer: (ctx: NavigateCtx) => void;
 export declare const navigateToPreviousContainer: (ctx: NavigateCtx) => void;
-export declare const enterChildNode: (ctx: NavigateCtx) => void;
+export declare const enterChildNode: (ctx: NavigateCtx) => Promise<void>;
 export declare const exitToParentNode: (ctx: NavigateCtx) => void;

package/dist/{lib/utils → navigation/actions/default}/default-action-utils.js

@@ -1,12 +1,12 @@
-// -- Basic item navigation --
 const navigateByOffset = (ctx, offset) => {
     const len = ctx.children.length;
+    if (len === 0)
+        return;
     const newIndex = (ctx.getSelectedIndex() + offset + len) % len;
-    ctx.select(newIndex);
+    ctx.updateSelection(newIndex);
 };
 export const navigateToNextItem = (ctx) => navigateByOffset(ctx, 1);
 export const navigateToPreviousItem = (ctx) => navigateByOffset(ctx, -1);
-// -- Cross-container navigation --
 const navigateToSiblingContainer = (ctx, direction) => {
     if (!ctx.navigationNode.enableChildNavigationAcrossContainers)
         return;
@@ -31,16 +31,17 @@ const navigateToSiblingContainer = (ctx, direction) => {
 };
 export const navigateToNextContainer = (ctx) => navigateToSiblingContainer(ctx, 1);
 export const navigateToPreviousContainer = (ctx) => navigateToSiblingContainer(ctx, -1);
-export const enterChildNode = (ctx) => {
-    const current = ctx.navigationNode.children[ctx._selectedIndex];
-    if (!current)
+export const enterChildNode = async (ctx) => {
+    const currentNode = ctx.breadCrumb.at(-1);
+    const focusNode = currentNode?.children[ctx.getSelectedIndex()];
+    if (!currentNode || !focusNode)
+        return;
+    if (!focusNode?.children?.length) {
+        await ctx.enterChildNode(focusNode);
         return;
-    if (!current.children?.length) {
-        ctx.confirm(current);
     }
     else {
-        ctx.select(-1);
-        ctx.enterChildNode(current);
+        ctx.enterChildNode(focusNode);
     }
 };
 export const exitToParentNode = (ctx) => {

package/dist/navigation/actions/default/default-actions.d.ts

@@ -0,0 +1,2 @@
+import { ActionEntry } from '../../model/action-map.model.js';
+export declare const DefaultActions: ActionEntry[];

package/dist/navigation/actions/default/default-actions.js

@@ -0,0 +1,78 @@
+import { Mode } from '../../model/action-map.model.js';
+import { patchState } from '../../state/state.js';
+import { KeyIntent } from '../../utils/key-intent.js';
+import { enterChildNode, exitToParentNode, navigateToNextContainer, navigateToNextItem, navigateToPreviousContainer, navigateToPreviousItem, } from './default-action-utils.js';
+export const DefaultActions = [
+    {
+        intent: KeyIntent.ToggleCommandLine,
+        mode: Mode.DEFAULT,
+        description: '[:] Toggle command line',
+        action: () => patchState({
+            mode: Mode.COMMAND_LINE,
+        }),
+    },
+    {
+        intent: KeyIntent.ToggleCommandLine,
+        mode: Mode.COMMAND_LINE,
+        description: '[ESC] Toggle command line',
+        action: () => patchState({
+            mode: Mode.DEFAULT,
+        }),
+    },
+    // {
+    // 	intent: KeyIntent.ToggleHelp,
+    // 	mode: Mode.DEFAULT,
+    // 	description: '[F1] Toggle HELP menu',
+    // 	action: () =>
+    // 		setState(state => ({
+    // 			...state,
+    // 			mode: Mode.HELP,
+    // 		})),
+    // },
+    // {
+    // 	intent: KeyIntent.ToggleHelp,
+    // 	mode: Mode.HELP,
+    // 	description: '[F1] Close HELP menu',
+    // 	action: () =>
+    // 		setState(state => ({
+    // 			...state,
+    // 			mode: Mode.DEFAULT,
+    // 		})),
+    // },
+    {
+        intent: KeyIntent.Confirm,
+        mode: Mode.DEFAULT,
+        description: '[ENTER/E] Confirm/Enter context',
+        action: enterChildNode,
+    },
+    {
+        intent: KeyIntent.Exit,
+        mode: Mode.DEFAULT,
+        description: '[ESC/Q] Exit application',
+        action: exitToParentNode,
+    },
+    {
+        mode: Mode.DEFAULT,
+        description: '[ARROWS/HJKL] Navigate',
+    },
+    {
+        intent: KeyIntent.NavPreviousItem,
+        mode: Mode.DEFAULT,
+        action: navigateToPreviousItem,
+    },
+    {
+        intent: KeyIntent.NavNextItem,
+        mode: Mode.DEFAULT,
+        action: navigateToNextItem,
+    },
+    {
+        intent: KeyIntent.NavToPreviousContainer,
+        mode: Mode.DEFAULT,
+        action: navigateToPreviousContainer,
+    },
+    {
+        intent: KeyIntent.NavToNextContainer,
+        mode: Mode.DEFAULT,
+        action: navigateToNextContainer,
+    },
+];

package/dist/navigation/actions/input/command-line-input.d.ts

@@ -0,0 +1,2 @@
+import { ActionEntry } from '../../model/action-map.model.js';
+export declare const onConfirmCommandLineSequenceInput: (...args: Parameters<NonNullable<ActionEntry["action"]>>) => void;

package/dist/navigation/actions/input/command-line-input.js

@@ -0,0 +1,18 @@
+import { commandLineSequenceActions } from '../../command-line/command-line-sequence-actions.js';
+import { getCommandLineIntent } from '../../command-line/command-line-sequence-intent.js';
+import { clearCommandLine, getCommandLineInput, updateCommandHistory, } from '../../state/command-line.state.js';
+export const onConfirmCommandLineSequenceInput = (...args) => {
+    const commandSequence = getCommandLineInput();
+    const [ctx] = [...args];
+    const [firstItem, ...rest] = commandSequence.split(' ');
+    const command = (firstItem || '').trim();
+    const value = rest.join(' ').trim();
+    if (!command)
+        return;
+    const intent = getCommandLineIntent(command);
+    const actionMeta = commandLineSequenceActions.find(x => x.intent === intent);
+    actionMeta?.action?.(ctx, actionMeta, { command, value });
+    updateCommandHistory();
+    clearCommandLine();
+    return;
+};

package/dist/navigation/actions/input/input-actions-utils.d.ts

@@ -0,0 +1,8 @@
+import { ActionEntry } from '../../model/action-map.model.js';
+export declare const CommandLineIntent: {
+    readonly AddItem: "add-item";
+    readonly ViewHelp: "view-help";
+};
+export declare const getCommandLineIntent: (input: string) => "add-item" | "view-help" | undefined;
+export declare const inputActions: ActionEntry[];
+export declare const onConfirmCommandLineInput: (input: string) => void;

package/dist/navigation/actions/input/input-actions-utils.js

@@ -0,0 +1,47 @@
+import { Mode } from '../../model/action-map.model.js';
+import { patchState } from '../../state/state.js';
+export const CommandLineIntent = {
+    AddItem: 'add-item',
+    ViewHelp: 'view-help',
+};
+export const getCommandLineIntent = (input) => {
+    switch (input) {
+        case 'help':
+        case 'h':
+            return CommandLineIntent.ViewHelp;
+        case 'add':
+        case 'a':
+            return CommandLineIntent.AddItem;
+        default:
+            return;
+    }
+};
+export const inputActions = [
+    {
+        intent: CommandLineIntent.ViewHelp,
+        mode: Mode.DEFAULT, // Make accept array
+        action: () => {
+            patchState({
+                mode: Mode.HELP,
+                commandLineInput: '',
+            });
+        },
+    },
+];
+export const onConfirmCommandLineInput = (input) => {
+    switch (input.trim()) {
+        case 'help':
+        case 'h':
+            patchState({
+                mode: Mode.HELP,
+                commandLineInput: '',
+            });
+            return;
+        default:
+            patchState({
+                mode: Mode.DEFAULT,
+                commandLineInput: '',
+            });
+            return;
+    }
+};

package/dist/navigation/actions/input/input-actions.d.ts

@@ -0,0 +1,2 @@
+import { ActionEntry } from '../../model/action-map.model.js';
+export declare const inputActions: ActionEntry[];

package/dist/navigation/actions/input/input-actions.js

@@ -0,0 +1,43 @@
+import { Mode } from '../../model/action-map.model.js';
+import { getNextCommand, getPrevCommand, updateCommandLineInput, } from '../../state/command-line.state.js';
+import { patchState } from '../../state/state.js';
+import { KeyIntent } from '../../utils/key-intent.js';
+import { onConfirmCommandLineSequenceInput } from './command-line-input.js';
+export const inputActions = [
+    {
+        intent: KeyIntent.ToggleHelp,
+        mode: Mode.HELP,
+        action: () => {
+            patchState({
+                mode: Mode.DEFAULT,
+            });
+        },
+    },
+    {
+        intent: KeyIntent.Confirm,
+        mode: Mode.COMMAND_LINE,
+        action: (...args) => {
+            onConfirmCommandLineSequenceInput(...args);
+        },
+    },
+    {
+        intent: KeyIntent.CaptureInput,
+        mode: Mode.COMMAND_LINE,
+        action: (_1, _2, { sequence }) => updateCommandLineInput(s => s + sequence),
+    },
+    {
+        intent: KeyIntent.EraseInput,
+        mode: Mode.COMMAND_LINE,
+        action: () => updateCommandLineInput(s => s.slice(0, -1)),
+    },
+    {
+        intent: KeyIntent.GetLastCommandFromHistory,
+        mode: Mode.COMMAND_LINE,
+        action: () => getPrevCommand(),
+    },
+    {
+        intent: KeyIntent.GetNextCommandFromHistory,
+        mode: Mode.COMMAND_LINE,
+        action: () => getNextCommand(),
+    },
+];

package/dist/navigation/actions/move/move-actions-routes.d.ts

@@ -0,0 +1,4 @@
+import { ActionEntry } from '../../model/action-map.model.js';
+export declare const toggleMoveMode: ActionEntry[];
+export declare const moveWithinParent: ActionEntry[];
+export declare const moveAcrossParents: ActionEntry[];

package/dist/navigation/actions/move/move-actions-routes.js

@@ -0,0 +1,55 @@
+import { Mode } from '../../model/action-map.model.js';
+import { setState } from '../../state/state.js';
+import { KeyIntent } from '../../utils/key-intent.js';
+import { moveChildNextWithinParent, moveChildPreviousWithinParent, moveChildToNextParent, moveChildToPreviousParent, } from './move-actions-utils.js';
+export const toggleMoveMode = [
+    {
+        intent: KeyIntent.ToggleMove,
+        mode: Mode.DEFAULT,
+        description: '[Y] Toggle move/yank mode',
+        action: () => {
+            setState(state => ({
+                ...state,
+                mode: Mode.MOVE,
+            }));
+        },
+    },
+    {
+        intent: KeyIntent.ToggleMove,
+        mode: Mode.MOVE,
+        action: () => {
+            setState(state => ({
+                ...state,
+                mode: Mode.DEFAULT,
+            }));
+        },
+    },
+];
+export const moveWithinParent = [
+    {
+        mode: Mode.MOVE,
+        description: '[Y, ARROW KEYS] Move item',
+    },
+    {
+        intent: KeyIntent.MovePreviousItem,
+        mode: Mode.MOVE,
+        action: moveChildPreviousWithinParent,
+    },
+    {
+        intent: KeyIntent.MoveNextItem,
+        mode: Mode.MOVE,
+        action: moveChildNextWithinParent,
+    },
+];
+export const moveAcrossParents = [
+    {
+        intent: KeyIntent.MoveToNextContainer,
+        mode: Mode.MOVE,
+        action: moveChildToNextParent,
+    },
+    {
+        intent: KeyIntent.MoveToPreviousContainer,
+        mode: Mode.MOVE,
+        action: moveChildToPreviousParent,
+    },
+];

package/dist/{lib/actions → navigation/actions/move}/move-actions-utils.d.ts

@@ -1,4 +1,4 @@
-import { NavigateCtx } from '../navigation-context.js';
+import { NavigateCtx } from '../../model/navigation-ctx.model.js';
 export declare const moveChildToNextParent: (ctx: NavigateCtx) => void;
 export declare const moveChildToPreviousParent: (ctx: NavigateCtx) => void;
 export declare const moveChildPreviousWithinParent: (ctx: NavigateCtx) => void;

package/dist/{board/actions/move-actions.js → navigation/actions/move/move-actions-utils.js}

@@ -6,11 +6,12 @@ function moveItemInArray({ array, from, to, }) {
         array.splice(to, 0, item);
 }
 function moveNodeToSiblingContainer(ctx, direction) {
-    const ancestors = ctx.breadCrumb;
-    const parent = ancestors.at(-1);
-    const grandParent = ancestors.at(-2);
+    const parent = ctx.breadCrumb.at(-1);
+    const grandParent = ctx.breadCrumb.at(-2);
     if (!parent || !grandParent)
         return;
+    if (!Array.isArray(grandParent.children))
+        return;
     const parentIndex = grandParent.children.findIndex(x => x.id === parent.id);
     const targetIndex = parentIndex + direction;
     if (parentIndex < 0 ||
@@ -20,21 +21,24 @@ function moveNodeToSiblingContainer(ctx, direction) {
     const sibling = grandParent.children[targetIndex];
     if (!sibling)
         return;
-    if (!sibling?.children?.length && !Array.isArray(sibling.children))
+    if (!Array.isArray(parent.children))
         return;
-    const currentIndex = ctx._selectedIndex;
+    if (!Array.isArray(sibling.children))
+        sibling.children = []; // normalize empty container
+    const currentIndex = ctx.getSelectedIndex();
     if (currentIndex < 0 || currentIndex >= parent.children.length)
         return;
     const [node] = parent.children.splice(currentIndex, 1);
+    if (!node)
+        return;
     sibling.children.push(node);
     const newBreadCrumb = [...ctx.breadCrumb.slice(0, -1), sibling];
-    const newIndex = sibling.children.length - 1;
-    ctx.reInvokeNavigate(newIndex, newBreadCrumb);
+    ctx.reInvokeNavigate(sibling.children.length - 1, newBreadCrumb);
 }
 export const moveChildToNextParent = (ctx) => moveNodeToSiblingContainer(ctx, 1);
 export const moveChildToPreviousParent = (ctx) => moveNodeToSiblingContainer(ctx, -1);
 function moveChildWithinParent(ctx, direction) {
-    const from = ctx._selectedIndex;
+    const from = ctx._selectionIndex;
     const to = from + direction;
     if (to < 0 || to >= ctx.navigationNode.children.length)
         return;
@@ -43,7 +47,7 @@ function moveChildWithinParent(ctx, direction) {
         from,
         to,
     });
-    ctx.select(to);
+    ctx.updateSelection(to);
 }
 export const moveChildPreviousWithinParent = (ctx) => moveChildWithinParent(ctx, -1);
 export const moveChildNextWithinParent = (ctx) => moveChildWithinParent(ctx, 1);

package/dist/navigation/actions/move/move-actions.d.ts

@@ -0,0 +1,4 @@
+import { ActionEntry } from '../../model/action-map.model.js';
+export declare const toggleMoveMode: ActionEntry[];
+export declare const moveWithinParent: ActionEntry[];
+export declare const moveAcrossParents: ActionEntry[];