@m2c2kit/cli 0.3.5 → 0.3.7

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+/**
+ * The code in this file is adapted from a reference CLI implementation from
+ * the Angular devkit repository:
+ *   https://github.com/angular/angular-cli/blob/b674bd2c3c3e63693881ba502493bc803a820772/packages/angular_devkit/schematics_cli/bin/schematics.ts
+ *
+ * The license for that code is as follows:
+ *
+ * The MIT License
+ * Copyright (c) 2010-2023 Google LLC. http://angular.io/license
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+import "symbol-observable";
+import { ProcessOutput } from "@angular-devkit/core/node";
+export interface MainOptions {
+    args: string[];
+    stdout?: ProcessOutput;
+    stderr?: ProcessOutput;
+}
+export declare function main({ args, stdout, stderr, }: MainOptions): Promise<0 | 1>;

package/dist/index.js

@@ -0,0 +1,446 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * The code in this file is adapted from a reference CLI implementation from
+ * the Angular devkit repository:
+ *   https://github.com/angular/angular-cli/blob/b674bd2c3c3e63693881ba502493bc803a820772/packages/angular_devkit/schematics_cli/bin/schematics.ts
+ *
+ * The license for that code is as follows:
+ *
+ * The MIT License
+ * Copyright (c) 2010-2023 Google LLC. http://angular.io/license
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = void 0;
+// symbol polyfill must go first
+require("symbol-observable");
+const core_1 = require("@angular-devkit/core");
+const node_1 = require("@angular-devkit/core/node");
+const schematics_1 = require("@angular-devkit/schematics");
+const tools_1 = require("@angular-devkit/schematics/tools");
+const ansiColors = __importStar(require("ansi-colors"));
+const fs_1 = require("fs");
+const inquirer = __importStar(require("inquirer"));
+const path = __importStar(require("path"));
+const yargs_parser_1 = __importStar(require("yargs-parser"));
+/**
+ * Parse the name of schematic passed in argument, and return a {collection, schematic} named
+ * tuple. The user can pass in `collection-name:schematic-name`, and this function will either
+ * return `{collection: 'collection-name', schematic: 'schematic-name'}`, or it will error out
+ * and show usage.
+ *
+ * In the case where a collection name isn't part of the argument, the default is to use the
+ * schematics package (@angular-devkit/schematics-cli) as the collection.
+ *
+ * This logic is entirely up to the tooling.
+ *
+ * @param str The argument to parse.
+ * @return {{collection: string, schematic: (string)}}
+ */
+function parseSchematicName(str) {
+    //let collection = '@angular-devkit/schematics-cli';
+    let collection = "@m2c2kit/schematics";
+    let schematic = str;
+    if (schematic?.includes(":")) {
+        const lastIndexOfColon = schematic.lastIndexOf(":");
+        [collection, schematic] = [
+            schematic.slice(0, lastIndexOfColon),
+            schematic.substring(lastIndexOfColon + 1),
+        ];
+    }
+    return { collection, schematic };
+}
+function _listSchematics(workflow, collectionName, logger) {
+    try {
+        const collection = workflow.engine.createCollection(collectionName);
+        logger.info(collection.listSchematicNames().join("\n"));
+    }
+    catch (error) {
+        logger.fatal(error instanceof Error ? error.message : `${error}`);
+        return 1;
+    }
+    return 0;
+}
+function _createPromptProvider() {
+    return (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;
+                };
+            }
+            switch (definition.type) {
+                case "confirmation":
+                    return { ...question, type: "confirm" };
+                case "list":
+                    return {
+                        ...question,
+                        type: definition.multiselect ? "checkbox" : "list",
+                        choices: definition.items &&
+                            definition.items.map((item) => {
+                                if (typeof item == "string") {
+                                    return item;
+                                }
+                                else {
+                                    return {
+                                        name: item.label,
+                                        value: item.value,
+                                    };
+                                }
+                            }),
+                    };
+                default:
+                    return { ...question, type: definition.type };
+            }
+        });
+        return inquirer.prompt(questions);
+    };
+}
+function findUp(names, from) {
+    if (!Array.isArray(names)) {
+        names = [names];
+    }
+    const root = path.parse(from).root;
+    let currentDir = from;
+    while (currentDir && currentDir !== root) {
+        for (const name of names) {
+            const p = path.join(currentDir, name);
+            if ((0, fs_1.existsSync)(p)) {
+                return p;
+            }
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    return null;
+}
+/**
+ * return package manager' name by lock file
+ */
+function getPackageManagerName() {
+    // order by check priority
+    const LOCKS = {
+        "package-lock.json": "npm",
+        "yarn.lock": "yarn",
+        "pnpm-lock.yaml": "pnpm",
+    };
+    const lockPath = findUp(Object.keys(LOCKS), process.cwd());
+    if (lockPath) {
+        return LOCKS[path.basename(lockPath)];
+    }
+    return "npm";
+}
+// eslint-disable-next-line max-lines-per-function
+async function main({ args, stdout = process.stdout, stderr = process.stderr, }) {
+    const { cliOptions, schematicOptions, _ } = parseArgs(args);
+    // Create a separate instance to prevent unintended global changes to the color configuration
+    const colors = ansiColors.create();
+    /** Create the DevKit Logger used through the CLI. */
+    const logger = (0, node_1.createConsoleLogger)(!!cliOptions.verbose, stdout, stderr, {
+        info: (s) => s,
+        debug: (s) => s,
+        warn: (s) => colors.bold.yellow(s),
+        error: (s) => colors.bold.red(s),
+        fatal: (s) => colors.bold.red(s),
+    });
+    if (cliOptions.help) {
+        logger.info(getUsage());
+        return 0;
+    }
+    /** Get the collection an schematic name from the first argument. */
+    const { collection: collectionName, schematic: schematicName } = parseSchematicName(_.shift() || null);
+    const isLocalCollection = collectionName.startsWith(".") || collectionName.startsWith("/");
+    /** Gather the arguments for later use. */
+    const debugPresent = cliOptions.debug !== null;
+    const debug = debugPresent ? !!cliOptions.debug : isLocalCollection;
+    const dryRunPresent = cliOptions["dry-run"] !== null;
+    const dryRun = dryRunPresent ? !!cliOptions["dry-run"] : debug;
+    const force = !!cliOptions.force;
+    const allowPrivate = !!cliOptions["allow-private"];
+    /** Create the workflow scoped to the working directory that will be executed with this run. */
+    const workflow = new tools_1.NodeWorkflow(process.cwd(), {
+        force,
+        dryRun,
+        resolvePaths: [process.cwd(), __dirname],
+        schemaValidation: true,
+        packageManager: getPackageManagerName(),
+    });
+    /** If the user wants to list schematics, we simply show all the schematic names. */
+    if (cliOptions["list-schematics"]) {
+        return _listSchematics(workflow, collectionName, logger);
+    }
+    if (!schematicName) {
+        logger.info(getUsage());
+        return 1;
+    }
+    if (debug) {
+        logger.info(`Debug mode enabled${isLocalCollection ? " by default for local collections" : ""}.`);
+    }
+    // Indicate to the user when nothing has been done. This is automatically set to off when there's
+    // a new DryRunEvent.
+    let nothingDone = true;
+    // Logging queue that receives all the messages to show the users. This only get shown when no
+    // errors happened.
+    let loggingQueue = [];
+    let error = false;
+    /**
+     * Logs out dry run events.
+     *
+     * All events will always be executed here, in order of discovery. That means that an error would
+     * be shown along other events when it happens. Since errors in workflows will stop the Observable
+     * from completing successfully, we record any events other than errors, then on completion we
+     * show them.
+     *
+     * This is a simple way to only show errors when an error occur.
+     */
+    workflow.reporter.subscribe((event) => {
+        nothingDone = false;
+        // Strip leading slash to prevent confusion.
+        const eventPath = event.path.startsWith("/")
+            ? event.path.slice(1)
+            : 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}.`);
+                break;
+            case "update":
+                loggingQueue.push(`${colors.cyan("UPDATE")} ${eventPath} (${event.content.length} bytes)`);
+                break;
+            case "create":
+                loggingQueue.push(`${colors.green("CREATE")} ${eventPath} (${event.content.length} bytes)`);
+                break;
+            case "delete":
+                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}`);
+                break;
+        }
+    });
+    /**
+     * Listen to lifecycle events of the workflow to flush the logs between each phases.
+     */
+    workflow.lifeCycle.subscribe((event) => {
+        if (event.kind == "workflow-end" || event.kind == "post-tasks-start") {
+            if (!error) {
+                // Flush the log queue and clean the error state.
+                loggingQueue.forEach((log) => logger.info(log));
+            }
+            loggingQueue = [];
+            error = false;
+        }
+    });
+    // Show usage of deprecated options
+    workflow.registry.useXDeprecatedProvider((msg) => logger.warn(msg));
+    // Pass the rest of the arguments as the smart default "argv". Then delete it.
+    workflow.registry.addSmartDefaultProvider("argv", (schema) => "index" in schema ? _[Number(schema["index"])] : _);
+    // Add prompts.
+    if (cliOptions.interactive && isTTY()) {
+        workflow.registry.usePromptProvider(_createPromptProvider());
+    }
+    /**
+     *  Execute the workflow, which will report the dry run events, run the tasks, and complete
+     *  after all is done.
+     *
+     *  The Observable returned will properly cancel the workflow if unsubscribed, error out if ANY
+     *  step of the workflow failed (sink or task), with details included, and will only complete
+     *  when everything is done.
+     */
+    try {
+        await workflow
+            .execute({
+            collection: collectionName,
+            schematic: schematicName,
+            options: schematicOptions,
+            allowPrivate: allowPrivate,
+            debug: debug,
+            logger: logger,
+        })
+            .toPromise();
+        if (nothingDone) {
+            logger.info("Nothing to be done.");
+        }
+        else if (dryRun) {
+            logger.info(`Dry run enabled${dryRunPresent ? "" : " by default in debug mode"}. No files written to disk.`);
+        }
+        return 0;
+    }
+    catch (err) {
+        if (err instanceof schematics_1.UnsuccessfulWorkflowExecution) {
+            // "See above" because we already printed the error.
+            logger.fatal("The Schematic workflow failed. See above.");
+        }
+        else if (debug && err instanceof Error) {
+            logger.fatal(`An error occured:\n${err.stack}`);
+        }
+        else {
+            logger.fatal(`Error: ${err instanceof Error ? err.message : err}`);
+        }
+        return 1;
+    }
+}
+exports.main = main;
+/**
+ * Get usage of the CLI tool.
+ */
+function getUsage() {
+    return core_1.tags.stripIndent `
+  m2 <command> [options, ...]
+
+  Commands:
+    m2 new <name>         create a new m2c2kit app.
+
+  Options:
+      --debug             Debug mode. This is true by default if the collection is a relative
+                          path (in that case, turn off with --debug=false).
+
+      --allow-private     Allow private schematics to be run from the command line. Default to
+                          false.
+
+      --dry-run           Do not output anything, but instead just show what actions would be
+                          performed. Default to true if debug is also true.
+
+      --force             Force overwriting files that would otherwise be an error.
+
+      --list-schematics   List all schematics from the collection, by name. A collection name
+                          should be suffixed by a colon. Example: '@angular-devkit/schematics-cli:'.
+
+      --no-interactive    Disables interactive input prompts.
+
+      --verbose           Show more information.
+
+      --help              Show this message.
+
+  Any additional option is passed to the Schematics depending on its schema.
+  `;
+}
+/** Parse the command line. */
+const booleanArgs = [
+    "allow-private",
+    "debug",
+    "dry-run",
+    "force",
+    "help",
+    "list-schematics",
+    "verbose",
+    "interactive",
+];
+/** Parse the command line. */
+function parseArgs(args) {
+    const { _, ...options } = (0, yargs_parser_1.default)(args, {
+        boolean: booleanArgs,
+        default: {
+            interactive: true,
+            debug: null,
+            "dry-run": null,
+        },
+        configuration: {
+            "dot-notation": false,
+            "boolean-negation": true,
+            "strip-aliased": true,
+            "camel-case-expansion": false,
+        },
+    });
+    // Camelize options as yargs will return the object in kebab-case when camel casing is disabled.
+    const schematicOptions = {};
+    const cliOptions = {};
+    const isCliOptions = (key) => booleanArgs.includes(key);
+    for (const [key, value] of Object.entries(options)) {
+        if (/[A-Z]/.test(key)) {
+            throw new Error(`Unknown argument ${key}. Did you mean ${(0, yargs_parser_1.decamelize)(key)}?`);
+        }
+        if (isCliOptions(key)) {
+            cliOptions[key] = value;
+        }
+        else {
+            schematicOptions[(0, yargs_parser_1.camelCase)(key)] = value;
+        }
+    }
+    return {
+        _: _.map((v) => v.toString()),
+        schematicOptions,
+        cliOptions,
+    };
+}
+function isTTY() {
+    const isTruthy = (value) => {
+        // Returns true if value is a string that is anything but 0 or false.
+        return (value !== undefined && value !== "0" && value.toUpperCase() !== "FALSE");
+    };
+    // If we force TTY, we always return true.
+    const force = process.env["NG_FORCE_TTY"];
+    if (force !== undefined) {
+        return isTruthy(force);
+    }
+    return !!process.stdout.isTTY && !isTruthy(process.env["CI"]);
+}
+if (require.main === module) {
+    const args = process.argv.slice(2);
+    main({ args })
+        .then((exitCode) => (process.exitCode = exitCode))
+        .catch((e) => {
+        throw e;
+    });
+}

