inquirer-plugins 1.0.0-alpha.1

package/README.md

@@ -0,0 +1 @@
+# inquirer-plugins

package/dist/_internal/plugins/table/table.d.ts

@@ -0,0 +1,11 @@
+import { Column, Cell } from './types.js';
+export declare class TableClass {
+    columns: Column[];
+    rows: string[][];
+    constructor(columns: Column[], rows: Cell[][]);
+    get header(): string[];
+    getColumnType(columnIndex: number): import("../../types/parse-types.js").ParseType;
+    updateRow(rowIndex: number, columnIndex: number, value: string): void;
+    getValue(rowIndex: number, columnIndex: number): string;
+    getResult(): Record<string, Cell>[];
+}

package/dist/_internal/plugins/table/table.js

@@ -0,0 +1,59 @@
+import { PARSE_TYPES } from '../../types/parse-types.js';
+import { trim } from '../../utils/chalk.js';
+import { parse } from '../../utils/parse-types.js';
+export class TableClass {
+    columns = [];
+    rows = [];
+    constructor(columns, rows) {
+        this.columns = columns;
+        this.rows = rows.map(columns => columns.map(value => `${value}`));
+    }
+    get header() {
+        return this.columns.map(({ name }) => `${name}`);
+    }
+    getColumnType(columnIndex) {
+        if (!(columnIndex in this.columns)) {
+            return PARSE_TYPES.input;
+        }
+        return this.columns[columnIndex].type;
+    }
+    updateRow(rowIndex, columnIndex, value) {
+        if (!(rowIndex in this.rows)) {
+            return;
+        }
+        const columns = this.rows[rowIndex];
+        if (!(columnIndex in columns)) {
+            return;
+        }
+        const validate = this.columns[columnIndex].validate || (() => true);
+        if (!validate(value)) {
+            return;
+        }
+        const parser = this.columns[columnIndex].parser || ((txt) => txt);
+        const parsed = parser(value);
+        columns[columnIndex] = `${parsed}`;
+    }
+    getValue(rowIndex, columnIndex) {
+        if (!(rowIndex in this.rows)) {
+            return '';
+        }
+        const columns = this.rows[rowIndex];
+        if (!(columnIndex in columns)) {
+            return '';
+        }
+        return columns[columnIndex];
+    }
+    getResult() {
+        const result = [];
+        for (let i = 0; i < this.rows.length; i++) {
+            result.push({});
+            for (let ii = 0; ii < (this.rows[i] || []).length; ii++) {
+                const { name: n, type, parser } = this.columns[ii];
+                const name = trim(n.toString());
+                const value = trim(this.rows[i][ii]);
+                result[i][name] = parser ? parser(value) : parse(value, type);
+            }
+        }
+        return result;
+    }
+}

package/dist/_internal/plugins/table/types.d.ts

@@ -0,0 +1,45 @@
+import { ChalkInstance } from 'chalk';
+import { ParseType } from '../../types/parse-types.js';
+export declare const DEFAULT_PAGE_SIZE = 5;
+export declare const INDEX_ERRORS: Readonly<{
+    readonly excess: "excess";
+    readonly disabled: "disabled";
+}>;
+export interface DefaultOptions extends Required<Omit<TableQuestion, 'type' | 'name' | 'colors'>> {
+    colors: Colors;
+}
+export declare const DEFAULT_OPTIONS: DefaultOptions;
+export interface RequiredOptions extends Required<Omit<TableQuestion, 'colors'>> {
+    colors: Colors;
+}
+export interface Colors {
+    selected: ChalkInstance;
+    editable: ChalkInstance;
+    editing: ChalkInstance;
+}
+export interface ValidateResult {
+    isValid: boolean;
+    message: string;
+}
+export interface TableQuestion {
+    type: string;
+    name: string;
+    message?: string | ChalkInstance;
+    description?: string | ChalkInstance;
+    escapeMessage?: string | ChalkInstance;
+    confirmMessage?: string | ChalkInstance;
+    disableColumnIndexes?: number[];
+    colors?: Partial<Colors>;
+    columns: Column[];
+    rows: Cell[][];
+    validate?: (...args: any[]) => ValidateResult;
+    pageSize?: number;
+}
+export interface Column {
+    name: string | ChalkInstance;
+    value: string;
+    type: ParseType;
+    validate?: (input: string) => boolean;
+    parser?: (input: any) => any;
+}
+export type Cell = number | string | boolean;

