@m2c2kit/cli 0.3.14 → 0.3.16

package/dist/index.d.ts

@@ -2,13 +2,13 @@
 /**
  * The code in this file is adapted from a reference CLI implementation from
  * the Angular devkit repository:
- *   https://github.com/angular/angular-cli/blob/72cf799388e16c21855b12a08b29f7dbcb464845/packages/angular_devkit/schematics_cli/bin/schematics.ts
+ *   https://github.com/angular/angular-cli/blob/f5c250ab48e22c5aff31d8ebd35fb9a88e380fd7/packages/angular_devkit/schematics_cli/bin/schematics.ts
  * The license for that code is as follows:
  * @license
  * Copyright Google LLC All Rights Reserved.
  *
  * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
+ * found in the LICENSE file at https://angular.dev/license
  */
 import "symbol-observable";
 import { ProcessOutput } from "@angular-devkit/core/node";
@@ -18,16 +18,3 @@ export interface MainOptions {
     stderr?: ProcessOutput;
 }
 export declare function main({ args, stdout, stderr, }: MainOptions): Promise<0 | 1>;
-/**
- * This uses a dynamic import to load a module which may be ESM.
- * CommonJS code can load ESM code via a dynamic import. Unfortunately, TypeScript
- * will currently, unconditionally downlevel dynamic import into a require call.
- * require calls cannot load ESM code and will result in a runtime error. To workaround
- * this, a Function constructor is used to prevent TypeScript from changing the dynamic import.
- * Once TypeScript provides support for keeping the dynamic import this workaround can
- * be dropped.
- *
- * @param modulePath The path of the module to load.
- * @returns A Promise that resolves to the dynamically imported module.
- */
-export declare function loadEsmModule<T>(modulePath: string | URL): Promise<T>;

package/dist/index.js

@@ -3,13 +3,13 @@
 /**
  * The code in this file is adapted from a reference CLI implementation from
  * the Angular devkit repository:
- *   https://github.com/angular/angular-cli/blob/72cf799388e16c21855b12a08b29f7dbcb464845/packages/angular_devkit/schematics_cli/bin/schematics.ts
+ *   https://github.com/angular/angular-cli/blob/f5c250ab48e22c5aff31d8ebd35fb9a88e380fd7/packages/angular_devkit/schematics_cli/bin/schematics.ts
  * The license for that code is as follows:
  * @license
  * Copyright Google LLC All Rights Reserved.
  *
  * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
+ * found in the LICENSE file at https://angular.dev/license
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -38,7 +38,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadEsmModule = exports.main = void 0;
+exports.main = main;
 // symbol polyfill must go first
 require("symbol-observable");
 const node_1 = require("@angular-devkit/core/node");
@@ -75,6 +75,9 @@ function parseSchematicName(str) {
     }
     return { collection, schematic };
 }
+function removeLeadingSlash(value) {
+    return value[0] === "/" ? value.slice(1) : value;
+}
 function _listSchematics(workflow, collectionName, logger) {
     try {
         const collection = workflow.engine.createCollection(collectionName);
@@ -88,66 +91,80 @@ function _listSchematics(workflow, collectionName, logger) {
 }
 function _createPromptProvider() {
     return async (definitions) => {
-        const questions = definitions.map((definition) => {
-            const question = {
-                name: definition.id,
-                message: definition.message,
-                default: definition.default,
-            };
-            const validator = definition.validator;
-            if (validator) {
-                question.validate = (input) => validator(input);
-                // Filter allows transformation of the value prior to validation
-                question.filter = async (input) => {
-                    for (const type of definition.propertyTypes) {
-                        let value;
-                        switch (type) {
-                            case "string":
-                                value = String(input);
-                                break;
-                            case "integer":
-                            case "number":
-                                value = Number(input);
-                                break;
-                            default:
-                                value = input;
-                                break;
-                        }
-                        // Can be a string if validation fails
-                        const isValid = (await validator(value)) === true;
-                        if (isValid) {
-                            return value;
-                        }
-                    }
-                    return input;
-                };
-            }
+        let prompts;
+        const answers = {};
+        for (const definition of definitions) {
+            // Only load prompt package if needed
+            prompts ?? (prompts = await Promise.resolve().then(() => __importStar(require("@inquirer/prompts"))));
             switch (definition.type) {
                 case "confirmation":
-                    return { ...question, type: "confirm" };
+                    answers[definition.id] = await prompts.confirm({
+                        message: definition.message,
+                        default: definition.default,
+                    });
+                    break;
                 case "list":
-                    return {
-                        ...question,
-                        type: definition.multiselect ? "checkbox" : "list",
-                        choices: definition.items &&
-                            definition.items.map((item) => {
-                                if (typeof item == "string") {
-                                    return item;
+                    if (!definition.items?.length) {
+                        continue;
+                    }
+                    answers[definition.id] = await (definition.multiselect ? prompts.checkbox : prompts.select)({
+                        message: definition.message,
+                        default: definition.default,
+                        choices: definition.items.map((item) => typeof item == "string"
+                            ? {
+                                name: item,
+                                value: item,
+                            }
+                            : {
+                                name: item.label,
+                                value: item.value,
+                            }),
+                    });
+                    break;
+                case "input": {
+                    let finalValue;
+                    answers[definition.id] = await prompts.input({
+                        message: definition.message,
+                        default: definition.default,
+                        async validate(value) {
+                            if (definition.validator === undefined) {
+                                return true;
+                            }
+                            let lastValidation = false;
+                            for (const type of definition.propertyTypes) {
+                                let potential;
+                                switch (type) {
+                                    case "string":
+                                        potential = String(value);
+                                        break;
+                                    case "integer":
+                                    case "number":
+                                        potential = Number(value);
+                                        break;
+                                    default:
+                                        potential = value;
+                                        break;
                                 }
-                                else {
-                                    return {
-                                        name: item.label,
-                                        value: item.value,
-                                    };
+                                lastValidation = await definition.validator(potential);
+                                // Can be a string if validation fails
+                                if (lastValidation === true) {
+                                    finalValue = potential;
+                                    return true;
                                 }
-                            }),
-                    };
-                default:
-                    return { ...question, type: definition.type };
+                            }
+                            return lastValidation;
+                        },
+                    });
+                    // Use validated value if present.
+                    // This ensures the correct type is inserted into the final schema options.
+                    if (finalValue !== undefined) {
+                        answers[definition.id] = finalValue;
+                    }
+                    break;
+                }
             }
-        });
-        const { default: inquirer } = await loadEsmModule("inquirer");
-        return inquirer.prompt(questions);
+        }
+        return answers;
     };
 }
 function findUp(names, from) {
@@ -249,17 +266,11 @@ async function main({ args, stdout = process.stdout, stderr = process.stderr, })
     workflow.reporter.subscribe((event) => {
         nothingDone = false;
         // Strip leading slash to prevent confusion.
-        const eventPath = event.path.startsWith("/")
-            ? event.path.slice(1)
-            : event.path;
+        const eventPath = removeLeadingSlash(event.path);
         switch (event.kind) {
             case "error":
                 error = true;
-                // eslint-disable-next-line no-case-declarations
-                const desc = event.description == "alreadyExist"
-                    ? "already exists"
-                    : "does not exist";
-                logger.error(`ERROR! ${eventPath} ${desc}.`);
+                logger.error(`ERROR! ${eventPath} ${event.description == "alreadyExist" ? "already exists" : "does not exist"}.`);
                 break;
             case "update":
                 loggingQueue.push(`${colors.cyan("UPDATE")} ${eventPath} (${event.content.length} bytes)`);
@@ -271,11 +282,7 @@ async function main({ args, stdout = process.stdout, stderr = process.stderr, })
                 loggingQueue.push(`${colors.yellow("DELETE")} ${eventPath}`);
                 break;
             case "rename":
-                // eslint-disable-next-line no-case-declarations
-                const eventToPath = event.to.startsWith("/")
-                    ? event.to.slice(1)
-                    : event.to;
-                loggingQueue.push(`${colors.blue("RENAME")} ${eventPath} => ${eventToPath}`);
+                loggingQueue.push(`${colors.blue("RENAME")} ${eventPath} => ${removeLeadingSlash(event.to)}`);
                 break;
         }
     });
@@ -333,7 +340,7 @@ async function main({ args, stdout = process.stdout, stderr = process.stderr, })
             logger.fatal("The Schematic workflow failed. See above.");
         }
         else if (debug && err instanceof Error) {
-            logger.fatal(`An error occurred:\n${err.stack}`);
+            logger.fatal(`An error occured:\n${err.stack}`);
         }
         else {
             logger.fatal(`Error: ${err instanceof Error ? err.message : err}`);
@@ -341,7 +348,6 @@ async function main({ args, stdout = process.stdout, stderr = process.stderr, })
         return 1;
     }
 }
-exports.main = main;
 /**
  * Get usage of the CLI tool.
  */