package/package.json

@@ -1,44 +1,32 @@
 {
   "name": "@m2c2kit/cli",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "description": "m2c2kit command line interface",
-  "module": "dist/cli.js",
   "files": [
     "dist/**"
   ],
-  "type": "module",
   "bin": {
-    "m2": "./dist/cli.js"
-  },
-  "engines": {
-    "node": ">=16.0.0"
+    "m2": "./dist/index.js"
   },
   "scripts": {
-    "build": "npm run clean && npm run compile && npm run copy-files && npm run write-dotenv",
+    "build": "npm run clean && npm run compile",
     "compile": "tsc",
-    "clean": "rimraf dist build/",
-    "copy-files": "cpy --flat build/src/*.js dist && cpy templates assets dist",
-    "write-dotenv": "node write-dotenv.js"
+    "clean": "rimraf dist"
   },
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "axios": "1.2.4",
-    "chalk": "5.2.0",
-    "conf": "11.0.1",
-    "form-data": "4.0.0",
-    "handlebars": "4.7.7",
-    "ora": "6.3.0",
-    "prompts": "2.4.2",
-    "yargs": "17.7.1"
+    "@angular-devkit/core": "^16.0.2",
+    "@angular-devkit/schematics": "^16.0.2",
+    "@m2c2kit/schematics": "^0.1.0",
+    "@schematics/angular": "^16.0.2",
+    "@types/inquirer": "^8.2.4",
+    "ansi-colors": "4.1.3",
+    "inquirer": "8.2.4",
+    "symbol-observable": "4.0.0",
+    "yargs-parser": "21.1.1"
   },
   "devDependencies": {
-    "@types/node": "18.15.12",
-    "@types/prompts": "2.4.4",
-    "@types/yargs": "17.0.24",
-    "cpy-cli": "4.2.0",
-    "rimraf": "5.0.0",
-    "tslib": "2.5.0",
-    "typescript": "5.0.4"
+    "rimraf": "5.0.1"
   }
 }

package/dist/.env

@@ -1 +0,0 @@
-CLI_VERSION=0.3.5