zcatalyst-cli 1.20.2 → 1.22.0

package/lib/port-resolver.d.ts

@@ -0,0 +1,24 @@
+declare const featureRef: {
+    client: string;
+    aio: string;
+    bio: string;
+    master: string;
+    appsail: string;
+    slate: string;
+    browserlogic: string;
+};
+type TFeatureType = 'http' | 'debug';
+type TGetPortOptions = {
+    name?: string;
+    duplicateCheck?: boolean;
+    searchSpan?: number;
+    fallbackNeeded?: boolean;
+    server?: 'master' | 'service';
+};
+export default class PortResolver {
+    #private;
+    static freePort(port: number): void;
+    static getFreePort(startPort: number, searchSpan?: number, dupCheck?: boolean): Promise<number>;
+    static getPort(feature: keyof typeof featureRef, type: TFeatureType, { name, duplicateCheck, searchSpan, fallbackNeeded, server }?: TGetPortOptions): Promise<number>;
+}
+export {};

package/lib/port-resolver.js

@@ -20,10 +20,10 @@ var _a, _PortResolver_takenPorts, _PortResolver_isPortTaken;
 Object.defineProperty(exports, "__esModule", { value: true });
 const ansi_colors_1 = require("ansi-colors");
 const portfinder_1 = require("portfinder");
-const error_1 = __importDefault(require("./error"));
+const index_js_1 = __importDefault(require("./error/index.js"));
 const runtime_store_1 = __importDefault(require("./runtime-store"));
 const constants_1 = require("./util_modules/constants");
