epiq 0.0.2 → 0.0.4

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

@@ -0,0 +1,44 @@
+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 { Intent } from '../../utils/key-intent.js';
+import { onConfirmCommandLineSequenceInput } from './command-line-input.js';
+export const inputActions = [
+    {
+        intent: Intent.ViewHelp,
+        mode: Mode.DEFAULT,
+        action: () => patchState({ mode: Mode.HELP }),
+    },
+    {
+        intent: Intent.Exit,
+        mode: Mode.HELP,
+        action: () => patchState({ mode: Mode.DEFAULT }),
+    },
+    {
+        intent: Intent.Confirm,
+        mode: Mode.COMMAND_LINE,
+        action: (...args) => {
+            onConfirmCommandLineSequenceInput(...args);
+        },
+    },
+    {
+        intent: Intent.CaptureInput,
+        mode: Mode.COMMAND_LINE,
+        action: (_1, _2, { sequence }) => updateCommandLineInput(s => s + sequence),
+    },
+    {
+        intent: Intent.EraseInput,
+        mode: Mode.COMMAND_LINE,
+        action: () => updateCommandLineInput(s => s.slice(0, -1)),
+    },
+    {
+        intent: Intent.GetLastCommandFromHistory,
+        mode: Mode.COMMAND_LINE,
+        action: () => getPrevCommand(),
+    },
+    {
+        intent: Intent.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/navigation/actions/move/move-actions-utils.d.ts

@@ -0,0 +1,4 @@
+export declare const moveChildToNextParent: () => void;
+export declare const moveChildToPreviousParent: () => void;
+export declare const moveChildPreviousWithinParent: () => void;
+export declare const moveChildNextWithinParent: () => void;

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

@@ -0,0 +1,66 @@
+import { appState } from '../../state/state.js';
+import { navigator } from '../default/navigation-action-utils.js';
+function moveItemInArray({ array, from, to, }) {
+    if (from < 0 || from >= array.length || to < 0 || to >= array.length)
+        return;
+    const [item] = array.splice(from, 1);
+    if (item)
+        array.splice(to, 0, item);
+}
+function moveNodeToSiblingContainer(direction) {
+    const currentNode = appState.breadCrumb.at(-1);
+    const parentNode = appState.breadCrumb.at(-2);
+    if (!currentNode || !parentNode)
+        return;
+    if (!Array.isArray(parentNode.children))
+        return;
+    const currentNodeIndex = parentNode.children.findIndex(x => x.id === currentNode.id);
+    const targetNodeIndex = currentNodeIndex + direction;
+    if (currentNodeIndex < 0 ||
+        targetNodeIndex < 0 ||
+        targetNodeIndex >= parentNode.children.length)
+        return;
+    const siblingNode = parentNode.children[targetNodeIndex];
+    if (!siblingNode)
+        return;
+    if (!Array.isArray(currentNode.children))
+        return;
+    if (!Array.isArray(siblingNode.children))
+        siblingNode.children = []; // normalize empty container
+    const currentSelectionIndex = appState.selectedIndex;
+    if (currentSelectionIndex < 0 ||
+        currentSelectionIndex >= currentNode.children.length)
+        return;
+    const [moveNode] = currentNode.children.splice(currentSelectionIndex, 1);
+    if (!moveNode)
+        return;
+    siblingNode.children.push(moveNode);
+    navigator.navigate({
+        selectedIndex: siblingNode.children.length - 1,
+        currentNode: siblingNode,
+    });
+}
+export const moveChildToNextParent = () => {
+    moveNodeToSiblingContainer(1);
+};
+export const moveChildToPreviousParent = () => {
+    moveNodeToSiblingContainer(-1);
+};
+function moveChildWithinParent(direction) {
+    const from = appState.selectedIndex;
+    const to = from + direction;
+    if (to < 0 || to >= appState.currentNode.children.length)
+        return;
+    moveItemInArray({
+        array: appState.currentNode.children,
+        from,
+        to,
+    });
+    navigator.navigate({ selectedIndex: to });
+}
+export const moveChildPreviousWithinParent = () => {
+    moveChildWithinParent(-1);
+};
+export const moveChildNextWithinParent = () => {
+    moveChildWithinParent(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[];

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

@@ -0,0 +1,59 @@
+import { Mode } from '../../model/action-map.model.js';
+import { patchState } from '../../state/state.js';
+import { Intent } from '../../utils/key-intent.js';
+import { moveChildNextWithinParent, moveChildPreviousWithinParent, moveChildToNextParent, moveChildToPreviousParent, } from './move-actions-utils.js';
+export const toggleMoveMode = [
+    {
+        intent: Intent.Exit,
+        mode: Mode.MOVE,
+        description: '[Y] Exit yank mode',
+        action: () => {
+            patchState({
+                mode: Mode.DEFAULT,
+            });
+        },
+    },
+    {
+        intent: Intent.InitMove,
+        mode: Mode.DEFAULT,
+        description: '[Y] Toggle move/yank mode',
+        action: () => {
+            patchState({
+                mode: Mode.MOVE,
+            });
+        },
+    },
+    {
+        intent: Intent.InitMove, // Change name to toggle move?
+        mode: Mode.MOVE,
+        action: () => {
+            patchState({
+                mode: Mode.DEFAULT,
+            });
+        },
+    },
+];
+export const moveWithinParent = [
+    {
+        intent: Intent.MovePreviousItem,
+        mode: Mode.MOVE,
+        action: moveChildPreviousWithinParent,
+    },
+    {
+        intent: Intent.MoveNextItem,
+        mode: Mode.MOVE,
+        action: moveChildNextWithinParent,
+    },
+];
+export const moveAcrossParents = [
+    {
+        intent: Intent.MoveToNextContainer,
+        mode: Mode.MOVE,
+        action: moveChildToNextParent,
+    },
+    {
+        intent: Intent.MoveToPreviousContainer,
+        mode: Mode.MOVE,
+        action: moveChildToPreviousParent,
+    },
+];

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

@@ -1,4 +1,4 @@
-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;

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

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

package/dist/navigation/actions/navigate/navigation-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 './navigation-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/command-line/command-line-actions.d.ts

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

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

@@ -0,0 +1,32 @@
+import { addSwimlaneAction, addTicketAction, } from '../actions/add-item/add-item-actions.js';
+import { Mode } from '../model/action-map.model.js';
+import { patchState } from '../state/state.js';
+import { CommandLineIntent } from './command-line-sequence-intent.js';
+export const commandLineActions = [
+    {
+        intent: CommandLineIntent.ViewHelp,
+        mode: Mode.COMMAND_LINE,
+        action: () => {
+            patchState({
+                mode: Mode.HELP,
+                commandLineInput: '',
+            });
+        },
+    },
+    {
+        intent: CommandLineIntent.AddSwimlane,
+        mode: Mode.COMMAND_LINE,
+        action: (...args) => {
+            addSwimlaneAction(...args);
+            patchState({ commandLineInput: '', mode: Mode.DEFAULT });
+        },
+    },
+    {
+        intent: CommandLineIntent.AddTicket,
+        mode: Mode.COMMAND_LINE,
+        action: (...args) => {
+            addTicketAction(...args);
+            patchState({ commandLineInput: '', mode: Mode.DEFAULT });
+        },
+    },
+];

package/dist/navigation/command-line/command-line-intent.d.ts

@@ -0,0 +1,7 @@
+export declare const CommandLineIntent: {
+    readonly None: "none";
+    readonly AddSwimlane: "add-swimlane";
+    readonly AddTicket: "add-ticket";
+    readonly ViewHelp: "view-help";
+};
+export declare const getCommandLineIntent: (input: string) => (typeof CommandLineIntent)[keyof typeof CommandLineIntent];

package/dist/navigation/command-line/command-line-intent.js

@@ -0,0 +1,29 @@
+import { BoardItemTypes } from '../../board/model/board.model.js';
+import { navigationState } from '../state/state.js';
+export const CommandLineIntent = {
+    None: 'none',
+    AddSwimlane: 'add-swimlane',
+    AddTicket: 'add-ticket',
+    ViewHelp: 'view-help',
+};
+export const getCommandLineIntent = (input) => {
+    const actionContext = navigationState?.currentNode?.actionContext;
+    if (!actionContext)
+        return CommandLineIntent.None;
+    switch (input) {
+        case 'help':
+        case 'he':
+            return CommandLineIntent.ViewHelp;
+        case 'add':
+            switch (actionContext) {
+                case BoardItemTypes.SWIMLANE:
+                    return CommandLineIntent.AddSwimlane;
+                case BoardItemTypes.TICKET:
+                    return CommandLineIntent.AddTicket;
+                default:
+                    return CommandLineIntent.None;
+            }
+        default:
+            return CommandLineIntent.None;
+    }
+};

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

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

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

@@ -0,0 +1,44 @@
+import { addSwimlaneAction, addTicketAction, } from '../actions/add-item/add-item-actions.js';
+import { Mode } from '../model/action-map.model.js';
+import { getCommandLineArgumentValue } from '../state/command-line.state.js';
+import { patchState, updateState } from '../state/state.js';
+import { CmdIntent } from './command-line-sequence-intent.js';
+export const commands = [
+    {
+        intent: CmdIntent.ViewHelp,
+        mode: Mode.COMMAND_LINE,
+        action: () => patchState({ mode: Mode.HELP }),
+    },
+    {
+        intent: CmdIntent.AddSwimlane,
+        mode: Mode.COMMAND_LINE,
+        action: (...args) => {
+            addSwimlaneAction(...args);
+            patchState({ mode: Mode.DEFAULT });
+        },
+    },
+    {
+        intent: CmdIntent.AddTicket,
+        mode: Mode.COMMAND_LINE,
+        action: (...args) => {
+            addTicketAction(...args);
+            patchState({ mode: Mode.DEFAULT });
+        },
+    },
+    {
+        intent: CmdIntent.Rename,
+        mode: Mode.COMMAND_LINE,
+        action: () => {
+            updateState(s => ({
+                ...s,
+                mode: Mode.DEFAULT,
+                currentNode: s.currentNode
+                    ? {
+                        ...s.currentNode,
+                        name: getCommandLineArgumentValue(),
+                    }
+                    : null,
+            }));
+        },
+    },
+];

package/dist/navigation/command-line/command-line-sequence-intent.d.ts

@@ -0,0 +1,8 @@
+export declare const CmdIntent: {
+    readonly None: "none";
+    readonly AddSwimlane: "add-swimlane";
+    readonly AddTicket: "add-ticket";
+    readonly ViewHelp: "view-help";
+    readonly Rename: "rename";
+};
+export declare const getCommandIntent: (command: string) => (typeof CmdIntent)[keyof typeof CmdIntent];

package/dist/navigation/command-line/command-line-sequence-intent.js

@@ -0,0 +1,32 @@
+import { BoardItemTypes } from '../../board/model/board.model.js';
+import { appState } from '../state/state.js';
+export const CmdIntent = {
+    None: 'none',
+    AddSwimlane: 'add-swimlane',
+    AddTicket: 'add-ticket',
+    ViewHelp: 'view-help',
+    Rename: 'rename',
+};
+export const getCommandIntent = (command) => {
+    const actionContext = appState?.currentNode?.actionContext;
+    if (!actionContext)
+        return CmdIntent.None;
+    switch (command) {
+        case 'help':
+        case 'he':
+            return CmdIntent.ViewHelp;
+        case 'rename':
+            return CmdIntent.Rename;
+        case 'add':
+            switch (actionContext) {
+                case BoardItemTypes.SWIMLANE:
+                    return CmdIntent.AddSwimlane;
+                case BoardItemTypes.TICKET:
+                    return CmdIntent.AddTicket;
+                default:
+                    return CmdIntent.None;
+            }
+        default:
+            return CmdIntent.None;
+    }
+};

package/dist/navigation/command-line/commands.d.ts

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

package/dist/navigation/command-line/commands.js

@@ -0,0 +1,58 @@
+import { addSwimlaneAction, addTicketAction, } from '../actions/add-item/add-item-actions.js';
+import { Mode } from '../model/action-map.model.js';
+import { getCommandLineArgumentValue } from '../state/command-line.state.js';
+import { appState, patchState, updateState } from '../state/state.js';
+import { CmdIntent } from './command-line-sequence-intent.js';
+export const commands = [
+    {
+        intent: CmdIntent.ViewHelp,
+        mode: Mode.COMMAND_LINE,
+        action: () => patchState({ mode: Mode.HELP }),
+    },
+    {
+        intent: CmdIntent.AddSwimlane,
+        mode: Mode.COMMAND_LINE,
+        action: (...args) => {
+            addSwimlaneAction(...args);
+            patchState({ mode: Mode.DEFAULT });
+        },
+    },
+    {
+        intent: CmdIntent.AddTicket,
+        mode: Mode.COMMAND_LINE,
+        action: (...args) => {
+            addTicketAction(...args);
+            patchState({ mode: Mode.DEFAULT });
+        },
+    },
+    {
+        intent: CmdIntent.Rename,
+        mode: Mode.COMMAND_LINE,
+        action: () => {
+            updateState(s => {
+                // Update board on file
+                const newBoard = appState.rootNode;
+                const currentId = s.currentNode?.id;
+                if (!currentId)
+                    return s;
+                const findItemInBoard = (item, id) => {
+                    if (item.id === id)
+                        return item;
+                    return (item.children.find((child) => findItemInBoard(child, id)) ||
+                        undefined);
+                };
+                const newName = getCommandLineArgumentValue();
+                const itemInBoard = findItemInBoard(newBoard, currentId);
+                if (!itemInBoard)
+                    return s;
+                itemInBoard.name = newName;
+                return {
+                    ...s,
+                    mode: Mode.DEFAULT,
+                    rootNode: newBoard,
+                    currentNode: itemInBoard,
+                };
+            });
+        },
+    },
+];

package/dist/navigation/keypress-listener.d.ts

@@ -0,0 +1 @@
+export declare function initListeners(): void;

package/dist/navigation/keypress-listener.js

@@ -0,0 +1,33 @@
+import readline from 'readline';
+import { appState } from './state/state.js';
+import { getKeyIntent } from './utils/key-intent.js';
+import { navigator } from './actions/default/navigation-action-utils.js';
+let currentKeypressListener;
+const getKeyPressListener = () => {
+    return async function onKeyPress(_, key) {
+        if (key.ctrl && key.name === 'c')
+            return navigator.exit();
+        const filteredActions = appState.availableActions.filter(a => a.mode === appState.mode);
+        const actionMeta = filteredActions.find(({ intent, mode }) => getKeyIntent(key, mode) === intent);
+        if (!actionMeta?.action)
+            return;
+        try {
+            const res = actionMeta.action(navigator, actionMeta, key);
+            if (res instanceof Promise)
+                await res;
+        }
+        catch (err) {
+            console.error(err);
+        }
+    };
+};
+export function initListeners() {
+    if (currentKeypressListener) {
+        process.stdin.removeListener('keypress', currentKeypressListener);
+    }
+    currentKeypressListener = getKeyPressListener();
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY)
+        process.stdin.setRawMode(true);
+    process.stdin.on('keypress', currentKeypressListener);
+}

package/dist/navigation/model/action-map.model.d.ts

@@ -1,14 +1,26 @@
+import { Navigator } from '../actions/default/navigation-action-utils.js';
+import readline from 'readline';
 export declare const Mode: {
     readonly DEFAULT: "default";
     readonly MOVE: "move";
+    readonly HELP: "help";
+    readonly COMMAND_LINE: "command-line";
 };
-export type ModeOptions = (typeof Mode)[keyof typeof Mode];
-export type ActionEntry<TArgs extends any[] = []> = {
+export type ModeUnion = (typeof Mode)[keyof typeof Mode];
+export type ActionEntry = {
     intent?: string;
-    mode: string;
+    mode: ModeUnion;
     description?: `[${string}] ${string}`;
-    action?: (...args: TArgs) => void;
+    action?: (...args: [Navigator, ActionEntry, readline.Key]) => void | Promise<void>;
 };
 export type ActionMap<T extends Record<string, any[]>> = {
-    [K in keyof T]: ActionEntry<T[K]>[];
+    [K in keyof T]: ActionEntry[];
 };
+type CommandLineInput = {
+    value: string;
+    command: string;
+};
+export type CommandLineActionEntry = Omit<ActionEntry, 'action'> & {
+    action?: (...args: [Navigator, CommandLineActionEntry, CommandLineInput]) => void | Promise<void>;
+};
+export {};

package/dist/navigation/model/action-map.model.js

@@ -1,4 +1,6 @@
 export const Mode = {
     DEFAULT: 'default',
     MOVE: 'move',
+    HELP: 'help',
+    COMMAND_LINE: 'command-line',
 };

package/dist/navigation/model/navigation-ctx.model.d.ts

@@ -1,16 +1 @@
-import { NavigationTree } from './navigation-tree.model.js';
-export interface NavigateCtx {
-    _selectedIndex: number;
-    breadCrumb: Array<NavigationTree<NavigationTree>>;
-    navigationNode: NavigationTree<NavigationTree>;
-    children: NavigationTree[];
-    getSelectedIndex(): number;
-    select(index: number): void;
-    selectNone(): void;
-    reInvokeNavigate(index: number, breadCrumb: NavigationTree<NavigationTree>[]): void;
-    render(): void;
-    confirm(selected: NavigationTree<NavigationTree>): void;
-    exit(): void;
-    enterChildNode(node: NavigationTree<NavigationTree>): void;
-    enterParentNode(): void;
-}
+export {};

package/dist/navigation/model/navigation-ctx.model.js

@@ -1,2 +1 @@
-// navigation-context.ts
 export {};