package/dist/_internal/plugins/table/types.js

@@ -0,0 +1,23 @@
+import chalk from 'chalk';
+import { hop, success, warn } from '../../utils/chalk.js';
+export const DEFAULT_PAGE_SIZE = 5;
+export const INDEX_ERRORS = Object.freeze({
+    excess: 'excess',
+    disabled: 'disabled',
+});
+export const DEFAULT_OPTIONS = {
+    message: '',
+    description: '',
+    escapeMessage: chalk.red('Press ESC again to exit!'),
+    confirmMessage: chalk.red('Press ENTER again to confirm!'),
+    disableColumnIndexes: [],
+    colors: {
+        selected: warn,
+        editable: success,
+        editing: hop,
+    },
+    columns: [],
+    rows: [],
+    pageSize: DEFAULT_PAGE_SIZE,
+    validate: () => ({ isValid: true, message: '' }),
+};

package/dist/_internal/plugins/table/utils.d.ts

@@ -0,0 +1,3 @@
+export declare const isNoChoiceOfIndex: (maxIndex: number, disableIndexes: number[]) => boolean;
+export declare const gateValidateColumnIndexError: (index: number, maxIndex: number, disableIndexes: number[]) => false | "disabled" | "excess";
+export declare const getNextIndex: (index: number, maxIndex: number, num: number) => number;

package/dist/_internal/plugins/table/utils.js

@@ -0,0 +1,22 @@
+import { INDEX_ERRORS } from '../../plugins/table/types.js';
+export const isNoChoiceOfIndex = (maxIndex, disableIndexes) => {
+    return disableIndexes.length > maxIndex && [...Array(maxIndex).keys()].every(index => disableIndexes.includes(index));
+};
+export const gateValidateColumnIndexError = (index, maxIndex, disableIndexes) => {
+    if (index > maxIndex || index < 0) {
+        return INDEX_ERRORS.excess;
+    }
+    if (disableIndexes.includes(index)) {
+        return INDEX_ERRORS.disabled;
+    }
+    return false;
+};
+export const getNextIndex = (index, maxIndex, num) => {
+    if (index > maxIndex) {
+        return 0;
+    }
+    if (index < 0) {
+        return maxIndex;
+    }
+    return index > maxIndex ? 0 : index + num;
+};

package/dist/_internal/plugins/table.d.ts

@@ -0,0 +1,49 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Interface as ReadLineInterface, Key } from 'readline';
+import { Question, Answers } from 'inquirer';
+import Base from 'inquirer/lib/prompts/base.js';
+import { Done } from '../types/inquirer.js';
+import { TableClass } from './table/table.js';
+import { RequiredOptions, TableQuestion } from './table/types.js';
+export declare class TablePlugin extends Base {
+    table: TableClass;
+    options: RequiredOptions;
+    done: Done;
+    pointerIndexes: {
+        row: number;
+        column: number;
+    };
+    isNextCloses: {
+        escape: boolean;
+    };
+    editing: boolean;
+    temporaryBackup: string | null;
+    answers: Answers;
+    constructor(question: Question<TableQuestion>, readLine: ReadLineInterface, answers: Answers);
+    getCurrentValues(): Record<string, import("./table/types.js").Cell>[];
+    isEditable(index: number): boolean;
+    _run(callback: Done): this;
+    get maxPageIndex(): number;
+    get maxRowIndex(): number;
+    get maxColumnIndex(): number;
+    onDownKey(): void;
+    onUpKey(): void;
+    updateColumnIndex(num: number): void;
+    onLeftKey(): void;
+    onRightKey(): void;
+    clear(): void;
+    onEnd(state: any): void;
+    validate(): import("./table/types.js").ValidateResult;
+    onError(_state: any): void;
+    validateValue(): void;
+    updateChoice(value: string): void;
+    get currentValue(): string;
+    onEditPress(key: Key): void;
+    getShowRowIndex(): {
+        rowIndexFrom: number;
+        rowIndexTo: number;
+    };
+    isSelected(rowIndex: number, columnIndex: number): boolean;
+    getColor(_value: string, isSelected: boolean, isEditable: boolean): string;
+    render(isDisconnect?: boolean): void;
+}

