@angular/cli 22.2.2 → 22.3.0-next.1

package/lib/cli/index.js

@@ -1,113 +1,361 @@
-"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.dev/license
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VERSION = void 0;
-exports.default = default_1;
-const core_1 = require("@angular-devkit/core");
-const node_util_1 = require("node:util");
-const command_module_1 = require("../../src/command-builder/command-module");
-const command_runner_1 = require("../../src/command-builder/command-runner");
-const color_1 = require("../../src/utilities/color");
-const environment_options_1 = require("../../src/utilities/environment-options");
-const log_file_1 = require("../../src/utilities/log-file");
-const node_version_1 = require("../../src/utilities/node-version");
-var version_1 = require("../../src/utilities/version");
-Object.defineProperty(exports, "VERSION", { enumerable: true, get: function () { return version_1.VERSION; } });
-/* eslint-disable no-console */
-async function default_1(options) {
-    // This node version check ensures that the requirements of the project instance of the CLI are met
-    if (!(0, node_version_1.isNodeVersionMinSupported)()) {
-        process.stderr.write(`Node.js version ${process.version} detected.\n` +
-            `The Angular CLI requires a minimum of v${node_version_1.supportedNodeVersions[0]}.\n\n` +
-            'Please update your Node.js version or visit https://nodejs.org/ for additional instructions.\n');
-        return 3;
+import {
+  writeErrorToLogFile
+} from "../chunk-SN4KY4Z3.js";
+import {
+  isNodeVersionMinSupported,
+  supportedNodeVersions
+} from "../chunk-XFL2J3CJ.js";
+import {
+  RootCommands,
+  RootCommandsAliases
+} from "../chunk-5AASRQKS.js";
+import {
+  getCacheConfig
+} from "../chunk-A2VIYA2E.js";
+import {
+  addCommandModuleToYargs,
+  demandCommandFailureMessage
+} from "../chunk-G7TRU43D.js";
+import {
+  CommandModuleError,
+  createPackageManager
+} from "../chunk-YM7ILCS5.js";
+import {
+  VERSION,
+  ngDebug
+} from "../chunk-XG3HVNIL.js";
+import {
+  colors,
+  supportColor
+} from "../chunk-GHUUJYOY.js";
+import {
+  assertIsError,
+  getProjectByCwd,
+  getWorkspace
+} from "../chunk-FZ5GFCWU.js";
+
+// packages/angular/cli/lib/cli/index.js
+import { logging } from "@angular-devkit/core";
+import { format, stripVTControlCharacters } from "node:util";
+
+// packages/angular/cli/src/command-builder/command-runner.js
+import { isJsonObject } from "@angular-devkit/core";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import yargs from "yargs";
+import { Parser as yargsParser } from "yargs/helpers";
+
+// packages/angular/cli/src/command-builder/utilities/json-help.js
+var yargsDefaultCommandRegExp = /^\$0|\*/;
+function jsonHelpUsage(localYargs) {
+  const localYargsInstance = localYargs;
+  const { deprecatedOptions, alias: aliases, array, string, boolean, number, choices, demandedOptions, default: defaultVal, hiddenOptions = [] } = localYargsInstance.getOptions();
+  const internalMethods = localYargsInstance.getInternalMethods();
+  const usageInstance = internalMethods.getUsageInstance();
+  const context = internalMethods.getContext();
+  const descriptions = usageInstance.getDescriptions();
+  const groups = localYargsInstance.getGroups();
+  const positional = groups[usageInstance.getPositionalGroupName()];
+  const seen = /* @__PURE__ */ new Set();
+  const hidden = new Set(hiddenOptions);
+  const normalizeOptions = [];
+  const allAliases = /* @__PURE__ */ new Set([...Object.values(aliases).flat()]);
+  for (const [names, type] of [
+    [number, "number"],
+    [array, "array"],
+    [string, "string"],
+    [boolean, "boolean"]
+  ]) {
+    for (const name of names) {
+      if (allAliases.has(name) || hidden.has(name) || seen.has(name)) {
+        continue;
+      }
+      seen.add(name);
+      const positionalIndex = positional?.indexOf(name) ?? -1;
+      const alias = aliases[name];
+      normalizeOptions.push({
+        name,
+        type,
+        deprecated: deprecatedOptions[name],
+        aliases: alias?.length > 0 ? alias : void 0,
+        default: defaultVal[name],
+        required: demandedOptions[name],
+        enum: choices[name],
+        description: descriptions[name]?.replace("__yargsString__:", ""),
+        positional: positionalIndex >= 0 ? positionalIndex : void 0
+      });
     }
-    const colorLevels = {
-        info: (s) => s,
-        debug: (s) => s,
-        warn: (s) => color_1.colors.bold(color_1.colors.yellow(s)),
-        error: (s) => color_1.colors.bold(color_1.colors.red(s)),
-        fatal: (s) => color_1.colors.bold(color_1.colors.red(s)),
-    };
-    const logger = new core_1.logging.IndentLogger('cli-main-logger');
-    const logInfo = console.log;
-    const logWarn = console.warn;
-    const logError = console.error;
-    const useColor = (0, color_1.supportColor)();
-    const loggerFinished = logger.forEach((entry) => {
-        if (!environment_options_1.ngDebug && entry.level === 'debug') {
-            return;
-        }
-        const color = useColor ? colorLevels[entry.level] : node_util_1.stripVTControlCharacters;
-        const message = color(entry.message);
-        switch (entry.level) {
-            case 'warn':
-            case 'fatal':
-            case 'error':
-                logError(message);
-                break;
-            default:
-                logInfo(message);
-                break;
-        }
-    });
-    // Redirect console to logger
-    console.info = console.log = function (...args) {
-        logger.info((0, node_util_1.format)(...args));
+  }
+  const subcommands = usageInstance.getCommands().map(([name, rawDescription2, isDefault, aliases2, deprecated]) => ({
+    name: name.split(" ", 1)[0].replace(yargsDefaultCommandRegExp, ""),
+    command: name.replace(yargsDefaultCommandRegExp, ""),
+    default: isDefault || void 0,
+    ...parseDescription(rawDescription2),
+    aliases: aliases2,
+    deprecated
+  })).sort((a, b) => a.name.localeCompare(b.name));
+  const [command, rawDescription] = usageInstance.getUsage()[0] ?? [];
+  const defaultSubCommand = subcommands.find((x) => x.default)?.command ?? "";
+  const otherSubcommands = subcommands.filter((s) => !s.default);
+  const output = {
+    name: [...context.commands].pop(),
+    command: `${command?.replace(yargsDefaultCommandRegExp, localYargsInstance["$0"])}${defaultSubCommand}`,
+    ...parseDescription(rawDescription),
+    options: normalizeOptions.sort((a, b) => a.name.localeCompare(b.name)),
+    subcommands: otherSubcommands.length ? otherSubcommands : void 0
+  };
+  return JSON.stringify(output, void 0, 2);
+}
+function parseDescription(rawDescription) {
+  try {
+    const { longDescription, describe: shortDescription, longDescriptionRelativePath } = JSON.parse(rawDescription);
+    return {
+      shortDescription,
+      longDescriptionRelativePath,
+      longDescription
     };
-    console.warn = function (...args) {
-        logger.warn((0, node_util_1.format)(...args));
+  } catch {
+    return {
+      shortDescription: rawDescription
     };
-    console.error = function (...args) {
-        logger.error((0, node_util_1.format)(...args));
+  }
+}
+
+// packages/angular/cli/src/command-builder/utilities/normalize-options-middleware.js
+function createNormalizeOptionsMiddleware(localeYargs) {
+  return (args) => {
+    const { array } = localeYargs.getOptions();
+    const arrayOptions = new Set(array);
+    for (const [key, value] of Object.entries(args)) {
+      if (key !== "_" && Array.isArray(value) && !arrayOptions.has(key)) {
+        const newValue = value.pop();
+        console.warn(`Option '${key}' has been specified multiple times. The value '${newValue}' will be used.`);
+        args[key] = newValue;
+      }
+    }
+  };
+}
+
+// packages/angular/cli/src/command-builder/command-runner.js
+async function runCommand(args, logger) {
+  const { $0, _, help = false, dryRun = false, jsonHelp = false, getYargsCompletions = false, ...rest } = yargsParser(args, {
+    boolean: ["help", "json-help", "get-yargs-completions", "dry-run"],
+    alias: { "collection": "c" }
+  });
+  const positional = getYargsCompletions ? _.slice(1) : _;
+  let workspace;
+  let globalConfiguration;
+  try {
+    [workspace, globalConfiguration] = await Promise.all([
+      getWorkspace("local"),
+      getWorkspace("global")
+    ]);
+  } catch (e) {
+    assertIsError(e);
+    logger.fatal(e.message);
+    return 1;
+  }
+  const root = workspace?.basePath ?? process.cwd();
+  const cacheConfig = workspace && getCacheConfig(workspace);
+  const packageManager = await createPackageManager({
+    cwd: root,
+    logger,
+    dryRun: dryRun || help || jsonHelp || getYargsCompletions,
+    tempDirectory: cacheConfig?.enabled ? cacheConfig.path : void 0,
+    configuredPackageManager: await getConfiguredPackageManager(root, workspace, globalConfiguration)
+  });
+  const localYargs = yargs(args);
+  const context = {
+    globalConfiguration,
+    workspace,
+    logger,
+    currentDirectory: process.cwd(),
+    yargsInstance: localYargs,
+    root,
+    packageManager,
+    args: {
+      positional: positional.map((v) => v.toString()),
+      options: {
+        help,
+        jsonHelp,
+        getYargsCompletions,
+        ...rest
+      }
+    }
+  };
+  for (const CommandModule of await getCommandsToRegister(positional[0])) {
+    addCommandModuleToYargs(CommandModule, context);
+  }
+  const usageInstance = localYargs.getInternalMethods().getUsageInstance();
+  if (jsonHelp) {
+    usageInstance.help = () => jsonHelpUsage(localYargs);
+  } else if (!help) {
+    usageInstance.cacheHelpMessage = () => {
     };
-    try {
-        return await (0, command_runner_1.runCommand)(options.cliArgs, logger);
+  }
+  localYargs.command("*", false, (builder) => builder.version("version", "Show Angular CLI version.", VERSION.full));
+  await localYargs.scriptName("ng").parserConfiguration({
+    "populate--": true,
+    "unknown-options-as-args": false,
+    "dot-notation": false,
+    "boolean-negation": true,
+    "strip-aliased": true,
+    "strip-dashed": true,
+    "camel-case-expansion": false
+  }).option("json-help", {
+    describe: "Show help in JSON format.",
+    implies: ["help"],
+    hidden: true,
+    type: "boolean"
+  }).help("help", "Shows a help message for this command in the console.").updateStrings({
+    "Commands:": colors.cyan("Commands:"),
+    "Options:": colors.cyan("Options:"),
+    "Positionals:": colors.cyan("Arguments:"),
+    "deprecated": colors.yellow("deprecated"),
+    "deprecated: %s": colors.yellow("deprecated:") + " %s",
+    "Did you mean %s?": "Unknown command. Did you mean %s?"
+  }).epilogue("For more information, see https://angular.dev/cli/.\n").demandCommand(1, demandCommandFailureMessage).recommendCommands().middleware(createNormalizeOptionsMiddleware(localYargs)).version(false).showHelpOnFail(false).strict().fail((msg, err) => {
+    throw msg ? (
+      // Validation failed example: `Unknown argument:`
+      new CommandModuleError(msg)
+    ) : (
+      // Unknown exception, re-throw.
+      err
+    );
+  }).wrap(localYargs.terminalWidth()).parseAsync();
+  return +(process.exitCode ?? 0);
+}
+async function getCommandsToRegister(commandName) {
+  const commands = [];
+  if (commandName in RootCommands) {
+    commands.push(RootCommands[commandName]);
+  } else if (commandName in RootCommandsAliases) {
+    commands.push(RootCommandsAliases[commandName]);
+  } else {
+    Object.values(RootCommands).forEach((c) => commands.push(c));
+  }
+  return Promise.all(commands.map((command) => command.factory().then((m) => m.default)));
+}
+async function getConfiguredPackageManager(root, localWorkspace, globalWorkspace) {
+  let result;
+  try {
+    const packageJsonPath = join(root, "package.json");
+    const pkgJson = JSON.parse(await readFile(packageJsonPath, "utf-8"));
+    result = getPackageManager(pkgJson);
+  } catch {
+  }
+  if (result) {
+    return result;
+  }
+  if (localWorkspace) {
+    const project = getProjectByCwd(localWorkspace);
+    if (project) {
+      result = getPackageManager(localWorkspace.projects.get(project)?.extensions["cli"]);
     }
-    catch (err) {
-        if (err instanceof command_module_1.CommandModuleError) {
-            logger.fatal(`Error: ${err.message}`);
-        }
-        else if (err instanceof Error) {
-            try {
-                const logPath = (0, log_file_1.writeErrorToLogFile)(err);
-                logger.fatal(`An unhandled exception occurred: ${err.message}\n` +
-                    `See "${logPath}" for further details.`);
-            }
-            catch (e) {
-                logger.fatal(`An unhandled exception occurred: ${err.message}\n` +
-                    `Fatal error writing debug log file: ${e}`);
-                if (err.stack) {
-                    logger.fatal(err.stack);
-                }
-            }
-            return 127;
-        }
-        else if (typeof err === 'string') {
-            logger.fatal(err);
-        }
-        else if (typeof err === 'number') {
-            // Log nothing.
-        }
-        else {
-            logger.fatal(`An unexpected error occurred: ${err}`);
-        }
-        return 1;
+    result ??= getPackageManager(localWorkspace.extensions["cli"]);
+  }
+  result ??= getPackageManager(globalWorkspace.extensions["cli"]);
+  return result;
+}
+function getPackageManager(source) {
+  if (source && isJsonObject(source)) {
+    const value = source["packageManager"];
+    if (typeof value === "string") {
+      return value.split("@", 2);
+    }
+  }
+  return void 0;
+}
+
+// packages/angular/cli/lib/cli/index.js
+async function execute(options) {
+  if (!isNodeVersionMinSupported()) {
+    process.stderr.write(`Node.js version ${process.version} detected.
+The Angular CLI requires a minimum of v${supportedNodeVersions[0]}.
+
+Please update your Node.js version or visit https://nodejs.org/ for additional instructions.
+`);
+    return 3;
+  }
+  const colorLevels = {
+    info: (s) => s,
+    debug: (s) => s,
+    warn: (s) => colors.bold(colors.yellow(s)),
+    error: (s) => colors.bold(colors.red(s)),
+    fatal: (s) => colors.bold(colors.red(s))
+  };
+  const logger = new logging.IndentLogger("cli-main-logger");
+  const logInfo = console.log;
+  const logWarn = console.warn;
+  const logError = console.error;
+  const useColor = supportColor();
+  const loggerFinished = logger.forEach((entry) => {
+    if (!ngDebug && entry.level === "debug") {
+      return;
     }
-    finally {
-        logger.complete();
-        await loggerFinished;
-        // Restore original console methods so that late consumers
-        // (e.g. process.on('exit') handlers) still produce output.
-        console.log = console.info = logInfo;
-        console.warn = logWarn;
-        console.error = logError;
+    const color = useColor ? colorLevels[entry.level] : stripVTControlCharacters;
+    const message = color(entry.message);
+    switch (entry.level) {
+      case "warn":
+      case "fatal":
+      case "error":
+        logError(message);
+        break;
+      default:
+        logInfo(message);
+        break;
     }
+  });
+  console.info = console.log = function(...args) {
+    logger.info(format(...args));
+  };
+  console.warn = function(...args) {
+    logger.warn(format(...args));
+  };
+  console.error = function(...args) {
+    logger.error(format(...args));
+  };
+  try {
+    return await runCommand(options.cliArgs, logger);
+  } catch (err) {
+    if (err instanceof CommandModuleError) {
+      logger.fatal(`Error: ${err.message}`);
+    } else if (err instanceof Error) {
+      try {
+        const logPath = writeErrorToLogFile(err);
+        logger.fatal(`An unhandled exception occurred: ${err.message}
+See "${logPath}" for further details.`);
+      } catch (e) {
+        logger.fatal(`An unhandled exception occurred: ${err.message}
+Fatal error writing debug log file: ${e}`);
+        if (err.stack) {
+          logger.fatal(err.stack);
+        }
+      }
+      return 127;
+    } else if (typeof err === "string") {
+      logger.fatal(err);
+    } else if (typeof err === "number") {
+    } else {
+      logger.fatal(`An unexpected error occurred: ${err}`);
+    }
+    return 1;
+  } finally {
+    logger.complete();
+    await loggerFinished;
+    console.log = console.info = logInfo;
+    console.warn = logWarn;
+    console.error = logError;
+  }
 }
-//# sourceMappingURL=index.js.map
+export {
+  VERSION,
+  execute as default
+};
+/**
+ * @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.dev/license
+ */

package/lib/cli-4CMZ6KMR.js

@@ -0,0 +1,48 @@
+import {
+  ArchitectCommandModule
+} from "./chunk-CAZUOCTC.js";
+import "./chunk-DHWVZMLH.js";
+import "./chunk-YM7ILCS5.js";
+import "./chunk-XG3HVNIL.js";
+import "./chunk-GHUUJYOY.js";
+import "./chunk-FZ5GFCWU.js";
+
+// packages/angular/cli/src/commands/deploy/long-description.md
+var long_description_default = 'The command takes an optional project name, as specified in the `projects` section of the `angular.json` workspace configuration file.\nWhen a project name is not supplied, executes the `deploy` builder for the default project.\n\nTo use the `ng deploy` command, use `ng add` to add a package that implements deployment capabilities to your favorite platform.\nAdding the package automatically updates your workspace configuration, adding a deployment\n[CLI builder](tools/cli/cli-builder).\nFor example:\n\n```json\n"projects": {\n  "my-project": {\n    ...\n    "architect": {\n      ...\n      "deploy": {\n        "builder": "@angular/fire:deploy",\n        "options": {}\n      }\n    }\n  }\n}\n```\n';
+
+// packages/angular/cli/src/commands/deploy/cli.js
+var DeployCommandModule = class extends ArchitectCommandModule {
+  // The below choices should be kept in sync with the list in https://angular.dev/tools/cli/deployment
+  missingTargetChoices = [
+    {
+      name: "Amazon S3",
+      value: "@jefiozie/ngx-aws-deploy"
+    },
+    {
+      name: "Firebase",
+      value: "@angular/fire"
+    },
+    {
+      name: "Netlify",
+      value: "@netlify-builder/deploy"
+    },
+    {
+      name: "GitHub Pages",
+      value: "angular-cli-ghpages"
+    }
+  ];
+  multiTarget = false;
+  command = "deploy [project]";
+  longDescription = long_description_default;
+  describe = "Invokes the deploy builder for a specified project or for the default project in the workspace.";
+};
+export {
+  DeployCommandModule as default
+};
+/**
+ * @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.dev/license
+ */

package/lib/cli-4Q7DGTBA.js

@@ -0,0 +1,33 @@
+import {
+  ArchitectCommandModule
+} from "./chunk-CAZUOCTC.js";
+import "./chunk-DHWVZMLH.js";
+import {
+  RootCommands
+} from "./chunk-5AASRQKS.js";
+import "./chunk-YM7ILCS5.js";
+import "./chunk-XG3HVNIL.js";
+import "./chunk-GHUUJYOY.js";
+import "./chunk-FZ5GFCWU.js";
+
+// packages/angular/cli/src/commands/test/long-description.md
+var long_description_default = "Takes the name of the project, as specified in the `projects` section of the `angular.json` workspace configuration file.\nWhen a project name is not supplied, it will execute for all projects.\n";
+
+// packages/angular/cli/src/commands/test/cli.js
+var TestCommandModule = class extends ArchitectCommandModule {
+  multiTarget = true;
+  command = "test [project]";
+  aliases = RootCommands["test"].aliases;
+  describe = "Runs unit tests in a project.";
+  longDescription = long_description_default;
+};
+export {
+  TestCommandModule as default
+};
+/**
+ * @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.dev/license
+ */

package/lib/cli-6AHY7ADW.js

@@ -0,0 +1,96 @@
+import {
+  ArchitectBaseCommandModule
+} from "./chunk-DHWVZMLH.js";
+import {
+  CommandModuleError,
+  CommandScope
+} from "./chunk-YM7ILCS5.js";
+import "./chunk-XG3HVNIL.js";
+import "./chunk-GHUUJYOY.js";
+import "./chunk-FZ5GFCWU.js";
+
+// packages/angular/cli/src/commands/run/long-description.md
+var long_description_default = "Architect is the tool that the CLI uses to perform complex tasks such as compilation, according to provided configurations.\nThe CLI commands run Architect targets such as `build`, `serve`, `test`, and `lint`.\nEach named target has a default configuration, specified by an `options` object,\nand an optional set of named alternate configurations in the `configurations` object.\n\nFor example, the `serve` target for a newly generated app has a predefined\nalternate configuration named `production`.\n\nYou can define new targets and their configuration options in the `architect` section\nof the `angular.json` file which you can run them from the command line using the `ng run` command.\n";
+
+// packages/angular/cli/src/commands/run/cli.js
+var RunCommandModule = class extends ArchitectBaseCommandModule {
+  scope = CommandScope.In;
+  command = "run <target>";
+  describe = "Runs an Architect target with an optional custom builder configuration defined in your project.";
+  longDescription = long_description_default;
+  async builder(argv) {
+    const { jsonHelp, getYargsCompletions, help } = this.context.args.options;
+    const localYargs = argv.positional("target", {
+      describe: "The Architect target to run provided in the following format `project:target[:configuration]`.",
+      type: "string",
+      demandOption: true,
+      // Show only in when using --help and auto completion because otherwise comma seperated configuration values will be invalid.
+      // Also, hide choices from JSON help so that we don't display them in AIO.
+      choices: (getYargsCompletions || help) && !jsonHelp ? this.getTargetChoices() : void 0
+    }).middleware((args) => {
+      const { configuration, target: target2 } = args;
+      if (typeof configuration === "string" && target2) {
+        const targetWithConfig = target2.split(":", 2);
+        targetWithConfig.push(configuration);
+        throw new CommandModuleError(`Unknown argument: configuration.
+Provide the configuration as part of the target 'ng run ${targetWithConfig.join(":")}'.`);
+      }
+    }, true).strict();
+    const target = this.makeTargetSpecifier();
+    if (!target) {
+      return localYargs;
+    }
+    const schemaOptions = await this.getArchitectTargetOptions(target);
+    return this.addSchemaOptionsToCommand(localYargs, schemaOptions);
+  }
+  async run(options) {
+    const target = this.makeTargetSpecifier(options);
+    const { target: _target, ...extraOptions } = options;
+    if (!target) {
+      throw new CommandModuleError("Cannot determine project or target.");
+    }
+    return this.runSingleTarget(target, extraOptions);
+  }
+  makeTargetSpecifier(options) {
+    const architectTarget = options?.target ?? this.context.args.positional[1];
+    if (!architectTarget) {
+      return void 0;
+    }
+    const [project = "", target = "", configuration] = architectTarget.split(":");
+    return {
+      project,
+      target,
+      configuration
+    };
+  }
+  /** @returns a sorted list of target specifiers to be used for auto completion. */
+  getTargetChoices() {
+    if (!this.context.workspace) {
+      return;
+    }
+    const targets = [];
+    for (const [projectName, project] of this.context.workspace.projects) {
+      for (const [targetName, target] of project.targets) {
+        const currentTarget = `${projectName}:${targetName}`;
+        targets.push(currentTarget);
+        if (!target.configurations) {
+          continue;
+        }
+        for (const configName of Object.keys(target.configurations)) {
+          targets.push(`${currentTarget}:${configName}`);
+        }
+      }
+    }
+    return targets.sort();
+  }
+};
+export {
+  RunCommandModule as default
+};
+/**
+ * @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.dev/license
+ */