@tsed/cli-prompts 7.0.0-beta.11

package/lib/esm/PromptRunner.js

@@ -0,0 +1,29 @@
+import { injectable } from "@tsed/di";
+import * as fn from "./fn/index.js";
+import { normalizeQuestion } from "./utils/normalizeQuestion.js";
+import { shouldAsk } from "./utils/shouldAsk.js";
+export class PromptRunner {
+    async run(questions, initialAnswers = {}) {
+        const queue = [].concat(questions ?? []).filter(Boolean);
+        const answers = { ...initialAnswers };
+        const collected = {};
+        for (const question of queue) {
+            if (!(await shouldAsk(question, answers))) {
+                continue;
+            }
+            const normalized = await normalizeQuestion(question, answers);
+            const response = await this.prompt(normalized, answers);
+            answers[question.name] = response;
+            collected[question.name] = response;
+        }
+        return collected;
+    }
+    async prompt(question, answers) {
+        const type = question.type;
+        if (!fn[type]) {
+            throw new Error(`Unsupported prompt type: ${type}`);
+        }
+        return fn[type](question, answers);
+    }
+}
+injectable(PromptRunner);

package/lib/esm/errors/PromptCancelledError.js

@@ -0,0 +1,6 @@
+export class PromptCancelledError extends Error {
+    constructor(message = "Prompt cancelled") {
+        super(message);
+        this.name = "PromptCancelledError";
+    }
+}

package/lib/esm/fn/autocomplete.js

@@ -0,0 +1,60 @@
+import { select, text } from "@clack/prompts";
+import { ensureNotCancelled } from "../utils/ensureNotCancelled.js";
+import { normalizeChoices } from "../utils/normalizeChoices.js";
+import { CONTINUE, processPrompt } from "../utils/processPrompt.js";
+import { resolveListDefault } from "../utils/resolveListDefault.js";
+const SEARCH_ACTION = "__tsed_cli_search_again__";
+export async function autocomplete(question, answers) {
+    if (!question.source) {
+        throw new Error(`Question "${question.name}" must provide a source for autocomplete prompts.`);
+    }
+    let keyword = "";
+    let choices = await resolveAutocompleteChoices(question.source, answers, keyword);
+    async function display() {
+        keyword = await promptKeyword(question.message, keyword, true);
+        choices = await resolveAutocompleteChoices(question.source, answers, keyword);
+    }
+    return processPrompt(question, answers, async () => {
+        if (!choices.length) {
+            await display();
+            return CONTINUE;
+        }
+        const selection = await select({
+            message: buildAutocompleteMessage(question.message, keyword),
+            options: [
+                ...choices.map((choice) => ({
+                    label: choice.label,
+                    value: choice.value,
+                    hint: choice.hint
+                })),
+                {
+                    label: "🔍 Search again",
+                    value: SEARCH_ACTION,
+                    hint: "Type another keyword"
+                }
+            ],
+            initialValue: resolveListDefault(question, choices),
+            maxItems: question.pageSize
+        });
+        if (selection === SEARCH_ACTION) {
+            await display();
+            return CONTINUE;
+        }
+        return selection;
+    });
+}
+async function resolveAutocompleteChoices(source, answers, keyword) {
+    const items = await source(answers, keyword);
+    return normalizeChoices(items);
+}
+async function promptKeyword(message, keyword, emptyState) {
+    const label = emptyState ? `${message} (no matches, type to search)` : `${message} (type to refine search)`;
+    const result = await text({
+        message: label,
+        initialValue: keyword
+    });
+    return ensureNotCancelled(result).trim();
+}
+function buildAutocompleteMessage(message, keyword) {
+    return keyword ? `${message} (filter: ${keyword})` : message;
+}

package/lib/esm/fn/checkbox.js