package/dist/_internal/plugins/table.js

@@ -0,0 +1,257 @@
+import cliCursor from 'cli-cursor';
+import Table from 'cli-table3';
+import Base from 'inquirer/lib/prompts/base.js';
+import observe from 'inquirer/lib/utils/events.js';
+import { map } from 'rxjs/operators';
+import { dim, error } from '../utils/chalk.js';
+import { getKeypressValue } from '../utils/keypress.js';
+import { TableClass } from './table/table.js';
+import { DEFAULT_OPTIONS } from './table/types.js';
+import { isNoChoiceOfIndex, gateValidateColumnIndexError, getNextIndex } from './table/utils.js';
+export class TablePlugin extends Base {
+    table = new TableClass([], []);
+    options;
+    done;
+    pointerIndexes = {
+        row: 0,
+        column: 0,
+    };
+    isNextCloses = {
+        escape: false,
+    };
+    editing = false;
+    temporaryBackup = null;
+    answers = [];
+    constructor(question, readLine, answers) {
+        super({ ...question, validate: () => false }, readLine, answers);
+        this.options = {
+            ...DEFAULT_OPTIONS,
+            ...this.opt,
+            validate: question.validate || DEFAULT_OPTIONS.validate,
+        };
+        this.answers = answers;
+        this.table = new TableClass(this.options.columns, this.options.rows);
+        if (isNoChoiceOfIndex(this.maxColumnIndex, this.options.disableColumnIndexes)) {
+            throw new Error('disableColumnIndexes contains all of index.');
+        }
+        this.pointerIndexes.row = 0;
+        this.updateColumnIndex(1);
+    }
+    getCurrentValues() {
+        return this.table.getResult();
+    }
+    isEditable(index) {
+        return !this.options.disableColumnIndexes.includes(index);
+    }
+    _run(callback) {
+        this.done = callback;
+        const events = observe(this.rl);
+        const validation = this.handleSubmitEvents(events.line.pipe(map(this.getCurrentValues.bind(this))));
+        validation.success.forEach(this.onEnd.bind(this));
+        validation.error.forEach(this.onError.bind(this));
+        events.keypress.forEach(({ key }) => {
+            if (key.name !== 'escape') {
+                this.isNextCloses.escape = false;
+            }
+            if (!this.editing) {
+                switch (key.name) {
+                    case 'down':
+                        return this.onDownKey();
+                    case 'up':
+                        return this.onUpKey();
+                    case 'left':
+                        return this.onLeftKey();
+                    case 'right':
+                        return this.onRightKey();
+                    case 'escape':
+                        if (!this.isNextCloses.escape) {
+                            this.isNextCloses.escape = true;
+                            return this.render();
+                        }
+                        else {
+                            this.render();
+                            return this.onEnd(false);
+                        }
+                    default:
+                        if (this.isEditable(this.pointerIndexes.column)) {
+                            this.editing = true;
+                            this.onEditPress(key);
+                        }
+                }
+            }
+            else {
+                return this.onEditPress(key);
+            }
+        });
+        cliCursor.hide();
+        this.render();
+        return this;
+    }
+    get maxPageIndex() {
+        return this.options.pageSize - 1;
+    }
+    get maxRowIndex() {
+        return this.table.rows.length - 1;
+    }
+    get maxColumnIndex() {
+        return this.table.columns.length - 1;
+    }
+    onDownKey() {
+        if (this.pointerIndexes.row < this.maxRowIndex) {
+            ++this.pointerIndexes.row;
+        }
+        this.render();
+    }
+    onUpKey() {
+        if (this.pointerIndexes.row > 0) {
+            --this.pointerIndexes.row;
+        }
+        this.render();
+    }
+    updateColumnIndex(num) {
+        let index = this.pointerIndexes.column;
+        for (let c = 0; c <= this.maxColumnIndex; c++) {
+            index = getNextIndex(index, this.maxColumnIndex, num);
+            const error = gateValidateColumnIndexError(index, this.maxColumnIndex, this.options.disableColumnIndexes);
+            if (!error) {
+                break;
+            }
+        }
+        this.pointerIndexes.column = index;
+    }
+    onLeftKey() {
+        this.updateColumnIndex(-1);
+        this.render();
+    }
+    onRightKey() {
+        this.updateColumnIndex(1);
+        this.render();
+    }
+    clear() {
+        this.temporaryBackup = null;
+    }
+    onEnd(state) {
+        this.render(true);
+        this.clear();
+        this.status = 'answered';
+        this.screen.done();
+        cliCursor.show();
+        if (state) {
+            return this.done({
+                state,
+                result: this.table.getResult(),
+            });
+        }
+        else {
+            return this.done({
+                state,
+            });
+        }
+    }
+    validate() {
+        return this.options.validate(this.getCurrentValues(), this.answers);
+    }
+    onError(_state) {
+        this.clear();
+        if (this.editing) {
+            this.editing = false;
+            this.render();
+        }
+        else {
+            if (this.validate().isValid) {
+                return this.onEnd(true);
+            }
+            else {
+                return this.render();
+            }
+        }
+    }
+    validateValue() { }
+    updateChoice(value) {
+        this.table.updateRow(this.pointerIndexes.row, this.pointerIndexes.column, value);
+    }
+    get currentValue() {
+        return this.table.getValue(this.pointerIndexes.row, this.pointerIndexes.column);
+    }
+    onEditPress(key) {
+        let value = this.currentValue;
+        if (this.temporaryBackup === null) {
+            this.temporaryBackup = value;
+            value = '';
+        }
+        switch (key.name) {
+            case 'escape':
+                this.updateChoice(this.temporaryBackup);
+                this.editing = false;
+                break;
+            case 'delete':
+                this.updateChoice('');
+                break;
+            case 'backspace': {
+                let currentValue = value;
+                currentValue = currentValue.slice(0, -1);
+                this.updateChoice(currentValue);
+                break;
+            }
+            default:
+                this.updateChoice(`${value}${getKeypressValue(key)}`);
+                break;
+        }
+        this.render();
+    }
+    getShowRowIndex() {
+        const middleOfPage = Math.floor(this.options.pageSize / 2);
+        let rowIndexFrom = Math.max(0, this.pointerIndexes.row - middleOfPage);
+        const rowIndexTo = Math.min(this.maxRowIndex, rowIndexFrom + this.maxPageIndex);
+        rowIndexFrom = Math.min(rowIndexFrom, rowIndexTo - (this.options.pageSize - 1));
+        return { rowIndexFrom, rowIndexTo };
+    }
+    isSelected(rowIndex, columnIndex) {
+        return this.pointerIndexes.row === rowIndex && this.pointerIndexes.column === columnIndex;
+    }
+    getColor(_value, isSelected, isEditable) {
+        const value = isEditable ? _value : dim(_value);
+        if (!isSelected) {
+            return value;
+        }
+        if (this.editing) {
+            return isEditable ? this.options.colors.editing(value) : this.options.colors.selected(value);
+        }
+        return isEditable ? this.options.colors.editable(value) : this.options.colors.selected(value);
+    }
+    render(isDisconnect = false) {
+        let content = this.getQuestion();
+        let bottomContent = '';
+        content += this.options.description ? `\n${this.options.description}` : '';
+        const { rowIndexFrom, rowIndexTo } = this.getShowRowIndex();
+        const table = new Table({
+            head: this.table.header,
+        });
+        for (let i = 0; i < this.table.rows.length; i++) {
+            if (i < rowIndexFrom || i > rowIndexTo) {
+                continue;
+            }
+            const columnValues = [];
+            for (let ii = 0; ii < (this.table.rows[i] || []).length; ii++) {
+                const isEditable = this.isEditable(ii);
+                const value = this.table.rows[i][ii];
+                columnValues.push(this.getColor(value, this.isSelected(i, ii), isEditable));
+            }
+            table.push(columnValues);
+        }
+        content += '\n\n' + table.toString();
+        if (!isDisconnect) {
+            const validateResult = this.validate();
+            if (!this.editing && validateResult.isValid) {
+                bottomContent = this.options.confirmMessage;
+            }
+            if (!validateResult.isValid) {
+                bottomContent = validateResult.message || error('Something went wrong.');
+            }
+        }
+        if (this.isNextCloses.escape) {
+            bottomContent = this.options.escapeMessage;
+        }
+        this.screen.render(content, bottomContent);
+    }
+}

