@angular/cli 22.2.1 → 22.3.0-next.0

package/bin/ng.js

@@ -12,7 +12,7 @@
 'use strict';
 
 const path = require('path');
-const nodeUtils = require('../src/utilities/node-version');
+const nodeUtils = require('./version');
 
 // Error if the external CLI appears to be used inside a google3 context.
 if (process.cwd().split(path.sep).includes('google3')) {
@@ -43,20 +43,19 @@ if (rawCommandName === '--get-yargs-completions' || rawCommandName === 'completi
 // This node version check ensures that extremely old versions of node are not used.
 // These may not support ES2015 features such as const/let/async/await/etc.
 // These would then crash with a hard to diagnose error message.
-const [major] = process.versions.node.split('.', 1).map((part) => Number(part));
-
-if (major === 23 || major === 25) {
-  // Allow new odd numbered releases with a warning.
+if (nodeUtils.isNodeVersionSupported()) {
+  require('./bootstrap');
+} else if (nodeUtils.isNodeVersionRunnable()) {
   console.warn(
     'Node.js version ' +
       process.version +
       ' detected.\n' +
-      'Prior to version 27, odd numbered Node.js versions will not enter LTS status and should not be used for production.' +
-      ' For more information, please see https://nodejs.org/en/about/previous-releases/.',
+      'The Angular CLI has not been officially tested on this Node.js version and it is not supported for production use.\n' +
+      'For more information, please see https://nodejs.org/en/about/previous-releases/.',
   );
 
   require('./bootstrap');
-} else if (!nodeUtils.isNodeVersionSupported()) {
+} else {
   // Error and exit if less than the supported versions.
   console.error(
     'Node.js version ' +
@@ -69,6 +68,4 @@ if (major === 23 || major === 25) {
   );
 
   process.exitCode = 3;
-} else {
-  require('./bootstrap');
 }

package/bin/version.js

@@ -0,0 +1,98 @@
+'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
+ */
+
+/**
+ * The supported Node.js version for the Angular CLI.
+ */
+var SUPPORTED_NODE_VERSIONS = '^22.22.3 || ^24.15.0 || >=26.0.0';
+
+/**
+ * The version of the Angular CLI.
+ */
+var VERSION = '22.3.0-next.0';
+
+/**
+ * The supported Node.js versions.
+ */
+var supportedNodeVersions = SUPPORTED_NODE_VERSIONS.replace(/[\^~<>=]/g, '')
+  .split('||')
+  .map(function (v) {
+    return v.trim();
+  });
+
+/**
+ * Checks if the current Node.js version is officially supported.
+ * @param {string} [currentVersion] Optional Node.js version string to check. Defaults to `process.versions.node`.
+ * @param {string[]} [supportedVersions] Optional supported versions array. Defaults to `supportedNodeVersions`.
+ * @returns {boolean} `true` if the current Node.js version is officially supported, `false` otherwise.
+ */
+function isNodeVersionSupported(currentVersion, supportedVersions) {
+  if (SUPPORTED_NODE_VERSIONS.charAt(0) === '0' && !supportedVersions && !currentVersion) {
+    return true;
+  }
+
+  var parts = (currentVersion || process.versions.node).split('.', 3).map(Number);
+  var processMajor = parts[0];
+  var processMinor = parts[1];
+  var processPatch = parts[2];
+
+  var versions = supportedVersions || supportedNodeVersions;
+  for (var i = 0; i < versions.length; i++) {
+    var vParts = versions[i].split('.', 3).map(Number);
+    var major = vParts[0];
+    var minor = vParts[1];
+    var patch = vParts[2];
+    if (
+      (major === processMajor && processMinor === minor && processPatch >= patch) ||
+      (major === processMajor && processMinor > minor)
+    ) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Checks if the current Node.js version is runnable (newer than supported LTS or an interim odd release).
+ * @param {string} [currentVersion] Optional Node.js version string to check. Defaults to `process.versions.node`.
+ * @param {string[]} [supportedVersions] Optional supported versions array. Defaults to `supportedNodeVersions`.
+ * @returns {boolean} `true` if the current Node.js version is runnable, `false` otherwise.
+ */
+function isNodeVersionRunnable(currentVersion, supportedVersions) {
+  if (SUPPORTED_NODE_VERSIONS.charAt(0) === '0' && !supportedVersions && !currentVersion) {
+    return false;
+  }
+
+  var processMajor = Number((currentVersion || process.versions.node).split('.', 1)[0]);
+  var versions = supportedVersions || supportedNodeVersions;
+
+  var minMajor = Number(versions[0].split('.', 1)[0]);
+  var maxMajor = Number(versions[versions.length - 1].split('.', 1)[0]);
+
+  // Versions newer than the maximum supported major (e.g. Node 27, 28+)
+  if (processMajor > maxMajor) {
+    return true;
+  }
+
+  // Odd-numbered interim releases between min and max (e.g. Node 23, 25)
+  if (processMajor > minMajor && processMajor % 2 === 1) {
+    return true;
+  }
+
+  return false;
+}
+
+module.exports = {
+  VERSION: VERSION,
+  SUPPORTED_NODE_VERSIONS: SUPPORTED_NODE_VERSIONS,
+  supportedNodeVersions: supportedNodeVersions,
+  isNodeVersionSupported: isNodeVersionSupported,
+  isNodeVersionRunnable: isNodeVersionRunnable,
+};

package/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @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
+ */
+
+export declare class Version {
+  readonly full: string;
+  readonly major: string;
+  readonly minor: string;
+  readonly patch: string;
+  constructor(full: string);
+}
+
+export declare const VERSION: Version;
+
+export default function execute(options: { cliArgs: string[] }): Promise<number>;

package/lib/chunk-5AASRQKS.js

@@ -0,0 +1,85 @@
+// packages/angular/cli/src/commands/command-config.js
+var RootCommands = {
+  "add": {
+    factory: () => import("./cli-PDCEX7HQ.js")
+  },
+  "analytics": {
+    factory: () => import("./cli-LYBZEMDR.js")
+  },
+  "build": {
+    factory: () => import("./cli-Y2ECUR33.js"),
+    aliases: ["b"]
+  },
+  "cache": {
+    factory: () => import("./cli-PU5VH7JB.js")
+  },
+  "completion": {
+    factory: () => import("./cli-QUH44NUB.js")
+  },
+  "config": {
+    factory: () => import("./cli-A5UAJDO6.js")
+  },
+  "deploy": {
+    factory: () => import("./cli-4CMZ6KMR.js")
+  },
+  "e2e": {
+    factory: () => import("./cli-PJVTDBQM.js"),
+    aliases: ["e"]
+  },
+  "extract-i18n": {
+    factory: () => import("./cli-VVITNTBC.js")
+  },
+  "generate": {
+    factory: () => import("./cli-YDSMJOSO.js"),
+    aliases: ["g"]
+  },
+  "lint": {
+    factory: () => import("./cli-BQRFWIMG.js")
+  },
+  "make-this-awesome": {
+    factory: () => import("./cli-CWICUPZW.js")
+  },
+  "mcp": {
+    factory: () => import("./cli-ACLGUIBI.js")
+  },
+  "new": {
+    factory: () => import("./cli-L4TM4JH3.js"),
+    aliases: ["n"]
+  },
+  "run": {
+    factory: () => import("./cli-6AHY7ADW.js")
+  },
+  "serve": {
+    factory: () => import("./cli-DWQUM3M2.js"),
+    aliases: ["dev", "s"]
+  },
+  "test": {
+    factory: () => import("./cli-4Q7DGTBA.js"),
+    aliases: ["t"]
+  },
+  "update": {
+    factory: () => import("./cli-XM4L4PP4.js")
+  },
+  "version": {
+    factory: () => import("./cli-PRIRL3WP.js"),
+    aliases: ["v"]
+  }
+};
+var RootCommandsAliases = Object.values(RootCommands).reduce((prev, current) => {
+  current.aliases?.forEach((alias) => {
+    prev[alias] = current;
+  });
+  return prev;
+}, {});
+
+export {
+  RootCommands,
+  RootCommandsAliases
+};
+/**
+ * @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/chunk-A2VIYA2E.js

@@ -0,0 +1,165 @@
+// packages/angular/cli/src/commands/cache/utilities.js
+import { isJsonObject } from "@angular-devkit/core";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+
+// packages/angular/cli/lib/config/workspace-schema.js
+var Environment;
+(function(Environment2) {
+  Environment2["All"] = "all";
+  Environment2["Ci"] = "ci";
+  Environment2["Local"] = "local";
+})(Environment || (Environment = {}));
+var PackageManager;
+(function(PackageManager2) {
+  PackageManager2["Bun"] = "bun";
+  PackageManager2["Npm"] = "npm";
+  PackageManager2["Pnpm"] = "pnpm";
+  PackageManager2["Yarn"] = "yarn";
+})(PackageManager || (PackageManager = {}));
+var FileNameStyleGuide;
+(function(FileNameStyleGuide2) {
+  FileNameStyleGuide2["The2016"] = "2016";
+  FileNameStyleGuide2["The2025"] = "2025";
+})(FileNameStyleGuide || (FileNameStyleGuide = {}));
+var SchematicsAngularApplicationStyle;
+(function(SchematicsAngularApplicationStyle2) {
+  SchematicsAngularApplicationStyle2["Css"] = "css";
+  SchematicsAngularApplicationStyle2["Less"] = "less";
+  SchematicsAngularApplicationStyle2["Sass"] = "sass";
+  SchematicsAngularApplicationStyle2["Scss"] = "scss";
+  SchematicsAngularApplicationStyle2["Tailwind"] = "tailwind";
+})(SchematicsAngularApplicationStyle || (SchematicsAngularApplicationStyle = {}));
+var TestRunner;
+(function(TestRunner2) {
+  TestRunner2["Karma"] = "karma";
+  TestRunner2["Vitest"] = "vitest";
+})(TestRunner || (TestRunner = {}));
+var ViewEncapsulation;
+(function(ViewEncapsulation2) {
+  ViewEncapsulation2["Emulated"] = "Emulated";
+  ViewEncapsulation2["None"] = "None";
+  ViewEncapsulation2["ShadowDom"] = "ShadowDom";
+})(ViewEncapsulation || (ViewEncapsulation = {}));
+var ChangeDetection;
+(function(ChangeDetection2) {
+  ChangeDetection2["Eager"] = "Eager";
+  ChangeDetection2["OnPush"] = "OnPush";
+})(ChangeDetection || (ChangeDetection = {}));
+var SchematicsAngularComponentStyle;
+(function(SchematicsAngularComponentStyle2) {
+  SchematicsAngularComponentStyle2["Css"] = "css";
+  SchematicsAngularComponentStyle2["Less"] = "less";
+  SchematicsAngularComponentStyle2["None"] = "none";
+  SchematicsAngularComponentStyle2["Sass"] = "sass";
+  SchematicsAngularComponentStyle2["Scss"] = "scss";
+})(SchematicsAngularComponentStyle || (SchematicsAngularComponentStyle = {}));
+var Implement;
+(function(Implement2) {
+  Implement2["CanActivate"] = "CanActivate";
+  Implement2["CanActivateChild"] = "CanActivateChild";
+  Implement2["CanDeactivate"] = "CanDeactivate";
+  Implement2["CanMatch"] = "CanMatch";
+})(Implement || (Implement = {}));
+var TypeSeparator;
+(function(TypeSeparator2) {
+  TypeSeparator2["Empty"] = "-";
+  TypeSeparator2["TypeSeparator"] = ".";
+})(TypeSeparator || (TypeSeparator = {}));
+var AiConfig;
+(function(AiConfig2) {
+  AiConfig2["ClaudeCode"] = "claude-code";
+  AiConfig2["Cursor"] = "cursor";
+  AiConfig2["GeminiCli"] = "gemini-cli";
+  AiConfig2["None"] = "none";
+  AiConfig2["OpenAiCodex"] = "open-ai-codex";
+  AiConfig2["Vscode"] = "vscode";
+})(AiConfig || (AiConfig = {}));
+
+// packages/angular/cli/src/commands/cache/utilities.js
+function updateCacheConfig(workspace, key, value) {
+  const cli = workspace.extensions["cli"] ??= {};
+  const cache = cli["cache"] ??= {};
+  cache[key] = value;
+  return workspace.save();
+}
+function getCacheBasePath(workspaceRoot, cachePathSetting) {
+  if (isAbsolute(cachePathSetting)) {
+    return cachePathSetting;
+  }
+  try {
+    let currentDir = workspaceRoot;
+    while (true) {
+      const gitPath = join(currentDir, ".git");
+      if (existsSync(gitPath)) {
+        const stat = statSync(gitPath);
+        if (stat.isFile()) {
+          const content = readFileSync(gitPath, "utf8");
+          const match = /^gitdir:\s*(.+)$/m.exec(content);
+          if (match) {
+            const gitdir = resolve(currentDir, match[1].trim());
+            const commondirPath = join(gitdir, "commondir");
+            if (existsSync(commondirPath)) {
+              const commondir = readFileSync(commondirPath, "utf8").trim();
+              const commonGitDir = resolve(gitdir, commondir);
+              const relativeWorkspacePath = relative(currentDir, workspaceRoot);
+              const mainWorkspaceRoot = resolve(dirname(commonGitDir), relativeWorkspacePath);
+              if (existsSync(mainWorkspaceRoot)) {
+                return resolve(mainWorkspaceRoot, cachePathSetting);
+              }
+            }
+          }
+        }
+        break;
+      }
+      const parentDir = dirname(currentDir);
+      if (parentDir === currentDir) {
+        break;
+      }
+      currentDir = parentDir;
+    }
+  } catch {
+  }
+  return resolve(workspaceRoot, cachePathSetting);
+}
+function getCacheConfig(workspace) {
+  if (!workspace) {
+    throw new Error(`Cannot retrieve cache configuration as workspace is not defined.`);
+  }
+  const defaultSettings = {
+    path: getCacheBasePath(workspace.basePath, ".angular/cache"),
+    environment: Environment.Local,
+    enabled: true
+  };
+  const cliSetting = workspace.extensions["cli"];
+  if (!cliSetting || !isJsonObject(cliSetting)) {
+    return defaultSettings;
+  }
+  const cacheSettings = cliSetting["cache"];
+  if (!isJsonObject(cacheSettings)) {
+    return defaultSettings;
+  }
+  const {
+    path = ".angular/cache",
+    environment = defaultSettings.environment,
+    enabled = defaultSettings.enabled
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  } = cacheSettings;
+  return {
+    path: getCacheBasePath(workspace.basePath, path),
+    environment,
+    enabled
+  };
+}
+
+export {
+  updateCacheConfig,
+  getCacheConfig
+};
+/**
+ * @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/chunk-CAZUOCTC.js

@@ -0,0 +1,225 @@
+import {
+  ArchitectBaseCommandModule
+} from "./chunk-DHWVZMLH.js";
+import {
+  CommandModuleError,
+  memoize
+} from "./chunk-YM7ILCS5.js";
+import {
+  getProjectByCwd
+} from "./chunk-FZ5GFCWU.js";
+
+// packages/angular/cli/src/command-builder/architect-command-module.js
+var __runInitializers = function(thisArg, initializers, value) {
+  var useValue = arguments.length > 2;
+  for (var i = 0; i < initializers.length; i++) {
+    value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+  }
+  return useValue ? value : void 0;
+};
+var __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+  function accept(f) {
+    if (f !== void 0 && typeof f !== "function")
+      throw new TypeError("Function expected");
+    return f;
+  }
+  var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+  var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+  var _, done = false;
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    var context = {};
+    for (var p in contextIn)
+      context[p] = p === "access" ? {} : contextIn[p];
+    for (var p in contextIn.access)
+      context.access[p] = contextIn.access[p];
+    context.addInitializer = function(f) {
+      if (done)
+        throw new TypeError("Cannot add initializers after decoration has completed");
+      extraInitializers.push(accept(f || null));
+    };
+    var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+    if (kind === "accessor") {
+      if (result === void 0)
+        continue;
+      if (result === null || typeof result !== "object")
+        throw new TypeError("Object expected");
+      if (_ = accept(result.get))
+        descriptor.get = _;
+      if (_ = accept(result.set))
+        descriptor.set = _;
+      if (_ = accept(result.init))
+        initializers.unshift(_);
+    } else if (_ = accept(result)) {
+      if (kind === "field")
+        initializers.unshift(_);
+      else
+        descriptor[key] = _;
+    }
+  }
+  if (target)
+    Object.defineProperty(target, contextIn.name, descriptor);
+  done = true;
+};
+var ArchitectCommandModule = (() => {
+  let _classSuper = ArchitectBaseCommandModule;
+  let _instanceExtraInitializers = [];
+  let _getProjectNamesByTarget_decorators;
+  return class ArchitectCommandModule extends _classSuper {
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      _getProjectNamesByTarget_decorators = [memoize];
+      __esDecorate(this, null, _getProjectNamesByTarget_decorators, { kind: "method", name: "getProjectNamesByTarget", static: false, private: false, access: { has: (obj) => "getProjectNamesByTarget" in obj, get: (obj) => obj.getProjectNamesByTarget }, metadata: _metadata }, null, _instanceExtraInitializers);
+      if (_metadata)
+        Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+    }
+    async builder(argv) {
+      const target = this.getArchitectTarget();
+      if (this.findDefaultBuilderName && this.context.workspace) {
+        for (const [project2, projectDefinition] of this.context.workspace.projects) {
+          const targetDefinition = projectDefinition.targets.get(target);
+          if (targetDefinition?.builder) {
+            continue;
+          }
+          const defaultBuilder = await this.findDefaultBuilderName(projectDefinition, {
+            project: project2,
+            target
+          });
+          if (!defaultBuilder) {
+            continue;
+          }
+          if (targetDefinition) {
+            targetDefinition.builder = defaultBuilder;
+          } else {
+            projectDefinition.targets.set(target, {
+              builder: defaultBuilder
+            });
+          }
+        }
+      }
+      const project = this.getArchitectProject();
+      const { jsonHelp, getYargsCompletions, help } = this.context.args.options;
+      const localYargs = argv.positional("project", {
+        describe: "The name of the project to build. Can be an application or a library.",
+        type: "string",
+        // Hide choices from JSON help so that we don't display them in AIO.
+        choices: jsonHelp ? void 0 : this.getProjectChoices()
+      }).option("configuration", {
+        describe: `One or more named builder configurations as a comma-separated list as specified in the "configurations" section in angular.json.
+The builder uses the named configurations to run the given target.
+For more information, see https://angular.dev/reference/configs/workspace-config#alternate-build-configurations.`,
+        alias: "c",
+        type: "string",
+        // 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 && project ? this.getConfigurationChoices(project) : void 0
+      }).strict();
+      if (!project) {
+        return localYargs;
+      }
+      const schemaOptions = await this.getArchitectTargetOptions({
+        project,
+        target
+      });
+      return this.addSchemaOptionsToCommand(localYargs, schemaOptions);
+    }
+    async run(options) {
+      const originalProcessTitle = process.title;
+      try {
+        const target = this.getArchitectTarget();
+        const { configuration = "", project, ...architectOptions } = options;
+        if (project) {
+          process.title = `${originalProcessTitle} (${project})`;
+          return await this.runSingleTarget({ configuration, target, project }, architectOptions);
+        }
+        let result = 0;
+        const projectNames = this.getProjectNamesByTarget(target);
+        if (!projectNames) {
+          return this.onMissingTarget("Cannot determine project or target for command.");
+        }
+        for (const project2 of projectNames) {
+          process.title = `${originalProcessTitle} (${project2})`;
+          result |= await this.runSingleTarget({ configuration, target, project: project2 }, architectOptions);
+        }
+        return result;
+      } finally {
+        process.title = originalProcessTitle;
+      }
+    }
+    getArchitectProject() {
+      const { options, positional } = this.context.args;
+      const [, projectName] = positional;
+      if (projectName) {
+        return projectName;
+      }
+      if (typeof options["project"] === "string") {
+        return options["project"];
+      }
+      const target = this.getArchitectTarget();
+      const projectFromTarget = this.getProjectNamesByTarget(target);
+      return projectFromTarget?.length ? projectFromTarget[0] : void 0;
+    }
+    getProjectNamesByTarget(target) {
+      const workspace = this.getWorkspaceOrThrow();
+      const allProjectsForTargetName = [];
+      for (const [name, project] of workspace.projects) {
+        if (project.targets.has(target)) {
+          allProjectsForTargetName.push(name);
+        }
+      }
+      if (allProjectsForTargetName.length === 0) {
+        return void 0;
+      }
+      if (this.multiTarget) {
+        return allProjectsForTargetName;
+      } else {
+        if (allProjectsForTargetName.length === 1) {
+          return allProjectsForTargetName;
+        }
+        const maybeProject = getProjectByCwd(workspace);
+        if (maybeProject) {
+          return allProjectsForTargetName.includes(maybeProject) ? [maybeProject] : void 0;
+        }
+        const { getYargsCompletions, help } = this.context.args.options;
+        if (!getYargsCompletions && !help) {
+          throw new CommandModuleError(`Cannot determine project for command.
+This is a multi-project workspace and more than one project supports this command. Run "ng ${this.command}" to execute the command for a specific project or change the current working directory to a project directory.
+
+Available projects are:
+${allProjectsForTargetName.sort().map((p) => `- ${p}`).join("\n")}`);
+        }
+      }
+      return void 0;
+    }
+    /** @returns a sorted list of project names to be used for auto completion. */
+    getProjectChoices() {
+      const { workspace } = this.context;
+      return workspace ? [...workspace.projects.keys()].sort() : void 0;
+    }
+    /** @returns a sorted list of configuration names to be used for auto completion. */
+    getConfigurationChoices(project) {
+      const projectDefinition = this.context.workspace?.projects.get(project);
+      if (!projectDefinition) {
+        return void 0;
+      }
+      const target = this.getArchitectTarget();
+      const configurations = projectDefinition.targets.get(target)?.configurations;
+      return configurations ? Object.keys(configurations).sort() : void 0;
+    }
+    constructor() {
+      super(...arguments);
+      __runInitializers(this, _instanceExtraInitializers);
+    }
+  };
+})();
+
+export {
+  ArchitectCommandModule
+};
+/**
+ * @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
+ */