epiq 0.0.1 → 0.0.3

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

@@ -0,0 +1,53 @@
+import { Mode } from '../../model/action-map.model.js';
+import { patchState } 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: () => {
+            patchState({
+                mode: Mode.MOVE,
+            });
+        },
+    },
+    {
+        intent: KeyIntent.ToggleMove,
+        mode: Mode.MOVE,
+        action: () => {
+            patchState({
+                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/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 commandLineSequenceActions: CommandLineActionEntry[];

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

@@ -0,0 +1,31 @@
+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 { CommandLineSequenceIntent } from './command-line-sequence-intent.js';
+export const commandLineSequenceActions = [
+    {
+        intent: CommandLineSequenceIntent.ViewHelp,
+        mode: Mode.COMMAND_LINE,
+        action: () => {
+            patchState({
+                mode: Mode.HELP,
+            });
+        },
+    },
+    {
+        intent: CommandLineSequenceIntent.AddSwimlane,
+        mode: Mode.COMMAND_LINE,
+        action: (...args) => {
+            addSwimlaneAction(...args);
+            patchState({ mode: Mode.DEFAULT });
+        },
+    },
+    {
+        intent: CommandLineSequenceIntent.AddTicket,
+        mode: Mode.COMMAND_LINE,
+        action: (...args) => {
+            addTicketAction(...args);
+            patchState({ mode: Mode.DEFAULT });
+        },
+    },
+];

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

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

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

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

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

@@ -1,14 +1,26 @@
+import { NavigateCtx } from './navigation-ctx.model.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 | ModeUnion[];
     description?: `[${string}] ${string}`;
-    action?: (...args: TArgs) => void;
+    action?: (...args: [NavigateCtx, 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: [NavigateCtx, 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,11 +1,11 @@
 import { NavigationTree } from './navigation-tree.model.js';
 export interface NavigateCtx {
-    _selectedIndex: number;
+    _selectionIndex: number;
     breadCrumb: Array<NavigationTree<NavigationTree>>;
     navigationNode: NavigationTree<NavigationTree>;
     children: NavigationTree[];
     getSelectedIndex(): number;
-    select(index: number): void;
+    updateSelection(index: number): void;
     selectNone(): void;
     reInvokeNavigate(index: number, breadCrumb: NavigationTree<NavigationTree>[]): void;
     render(): void;

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

@@ -3,6 +3,7 @@ export type NavigationTree<TMeta = Record<string, unknown>> = {
     isSelected: boolean;
     childrenRenderAxis: 'vertical' | 'horizontal';
     name: string;
+    description?: string;
     children: NavigationTree<unknown>[];
     actionContext: string;
     enableChildNavigationAcrossContainers?: boolean;

package/dist/navigation/navigation.d.ts

@@ -4,7 +4,7 @@ export declare function navigate<T extends NavigationTree>({ index, breadCrumb,
     breadCrumb: Array<NavigationTree<NavigationTree>>;
     callbacks: Partial<{
         render: () => void;
-        onSelectChange: (s: T['children'][number], breadCrumb: T['children']) => void;
+        onSelectChange: (s: T['children'][number] | undefined, breadCrumb: T['children']) => void;
         onConfirm: (s: T['children'][number]) => void;
     }>;
 }): void;

package/dist/navigation/navigation.js

@@ -2,38 +2,51 @@ import readline from 'readline';
 import { navigationState } from './state/state.js';
 import { getKeyIntent } from './utils/key-intent.js';
 export function navigate({ index = 0, breadCrumb, callbacks, }) {
-    const { render = () => { }, onSelectChange = () => { }, onConfirm = () => { }, } = callbacks;
     const ctx = {
-        breadCrumb,
+        _selectionIndex: 0,
+        breadCrumb: breadCrumb,
+        render() {
+            callbacks.render?.();
+        },
         get navigationNode() {
-            return this.breadCrumb.at(-1);
+            return this.breadCrumb?.at(-1) ?? breadCrumb[0];
         },
         get children() {
             return this.navigationNode.children ?? [];
         },
-        selectNone: () => {
-            ctx.select(-1);
+        selectNone() {
+            ctx.updateSelection(-1);
         },
-        _selectedIndex: 0,
         getSelectedIndex() {
-            return this._selectedIndex;
+            return this._selectionIndex;
+        },
+        updateSelection(idx) {
+            this._selectionIndex = idx;
+            const children = this.navigationNode.children ?? [];
+            children.forEach((c, i) => (c.isSelected = i === idx));
+            if (idx < 0 || idx >= children.length) {
+                callbacks.onSelectChange?.(undefined, breadCrumb);
+                return;
+            }
+            callbacks.onSelectChange?.(children[idx], breadCrumb);
         },
-        select(i) {
-            this._selectedIndex = i;
-            updateSelection(ctx.navigationNode, breadCrumb, i, onSelectChange);
+        reInvokeNavigate(idx, crumb) {
+            cleanup();
+            navigate({ index: idx, breadCrumb: [...crumb], callbacks });
         },
-        render,
-        reInvokeNavigate(index, breadCrumb) {
-            return reInvokeNavigate(index, breadCrumb);
+        confirm(sel) {
+            return callbacks.onConfirm?.(sel);
         },
-        confirm: sel => onConfirm(sel),
-        exit: () => {
+        exit() {
             cleanup();
             process.exit(0);
         },
-        enterChildNode: node => reInvokeNavigate(0, [...breadCrumb, node]),
-        enterParentNode: () => {
-            ctx.select(-1); // Clear all on this level
+        enterChildNode(childNode) {
+            this.updateSelection(-1); // Clear all on this level
+            this.reInvokeNavigate(0, [...breadCrumb, childNode]);
+        },
+        enterParentNode() {
+            ctx.updateSelection(-1); // Clear all on this level
             if (breadCrumb.length < 2)
                 return; // Need at least grandparent + parent
             const ancestors = breadCrumb;
@@ -42,33 +55,34 @@ export function navigate({ index = 0, breadCrumb, callbacks, }) {
             if (!parent || !grandParent)
                 return;
             const parentIndex = grandParent?.children.findIndex(x => parent.id === x.id);
-            reInvokeNavigate(parentIndex, breadCrumb.slice(0, -1)); // Go to parent level
+            this.reInvokeNavigate(parentIndex, breadCrumb.slice(0, -1)); // Go to parent level
         },
     };
-    ctx.select(index);
-    function onKeyPress(_, key) {
+    ctx.updateSelection(index);
+    async function onKeyPress(_, key) {
         if (key.ctrl && key.name === 'c')
             return ctx.exit();
         const filteredActions = navigationState.availableActions.filter(x => x.mode === navigationState.mode);
-        const action = filteredActions?.find(actionMeta => {
-            const intent = getKeyIntent(key, ctx);
-            return intent === actionMeta.intent;
+        const actionMeta = filteredActions.find(actionMetaItem => {
+            const intent = getKeyIntent(key, ctx, navigationState.mode);
+            return intent === actionMetaItem.intent;
         });
-        action?.action?.(ctx);
+        if (actionMeta?.action) {
+            try {
+                const res = actionMeta.action(ctx, actionMeta, key);
+                if (res instanceof Promise)
+                    await res;
+            }
+            catch (err) {
+                console.error(err);
+            }
+        }
         ctx.render();
     }
     const cleanup = () => process.stdin.removeListener('keypress', onKeyPress);
-    const reInvokeNavigate = (idx, crumb) => {
-        cleanup();
-        navigate({ index: idx, breadCrumb: [...crumb], callbacks });
-    };
-    render();
+    callbacks.render?.();
     readline.emitKeypressEvents(process.stdin);
     if (process.stdin.isTTY)
         process.stdin.setRawMode(true);
     process.stdin.on('keypress', onKeyPress);
 }
-function updateSelection({ children }, breadCrumb, idx, onSelectChange) {
-    children.forEach((c, i) => (c.isSelected = i === idx));
-    onSelectChange(children[idx], breadCrumb);
-}

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

@@ -0,0 +1,13 @@
+export type CommandLineState = {
+    value: string;
+    commandHistory: string[];
+    commandHistoryIndex: number;
+};
+export declare let commandLineState: CommandLineState;
+export declare const updateCommandLineState: (cb: (old: CommandLineState) => CommandLineState) => void;
+export declare const updateCommandLineInput: (cb: (previous: string) => string) => void;
+export declare const updateCommandHistory: () => void;
+export declare const getPrevCommand: () => void;
+export declare const getNextCommand: () => void;
+export declare const clearCommandLine: () => void;
+export declare const getCommandLineInput: () => string;

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

@@ -0,0 +1,43 @@
+export let commandLineState = {
+    commandHistory: [],
+    value: '',
+    commandHistoryIndex: -1,
+};
+export const updateCommandLineState = (cb) => {
+    bug(commandLineState);
+    commandLineState = cb(structuredClone(commandLineState));
+};
+export const updateCommandLineInput = (cb) => {
+    updateCommandLineState(state => ({
+        ...state,
+        value: cb(state.value),
+    }));
+};
+export const updateCommandHistory = () => {
+    updateCommandLineState(state => ({
+        ...state,
+        commandHistory: [state.value, ...state.commandHistory].slice(0, 20),
+    }));
+};
+export const getPrevCommand = () => {
+    updateCommandLineState(s => {
+        const nextIndex = Math.min(s.commandHistoryIndex + 1, s.commandHistory.length - 1);
+        return {
+            ...s,
+            commandHistoryIndex: nextIndex,
+            value: s.commandHistory[nextIndex] ?? '',
+        };
+    });
+};
+export const getNextCommand = () => {
+    updateCommandLineState(s => {
+        const nextIndex = Math.min(s.commandHistoryIndex - 1, s.commandHistory.length - 1);
+        return {
+            ...s,
+            commandHistoryIndex: nextIndex,
+            value: s.commandHistory[nextIndex] ?? '',
+        };
+    });
+};
+export const clearCommandLine = () => updateCommandLineInput(() => '');
+export const getCommandLineInput = () => commandLineState.value;

package/dist/navigation/state/state.d.ts

@@ -1,11 +1,12 @@
-import { ActionEntry, ModeOptions } from '../model/action-map.model.js';
-import { NavigateCtx } from '../model/navigation-ctx.model.js';
+import { ActionEntry, ModeUnion } from '../model/action-map.model.js';
 import { NavigationTree } from '../model/navigation-tree.model.js';
 export declare let navigationState: {
-    mode: ModeOptions;
-    availableActions: ActionEntry<[NavigateCtx]>[];
-    viewHelp: boolean;
+    mode: ModeUnion;
+    availableActions: ActionEntry[];
+    availableHints: readonly string[];
     currentNode: NavigationTree<NavigationTree> | null;
     breadCrumb: NavigationTree<NavigationTree>[];
 };
-export declare const setState: (cb: (oldState: typeof navigationState) => typeof navigationState) => void;
+export declare const updateState: (cb: (oldState: typeof navigationState) => typeof navigationState) => void;
+export declare const patchState: (patch: Partial<typeof navigationState>) => void;
+export declare const flashHint: (hints: string[]) => Promise<void>;

package/dist/navigation/state/state.js

@@ -1,10 +1,39 @@
+import { Hints } from '../../board/hints/hints.js';
+import { triggerRender } from '../../cli.js';
 export let navigationState = {
     mode: 'default',
     availableActions: [],
-    viewHelp: false,
+    availableHints: [],
     currentNode: null,
     breadCrumb: [],
 };
-export const setState = (cb) => {
+export const updateState = (cb) => {
     navigationState = cb(navigationState);
 };
+export const patchState = (patch) => updateState(oldState => ({
+    ...oldState,
+    ...patch,
+}));
+// Utilities for updating specific parts of the state
+export const flashHint = async (hints) => {
+    await new Promise(resolve => {
+        setTimeout(() => {
+            updateState(state => {
+                const { currentNode, mode } = state;
+                const contextualHints = (currentNode &&
+                    Hints[currentNode.actionContext + mode]) ??
+                    (currentNode && Hints[currentNode.actionContext]) ?? [''];
+                return {
+                    ...state,
+                    availableHints: contextualHints,
+                };
+            });
+            triggerRender();
+            resolve();
+        }, 3000);
+        patchState({
+            availableHints: hints,
+        });
+        triggerRender();
+    });
+};

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

@@ -0,0 +1,3 @@
+import { KeyIntent } from './key-intent.js';
+import readline from 'readline';
+export declare const getCommandLineIntent: (key: readline.Key) => KeyIntent.Confirm | KeyIntent.ToggleCommandLine | KeyIntent.CaptureInput | KeyIntent.EraseInput | KeyIntent.GetLastCommandFromHistory | KeyIntent.GetNextCommandFromHistory;

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

@@ -0,0 +1,17 @@
+import { KeyIntent } from './key-intent.js';
+export const getCommandLineIntent = (key) => {
+    switch (key.name) {
+        case 'up':
+            return KeyIntent.GetLastCommandFromHistory;
+        case 'down':
+            return KeyIntent.GetNextCommandFromHistory;
+        case 'return':
+            return KeyIntent.Confirm;
+        case 'backspace':
+            return KeyIntent.EraseInput;
+        case 'escape':
+            return KeyIntent.ToggleCommandLine;
+        default:
+            return KeyIntent.CaptureInput;
+    }
+};

package/dist/navigation/utils/getKeyIntent.d.ts

@@ -0,0 +1,5 @@
+import readline from 'readline';
+import { ModeUnion } from '../model/action-map.model.js';
+import { NavigateCtx } from '../model/navigation-ctx.model.js';
+import { KeyIntent } from './key-intent.js';
+export declare function getKeyIntent(key: readline.Key, ctx: NavigateCtx, mode: ModeUnion): KeyIntent | null;