package/dist/_internal/plugins/test.d.ts

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

package/dist/_internal/plugins/test.js

@@ -0,0 +1,47 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { success, warn, hop, cyan } from '../utils/chalk.js';
+import { TablePlugin } from './table.js';
+const run = async () => {
+    inquirer.registerPrompt('table-input', TablePlugin);
+    const rows = [...Array(33).keys()].map(i => [cyan(`--path ${i}--`), '--id--', true, i + 100, '--lock--']);
+    const question = {
+        type: 'table-input',
+        name: 'links',
+        message: chalk.red('GENERATE LINKS PATH SETTINGS'),
+        description: 'Edit setting.',
+        disableColumnIndexes: [0],
+        colors: {
+            selected: warn,
+            editable: success,
+            editing: hop,
+        },
+        columns: [
+            { name: cyan.bold('filepath'), value: 'path', type: 'input' },
+            { name: cyan.bold('id'), value: 'id', type: 'input', parser: () => 'aaa' },
+            { name: cyan.bold('title'), value: 'title', type: 'confirm' },
+            {
+                name: cyan.bold('num'),
+                value: 'output',
+                type: 'number',
+                validate: (value) => /^\d*$/.test(value) || value === '0' || !value,
+            },
+            { name: cyan.bold('lock'), value: 'lock', type: 'input' },
+        ],
+        rows: rows,
+        validate: (inputs, _answers) => {
+            const isValid = inputs.every((i) => Object.values(i).every(v => `${v}`.length));
+            return {
+                isValid,
+                message: isValid ? '' : 'not allow empty input',
+            };
+        },
+    };
+    const answers = await inquirer.prompt([
+        question,
+    ]);
+    console.log('answers', JSON.stringify(answers, null, 2));
+};
+run().then(() => {
+    console.log('--- end ---');
+});

