zcatalyst-cli 1.15.0-beta.2 → 1.15.0-beta.4

package/lib/internal/api.js

@@ -53,10 +53,11 @@ class API {
             headers
         };
         if (!isExternal) {
-            this.requestOpts.headers = Object.assign(Object.assign({}, this.requestOpts.headers), { Accept: 'application/vnd.catalyst.v2+json', 'User-Agent': runtime_store_1.default.get('context.cli.package.name') +
-                    '/' +
-                    runtime_store_1.default.get('context.cli.package.version'), 'X-CATALYST-Environment': env, 'CATALYST-ORG': envId });
+            this.requestOpts.headers = Object.assign(Object.assign({}, this.requestOpts.headers), { Accept: 'application/vnd.catalyst.v2+json', 'X-CATALYST-Environment': env, 'CATALYST-ORG': envId });
         }
+        this.requestOpts.headers = Object.assign(Object.assign({}, this.requestOpts.headers), { 'User-Agent': runtime_store_1.default.get('context.cli.package.name') +
+                '/' +
+                runtime_store_1.default.get('context.cli.package.version') });
         this.authNeeded = authNeeded;
         this.resolveOnHTTPError = resolveOnError;
         this.logOpts = log;
@@ -216,8 +217,7 @@ class API {
             this.authNeeded = js_1.JS.get(options, 'authNeeded', this.authNeeded);
             this.logOpts = js_1.JS.get(options, 'log', this.logOpts);
             this.requestOpts = js_1.JS.defaultsDeep(js_1.JS.omit(options, ['origin', 'auth', 'maxRetry', 'resolveOnError', 'log']), this.requestOpts);
-            this.requestOpts.url =
-                js_1.JS.get(options, 'origin', this.requestOpts.url || constants_1.ORIGIN.admin) + path;
+            this.requestOpts.url = ((options === null || options === void 0 ? void 0 : options.origin) || this.requestOpts.url || constants_1.ORIGIN.admin) + path;
             this.requestOpts.method = method;
             if (this.authNeeded) {
                 yield this._addAuthHeader();

package/lib/internal/command.js

@@ -48,6 +48,7 @@ const option_1 = require("../util_modules/option");
 const project_1 = require("../util_modules/project");
 class Command {
     constructor(cmd) {
+        this.isSubCommand = false;
         this.command = cmd;
         this.cmdName = cmd.split(' ')[0];
         this.aliasName = null;
@@ -87,6 +88,19 @@ class Command {
         this.helpText = text;
         return this;
     }
+    addSubCommand(command) {
+        this.subCommand = command;
+        command.isSubCommand = true;
+        return this;
+    }
+    helpConfig(config) {
+        this._helpConfig = config;
+        return this;
+    }
+    usage(cmdUsage) {
+        this.cmdUsage = cmdUsage;
+        return this;
+    }
     action(fn) {
         this.cmdAction = fn;
         return this;
@@ -95,9 +109,9 @@ class Command {
         this.optIgnores = opts;
         return this;
     }
-    register(client) {
+    register(client, cli) {
         this.client = client;
-        const program = client.cli;
+        const program = cli || client.cli;
         const cmd = program.command(this.command);
         if (this.aliasName !== null) {
             cmd.alias(this.aliasName);
@@ -105,11 +119,17 @@ class Command {
         if (this.cmdDescription !== null) {
             cmd.description(this.cmdDescription);
         }
+        if (this.cmdUsage) {
+            cmd.usage(this.cmdUsage);
+        }
         if (this.helpText !== null) {
             cmd.on('--help', () => {
                 (0, logger_1.info)(this.helpText);
             });
         }
+        if (this._helpConfig) {
+            cmd.configureHelp(this._helpConfig);
+        }
         cmd.allowUnknownOption(this.allowUnknownOptions);
         this.cmdOptions.forEach((args) => {
             if (args.length > 0) {
@@ -142,6 +162,9 @@ class Command {
                 yield (0, track_1.default)(errorEvent, preppedMessage, duration);
             }
         }));
+        if (this.subCommand) {
+            this.subCommand.register(client, cmd);
+        }
         return cmd;
     }
     _prepare(cmd) {
@@ -175,7 +198,7 @@ class Command {
                 ? command.parseOptions(process.argv).unknown
                 : undefined;
             runtime_store_1.default.set('opts', Object.assign({ _name: command.name(), unknownOpts }, opts));
-            this._prepare(command);
+            this._prepare(this.isSubCommand && command.parent ? command.parent : command);
             try {
                 yield (0, migration_1.default)(runtime_store_1.default.get('context.cli.package.version'));
             }

package/lib/option-filter.js

@@ -36,7 +36,18 @@ const fs_1 = require("./util_modules/fs");
 const js_1 = require("./util_modules/js");
 const option_1 = require("./util_modules/option");
 const project_1 = require("./util_modules/project");
-const validGlobalTargets = ['functions', 'client', 'apig'];
+const onlyExceptTargets = [
+    { filterName: ['functions'], target: 'functions' },
+    { filterName: ['client'], target: 'client' },
+    { filterName: ['apig'], target: 'apig' },
+    { filterName: ['appsail'], target: 'appsail' }
+];
+const portTargets = [
+    { filterName: ['appsail'], target: 'appsail' },
+    { filterName: ['advancedio', 'aio'], target: 'advancedio' },
+    { filterName: ['basicio', 'bio'], target: 'basicio' },
+    { filterName: ['client'], target: 'client' }
+];
 function enrichOptsData(opt, optValue, validTargets, multiTargetSupport = true) {
     if (optValue === undefined || typeof optValue === 'boolean') {
         return [];
@@ -56,28 +67,32 @@ function enrichOptsData(opt, optValue, validTargets, multiTargetSupport = true)
             });
         }
         const entrySet = entry.split(':');
-        if (!validTargets.includes(entrySet[0])) {
+        const resultantTarget = validTargets.find((targs) => targs.filterName.includes(entrySet[0]));
+        if (!resultantTarget) {
             throw new error_1.default(`Invalid target "${entrySet[0]}" specified for option "${opt}".`, {
                 exit: 1,
                 errorId: 'OPT-FILTER-2',
                 arg: [
                     ansi_colors_1.bold.red(entrySet[0]),
                     (0, ansi_colors_1.bold)('--' + opt),
-                    (0, ansi_colors_1.bold)(validTargets.map((target) => '* ' + target).join('\n'))
+                    (0, ansi_colors_1.bold)(validTargets
+                        .map((target) => '* ' + target.filterName.join(' | '))
+                        .join('\n'))
                 ]
             });
         }
-        if (!multiTargetSupport && accumulator.some((res) => res.target === entrySet[0])) {
+        if (!multiTargetSupport &&
+            accumulator.some((res) => res.target.filterName.includes(entrySet[0]))) {
             throw new error_1.default(`Target "${entrySet[0]}" is specified more than once for option "${opt}". Please specify only one.`, {
                 exit: 1
             });
         }
         const resultant = {
             hasFilter: false,
-            target: entrySet[0]
+            target: resultantTarget
         };
         if (accumulator.some((res, idx) => {
-            const truthy = res.target === entrySet[0] &&
+            const truthy = res.target.filterName.includes(entrySet[0]) &&
                 ((res.hasFilter && entrySet.length === 1) ||
                     (!res.hasFilter && entrySet.length === 2));
             if (truthy) {
@@ -115,22 +130,22 @@ function validateTargets() {
             arg: [(0, ansi_colors_1.bold)('--only'), (0, ansi_colors_1.bold)('--except')]
         });
     }
-    const enrichedOnlyOpts = enrichOptsData('only', (0, option_1.getOptionValue)('only'), validGlobalTargets);
+    const enrichedOnlyOpts = enrichOptsData('only', (0, option_1.getOptionValue)('only'), onlyExceptTargets);
     if (enrichedOnlyOpts.length > 0) {
         return enrichedOnlyOpts;
     }
-    const enrichedExceptOpts = enrichOptsData('except', (0, option_1.getOptionValue)('except'), validGlobalTargets);
+    const enrichedExceptOpts = enrichOptsData('except', (0, option_1.getOptionValue)('except'), onlyExceptTargets);
     if (enrichedExceptOpts.length > 0) {
         return enrichedExceptOpts;
     }
     return [];
 }
 function validatePorts() {
-    const customHttpPort = (0, option_1.getOptionValue)('http', false);
-    const enrichedDebugOpts = enrichOptsData('debug', (0, option_1.getOptionValue)('debug'), Object.keys(constants_1.DEFAULT.serve_port.debug));
+    const customHttpPort = enrichOptsData('debug', (0, option_1.getOptionValue)('debug'), portTargets);
+    const enrichedDebugOpts = enrichOptsData('debug', (0, option_1.getOptionValue)('debug'), portTargets);
     if (enrichedDebugOpts.some((opt) => {
         const noFilter = !opt.hasFilter;
-        if (opt.target === 'client') {
+        if (opt.target.target === 'client') {
             throw new error_1.default('Client cannot be debugged', {
                 exit: 1,
                 errorId: 'OPT-FILTER-5'
@@ -144,8 +159,8 @@ function validatePorts() {
             arg: [
                 (0, ansi_colors_1.bold)('--debug'),
                 ansi_colors_1.italic.red('--debug <target>'),
-                (0, ansi_colors_1.bold)('* basicio: ') + ansi_colors_1.italic.green('--debug basicio:<port>'),
-                (0, ansi_colors_1.bold)('* advancedio: ') + ansi_colors_1.italic.green('--debug advancedio:<name>:<port>')
+                (0, ansi_colors_1.bold)('* basicio: ') + ansi_colors_1.italic.green('--debug <basicio|bio>:<port>'),
+                (0, ansi_colors_1.bold)('* advancedio: ') + ansi_colors_1.italic.green('--debug <advancedio|aio>:<name>:<port>')
             ]
         });
     }
@@ -158,19 +173,19 @@ function filterPorts() {
     const validOptResultants = validatePorts();
     runtime_store_1.default.set(`context.port.http.master`, validOptResultants.port);
     validOptResultants.debug.forEach((res) => {
-        if (res.target === constants_1.REMOTE_REF.functions.type[constants_1.FN_TYPE.advanced] && !res.specific) {
+        if (res.target.target === constants_1.REMOTE_REF.functions.type[constants_1.FN_TYPE.advanced] && !res.specific) {
             throw new error_1.default('Invalid input format for advancedio target', {
                 exit: 1,
                 errorId: 'OPT-FILTER-7',
                 arg: [
                     (0, ansi_colors_1.bold)('--debug'),
                     (0, ansi_colors_1.bold)('advancedio'),
-                    ansi_colors_1.italic.red('--debug advancedio:<name|port>'),
-                    ansi_colors_1.italic.green('--debug advancedio:<name>:<port>')
+                    ansi_colors_1.italic.red('--debug <advancedio|aio>:<name|port>'),
+                    ansi_colors_1.italic.green('--debug <advancedio|aio>:<name>:<port>')
                 ]
             });
         }
-        else if (res.target === constants_1.REMOTE_REF.functions.type[constants_1.FN_TYPE.basic]) {
+        else if (res.target.target === constants_1.REMOTE_REF.functions.type[constants_1.FN_TYPE.basic]) {
             runtime_store_1.default.set(`context.port.debug.${res.target}`, res.filter);
         }
         else {
@@ -182,10 +197,13 @@ exports.filterPorts = filterPorts;
 function filterTargets(pathSense = true) {
     const validTargetResultants = validateTargets();
     const config = runtime_store_1.default.get('config');
-    let targets = validGlobalTargets.filter((t) => config.has(t));
+    let targets = onlyExceptTargets.filter((t) => config.has(t.target)).map((t) => t.target);
     if (validTargetResultants.length === 0) {
         if (runtime_store_1.default.get('project.root') !== runtime_store_1.default.get('cwd')) {
             targets = targets.filter((target) => {
+                if (target === 'appsail') {
+                    return true;
+                }
                 if (target === 'apig' && (0, option_1.getCurrentCommand)() === 'serve') {
                     return true;
                 }
@@ -200,18 +218,19 @@ function filterTargets(pathSense = true) {
     }
     else if ((0, option_1.getOptionValue)('only', false)) {
         targets = validTargetResultants.map((resultant) => {
-            return resultant.target;
+            return resultant.target.target;
         });
     }
     else if ((0, option_1.getOptionValue)('except', false)) {
         const unwantedTargets = validTargetResultants
             .filter((val) => {
-            if (val.target === 'functions' && val.hasFilter) {
+            if ((val.target.target === 'functions' || val.target.target === 'appsail') &&
+                val.hasFilter) {
                 return false;
             }
             return true;
         })
-            .map((resultant) => resultant.target);
+            .map((resultant) => resultant.target.target);
         targets = targets.filter((target) => !unwantedTargets.includes(target));
     }
     targets = js_1.JS.uniq(targets);

package/lib/prompt/index.js

@@ -63,6 +63,11 @@ exports.default = {
                 const filePathExt = yield Promise.resolve().then(() => __importStar(require('./types/file-path')));
                 inquirer_1.default.registerPrompt('file-path', filePathExt.default);
                 break;
+            case 'tree': {
+                const treeExt = yield Promise.resolve().then(() => __importStar(require('./types/tree')));
+                inquirer_1.default.registerPrompt('tree', treeExt.default);
+                break;
+            }
             default:
                 throw new error_1.default('No such type registered', { exit: 2 });
         }

package/lib/prompt/types/file-path.js

@@ -19,7 +19,10 @@ const fs_1 = require("../../util_modules/fs");
 const ansi_colors_1 = require("ansi-colors");
 function getPaths(rootPath, pattern, exclude, defaultItem) {
     return __awaiter(this, void 0, void 0, function* () {
-        const nodeList = yield fs_1.ASYNC.walk(rootPath, { filter: { exclude, excludeDir: false } });
+        const nodeList = yield fs_1.ASYNC.walk(rootPath, {
+            filter: { exclude, excludeDir: false },
+            includeDirPaths: true
+        });
         const filteredNodes = fuzzy_1.default.filter(pattern || '', nodeList).map((e) => e.string);
         if (!pattern && defaultItem) {
             filteredNodes.unshift(defaultItem);

package/lib/prompt/types/tree.js

@@ -0,0 +1,297 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _TreeNode_instances, _TreeNode_constructNodes;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeNode = void 0;
+const ansi_colors_1 = require("ansi-colors");
+const cli_cursor_1 = __importDefault(require("cli-cursor"));
+const base_js_1 = __importDefault(require("inquirer/lib/prompts/base.js"));
+const events_js_1 = __importDefault(require("inquirer/lib/utils/events.js"));
+const paginator_js_1 = __importDefault(require("inquirer/lib/utils/paginator.js"));
+const figures = {
+    arrowRight: '→',
+    arrowDown: '↓'
+};
+var ETreeState;
+(function (ETreeState) {
+    ETreeState[ETreeState["OPEN"] = 1] = "OPEN";
+    ETreeState[ETreeState["CLOSED"] = 2] = "CLOSED";
+    ETreeState[ETreeState["EXPANDED"] = 3] = "EXPANDED";
+})(ETreeState || (ETreeState = {}));
+class TreeNode {
+    constructor(root) {
+        _TreeNode_instances.add(this);
+        this.open = false;
+        this.leaves = [];
+        this.activeIdx = 0;
+        this.prevActiveIdx = -1;
+        this.nodes = [];
+        this.level = 1;
+        this.root = root;
+    }
+    get indent() {
+        return this.level * 2;
+    }
+    addNode(node) {
+        if (node instanceof TreeNode) {
+            this.leaves.push(node);
+        }
+        else {
+            this.leaves.push(Object.assign({ isExpanded: false }, node));
+        }
+        return this;
+    }
+    buildTree({ paginator, force = false } = {}) {
+        if (this.nodes.length === 0 || force) {
+            __classPrivateFieldGet(this, _TreeNode_instances, "m", _TreeNode_constructNodes).call(this);
+        }
+        if (this.prevActiveIdx >= 0) {
+            this.nodes[this.prevActiveIdx] = (0, ansi_colors_1.stripColor)(this.nodes[this.prevActiveIdx]);
+        }
+        const activeNodeArr = this.nodes[this.activeIdx].split('\n');
+        this.nodes[this.activeIdx] =
+            (0, ansi_colors_1.cyan)((0, ansi_colors_1.stripColor)(activeNodeArr.shift() || '')) +
+                (activeNodeArr.length > 0 ? '\n' + activeNodeArr.join('\n') : '');
+        return paginator
+            ? paginator.paginate(this.nodes.join('\n'), this.activeIdx, 3)
+            : this.nodes.join('\n');
+    }
+    expandNode(display, expand) {
+        const lineLength = process.stdout.columns -
+            (display.length % (process.stdout.columns - this.indent)) -
+            this.indent;
+        return (this.wrapLine('- ' + display, this.indent - 2) +
+            ' '.repeat(lineLength) +
+            this.wrapLine(expand, this.indent + 2));
+    }
+    openTree(strict = false) {
+        const activeLeaf = this.leaves[this.activeIdx];
+        if (!(activeLeaf instanceof TreeNode)) {
+            if (!activeLeaf.expand || strict) {
+                return ETreeState.CLOSED;
+            }
+            this.nodes[this.activeIdx] = this.expandNode(activeLeaf.display, activeLeaf.expand);
+            activeLeaf.isExpanded = true;
+            return ETreeState.EXPANDED;
+        }
+        if (activeLeaf.leaves.length === 0) {
+            throw new Error('No leaves');
+        }
+        if (activeLeaf.open) {
+            const state = activeLeaf.openTree();
+            if (state === ETreeState.EXPANDED) {
+                const activeNode = this.nodes[this.activeIdx].split('\n')[0];
+                const subTree = activeLeaf.buildTree();
+                this.nodes[this.activeIdx] = activeNode + '\n' + subTree;
+                return state;
+            }
+            else if (state === ETreeState.CLOSED) {
+                return state;
+            }
+        }
+        const activeNode = this.nodes[this.activeIdx]
+            .split('\n')[0]
+            .replace(figures.arrowRight, figures.arrowDown);
+        activeLeaf.level = this.level + 1;
+        const subTree = activeLeaf.buildTree();
+        this.nodes[this.activeIdx] = activeNode + '\n' + subTree;
+        activeLeaf.open = true;
+        return ETreeState.OPEN;
+    }
+    closeTree() {
+        const activeLeaf = this.leaves[this.activeIdx];
+        if (!(activeLeaf instanceof TreeNode) || !activeLeaf.open) {
+            return;
+        }
+        const subActive = activeLeaf.leaves[activeLeaf.activeIdx];
+        if (subActive instanceof TreeNode && subActive.open) {
+            activeLeaf.closeTree();
+            this.nodes[this.activeIdx] = this.nodes[this.activeIdx].replace(/\n{1}[\s\S]*/m, '\n' + activeLeaf.buildTree({ force: true }));
+            return;
+        }
+        else if (!(subActive instanceof TreeNode) && subActive.expand && subActive.isExpanded) {
+            activeLeaf.nodes[activeLeaf.activeIdx] = this.wrapLine('+ ' + subActive.display, activeLeaf.indent - 2);
+            this.nodes[this.activeIdx] =
+                this.nodes[this.activeIdx].split('\n')[0] + '\n' + activeLeaf.buildTree();
+            subActive.isExpanded = false;
+            return;
+        }
+        this.nodes[this.activeIdx] = this.nodes[this.activeIdx]
+            .replace(figures.arrowDown, figures.arrowRight)
+            .replace(/\n{1}[\s\S]*/m, '');
+        activeLeaf.open = false;
+    }
+    moveActive(distance = 0) {
+        const activeLeaf = this.leaves[this.activeIdx];
+        if (activeLeaf instanceof TreeNode && activeLeaf.open) {
+            activeLeaf.moveActive(distance);
+            const subTree = activeLeaf.buildTree();
+            this.nodes[this.activeIdx] =
+                this.wrapLine(figures.arrowDown + ' ' + activeLeaf.root, this.indent - 2) +
+                    '\n' +
+                    subTree;
+            return;
+        }
+        const effectiveIndex = this.activeIdx + distance;
+        if (effectiveIndex === -1 && this.leaves.length > 1) {
+            this.prevActiveIdx = 0;
+            this.activeIdx = this.leaves.length - 1;
+            return;
+        }
+        else if (effectiveIndex === this.leaves.length && this.leaves.length > 1) {
+            this.prevActiveIdx = this.leaves.length - 1;
+            this.activeIdx = 0;
+            return;
+        }
+        else if (effectiveIndex <= -1 || effectiveIndex >= this.leaves.length) {
+            return;
+        }
+        this.prevActiveIdx = this.activeIdx;
+        this.activeIdx = effectiveIndex;
+    }
+    getValue() {
+        const activeLeaf = this.leaves[this.activeIdx];
+        if (activeLeaf instanceof TreeNode) {
+            return activeLeaf.getValue();
+        }
+        return activeLeaf;
+    }
+    wrapLine(line, indent) {
+        if (line.length <= process.stdout.columns - indent) {
+            return ' '.repeat(indent) + line;
+        }
+        const splitLine = line.slice(0, process.stdout.columns - indent);
+        return (' '.repeat(indent) +
+            splitLine +
+            this.wrapLine(line.slice(process.stdout.columns - (indent + 1)).trimStart(), indent));
+    }
+}
+exports.TreeNode = TreeNode;
+_TreeNode_instances = new WeakSet(), _TreeNode_constructNodes = function _TreeNode_constructNodes() {
+    const nodes = this.leaves.map((leaf) => {
+        if (leaf instanceof TreeNode) {
+            const rootNode = this.wrapLine((leaf.open ? figures.arrowDown : figures.arrowRight) + ' ' + leaf.root, this.indent - 2);
+            const subNodes = leaf.open ? '\n' + leaf.nodes.join('\n') : '';
+            return rootNode + subNodes;
+        }
+        if (leaf.expand) {
+            return this.wrapLine('+ ' + leaf.display, this.indent - 2);
+        }
+        return this.wrapLine(leaf.display, this.indent);
+    });
+    this.nodes = nodes;
+};
+class InquirerTree extends base_js_1.default {
+    constructor(question, rl, answers) {
+        const questionBase = {
+            name: question.name,
+            message: question.message
+        };
+        super(questionBase, rl, answers);
+        this.treeOpts = {
+            pageSize: 10,
+            multiple: false,
+            loop: true
+        };
+        this.message = question.message;
+        this.choices = new TreeNode();
+        question.treeChoices.forEach((choice) => this.choices.addNode(choice));
+        this.done = () => undefined;
+        this.opt.default = null;
+        this.paginator = new paginator_js_1.default(this.screen, { isInfinite: this.treeOpts.loop !== false });
+    }
+    _run(callback) {
+        this.done = callback;
+        cli_cursor_1.default.hide();
+        this.bindKeyEvents();
+        this.render();
+        return this;
+    }
+    bindKeyEvents() {
+        const events = (0, events_js_1.default)(this.rl);
+        events.normalizedDownKey.subscribe(() => {
+            try {
+                this.choices.moveActive(1);
+                this.render();
+            }
+            catch (er) {
+                this.render({ error: er });
+            }
+        });
+        events.normalizedUpKey.subscribe(() => {
+            try {
+                this.choices.moveActive(-1);
+                this.render();
+            }
+            catch (er) {
+                this.render({ error: er });
+            }
+        });
+        events.line.subscribe(() => {
+            try {
+                const treeState = this.choices.openTree(true);
+                if (treeState === ETreeState.OPEN) {
+                    this.render();
+                    return;
+                }
+                const answer = this.choices.getValue();
+                this.render({ answer });
+                this.screen.done();
+                cli_cursor_1.default.show();
+                if (this.done) {
+                    this.done(answer.value);
+                }
+            }
+            catch (er) {
+                this.render({ error: er });
+            }
+        });
+        events.keypress.subscribe((event) => {
+            try {
+                switch (event.key.name) {
+                    case 'right': {
+                        this.choices.openTree();
+                        break;
+                    }
+                    case 'left': {
+                        this.choices.closeTree();
+                        break;
+                    }
+                    default: {
+                        return;
+                    }
+                }
+                return this.render();
+            }
+            catch (er) {
+                this.render({ error: er });
+            }
+        });
+    }
+    constructTree() {
+        this.choices.buildTree();
+    }
+    render({ answer, error } = {}) {
+        let message = (0, ansi_colors_1.bold)(this.message);
+        if (answer) {
+            message += ` ${(0, ansi_colors_1.cyan)(answer.short)}`;
+        }
+        else {
+            message += (0, ansi_colors_1.dim)(` (Use arrow keys to navigate and enter to select)`);
+            message += '\n' + this.choices.buildTree();
+        }
+        let bottomContent = '';
+        if (error) {
+            bottomContent = '\n' + (0, ansi_colors_1.red)('>> ') + (error instanceof Error ? error.message : error);
+        }
+        this.screen.render(message, bottomContent);
+    }
+}
+exports.default = InquirerTree;