@@ -0,0 +1,28 @@
+import { multiselect } from "@clack/prompts";
+import { isArray } from "@tsed/core/utils/isArray";
+import { processPrompt } from "../utils/processPrompt.js";
+export async function checkbox(question, answers) {
+    if (!question.choices?.length) {
+        throw new Error(`Question "${question.name}" does not provide any choices`);
+    }
+    const initialValues = resolveCheckboxDefaults(question, question.choices);
+    return processPrompt(question, answers, () => multiselect({
+        message: question.message,
+        options: question.choices.map((choice) => ({
+            label: choice.label,
+            value: choice.value,
+            hint: choice.hint
+        })),
+        initialValues
+    }));
+}
+function resolveCheckboxDefaults(question, choices) {
+    if (isArray(question.default)) {
+        return question.default;
+    }
+    if (question.default !== undefined) {
+        return [question.default];
+    }
+    const checkedValues = choices.filter((choice) => choice.checked).map((choice) => choice.value);
+    return checkedValues.length ? checkedValues : [];
+}

package/lib/esm/fn/confirm.js

@@ -0,0 +1,10 @@
+import { confirm as c } from "@clack/prompts";
+import { isBoolean } from "@tsed/core/utils/isBoolean.js";
+import { processPrompt } from "../utils/processPrompt.js";
+export async function confirm(question, answers) {
+    const initialValue = isBoolean(question.default) ? question.default : undefined;
+    return processPrompt(question, answers, () => c({
+        message: question.message,
+        initialValue
+    }));
+}

package/lib/esm/fn/index.js

@@ -0,0 +1,6 @@
+export { autocomplete } from "./autocomplete.js";
+export { checkbox } from "./checkbox.js";
+export { confirm } from "./confirm.js";
+export { input } from "./input.js";
+export { list } from "./list.js";
+export { password } from "./password.js";

package/lib/esm/fn/input.js

@@ -0,0 +1,8 @@
+import { text } from "@clack/prompts";
+import { processPrompt } from "../utils/processPrompt.js";
+export async function input(question, answers) {
+    return processPrompt(question, answers, () => text({
+        message: question.message,
+        initialValue: String(question.default ?? "")
+    }));
+}

package/lib/esm/fn/list.js

@@ -0,0 +1,18 @@
+import { select } from "@clack/prompts";
+import { processPrompt } from "../utils/processPrompt.js";
+import { resolveListDefault } from "../utils/resolveListDefault.js";
+export async function list(question, answers) {
+    if (!question.choices?.length) {
+        throw new Error(`Question "${question.name}" does not provide any choices`);
+    }
+    return processPrompt(question, answers, () => select({
+        message: question.message,
+        options: question.choices.map((choice) => ({
+            label: choice.label,
+            value: choice.value,
+            hint: choice.hint
+        })),
+        initialValue: resolveListDefault(question, question.choices),
+        maxItems: question.pageSize
+    }));
+}

package/lib/esm/fn/password.js

@@ -0,0 +1,8 @@
+import { password as clackPassword } from "@clack/prompts";
+import { processPrompt } from "../utils/processPrompt.js";
+export async function password(question, answers) {
+    return processPrompt(question, answers, () => clackPassword({
+        message: question.message,
+        mask: question.mask === false ? undefined : String(question.mask || "•")
+    }));
+}

package/lib/esm/index.js

@@ -0,0 +1,3 @@
+export * from "./errors/PromptCancelledError.js";
+export * from "./interfaces/PromptQuestion.js";
+export * from "./PromptRunner.js";

package/lib/esm/interfaces/NormalizedPromptQuestion.js

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

package/lib/esm/interfaces/PromptQuestion.js

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

package/lib/esm/utils/applyTransforms.js

@@ -0,0 +1,10 @@
+export async function applyTransforms(question, answers, value) {
+    let next = value;
+    if (question.transformer) {
+        next = await question.transformer(next, answers, { isFinal: true });
+    }
+    if (question.filter) {
+        next = await question.filter(next, answers);
+    }
+    return next;
+}

package/lib/esm/utils/ensureNotCancelled.js