package/dist/_internal/types/inquirer.d.ts

@@ -0,0 +1 @@
+export type Done = (value: any) => void;

package/dist/_internal/types/inquirer.js

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

package/dist/_internal/types/parse-types.d.ts

@@ -0,0 +1,6 @@
+export declare const PARSE_TYPES: Readonly<{
+    readonly input: "input";
+    readonly number: "number";
+    readonly confirm: "confirm";
+}>;
+export type ParseType = (typeof PARSE_TYPES)[keyof typeof PARSE_TYPES];

package/dist/_internal/types/parse-types.js

@@ -0,0 +1,5 @@
+export const PARSE_TYPES = Object.freeze({
+    input: 'input',
+    number: 'number',
+    confirm: 'confirm',
+});

package/dist/_internal/utils/chalk.d.ts

@@ -0,0 +1,9 @@
+export declare const trim: (txt: string) => string;
+export declare const success: import("chalk").ChalkInstance;
+export declare const warn: import("chalk").ChalkInstance;
+export declare const info: import("chalk").ChalkInstance;
+export declare const error: import("chalk").ChalkInstance;
+export declare const hop: import("chalk").ChalkInstance;
+export declare const cyan: import("chalk").ChalkInstance;
+export declare const bold: import("chalk").ChalkInstance;
+export declare const dim: import("chalk").ChalkInstance;

