create-bcp-app 0.1.12 → 0.1.13

package/bin/create-bcp-app.mjs

@@ -2,8 +2,8 @@
 
 import path from "node:path";
 import {
-    createInterface,
-} from "node:readline/promises";
+    emitKeypressEvents,
+} from "node:readline";
 import {
     stdin as input,
     stdout as output,
@@ -19,11 +19,16 @@ import {
     normalizeDatabase,
 } from "../src/project-options.mjs";
 
+const ANSI = {
+    reset: "\u001B[0m",
+    selected: "\u001B[46m\u001B[30m\u001B[1m",
+    muted: "\u001B[2m",
+};
+
 await main();
 
 async function main() {
-    const args =
-        process.argv.slice(2);
+    const args = process.argv.slice(2);
 
     if (
         args.includes("--help") ||
@@ -36,35 +41,20 @@ async function main() {
     let parsed;
 
     try {
-        parsed =
-            parseArguments(
-                args
-            );
+        parsed = parseArguments(args);
     } catch (error) {
-        reportError(
-            error
-        );
+        reportError(error);
         return;
     }
 
     if (!parsed.projectDirectory) {
         printHelp();
-        process.exitCode =
-            1;
+        process.exitCode = 1;
         return;
     }
 
-    let prompt =
-        null;
-
     try {
-        const resolved =
-            await resolveOptions(
-                parsed
-            );
-
-        prompt =
-            resolved.prompt;
+        const resolved = await resolveOptions(parsed);
 
         console.log("");
         console.log(
@@ -74,68 +64,40 @@ async function main() {
         );
         console.log("");
 
-        const result =
-            await createBcpApp({
-                projectDirectory:
-                    parsed.projectDirectory,
-                install:
-                    parsed.install,
-                bcpPackage:
-                    parsed.bcpPackage,
-                tailwind:
-                    resolved.tailwind,
-                database:
-                    resolved.database,
-                auth:
-                    resolved.auth,
-                packageManager:
-                    "npm",
-            });
-
-        printSuccess(
-            result,
-            parsed.install
-        );
+        const result = await createBcpApp({
+            projectDirectory: parsed.projectDirectory,
+            install: parsed.install,
+            bcpPackage: parsed.bcpPackage,
+            tailwind: resolved.tailwind,
+            database: resolved.database,
+            auth: resolved.auth,
+            packageManager: "npm",
+        });
+
+        printSuccess(result, parsed.install);
     } catch (error) {
-        reportError(
-            error
-        );
-    } finally {
-        prompt?.close();
+        reportError(error);
     }
 }
 
-function parseArguments(
-    args
-) {
-    let projectDirectory =
-        null;
-    let install =
-        true;
-    let bcpPackage =
-        undefined;
-    let tailwind =
-        undefined;
-    let database =
-        undefined;
-    let auth =
-        undefined;
-    let acceptDefaults =
-        false;
+function parseArguments(args) {
+    let projectDirectory = null;
+    let install = true;
+    let bcpPackage = undefined;
+    let tailwind = undefined;
+    let database = undefined;
+    let auth = undefined;
+    let acceptDefaults = false;
 
     for (
         let index = 0;
         index < args.length;
         index++
     ) {
-        const value =
-            args[index];
+        const value = args[index];
 
-        if (
-            value === "--no-install"
-        ) {
-            install =
-                false;
+        if (value === "--no-install") {
+            install = false;
             continue;
         }
 
@@ -143,34 +105,22 @@ function parseArguments(
             value === "--yes" ||
             value === "-y"
         ) {
-            acceptDefaults =
-                true;
+            acceptDefaults = true;
             continue;
         }
 
-        if (
-            value === "--tailwind"
-        ) {
-            tailwind =
-                true;
+        if (value === "--tailwind") {
+            tailwind = true;
             continue;
         }
 
-        if (
-            value === "--no-tailwind"
-        ) {
-            tailwind =
-                false;
+        if (value === "--no-tailwind") {
+            tailwind = false;
             continue;
         }
 
-        if (
-            value === "--database"
-        ) {
-            const nextValue =
-                args[
-                    index + 1
-                ];
+        if (value === "--database") {
+            const nextValue = args[index + 1];
 
             if (!nextValue) {
                 throw new Error(
@@ -178,21 +128,13 @@ function parseArguments(
                 );
             }
 
-            database =
-                normalizeDatabase(
-                    nextValue
-                );
+            database = normalizeDatabase(nextValue);
             index++;
             continue;
         }
 
-        if (
-            value === "--auth"
-        ) {
-            const nextValue =
-                args[
-                    index + 1
-                ];
+        if (value === "--auth") {
+            const nextValue = args[index + 1];
 
             if (!nextValue) {
                 throw new Error(
@@ -200,21 +142,13 @@ function parseArguments(
                 );
             }
 
-            auth =
-                normalizeAuth(
-                    nextValue
-                );
+            auth = normalizeAuth(nextValue);
             index++;
             continue;
         }
 
-        if (
-            value === "--bcp"
-        ) {
-            const nextValue =
-                args[
-                    index + 1
-                ];
+        if (value === "--bcp") {
+            const nextValue = args[index + 1];
 
             if (!nextValue) {
                 throw new Error(
@@ -222,31 +156,24 @@ function parseArguments(
                 );
             }
 
-            bcpPackage =
-                nextValue;
+            bcpPackage = nextValue;
             index++;
             continue;
         }
 
-        if (
-            value.startsWith("-")
-        ) {
+        if (value.startsWith("-")) {
             throw new Error(
                 `Unknown option: ${value}`
             );
         }
 
-        if (
-            projectDirectory !==
-            null
-        ) {
+        if (projectDirectory !== null) {
             throw new Error(
                 "Only one project directory may be provided."
             );
         }
 
-        projectDirectory =
-            value;
+        projectDirectory = value;
     }
 
     return {
@@ -266,196 +193,79 @@ async function resolveOptions({
     auth: selectedAuth,
     acceptDefaults,
 }) {
-    let tailwind =
-        selectedTailwind;
-    let database =
-        selectedDatabase;
-    let auth =
-        selectedAuth;
+    let tailwind = selectedTailwind;
+    let database = selectedDatabase;
+    let auth = selectedAuth;
 
     if (acceptDefaults) {
         return {
-            tailwind:
-                tailwind ??
-                true,
-            database:
-                normalizeDatabase(
-                    database ??
-                    "none"
-                ),
-            auth:
-                normalizeAuth(
-                    auth ??
-                    "none"
-                ),
-            prompt:
-                null,
+            tailwind: tailwind ?? true,
+            database: normalizeDatabase(
+                database ?? "none"
+            ),
+            auth: normalizeAuth(
+                auth ?? "none"
+            ),
         };
     }
 
-    const interactive =
-        Boolean(
-            input.isTTY &&
-            output.isTTY
-        );
+    const interactive = Boolean(
+        input.isTTY &&
+        output.isTTY
+    );
 
     if (!interactive) {
         return {
-            tailwind:
-                tailwind ??
-                false,
-            database:
-                normalizeDatabase(
-                    database ??
-                    "none"
-                ),
-            auth:
-                normalizeAuth(
-                    auth ??
-                    "none"
-                ),
-            prompt:
-                null,
+            tailwind: tailwind ?? false,
+            database: normalizeDatabase(
+                database ?? "none"
+            ),
+            auth: normalizeAuth(
+                auth ?? "none"
+            ),
         };
     }
 
-    const needsPrompt =
-        tailwind === undefined ||
-        database === undefined ||
-        auth === undefined;
+    console.log("");
+    console.log("Configure your BCP app");
+    console.log("");
 
-    if (!needsPrompt) {
-        return {
-            tailwind:
-                Boolean(
-                    tailwind
-                ),
-            database:
-                normalizeDatabase(
-                    database
-                ),
-            auth:
-                normalizeAuth(
-                    auth
-                ),
-            prompt:
-                null,
-        };
+    if (tailwind === undefined) {
+        tailwind = await askTailwind();
     }
 
-    const prompt =
-        createInterface({
-            input,
-            output,
-        });
-
-    try {
-        console.log("");
-        console.log(
-            "Configure your BCP app"
-        );
-        console.log("");
-
-        if (
-            tailwind ===
-            undefined
-        ) {
-            tailwind =
-                await askYesNo(
-                    prompt,
-                    "Use Tailwind CSS?",
-                    true
-                );
-        }
-
-        if (
-            database ===
-            undefined
-        ) {
-            database =
-                await askDatabase(
-                    prompt
-                );
-        }
+    if (database === undefined) {
+        database = await askDatabase();
+    }
 
-        if (
-            auth ===
-            undefined
-        ) {
-            auth =
-                await askAuth(
-                    prompt
-                );
-        }
-    } catch (error) {
-        prompt.close();
-        throw error;
+    if (auth === undefined) {
+        auth = await askAuth();
     }
 
     return {
-        tailwind:
-            Boolean(
-                tailwind
-            ),
-        database:
-            normalizeDatabase(
-                database
-            ),
-        auth:
-            normalizeAuth(
-                auth
-            ),
-        prompt,
+        tailwind: Boolean(tailwind),
+        database: normalizeDatabase(database),
+        auth: normalizeAuth(auth),
     };
 }
 
-async function askYesNo(
-    prompt,
-    label,
-    defaultValue
-) {
-    const suffix =
-        defaultValue
-            ? " (Y/n) "
-            : " (y/N) ";
-
-    while (true) {
-        const answer =
-            (
-                await prompt.question(
-                    `${label}${suffix}`
-                )
-            )
-                .trim()
-                .toLowerCase();
-
-        if (!answer) {
-            return defaultValue;
-        }
-
-        if (
-            answer === "y" ||
-            answer === "yes"
-        ) {
-            return true;
-        }
-
-        if (
-            answer === "n" ||
-            answer === "no"
-        ) {
-            return false;
-        }
-
-        console.log(
-            "Please answer yes or no."
-        );
-    }
+function askTailwind() {
+    return askTerminalSelect(
+        "Use Tailwind CSS?",
+        [
+            {
+                value: true,
+                label: "Yes",
+            },
+            {
+                value: false,
+                label: "No",
+            },
+        ]
+    );
 }
 
-async function askDatabase(
-    prompt
-) {
+function askDatabase() {
     const labels = {
         none: "None",
         mysql: "MySQL",
@@ -464,130 +274,201 @@ async function askDatabase(
         mongodb: "MongoDB",
     };
 
-    console.log(
-        "Select a database:"
-    );
-
-    DATABASE_CHOICES.forEach(
-        (
-            value,
-            index
-        ) => {
-            console.log(
-                `  ${index + 1}) ${labels[value]}`
-            );
-        }
+    return askTerminalSelect(
+        "Select a database:",
+        DATABASE_CHOICES.map(
+            (value) => ({
+                value,
+                label: labels[value],
+            })
+        )
     );
-
-    while (true) {
-        const answer =
-            (
-                await prompt.question(
-                    "Database (1): "
-                )
-            ).trim();
-
-        if (!answer) {
-            return "none";
-        }
-
-        const choice =
-            DATABASE_CHOICES[
-                Number(answer) - 1
-            ];
-
-        if (choice) {
-            return choice;
-        }
-
-        const normalized =
-            answer.toLowerCase();
-
-        if (
-            DATABASE_CHOICES.includes(
-                normalized
-            )
-        ) {
-            return normalized;
-        }
-
-        console.log(
-            "Choose a number from the list or enter a database name."
-        );
-    }
 }
 
-async function askAuth(
-    prompt
-) {
+function askAuth() {
     const labels = {
         none: "None",
-        "jwt-cookie":
-            "JWT Cookie",
+        "jwt-cookie": "JWT Cookie",
     };
 
-    console.log(
-        "Select authentication:"
+    return askTerminalSelect(
+        "Select authentication:",
+        AUTH_CHOICES.map(
+            (value) => ({
+                value,
+                label: labels[value],
+            })
+        )
     );
+}
 
-    AUTH_CHOICES.forEach(
+function askTerminalSelect(
+    label,
+    choices
+) {
+    if (
+        !Array.isArray(choices) ||
+        choices.length === 0
+    ) {
+        return Promise.reject(
+            new Error(
+                "Interactive selection requires at least one choice."
+            )
+        );
+    }
+
+    if (
+        typeof input.setRawMode !== "function"
+    ) {
+        return Promise.resolve(
+            choices[0].value
+        );
+    }
+
+    return new Promise(
         (
-            value,
-            index
+            resolve,
+            reject
         ) => {
+            let selectedIndex = 0;
+            const previousRawMode =
+                input.isRaw === true;
+
+            const render = (
+                redraw = false
+            ) => {
+                if (redraw) {
+                    output.write(
+                        `\u001B[${choices.length}A`
+                    );
+                }
+
+                for (
+                    let index = 0;
+                    index < choices.length;
+                    index++
+                ) {
+                    const choice = choices[index];
+                    const selected =
+                        index === selectedIndex;
+
+                    output.write(
+                        "\u001B[2K\r"
+                    );
+
+                    if (selected) {
+                        output.write(
+                            `${ANSI.selected} > ${choice.label} ${ANSI.reset}\n`
+                        );
+                    } else {
+                        output.write(
+                            `   ${choice.label}\n`
+                        );
+                    }
+                }
+            };
+
+            const cleanup = () => {
+                input.removeListener(
+                    "keypress",
+                    onKeypress
+                );
+                input.setRawMode(
+                    previousRawMode
+                );
+
+                if (!previousRawMode) {
+                    input.pause();
+                }
+            };
+
+            const onKeypress = (
+                _character,
+                key = {}
+            ) => {
+                if (
+                    key.ctrl &&
+                    key.name === "c"
+                ) {
+                    cleanup();
+                    output.write("\n");
+                    reject(
+                        new Error(
+                            "Setup cancelled."
+                        )
+                    );
+                    return;
+                }
+
+                if (
+                    key.name === "escape"
+                ) {
+                    cleanup();
+                    output.write("\n");
+                    reject(
+                        new Error(
+                            "Setup cancelled."
+                        )
+                    );
+                    return;
+                }
+
+                if (key.name === "up") {
+                    selectedIndex = (
+                        selectedIndex - 1 +
+                        choices.length
+                    ) % choices.length;
+                    render(true);
+                    return;
+                }
+
+                if (key.name === "down") {
+                    selectedIndex = (
+                        selectedIndex + 1
+                    ) % choices.length;
+                    render(true);
+                    return;
+                }
+
+                if (
+                    key.name === "return" ||
+                    key.name === "enter"
+                ) {
+                    const selected =
+                        choices[selectedIndex];
+
+                    cleanup();
+                    output.write("\n");
+                    resolve(selected.value);
+                }
+            };
+
+            console.log(label);
             console.log(
-                `  ${index + 1}) ${labels[value]}`
+                `${ANSI.muted}Use ↑/↓ to move, Enter to select.${ANSI.reset}`
             );
-        }
-    );
-
-    while (true) {
-        const answer =
-            (
-                await prompt.question(
-                    "Authentication (1): "
-                )
-            ).trim();
-
-        if (!answer) {
-            return "none";
-        }
 
-        const choice =
-            AUTH_CHOICES[
-                Number(answer) - 1
-            ];
+            emitKeypressEvents(input);
+            input.on(
+                "keypress",
+                onKeypress
+            );
+            input.setRawMode(true);
+            input.resume();
 
-        if (choice) {
-            return choice;
+            render();
         }
-
-        const normalized =
-            answer.toLowerCase();
-
-        if (
-            AUTH_CHOICES.includes(
-                normalized
-            )
-        ) {
-            return normalized;
-        }
-
-        console.log(
-            "Choose a number from the list or enter an authentication preset name."
-        );
-    }
+    );
 }
 
 function printSuccess(
     result,
     installed
 ) {
-    const relative =
-        path.relative(
-            process.cwd(),
-            result.targetDirectory
-        ) || ".";
+    const relative = path.relative(
+        process.cwd(),
+        result.targetDirectory
+    ) || ".";
 
     console.log("");
     console.log(
@@ -606,28 +487,20 @@ function printSuccess(
         `Authentication: ${formatAuthName(result.auth)}`
     );
     console.log("");
-    console.log(
-        "Next steps:"
-    );
+    console.log("Next steps:");
     console.log(
         `  cd ${quoteIfNeeded(relative)}`
     );
 
     if (!installed) {
-        console.log(
-            "  npm install"
-        );
+        console.log("  npm install");
     }
 
-    console.log(
-        "  npm run dev"
-    );
+    console.log("  npm run dev");
     console.log("");
 }
 
-function formatDatabaseName(
-    value
-) {
+function formatDatabaseName(value) {
     const names = {
         none: "None",
         mysql: "MySQL",
@@ -636,21 +509,16 @@ function formatDatabaseName(
         mongodb: "MongoDB",
     };
 
-    return names[value] ??
-        value;
+    return names[value] ?? value;
 }
 
-function formatAuthName(
-    value
-) {
+function formatAuthName(value) {
     const names = {
         none: "None",
-        "jwt-cookie":
-            "JWT Cookie",
+        "jwt-cookie": "JWT Cookie",
     };
 
-    return names[value] ??
-        value;
+    return names[value] ?? value;
 }
 
 function printHelp() {
@@ -661,7 +529,8 @@ Usage:
   npx create-bcp-app <project-name> [options]
 
 Interactive setup:
-  - Choose whether to use Tailwind CSS
+  - Use ↑/↓ and Enter for every setup choice
+  - Choose Tailwind CSS: Yes or No
   - Choose a database: None, MySQL, PostgreSQL, SQLite or MongoDB
   - Choose authentication: None or JWT Cookie
 
@@ -684,31 +553,20 @@ Examples:
 `);
 }
 
-function quoteIfNeeded(
-    value
-) {
-    return /\s/.test(
-        value
-    )
-        ? JSON.stringify(
-            value
-        )
+function quoteIfNeeded(value) {
+    return /\s/.test(value)
+        ? JSON.stringify(value)
         : value;
 }
 
-function reportError(
-    error
-) {
+function reportError(error) {
     const message =
         error instanceof Error
             ? error.message
-            : String(
-                error
-            );
+            : String(error);
 
     console.error(
         `create-bcp-app: ${message}`
     );
-    process.exitCode =
-        1;
+    process.exitCode = 1;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-bcp-app",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "description": "Create a new BCP Framework application.",
   "type": "module",
   "license": "MIT",

package/src/index.mjs

@@ -250,12 +250,9 @@ function copyTemplate(
     sourceDirectory,
     targetDirectory
 ) {
-    fs.cpSync(
+    copyDirectoryContents(
         sourceDirectory,
-        targetDirectory,
-        {
-            recursive: true,
-        }
+        targetDirectory
     );
 
     const gitignoreTemplate =
@@ -279,6 +276,66 @@ function copyTemplate(
     }
 }
 
+function copyDirectoryContents(
+    sourceDirectory,
+    targetDirectory
+) {
+    fs.mkdirSync(
+        targetDirectory,
+        {
+            recursive: true,
+        }
+    );
+
+    const entries =
+        fs.readdirSync(
+            sourceDirectory,
+            {
+                withFileTypes: true,
+            }
+        );
+
+    for (
+        const entry
+        of entries
+    ) {
+        const sourcePath =
+            path.join(
+                sourceDirectory,
+                entry.name
+            );
+        const targetPath =
+            path.join(
+                targetDirectory,
+                entry.name
+            );
+
+        if (
+            entry.isDirectory()
+        ) {
+            copyDirectoryContents(
+                sourcePath,
+                targetPath
+            );
+            continue;
+        }
+
+        if (
+            entry.isFile()
+        ) {
+            fs.copyFileSync(
+                sourcePath,
+                targetPath
+            );
+            continue;
+        }
+
+        throw new Error(
+            `Unsupported template entry: ${sourcePath}`
+        );
+    }
+}
+
 function readPackageMetadata() {
     const packageJson =
         JSON.parse(