@@ -0,0 +1,9 @@
+import { cancel as cancelPrompt, isCancel } from "@clack/prompts";
+import { PromptCancelledError } from "../errors/PromptCancelledError.js";
+export function ensureNotCancelled(value) {
+    if (isCancel(value)) {
+        cancelPrompt();
+        throw new PromptCancelledError();
+    }
+    return value;
+}

package/lib/esm/utils/getValidationError.js

@@ -0,0 +1,14 @@
+import { isString } from "@tsed/core";
+export async function getValidationError(question, answers, value) {
+    if (!question.validate) {
+        return undefined;
+    }
+    const result = await question.validate(value, answers);
+    if (result === false) {
+        return "Invalid value.";
+    }
+    if (isString(result)) {
+        return result;
+    }
+    return undefined;
+}

package/lib/esm/utils/normalizeChoices.js

@@ -0,0 +1,17 @@
+export function normalizeChoices(inputs = []) {
+    return inputs.map((choice) => {
+        if (typeof choice === "object" && choice !== null && "value" in choice) {
+            const resolvedValue = choice.value ?? choice.name;
+            return {
+                label: choice.name ?? String(resolvedValue ?? ""),
+                value: resolvedValue,
+                hint: choice.short,
+                checked: choice.checked
+            };
+        }
+        return {
+            label: String(choice),
+            value: choice
+        };
+    });
+}

package/lib/esm/utils/normalizeQuestion.js

@@ -0,0 +1,23 @@
+import { normalizeChoices } from "./normalizeChoices.js";
+import { resolveMaybe } from "./resolveMaybe.js";
+export async function normalizeQuestion(question, answers) {
+    const normalized = {
+        ...question,
+        name: question.name,
+        type: question.type,
+        message: await resolveMaybe(question.message, answers)
+    };
+    if ("default" in question && question.default !== undefined) {
+        normalized.default = await resolveMaybe(question.default, answers);
+    }
+    if ("choices" in question && question.choices?.length) {
+        normalized.choices = normalizeChoices([...question.choices]);
+    }
+    if ("source" in question && question.source) {
+        const source = question.source;
+        normalized.source = (state, keyword) => {
+            return source({ ...answers, ...state }, keyword);
+        };
+    }
+    return normalized;
+}

package/lib/esm/utils/processPrompt.js

@@ -0,0 +1,20 @@
+import { note } from "@clack/prompts";
+import { applyTransforms } from "./applyTransforms.js";
+import { ensureNotCancelled } from "./ensureNotCancelled.js";
+import { getValidationError } from "./getValidationError.js";
+export const CONTINUE = Symbol.for("prompt:continue");
+export async function processPrompt(question, answers, cb) {
+    while (true) {
+        const result = await cb();
+        if (result === CONTINUE) {
+            continue;
+        }
+        const value = ensureNotCancelled(result);
+        const transformed = await applyTransforms(question, answers, value);
+        const error = await getValidationError(question, answers, transformed);
+        if (!error) {
+            return transformed;
+        }
+        note(error, "Validation error");
+    }
+}

package/lib/esm/utils/resolveListDefault.js

@@ -0,0 +1,13 @@
+export function resolveListDefault(question, choices) {
+    if (question.default !== undefined) {
+        if (typeof question.default === "number") {
+            return choices[question.default]?.value ?? choices[0]?.value;
+        }
+        return question.default;
+    }
+    const checked = choices.find((choice) => choice.checked);
+    if (checked) {
+        return checked.value;
+    }
+    return choices[0]?.value;
+}

package/lib/esm/utils/resolveMaybe.js

@@ -0,0 +1,6 @@
+export function resolveMaybe(value, answers) {
+    if (typeof value === "function") {
+        return value(answers);
+    }
+    return value;
+}

package/lib/esm/utils/shouldAsk.js

@@ -0,0 +1,9 @@
+export async function shouldAsk(question, answers) {
+    if (question.when === undefined) {
+        return true;
+    }
+    if (typeof question.when === "function") {
+        return !!(await question.when(answers));
+    }
+    return question.when;
+}