package/dist/_internal/utils/chalk.js

@@ -0,0 +1,10 @@
+import chalk from 'chalk';
+export const trim = (txt) => txt.replace(/\u001b\[[0-9;]*m/g, '');
+export const success = chalk.green;
+export const warn = chalk.hex('#FFA500');
+export const info = chalk.hex('#77CFF5');
+export const error = chalk.red;
+export const hop = chalk.hex('#F577F5');
+export const cyan = chalk.cyan;
+export const bold = chalk.bold;
+export const dim = chalk.dim;

package/dist/_internal/utils/keypress.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Key } from 'readline';
+export declare const getKeypressValue: (key: Key) => string | undefined;

package/dist/_internal/utils/keypress.js

@@ -0,0 +1,14 @@
+export const getKeypressValue = (key) => {
+    switch (key.name) {
+        case 'escape':
+        case 'delete':
+        case 'backspace':
+        case 'down':
+        case 'up':
+        case 'left':
+        case 'right':
+            return '';
+        default:
+            return key.sequence;
+    }
+};

package/dist/_internal/utils/parse-types.d.ts

@@ -0,0 +1,3 @@
+import { ParseType } from '../types/parse-types.js';
+export declare const parse: (value: string, type: ParseType) => string | number | boolean;
+export declare const parseView: (value: string, type: ParseType) => string | number | boolean;

package/dist/_internal/utils/parse-types.js

@@ -0,0 +1,22 @@
+import { PARSE_TYPES } from '../types/parse-types.js';
+const BOOL_VALUES = Object.freeze(['Y', 'y', 'yes', 'YES', 'x', 'v', 'o', 'true']);
+export const parse = (value, type) => {
+    switch (type) {
+        case PARSE_TYPES.number:
+            return value ? Number(value) : 0;
+        case PARSE_TYPES.confirm:
+            return BOOL_VALUES.includes(value);
+        default:
+            return value;
+    }
+};
+export const parseView = (value, type) => {
+    switch (type) {
+        case PARSE_TYPES.number:
+            return value ? Number(value) : 0;
+        case PARSE_TYPES.confirm:
+            return value === 'true';
+        default:
+            return value;
+    }
+};

package/dist/modules/table.d.ts

@@ -0,0 +1,2 @@
+export * from '../_internal/plugins/table.js';
+export * from '../_internal/plugins/table/types.js';

package/dist/modules/table.js

@@ -0,0 +1,2 @@
+export * from '../_internal/plugins/table.js';
+export * from '../_internal/plugins/table/types.js';

package/dist/modules/types/inquirer.d.ts

@@ -0,0 +1 @@
+export * from '../../_internal/types/inquirer.js';

package/dist/modules/types/inquirer.js

@@ -0,0 +1 @@
+export * from '../../_internal/types/inquirer.js';

package/dist/modules/types/parse-types.d.ts

@@ -0,0 +1 @@
+export * from '../../_internal/types/parse-types.js';

package/dist/modules/types/parse-types.js

@@ -0,0 +1 @@
+export * from '../../_internal/types/parse-types.js';