@angular-devkit/schematics-cli/bin/schematics.js

#!/usr/bin/env node
"use strict";
/**
 * @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
 */
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 inquirer = __importStar(require("inquirer"));
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 schematic = str;
    if (schematic === null || schematic === void 0 ? void 0 : 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);
            }
            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);
    };
}
// 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,
    });
    /** 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;
                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':
                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 `
  schematics [collection-name:]schematic-name [options, ...]

  By default, if the collection name is not specified, use the internal collection provided
  by the Schematics CLI.

  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;
    });
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schematics.js","sourceRoot":"","sources":["../../../../../../../packages/angular_devkit/schematics_cli/bin/schematics.ts"],"names":[],"mappings":"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","sourcesContent":["#!/usr/bin/env node\n/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n// symbol polyfill must go first\nimport 'symbol-observable';\nimport { logging, schema, tags } from '@angular-devkit/core';\nimport { ProcessOutput, createConsoleLogger } from '@angular-devkit/core/node';\nimport { UnsuccessfulWorkflowExecution } from '@angular-devkit/schematics';\nimport { NodeWorkflow } from '@angular-devkit/schematics/tools';\nimport * as ansiColors from 'ansi-colors';\nimport * as inquirer from 'inquirer';\nimport yargsParser, { camelCase, decamelize } from 'yargs-parser';\n\n/**\n * Parse the name of schematic passed in argument, and return a {collection, schematic} named\n * tuple. The user can pass in `collection-name:schematic-name`, and this function will either\n * return `{collection: 'collection-name', schematic: 'schematic-name'}`, or it will error out\n * and show usage.\n *\n * In the case where a collection name isn't part of the argument, the default is to use the\n * schematics package (@angular-devkit/schematics-cli) as the collection.\n *\n * This logic is entirely up to the tooling.\n *\n * @param str The argument to parse.\n * @return {{collection: string, schematic: (string)}}\n */\nfunction parseSchematicName(str: string | null): { collection: string; schematic: string | null } {\n  let collection = '@angular-devkit/schematics-cli';\n\n  let schematic = str;\n  if (schematic?.includes(':')) {\n    const lastIndexOfColon = schematic.lastIndexOf(':');\n    [collection, schematic] = [\n      schematic.slice(0, lastIndexOfColon),\n      schematic.substring(lastIndexOfColon + 1),\n    ];\n  }\n\n  return { collection, schematic };\n}\n\nexport interface MainOptions {\n  args: string[];\n  stdout?: ProcessOutput;\n  stderr?: ProcessOutput;\n}\n\nfunction _listSchematics(workflow: NodeWorkflow, collectionName: string, logger: logging.Logger) {\n  try {\n    const collection = workflow.engine.createCollection(collectionName);\n    logger.info(collection.listSchematicNames().join('\\n'));\n  } catch (error) {\n    logger.fatal(error instanceof Error ? error.message : `${error}`);\n\n    return 1;\n  }\n\n  return 0;\n}\n\nfunction _createPromptProvider(): schema.PromptProvider {\n  return (definitions) => {\n    const questions: inquirer.QuestionCollection = definitions.map((definition) => {\n      const question: inquirer.Question = {\n        name: definition.id,\n        message: definition.message,\n        default: definition.default,\n      };\n\n      const validator = definition.validator;\n      if (validator) {\n        question.validate = (input) => validator(input);\n      }\n\n      switch (definition.type) {\n        case 'confirmation':\n          return { ...question, type: 'confirm' };\n        case 'list':\n          return {\n            ...question,\n            type: definition.multiselect ? 'checkbox' : 'list',\n            choices:\n              definition.items &&\n              definition.items.map((item) => {\n                if (typeof item == 'string') {\n                  return item;\n                } else {\n                  return {\n                    name: item.label,\n                    value: item.value,\n                  };\n                }\n              }),\n          };\n        default:\n          return { ...question, type: definition.type };\n      }\n    });\n\n    return inquirer.prompt(questions);\n  };\n}\n\n// eslint-disable-next-line max-lines-per-function\nexport async function main({\n  args,\n  stdout = process.stdout,\n  stderr = process.stderr,\n}: MainOptions): Promise<0 | 1> {\n  const { cliOptions, schematicOptions, _ } = parseArgs(args);\n\n  // Create a separate instance to prevent unintended global changes to the color configuration\n  const colors = ansiColors.create();\n\n  /** Create the DevKit Logger used through the CLI. */\n  const logger = createConsoleLogger(!!cliOptions.verbose, stdout, stderr, {\n    info: (s) => s,\n    debug: (s) => s,\n    warn: (s) => colors.bold.yellow(s),\n    error: (s) => colors.bold.red(s),\n    fatal: (s) => colors.bold.red(s),\n  });\n\n  if (cliOptions.help) {\n    logger.info(getUsage());\n\n    return 0;\n  }\n\n  /** Get the collection an schematic name from the first argument. */\n  const { collection: collectionName, schematic: schematicName } = parseSchematicName(\n    _.shift() || null,\n  );\n\n  const isLocalCollection = collectionName.startsWith('.') || collectionName.startsWith('/');\n\n  /** Gather the arguments for later use. */\n  const debugPresent = cliOptions.debug !== null;\n  const debug = debugPresent ? !!cliOptions.debug : isLocalCollection;\n  const dryRunPresent = cliOptions['dry-run'] !== null;\n  const dryRun = dryRunPresent ? !!cliOptions['dry-run'] : debug;\n  const force = !!cliOptions.force;\n  const allowPrivate = !!cliOptions['allow-private'];\n\n  /** Create the workflow scoped to the working directory that will be executed with this run. */\n  const workflow = new NodeWorkflow(process.cwd(), {\n    force,\n    dryRun,\n    resolvePaths: [process.cwd(), __dirname],\n    schemaValidation: true,\n  });\n\n  /** If the user wants to list schematics, we simply show all the schematic names. */\n  if (cliOptions['list-schematics']) {\n    return _listSchematics(workflow, collectionName, logger);\n  }\n\n  if (!schematicName) {\n    logger.info(getUsage());\n\n    return 1;\n  }\n\n  if (debug) {\n    logger.info(\n      `Debug mode enabled${isLocalCollection ? ' by default for local collections' : ''}.`,\n    );\n  }\n\n  // Indicate to the user when nothing has been done. This is automatically set to off when there's\n  // a new DryRunEvent.\n  let nothingDone = true;\n\n  // Logging queue that receives all the messages to show the users. This only get shown when no\n  // errors happened.\n  let loggingQueue: string[] = [];\n  let error = false;\n\n  /**\n   * Logs out dry run events.\n   *\n   * All events will always be executed here, in order of discovery. That means that an error would\n   * be shown along other events when it happens. Since errors in workflows will stop the Observable\n   * from completing successfully, we record any events other than errors, then on completion we\n   * show them.\n   *\n   * This is a simple way to only show errors when an error occur.\n   */\n  workflow.reporter.subscribe((event) => {\n    nothingDone = false;\n    // Strip leading slash to prevent confusion.\n    const eventPath = event.path.startsWith('/') ? event.path.slice(1) : event.path;\n\n    switch (event.kind) {\n      case 'error':\n        error = true;\n\n        const desc = event.description == 'alreadyExist' ? 'already exists' : 'does not exist';\n        logger.error(`ERROR! ${eventPath} ${desc}.`);\n        break;\n      case 'update':\n        loggingQueue.push(`${colors.cyan('UPDATE')} ${eventPath} (${event.content.length} bytes)`);\n        break;\n      case 'create':\n        loggingQueue.push(`${colors.green('CREATE')} ${eventPath} (${event.content.length} bytes)`);\n        break;\n      case 'delete':\n        loggingQueue.push(`${colors.yellow('DELETE')} ${eventPath}`);\n        break;\n      case 'rename':\n        const eventToPath = event.to.startsWith('/') ? event.to.slice(1) : event.to;\n        loggingQueue.push(`${colors.blue('RENAME')} ${eventPath} => ${eventToPath}`);\n        break;\n    }\n  });\n\n  /**\n   * Listen to lifecycle events of the workflow to flush the logs between each phases.\n   */\n  workflow.lifeCycle.subscribe((event) => {\n    if (event.kind == 'workflow-end' || event.kind == 'post-tasks-start') {\n      if (!error) {\n        // Flush the log queue and clean the error state.\n        loggingQueue.forEach((log) => logger.info(log));\n      }\n\n      loggingQueue = [];\n      error = false;\n    }\n  });\n\n  // Show usage of deprecated options\n  workflow.registry.useXDeprecatedProvider((msg) => logger.warn(msg));\n\n  // Pass the rest of the arguments as the smart default \"argv\". Then delete it.\n  workflow.registry.addSmartDefaultProvider('argv', (schema) =>\n    'index' in schema ? _[Number(schema['index'])] : _,\n  );\n\n  // Add prompts.\n  if (cliOptions.interactive && isTTY()) {\n    workflow.registry.usePromptProvider(_createPromptProvider());\n  }\n\n  /**\n   *  Execute the workflow, which will report the dry run events, run the tasks, and complete\n   *  after all is done.\n   *\n   *  The Observable returned will properly cancel the workflow if unsubscribed, error out if ANY\n   *  step of the workflow failed (sink or task), with details included, and will only complete\n   *  when everything is done.\n   */\n  try {\n    await workflow\n      .execute({\n        collection: collectionName,\n        schematic: schematicName,\n        options: schematicOptions,\n        allowPrivate: allowPrivate,\n        debug: debug,\n        logger: logger,\n      })\n      .toPromise();\n\n    if (nothingDone) {\n      logger.info('Nothing to be done.');\n    } else if (dryRun) {\n      logger.info(\n        `Dry run enabled${\n          dryRunPresent ? '' : ' by default in debug mode'\n        }. No files written to disk.`,\n      );\n    }\n\n    return 0;\n  } catch (err) {\n    if (err instanceof UnsuccessfulWorkflowExecution) {\n      // \"See above\" because we already printed the error.\n      logger.fatal('The Schematic workflow failed. See above.');\n    } else if (debug && err instanceof Error) {\n      logger.fatal(`An error occured:\\n${err.stack}`);\n    } else {\n      logger.fatal(`Error: ${err instanceof Error ? err.message : err}`);\n    }\n\n    return 1;\n  }\n}\n\n/**\n * Get usage of the CLI tool.\n */\nfunction getUsage(): string {\n  return tags.stripIndent`\n  schematics [collection-name:]schematic-name [options, ...]\n\n  By default, if the collection name is not specified, use the internal collection provided\n  by the Schematics CLI.\n\n  Options:\n      --debug             Debug mode. This is true by default if the collection is a relative\n                          path (in that case, turn off with --debug=false).\n\n      --allow-private     Allow private schematics to be run from the command line. Default to\n                          false.\n\n      --dry-run           Do not output anything, but instead just show what actions would be\n                          performed. Default to true if debug is also true.\n\n      --force             Force overwriting files that would otherwise be an error.\n\n      --list-schematics   List all schematics from the collection, by name. A collection name\n                          should be suffixed by a colon. Example: '@angular-devkit/schematics-cli:'.\n\n      --no-interactive    Disables interactive input prompts.\n\n      --verbose           Show more information.\n\n      --help              Show this message.\n\n  Any additional option is passed to the Schematics depending on its schema.\n  `;\n}\n\n/** Parse the command line. */\nconst booleanArgs = [\n  'allow-private',\n  'debug',\n  'dry-run',\n  'force',\n  'help',\n  'list-schematics',\n  'verbose',\n  'interactive',\n] as const;\n\ntype ElementType<T extends ReadonlyArray<unknown>> = T extends ReadonlyArray<infer ElementType>\n  ? ElementType\n  : never;\n\ninterface Options {\n  _: string[];\n  schematicOptions: Record<string, unknown>;\n  cliOptions: Partial<Record<ElementType<typeof booleanArgs>, boolean | null>>;\n}\n\n/** Parse the command line. */\nfunction parseArgs(args: string[]): Options {\n  const { _, ...options } = yargsParser(args, {\n    boolean: booleanArgs as unknown as string[],\n    default: {\n      'interactive': true,\n      'debug': null,\n      'dry-run': null,\n    },\n    configuration: {\n      'dot-notation': false,\n      'boolean-negation': true,\n      'strip-aliased': true,\n      'camel-case-expansion': false,\n    },\n  });\n\n  // Camelize options as yargs will return the object in kebab-case when camel casing is disabled.\n  const schematicOptions: Options['schematicOptions'] = {};\n  const cliOptions: Options['cliOptions'] = {};\n\n  const isCliOptions = (\n    key: ElementType<typeof booleanArgs> | string,\n  ): key is ElementType<typeof booleanArgs> =>\n    booleanArgs.includes(key as ElementType<typeof booleanArgs>);\n\n  for (const [key, value] of Object.entries(options)) {\n    if (/[A-Z]/.test(key)) {\n      throw new Error(`Unknown argument ${key}. Did you mean ${decamelize(key)}?`);\n    }\n\n    if (isCliOptions(key)) {\n      cliOptions[key] = value;\n    } else {\n      schematicOptions[camelCase(key)] = value;\n    }\n  }\n\n  return {\n    _: _.map((v) => v.toString()),\n    schematicOptions,\n    cliOptions,\n  };\n}\n\nfunction isTTY(): boolean {\n  const isTruthy = (value: undefined | string) => {\n    // Returns true if value is a string that is anything but 0 or false.\n    return value !== undefined && value !== '0' && value.toUpperCase() !== 'FALSE';\n  };\n\n  // If we force TTY, we always return true.\n  const force = process.env['NG_FORCE_TTY'];\n  if (force !== undefined) {\n    return isTruthy(force);\n  }\n\n  return !!process.stdout.isTTY && !isTruthy(process.env['CI']);\n}\n\nif (require.main === module) {\n  const args = process.argv.slice(2);\n  main({ args })\n    .then((exitCode) => (process.exitCode = exitCode))\n    .catch((e) => {\n      throw e;\n    });\n}\n"]}