-const logger_1 = require("./util_modules/logger");
+const index_1 = require("./util_modules/logger/index");
 const featureRef = {
     client: 'client',
     aio: 'advancedio',
@@ -34,6 +34,9 @@ const featureRef = {
     browserlogic: 'browser_logic'
 };
 class PortResolver {
+    static freePort(port) {
+        __classPrivateFieldGet(this, _a, "f", _PortResolver_takenPorts).delete(port);
+    }
     static getFreePort(startPort, searchSpan = 0, dupCheck = false) {
         return __awaiter(this, void 0, void 0, function* () {
             if (searchSpan < 0) {
@@ -59,20 +62,20 @@ class PortResolver {
             port = isNaN(port) ? parseInt(runtime_store_1.default.get(`context.port.${type}.${feature}`), 10) : port;
             if (isNaN(port)) {
                 if (type === 'debug' && feature === 'client') {
-                    throw new error_1.default('client cannot be debugged', { exit: 2 });
+                    throw new index_js_1.default('client cannot be debugged', { exit: 2 });
                 }
                 if (!fallbackNeeded) {
                     return -1;
                 }
                 if (feature === 'appsail') {
                     if (!server || type !== 'http') {
-                        throw new error_1.default('Invalid appsail details', { exit: 2 });
+                        throw new index_js_1.default('Invalid appsail details', { exit: 2 });
                     }
                     port = constants_1.DEFAULT.serve_port['http']['appsail'][server];
                 }
                 else if (feature === 'slate') {
                     if (!server || type !== 'http') {
-                        throw new error_1.default('Invalid slate details', { exit: 2 });
+                        throw new index_js_1.default('Invalid slate details', { exit: 2 });
                     }
                     port = constants_1.DEFAULT.serve_port['http']['slate'][server];
                 }
@@ -84,7 +87,7 @@ class PortResolver {
                 searchSpan = 0;
             }
             if (port === -1) {
-                throw new error_1.default('port resolved to -1 for feature ' + feature + ' and type ' + type, {
+                throw new index_js_1.default('port resolved to -1 for feature ' + feature + ' and type ' + type, {
                     exit: 2
                 });
             }
@@ -94,10 +97,9 @@ class PortResolver {
             }
             catch (e) {
                 if (searchSpan === 0) {
-                    const err = error_1.default.getErrorInstance(e, {
+                    const err = index_js_1.default.getErrorInstance(e, {
                         message: `Provided port '${port}' is not available`,
-                        skipHelp: false,
-                        fileName: __filename
+                        skipHelp: false
                     });
                     err.errorId = 'PORT-RESOLVER-1';
                     err.arg = [
@@ -109,17 +111,16 @@ class PortResolver {
                     ];
                     throw err;
                 }
-                const cerr = error_1.default.getErrorInstance(e, {
+                const cerr = index_js_1.default.getErrorInstance(e, {
                     message: `No ports from '${port}' to ${port + searchSpan} is free to use as a ${type} port.`,
-                    skipHelp: server ? true : false,
-                    fileName: __filename
+                    skipHelp: server ? true : false
                 });
                 cerr.errorId = 'PORT-RESOLVER-2';
                 cerr.arg = [(0, ansi_colors_1.bold)(port + ''), (0, ansi_colors_1.bold)(port + searchSpan + ''), (0, ansi_colors_1.bold)('--' + type)];
                 throw cerr;
             }
             if (finalPort !== port) {
-                (0, logger_1.debug)(`${type} port : '${port}' is not available. Hence port '${finalPort}' will be used instead.`);
+                (0, index_1.debug)(`${type} port : '${port}' is not available. Hence port '${finalPort}' will be used instead.`);
             }
             return finalPort;
         });

package/lib/progress.d.ts

@@ -0,0 +1,34 @@
+import Throbber from './throbber';
+export interface IProgress {
+    title?: string;
+    fillChar?: string;
+    bgChar?: string;
+    startingChar?: string;
+    endingChar?: string;
+    total?: number;
+    failure?: (err?: string | Error) => string;
+    progressType?: 'upload' | 'download';
+}
+export default class Progress {
+    title: string;
+    fillChar: string;
+    bgChar: string;
+    startingChar: string;
+    endingChar: string;
+    total: number;
+    throbber: Throbber;
+    startTime: [number, number];
+    currentProgress: number;
+    currentProgressFrame: string;
+    failure?: (err?: string | Error) => string;
+    progressType: IProgress['progressType'];
+    constructor({ title, fillChar, bgChar, startingChar, endingChar, total, failure, progressType }?: IProgress);
+    private get MAX_SCREEN_LENGTH();
+    private get barLength();
+    private getCompleteness;
+    private fillProgress;
+    private fillSpace;
+    private updateProgress;
+    error(err?: string | Error): void;
+    tick(count?: number): void;
+}

package/lib/prompt/index.d.ts

@@ -0,0 +1,34 @@
+import inquirer from 'inquirer';
+import Separator from 'inquirer/lib/objects/separator';
+import PromptUI from 'inquirer/lib/ui/prompt';
+import { TreeData, TreeNode } from './types/tree';
+export interface IChoice extends inquirer.ChoiceOptions, inquirer.ListChoiceOptions, inquirer.CheckboxChoiceOptions {
+    id?: string;
+}
+export interface IQuestion extends inquirer.Question, inquirer.ListQuestionOptions {
+    name: string;
+    type?: inquirer.QuestionTypeName | 'file-path' | 'tree' | 'search-box' | 'with-desc';
+    defaultAns?: unknown;
+    choices?: Array<IChoice | TSeparator> | Array<string | TSeparator>;
+    treeChoices?: Array<TreeNode | TreeData>;
+    rootPath?: string;
+    exclude?: Array<string>;
+    excludeDir?: boolean;
+    ignoreFiles?: boolean;
+    depth?: number;
+    empTxt?: string;
+    validatingText?: string;
+    description?: string;
+}
+export type TSeparator = Separator;
+declare const _default: {
+    register: (type: 'file-path' | 'tree' | 'search-box' | 'with-desc') => Promise<void>;
+    deregister: (type: 'file-path' | 'tree' | 'search-box') => void;
+    separator: (line: string) => TSeparator;
+    choice: (name: string, { id, value, short, disabled, checked, ...otherOpts }?: IChoice) => IChoice;
+    ask: (...questions: Array<IQuestion>) => (Promise<inquirer.Answers> & {
+        ui: PromptUI;
+    }) | Promise<inquirer.Answers>;
+    question: (name: string, question: string, { type, defaultAns, choices, validate, filter, when, prefix, suffix, ...otheropts }?: Omit<IQuestion, 'name'>) => IQuestion;
+};
+export default _default;

package/lib/prompt/index.js

@@ -48,9 +48,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const inquirer_1 = __importDefault(require("inquirer"));
 const error_1 = __importDefault(require("../error"));
+const runtime_store_1 = __importDefault(require("../runtime-store"));
 const choice = (name, _a = {}) => {
-    var { value = name, short = name, disabled = false, checked = false } = _a, otherOpts = __rest(_a, ["value", "short", "disabled", "checked"]);
-    return Object.assign({ name,
+    var { id = name, value = name, short = name, disabled = false, checked = false } = _a, otherOpts = __rest(_a, ["id", "value", "short", "disabled", "checked"]);
+    return Object.assign({ id,
+        name,
         value,
         short,
         disabled,
@@ -72,6 +74,10 @@ exports.default = {
             case 'search-box':
                 module = yield Promise.resolve().then(() => __importStar(require('./types/search-box')));
                 break;
+            case 'with-desc': {
+                module = yield Promise.resolve().then(() => __importStar(require('./types/with-description')));
+                break;
+            }
             default:
                 throw new error_1.default('No such type registered', { exit: 2 });
         }
@@ -87,16 +93,50 @@ exports.default = {
     },
     choice,
     ask: (...questions) => {
-        for (const question of questions) {
-            if (question.type && ['file-path', 'tree', 'search-box'].includes(question.type)) {
-                if (!registeredTypes.has(question.type)) {
-                    throw new error_1.default(`Prompt type "${question.type}" is not registered.`, {
-                        exit: 2
-                    });
+        const runtimePrompt = runtime_store_1.default.get('prompt', false);
+        if (!runtimePrompt) {
+            for (const question of questions) {
+                if (question.type && ['file-path', 'tree', 'search-box'].includes(question.type)) {
+                    if (!registeredTypes.has(question.type)) {
+                        throw new error_1.default(`Prompt type "${question.type}" is not registered.`, {
+                            exit: 2
+                        });
+                    }
                 }
             }
+            return inquirer_1.default.prompt(questions);
         }
-        return inquirer_1.default.prompt(questions);
+        return new Promise((res, rej) => {
+            try {
+                const answers = {};
+                questions.forEach((question) => {
+                    var _a;
+                    const runtimeAns = runtimePrompt[question.name];
+                    if (runtimeAns !== undefined) {
+                        switch (question.type) {
+                            case 'checkbox': {
+                                answers[question.name] = question.choices
+                                    .filter((choice) => choice.id &&
+                                    runtimeAns.includes(choice.id))
+                                    .map((filteredChoice) => filteredChoice.value);
+                                break;
+                            }
+                            case 'list': {
+                                answers[question.name] = (_a = question.choices.find((choice) => choice.id === runtimeAns.toString())) === null || _a === void 0 ? void 0 : _a.value;
+                                break;
+                            }
+                            default: {
+                                answers[question.name] = runtimeAns;
+                            }
+                        }
+                    }
+                });
+                res(answers);
+            }
+            catch (err) {
+                rej(err);
+            }
+        });
     },
     question: (name, question, _a = {}) => {
         var { type = 'input', defaultAns, choices = [], validate = () => {

package/lib/prompt/types/file-path.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+import InquirerAutocomplete from 'inquirer-autocomplete-prompt';
+import { Answers } from 'inquirer';
+import { Interface } from 'readline';
+export default class InquirerFilePath extends InquirerAutocomplete<Answers> {
+    nbChoices: unknown;
+    answer: unknown;
+    answerName: unknown;
+    shortAnswer: unknown;
+    done?: (val: string) => void;
+    constructor(question: {
+        rootPath: string;
+        pattern: string;
+        exclude: Array<string>;
+        default: string;
+        ignoreFiles?: boolean;
+        excludeDir?: boolean;
+        empTxt?: string;
+        depth?: number;
+    }, rl: Interface, answers: Answers);
+    search(searchTerm: string): Promise<void>;
+    onSubmitAfterValidation(line: string): Promise<void>;
+    private checkValidationResult;
+    onSubmit(line: string): Promise<void>;
+}

package/lib/prompt/types/search-box.d.ts

@@ -0,0 +1,56 @@
+/// <reference types="node" />
+import inquirer, { Answers, Question } from 'inquirer';
+import Choice from 'inquirer/lib/objects/choice';
+import Choices from 'inquirer/lib/objects/choices';
+import Separator from 'inquirer/lib/objects/separator';
+import Base from 'inquirer/lib/prompts/base';
+import { Interface as ReadLineInterface } from 'readline';
+type SearchBoxPlusPromptOptions<T extends Answers = any> = Question<T> & {
+    highlight?: boolean;
+    searchable?: boolean;
+    defaults?: Array<string>;
+    notFoundMsg?: string;
+    searchMsg?: string;
+    pageSize: number;
+    source: (answersSoFar: Answers, input: string | undefined) => Promise<Array<unknown>>;
+    boxType: 'check-box' | 'list';
+};
+export default class SearchBox<TAnswers extends Answers = Answers> extends Base<SearchBoxPlusPromptOptions & {
+    states: unknown;
+}> {
+    private pointer;
+    private paginator;
+    private boxType;
+    private choices;
+    private checkedChoices;
+    private searching;
+    private lastQuery?;
+    private default?;
+    private value;
+    private lastSourcePromise?;
+    private done?;
+    constructor(questions: Question & SearchBoxPlusPromptOptions & {
+        states: unknown;
+    }, rl: ReadLineInterface, answers: Answers);
+    _run(callback: SearchBox<TAnswers>['done']): this;
+    getValue(choice: Choice<TAnswers> | Separator): string | undefined;
+    executeSource(): Promise<unknown>;
+    render({ answer, error }?: {
+        answer?: Array<Choice> | Choice;
+        error?: Error | string;
+    }): void;
+    onEnd(state: inquirer.prompts.SuccessfulPromptStateData | inquirer.prompts.FailedPromptStateData): void;
+    onError(state: inquirer.prompts.FailedPromptStateData): void;
+    getCurrentValue(): Array<unknown> | unknown;
+    onUpKey(): void;
+    onDownKey(): void;
+    onNumberKey(input: any): void;
+    onSpaceKey(): void;
+    onAllKey(): void;
+    onInverseKey(): void;
+    onKeypress(): void;
+    toggleChoice(choice: Choice<Answers> | Separator, nextChecked?: boolean): void;
+    static getCheckboxFigure(checked?: boolean): string;
+    renderChoices(choices: Choices<TAnswers>, pointer: number, checkBox?: boolean): string;
+}
+export {};

package/lib/prompt/types/search-box.js

@@ -3,28 +3,29 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const chalk_1 = __importDefault(require("chalk"));
+const ansi_colors_1 = require("ansi-colors");
 const cli_cursor_1 = __importDefault(require("cli-cursor"));
-const figures_1 = __importDefault(require("figures"));
 const choices_1 = __importDefault(require("inquirer/lib/objects/choices"));
 const base_1 = __importDefault(require("inquirer/lib/prompts/base"));
 const events_1 = __importDefault(require("inquirer/lib/utils/events"));
 const paginator_1 = __importDefault(require("inquirer/lib/utils/paginator"));
 const operators_1 = require("rxjs/operators");
+const error_1 = __importDefault(require("../../error"));
 class SearchBox extends base_1.default {
     constructor(questions, rl, answers) {
+        questions.prefix = '';
         super(questions, rl, answers);
         this.pointer = 0;
-        if (this.opt.highlight == null) {
+        if (!this.opt.highlight) {
             this.opt.highlight = false;
         }
-        if (typeof this.opt.searchable == null) {
+        if (!this.opt.searchable) {
             this.opt.searchable = false;
         }
-        if (typeof this.opt.default == null) {
+        if (this.opt.default === undefined || this.opt.default === null) {
             this.opt.default = undefined;
         }
-        if (this.opt.source == null) {
+        if (!this.opt.source) {
             this.throwParamError('source');
         }
         if (this.opt.notFoundMsg === undefined) {
@@ -33,8 +34,8 @@ class SearchBox extends base_1.default {
         if (this.opt.searchMsg === undefined) {
             this.opt.searchMsg = 'Searching...';
         }
+        this.boxType = this.opt.boxType || 'check-box';
         this.pointer = 0;
-        this.firstSourceLoading = true;
         this.choices = new choices_1.default([], answers);
         this.checkedChoices = [];
         this.value = [];
@@ -43,7 +44,6 @@ class SearchBox extends base_1.default {
         this.lastSourcePromise = undefined;
         this.default = this.opt.default;
         this.opt.default = undefined;
-        this.selection = [];
         this.done = undefined;
         this.paginator = new paginator_1.default(this.screen);
     }
@@ -60,15 +60,26 @@ class SearchBox extends base_1.default {
             events.normalizedDownKey
                 .pipe((0, operators_1.takeUntil)(validation.success))
                 .forEach(this.onDownKey.bind(this));
-            events.spaceKey.pipe((0, operators_1.takeUntil)(validation.success)).forEach(this.onSpaceKey.bind(this));
-            if (this.opt.searchable === false) {
-                events.numberKey
+            if (this.boxType === 'check-box') {
+                events.spaceKey
                     .pipe((0, operators_1.takeUntil)(validation.success))
-                    .forEach(this.onNumberKey.bind(this));
-                events.aKey.pipe((0, operators_1.takeUntil)(validation.success)).forEach(this.onAllKey.bind(this));
-                events.iKey
-                    .pipe((0, operators_1.takeUntil)(validation.success))
-                    .forEach(this.onInverseKey.bind(this));
+                    .forEach(this.onSpaceKey.bind(this));
+                if (this.opt.searchable === false) {
+                    events.numberKey
+                        .pipe((0, operators_1.takeUntil)(validation.success))
+                        .forEach(this.onNumberKey.bind(this));
+                    events.aKey
+                        .pipe((0, operators_1.takeUntil)(validation.success))
+                        .forEach(this.onAllKey.bind(this));
+                    events.iKey
+                        .pipe((0, operators_1.takeUntil)(validation.success))
+                        .forEach(this.onInverseKey.bind(this));
+                }
+                else {
+                    events.keypress
+                        .pipe((0, operators_1.takeUntil)(validation.success))
+                        .forEach(this.onKeypress.bind(this));
+                }
             }
             else {
                 events.keypress
@@ -127,62 +138,84 @@ class SearchBox extends base_1.default {
             this.pointer = 0;
             this.render();
             this.default = undefined;
-            this.firstSourceLoading = false;
         });
         return sourcePromise;
     }
-    render(error) {
+    render({ answer, error } = {}) {
         let message = this.getQuestion();
         let bottomContent = '';
         if (this.status === 'answered') {
-            message += chalk_1.default.cyan(this.selection.join(', '));
+            if (answer === undefined) {
+                throw new error_1.default(`Unable to get the answer for search-box(${this.opt.name}) :: ${answer}`, {
+                    exit: 2
+                });
+            }
+            message += (0, ansi_colors_1.cyan)(Array.isArray(answer) ? answer.map((ans) => ans.short).join(', ') : answer.short);
             return this.screen.render(message, bottomContent);
         }
-        if (this.firstSourceLoading) {
-            if (this.opt.searchable) {
-                message += `(Press ${chalk_1.default.cyan.bold('<space>')} to select, or type anything to filter the list)`;
-            }
-            else {
-                message += `(Press ${chalk_1.default.cyan.bold('<space>')} to select, ${chalk_1.default.cyan.bold('<a>')} to toggle all, ${chalk_1.default.cyan.bold('<i>')} to invert selection)`;
+        if (this.rl.line.length === 0) {
+            switch (this.boxType) {
+                case 'check-box': {
+                    if (this.opt.searchable) {
+                        message += (0, ansi_colors_1.dim)(`(Press ${ansi_colors_1.cyan.bold('<space>')} to select, or type anything to filter the list)`);
+                    }
+                    else {
+                        message += (0, ansi_colors_1.dim)(`(Press ${ansi_colors_1.cyan.bold('<space>')} to select, ${ansi_colors_1.cyan.bold('<a>')} to toggle all, ${ansi_colors_1.cyan.bold('<i>')} to invert selection)`);
+                    }
+                    break;
+                }
+                case 'list': {
+                    message += (0, ansi_colors_1.dim)(`(Press ${ansi_colors_1.cyan.bold('<return>')} to select)`);
+                    break;
+                }
             }
         }
         if (this.opt.searchable) {
-            message += this.rl.line;
+            message += (0, ansi_colors_1.green)(this.rl.line);
         }
         if (this.searching) {
-            message += `\n  ${chalk_1.default.cyan(this.opt.searchMsg)}`;
+            message += `\n  ${(0, ansi_colors_1.cyan)(this.opt.searchMsg || '')}`;
         }
         else if (!this.choices.length) {
-            message += `\n  ${chalk_1.default.yellow(this.opt.notFoundMsg)}`;
+            message += `\n  ${(0, ansi_colors_1.yellow)(this.opt.notFoundMsg || '')}`;
         }
         else {
-            const choicesStr = this.renderChoices(this.choices, this.pointer);
+            const choicesStr = this.renderChoices(this.choices, this.pointer, this.boxType === 'check-box');
             const choice = this.choices.getChoice(this.pointer);
             const indexPosition = this.choices.indexOf(choice);
             message += `\n${this.paginator.paginate(choicesStr, indexPosition, this.opt.pageSize)}`;
         }
         if (error) {
-            bottomContent = chalk_1.default.red('>> ') + error;
+            bottomContent = (0, ansi_colors_1.red)('>> ') + error;
         }
         return this.screen.render(message, bottomContent);
     }
     onEnd(state) {
         var _a;
         this.status = 'answered';
-        this.render();
+        const answer = 'value' in state ? state.value : undefined;
+        this.render({ answer });
         this.screen.done();
         cli_cursor_1.default.show();
-        (_a = this.done) === null || _a === void 0 ? void 0 : _a.call(this, 'value' in state ? state.value : undefined);
+        (_a = this.done) === null || _a === void 0 ? void 0 : _a.call(this, Array.isArray(answer) ? answer.map((ans) => ans.value) : answer.value);
     }
     onError(state) {
-        if (state.isValid) {
-            this.render();
+        if (typeof state.isValid === 'string') {
+            const _errStr = state.isValid;
+            this.executeSource().then(() => {
+                this.render({ error: _errStr });
+            });
         }
     }
     getCurrentValue() {
-        this.selection = this.checkedChoices.map((checkedChoice) => checkedChoice.short);
-        const values = this.checkedChoices.map((checkedChoice) => checkedChoice.value);
-        return values;
+        switch (this.boxType) {
+            case 'check-box': {
+                return this.checkedChoices;
+            }
+            case 'list': {
+                return this.choices.getChoice(this.pointer);
+            }
+        }
     }
     onUpKey() {
         const len = this.choices.realLength;
@@ -202,7 +235,10 @@ class SearchBox extends base_1.default {
         this.render();
     }
     onSpaceKey() {
-        if (this.choices.getChoice(this.pointer) == null) {
+        if (this.boxType !== 'check-box') {
+            return;
+        }
+        if (!this.choices.getChoice(this.pointer)) {
             return;
         }
         this.toggleChoice(this.choices.getChoice(this.pointer));
@@ -237,7 +273,7 @@ class SearchBox extends base_1.default {
         if (choice.type === 'separator') {
             return;
         }
-        const checked = nextChecked == null ? !((_a = choice.checked) !== null && _a !== void 0 ? _a : false) : nextChecked;
+        const checked = nextChecked === undefined ? !((_a = choice.checked) !== null && _a !== void 0 ? _a : false) : nextChecked;
         this.value = this.value.filter((eachValue) => eachValue !== choice.value);
         this.checkedChoices = this.checkedChoices.filter((checkedChoice) => checkedChoice.value !== choice.value);
         choice.checked = false;
@@ -248,9 +284,9 @@ class SearchBox extends base_1.default {
         }
     }
     static getCheckboxFigure(checked = false) {
-        return checked ? chalk_1.default.green(figures_1.default.radioOn) : figures_1.default.radioOff;
+        return checked ? (0, ansi_colors_1.green)('◉') : '◯';
     }
-    renderChoices(choices, pointer) {
+    renderChoices(choices, pointer, checkBox = true) {
         const output = [];
         let separatorOffset = 0;
         choices.forEach((choice, index) => {
@@ -265,13 +301,15 @@ class SearchBox extends base_1.default {
                 return;
             }
             if (index - separatorOffset === pointer) {
-                output.push(chalk_1.default.cyan(figures_1.default.pointer));
-                output.push(SearchBox.getCheckboxFigure(choice.checked));
-                output.push(' ');
-                output.push(this.opt.highlight ? chalk_1.default.gray(choice.name) : choice.name);
+                const pointedLine = checkBox
+                    ? `❯ ${SearchBox.getCheckboxFigure(choice.checked)} ${choice.name}`
+                    : `❯ ${choice.name}`;
+                output.push(this.opt.highlight ? (0, ansi_colors_1.cyan)(pointedLine) : pointedLine);
             }
             else {
-                output.push(` ${SearchBox.getCheckboxFigure(choice.checked)} ${choice.name}`);
+                output.push(checkBox
+                    ? `  ${SearchBox.getCheckboxFigure(choice.checked)} ${choice.name}`
+                    : `  ${choice.name}`);
             }
             output.push('\n');
         });

package/lib/prompt/types/tree.d.ts

@@ -0,0 +1,65 @@
+/// <reference types="node" />
+import { Answers } from 'inquirer';
+import BasePrompt from 'inquirer/lib/prompts/base.js';
+import Paginator from 'inquirer/lib/utils/paginator.js';
+import { Interface } from 'readline';
+export interface TreeData<T = unknown> {
+    display: string;
+    expand?: string;
+    value: T;
+    short: string;
+}
+declare enum ETreeState {
+    OPEN = 1,
+    CLOSED = 2,
+    EXPANDED = 3
+}
+export declare class TreeNode {
+    #private;
+    root?: string;
+    open: boolean;
+    leaves: Array<(TreeData & {
+        isExpanded: boolean;
+    }) | TreeNode>;
+    activeIdx: number;
+    prevActiveIdx: number;
+    nodes: string[];
+    level: number;
+    get indent(): number;
+    constructor(root?: string);
+    addNode(node: TreeData | TreeNode): this;
+    buildTree({ paginator, force }?: {
+        paginator?: Paginator;
+        force?: boolean;
+    }): string;
+    expandNode(display: string, expand: string): string;
+    openTree(strict?: boolean): ETreeState;
+    closeTree(): void;
+    moveActive(distance?: number): void;
+    getValue(): TreeData;
+    wrapLine(line: string, indent: number): string;
+}
+export default class InquirerTree extends BasePrompt {
+    paginator: Paginator;
+    done?: (val: unknown) => void;
+    treeOpts: {
+        pageSize: number;
+        multiple: boolean;
+        loop: boolean;
+    };
+    message: string;
+    choices: TreeNode;
+    constructor(question: {
+        message: string;
+        name: string;
+        treeChoices: Array<TreeNode | TreeData>;
+    }, rl: Interface, answers: Answers);
+    protected _run(callback: (...args: Array<unknown>) => void): this;
+    bindKeyEvents(): void;
+    constructTree(): void;
+    render({ answer, error }?: {
+        answer?: TreeData;
+        error?: string | Error;
+    }): void;
+}
+export {};