@@ -431,24 +437,3 @@ if (require.main === module) {
         throw e;
     });
 }
-/**
- * Lazily compiled dynamic import loader function.
- */
-let load;
-/**
- * This uses a dynamic import to load a module which may be ESM.
- * CommonJS code can load ESM code via a dynamic import. Unfortunately, TypeScript
- * will currently, unconditionally downlevel dynamic import into a require call.
- * require calls cannot load ESM code and will result in a runtime error. To workaround
- * this, a Function constructor is used to prevent TypeScript from changing the dynamic import.
- * Once TypeScript provides support for keeping the dynamic import this workaround can
- * be dropped.
- *
- * @param modulePath The path of the module to load.
- * @returns A Promise that resolves to the dynamically imported module.
- */
-function loadEsmModule(modulePath) {
-    load ?? (load = new Function("modulePath", `return import(modulePath);`));
-    return load(modulePath);
-}
-exports.loadEsmModule = loadEsmModule;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m2c2kit/cli",
-  "version": "0.3.14",
+  "version": "0.3.16",
   "description": "Command line interface to create new m2c2kit apps",
   "files": [
     "dist/**"
@@ -25,19 +25,19 @@
   },
   "homepage": "https://m2c2-project.github.io/m2c2kit",
   "dependencies": {
-    "@angular-devkit/core": "^17.3.0",
-    "@angular-devkit/schematics": "^17.3.0",
-    "@m2c2kit/schematics": "^0.1.13",
-    "@schematics/angular": "^17.3.0",
+    "@angular-devkit/core": "^18.1.0",
+    "@angular-devkit/schematics": "^18.1.0",
+    "@inquirer/prompts": "5.1.3",
+    "@m2c2kit/schematics": "0.1.16",
+    "@schematics/angular": "^18.1.0",
     "ansi-colors": "4.1.3",
-    "inquirer": "9.2.14",
     "symbol-observable": "4.0.0",
     "yargs-parser": "21.1.1"
   },
   "devDependencies": {
     "@types/inquirer": "9.0.7",
-    "rimraf": "5.0.5",
-    "typescript": "5.4.2"
+    "rimraf": "6.0.1",
+    "typescript": "5.5.3"
   },
   "engines": {
     "node": ">=18"