@ng-atomic/schematics 20.67.0 → 20.69.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/lib/page/index.js CHANGED
@@ -2491,6 +2491,7 @@ var require_delegate = __commonJS({
2491
2491
  _other;
2492
2492
  constructor(_other) {
2493
2493
  this._other = _other;
2494
+ this[interface_1.TreeSymbol] = () => this;
2494
2495
  }
2495
2496
  branch() {
2496
2497
  return this._other.branch();
@@ -2549,9 +2550,6 @@ var require_delegate = __commonJS({
2549
2550
  get actions() {
2550
2551
  return this._other.actions;
2551
2552
  }
2552
- [interface_1.TreeSymbol]() {
2553
- return this;
2554
- }
2555
2553
  };
2556
2554
  exports2.DelegateTree = DelegateTree;
2557
2555
  }
@@ -4440,6 +4438,7 @@ var require_scoped = __commonJS({
4440
4438
  _root;
4441
4439
  constructor(_base, scope) {
4442
4440
  this._base = _base;
4441
+ this[interface_1.TreeSymbol] = () => this;
4443
4442
  const normalizedScope = (0, core_1.normalize)("/" + scope);
4444
4443
  this._root = new ScopedDirEntry(this._base.getDir(normalizedScope), normalizedScope);
4445
4444
  }
@@ -4526,9 +4525,6 @@ var require_scoped = __commonJS({
4526
4525
  }
4527
4526
  return scopedActions;
4528
4527
  }
4529
- [interface_1.TreeSymbol]() {
4530
- return this;
4531
- }
4532
4528
  _fullPath(path) {
4533
4529
  return (0, core_1.join)(this._root.scope, (0, core_1.normalize)("/" + path));
4534
4530
  }
@@ -4615,9 +4611,6 @@ var require_host_tree = __commonJS({
4615
4611
  _recordSync;
4616
4612
  _ancestry = /* @__PURE__ */ new Set();
4617
4613
  _dirCache = /* @__PURE__ */ new Map();
4618
- [interface_1.TreeSymbol]() {
4619
- return this;
4620
- }
4621
4614
  static isHostTree(tree) {
4622
4615
  if (tree instanceof _HostTree) {
4623
4616
  return true;
@@ -4629,6 +4622,7 @@ var require_host_tree = __commonJS({
4629
4622
  }
4630
4623
  constructor(_backend = new core_1.virtualFs.Empty()) {
4631
4624
  this._backend = _backend;
4625
+ this[interface_1.TreeSymbol] = () => this;
4632
4626
  this._record = new core_1.virtualFs.CordHost(new core_1.virtualFs.SafeReadonlyHost(_backend));
4633
4627
  this._recordSync = new core_1.virtualFs.SyncDelegateHost(this._record);
4634
4628
  }
@@ -14433,8 +14427,8 @@ var require_null = __commonJS({
14433
14427
  };
14434
14428
  exports2.NullTreeDirEntry = NullTreeDirEntry;
14435
14429
  var NullTree = class _NullTree {
14436
- [interface_1.TreeSymbol]() {
14437
- return this;
14430
+ constructor() {
14431
+ this[interface_1.TreeSymbol] = () => this;
14438
14432
  }
14439
14433
  branch() {
14440
14434
  return new _NullTree();
@@ -424703,7 +424697,7 @@ ${fromBody}`;
424703
424697
  exports22.parseString = parseString;
424704
424698
  }
424705
424699
  });
424706
- var require_package4 = __commonJS22({
424700
+ var require_package3 = __commonJS22({
424707
424701
  "node_modules/editorconfig/package.json"(exports22, module22) {
424708
424702
  module22.exports = {
424709
424703
  name: "editorconfig",
@@ -424905,7 +424899,7 @@ ${fromBody}`;
424905
424899
  var fnmatch_1 = __importDefault22(require_fnmatch());
424906
424900
  var ini_1 = require_ini();
424907
424901
  exports22.parseString = ini_1.parseString;
424908
- var package_json_1 = __importDefault22(require_package4());
424902
+ var package_json_1 = __importDefault22(require_package3());
424909
424903
  var knownProps = {
424910
424904
  end_of_line: true,
424911
424905
  indent_style: true,
@@ -444342,22 +444336,26 @@ var require_format_files = __commonJS({
444342
444336
  "use strict";
444343
444337
  Object.defineProperty(exports2, "__esModule", { value: true });
444344
444338
  exports2.formatFiles = formatFiles;
444339
+ var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
444345
444340
  var devkit_exports_1 = require("nx/src/devkit-exports");
444346
444341
  var devkit_internals_1 = require("nx/src/devkit-internals");
444347
- var path = require("path");
444342
+ var path = tslib_1.__importStar(require("path"));
444348
444343
  async function formatFiles(tree, options = {}) {
444344
+ options.sortRootTsconfigPaths ??= process.env.NX_FORMAT_SORT_TSCONFIG_PATHS === "true";
444345
+ if (options.sortRootTsconfigPaths) {
444346
+ sortTsConfig(tree);
444347
+ }
444348
+ if (process.env.NX_SKIP_FORMAT === "true") {
444349
+ return;
444350
+ }
444349
444351
  let prettier;
444350
444352
  try {
444351
- prettier = await Promise.resolve().then(() => require_prettier());
444353
+ prettier = await Promise.resolve().then(() => tslib_1.__importStar(require_prettier()));
444352
444354
  if (!(0, devkit_internals_1.isUsingPrettierInTree)(tree)) {
444353
444355
  return;
444354
444356
  }
444355
444357
  } catch {
444356
444358
  }
444357
- options.sortRootTsconfigPaths ??= process.env.NX_FORMAT_SORT_TSCONFIG_PATHS === "true";
444358
- if (options.sortRootTsconfigPaths) {
444359
- sortTsConfig(tree);
444360
- }
444361
444359
  if (!prettier)
444362
444360
  return;
444363
444361
  const files = new Set(tree.listChanges().filter((file) => file.type !== "DELETE"));
@@ -444713,16 +444711,18 @@ var require_binary_extensions = __commonJS({
444713
444711
  }
444714
444712
  });
444715
444713
 
444716
- // node_modules/ejs/lib/utils.js
444714
+ // node_modules/ejs/lib/cjs/utils.js
444717
444715
  var require_utils = __commonJS({
444718
- "node_modules/ejs/lib/utils.js"(exports2) {
444716
+ "node_modules/ejs/lib/cjs/utils.js"(exports2, module2) {
444719
444717
  "use strict";
444718
+ Object.defineProperty(exports2, "__esModule", { value: true });
444719
+ var utils = {};
444720
444720
  var regExpChars = /[|\\{}()[\]^$+*?.]/g;
444721
444721
  var hasOwnProperty = Object.prototype.hasOwnProperty;
444722
444722
  var hasOwn = function(obj, key) {
444723
444723
  return hasOwnProperty.apply(obj, [key]);
444724
444724
  };
444725
- exports2.escapeRegExpChars = function(string) {
444725
+ utils.escapeRegExpChars = function(string) {
444726
444726
  if (!string) {
444727
444727
  return "";
444728
444728
  }
@@ -444751,7 +444751,7 @@ function encode_char(c) {
444751
444751
  return _ENCODE_HTML_RULES[c] || c;
444752
444752
  };
444753
444753
  `;
444754
- exports2.escapeXML = function(markup) {
444754
+ utils.escapeXML = function(markup) {
444755
444755
  return markup == void 0 ? "" : String(markup).replace(_MATCH_HTML, encode_char);
444756
444756
  };
444757
444757
  function escapeXMLToString() {
@@ -444759,14 +444759,14 @@ function encode_char(c) {
444759
444759
  }
444760
444760
  try {
444761
444761
  if (typeof Object.defineProperty === "function") {
444762
- Object.defineProperty(exports2.escapeXML, "toString", { value: escapeXMLToString });
444762
+ Object.defineProperty(utils.escapeXML, "toString", { value: escapeXMLToString });
444763
444763
  } else {
444764
- exports2.escapeXML.toString = escapeXMLToString;
444764
+ utils.escapeXML.toString = escapeXMLToString;
444765
444765
  }
444766
444766
  } catch (err) {
444767
444767
  console.warn("Unable to set escapeXML.toString (is the Function prototype frozen?)");
444768
444768
  }
444769
- exports2.shallowCopy = function(to, from) {
444769
+ utils.shallowCopy = function(to, from) {
444770
444770
  from = from || {};
444771
444771
  if (to !== null && to !== void 0) {
444772
444772
  for (var p in from) {
@@ -444781,7 +444781,7 @@ function encode_char(c) {
444781
444781
  }
444782
444782
  return to;
444783
444783
  };
444784
- exports2.shallowCopyFromList = function(to, from, list) {
444784
+ utils.shallowCopyFromList = function(to, from, list) {
444785
444785
  list = list || [];
444786
444786
  from = from || {};
444787
444787
  if (to !== null && to !== void 0) {
@@ -444800,7 +444800,7 @@ function encode_char(c) {
444800
444800
  }
444801
444801
  return to;
444802
444802
  };
444803
- exports2.cache = {
444803
+ utils.cache = {
444804
444804
  _data: {},
444805
444805
  set: function(key, val) {
444806
444806
  this._data[key] = val;
@@ -444815,12 +444815,12 @@ function encode_char(c) {
444815
444815
  this._data = {};
444816
444816
  }
444817
444817
  };
444818
- exports2.hyphenToCamel = function(str) {
444818
+ utils.hyphenToCamel = function(str) {
444819
444819
  return str.replace(/-[a-z]/g, function(match) {
444820
444820
  return match[1].toUpperCase();
444821
444821
  });
444822
444822
  };
444823
- exports2.createNullProtoObjWherePossible = (function() {
444823
+ utils.createNullProtoObjWherePossible = (function() {
444824
444824
  if (typeof Object.create == "function") {
444825
444825
  return function() {
444826
444826
  return /* @__PURE__ */ Object.create(null);
@@ -444835,8 +444835,8 @@ function encode_char(c) {
444835
444835
  return {};
444836
444836
  };
444837
444837
  })();
444838
- exports2.hasOwnOnlyObject = function(obj) {
444839
- var o = exports2.createNullProtoObjWherePossible();
444838
+ utils.hasOwnOnlyObject = function(obj) {
444839
+ var o = utils.createNullProtoObjWherePossible();
444840
444840
  for (var p in obj) {
444841
444841
  if (hasOwn(obj, p)) {
444842
444842
  o[p] = obj[p];
@@ -444844,71 +444844,30 @@ function encode_char(c) {
444844
444844
  }
444845
444845
  return o;
444846
444846
  };
444847
+ if (typeof exports2 != "undefined") {
444848
+ module2.exports = utils;
444849
+ }
444850
+ exports2.default = utils;
444847
444851
  }
444848
444852
  });
444849
444853
 
444850
- // node_modules/ejs/package.json
444851
- var require_package2 = __commonJS({
444852
- "node_modules/ejs/package.json"(exports2, module2) {
444853
- module2.exports = {
444854
- name: "ejs",
444855
- description: "Embedded JavaScript templates",
444856
- keywords: [
444857
- "template",
444858
- "engine",
444859
- "ejs"
444860
- ],
444861
- version: "3.1.10",
444862
- author: "Matthew Eernisse <mde@fleegix.org> (http://fleegix.org)",
444863
- license: "Apache-2.0",
444864
- bin: {
444865
- ejs: "./bin/cli.js"
444866
- },
444867
- main: "./lib/ejs.js",
444868
- jsdelivr: "ejs.min.js",
444869
- unpkg: "ejs.min.js",
444870
- repository: {
444871
- type: "git",
444872
- url: "git://github.com/mde/ejs.git"
444873
- },
444874
- bugs: "https://github.com/mde/ejs/issues",
444875
- homepage: "https://github.com/mde/ejs",
444876
- dependencies: {
444877
- jake: "^10.8.5"
444878
- },
444879
- devDependencies: {
444880
- browserify: "^16.5.1",
444881
- eslint: "^6.8.0",
444882
- "git-directory-deploy": "^1.5.1",
444883
- jsdoc: "^4.0.2",
444884
- "lru-cache": "^4.0.1",
444885
- mocha: "^10.2.0",
444886
- "uglify-js": "^3.3.16"
444887
- },
444888
- engines: {
444889
- node: ">=0.10.0"
444890
- },
444891
- scripts: {
444892
- test: "npx jake test"
444893
- }
444894
- };
444895
- }
444896
- });
444897
-
444898
- // node_modules/ejs/lib/ejs.js
444854
+ // node_modules/ejs/lib/cjs/ejs.js
444899
444855
  var require_ejs = __commonJS({
444900
- "node_modules/ejs/lib/ejs.js"(exports2) {
444856
+ "node_modules/ejs/lib/cjs/ejs.js"(exports2, module2) {
444901
444857
  "use strict";
444902
- var fs = require("fs");
444903
- var path = require("path");
444904
- var utils = require_utils();
444905
- var scopeOptionWarned = false;
444906
- var _VERSION_STRING = require_package2().version;
444858
+ var __importDefault2 = exports2 && exports2.__importDefault || function(mod) {
444859
+ return mod && mod.__esModule ? mod : { "default": mod };
444860
+ };
444861
+ Object.defineProperty(exports2, "__esModule", { value: true });
444862
+ var fs_1 = __importDefault2(require("fs"));
444863
+ var path_1 = __importDefault2(require("path"));
444864
+ var utils_js_1 = __importDefault2(require_utils());
444865
+ var DECLARATION_KEYWORD = "var";
444866
+ var ejs = {};
444907
444867
  var _DEFAULT_OPEN_DELIMITER = "<";
444908
444868
  var _DEFAULT_CLOSE_DELIMITER = ">";
444909
444869
  var _DEFAULT_DELIMITER = "%";
444910
444870
  var _DEFAULT_LOCALS_NAME = "locals";
444911
- var _NAME = "ejs";
444912
444871
  var _REGEX_STRING = "(<%%|%%>|<%=|<%-|<%_|<%#|<%|%>|-%>|_%>)";
444913
444872
  var _OPTS_PASSABLE_WITH_DATA = [
444914
444873
  "delimiter",
@@ -444916,7 +444875,6 @@ var require_ejs = __commonJS({
444916
444875
  "context",
444917
444876
  "debug",
444918
444877
  "compileDebug",
444919
- "client",
444920
444878
  "_with",
444921
444879
  "rmWhitespace",
444922
444880
  "strict",
@@ -444926,14 +444884,14 @@ var require_ejs = __commonJS({
444926
444884
  var _OPTS_PASSABLE_WITH_DATA_EXPRESS = _OPTS_PASSABLE_WITH_DATA.concat("cache");
444927
444885
  var _BOM = /^\uFEFF/;
444928
444886
  var _JS_IDENTIFIER = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
444929
- exports2.cache = utils.cache;
444930
- exports2.fileLoader = fs.readFileSync;
444931
- exports2.localsName = _DEFAULT_LOCALS_NAME;
444932
- exports2.promiseImpl = new Function("return this;")().Promise;
444933
- exports2.resolveInclude = function(name, filename, isDir) {
444934
- var dirname = path.dirname;
444935
- var extname = path.extname;
444936
- var resolve = path.resolve;
444887
+ ejs.cache = utils_js_1.default.cache;
444888
+ ejs.fileLoader = fs_1.default.readFileSync;
444889
+ ejs.localsName = _DEFAULT_LOCALS_NAME;
444890
+ ejs.promiseImpl = new Function("return this;")().Promise;
444891
+ ejs.resolveInclude = function(name, filename, isDir) {
444892
+ var dirname = path_1.default.dirname;
444893
+ var extname = path_1.default.extname;
444894
+ var resolve = path_1.default.resolve;
444937
444895
  var includePath = resolve(isDir ? filename : dirname(filename), name);
444938
444896
  var ext = extname(name);
444939
444897
  if (!ext) {
@@ -444944,36 +444902,36 @@ var require_ejs = __commonJS({
444944
444902
  function resolvePaths(name, paths) {
444945
444903
  var filePath;
444946
444904
  if (paths.some(function(v) {
444947
- filePath = exports2.resolveInclude(name, v, true);
444948
- return fs.existsSync(filePath);
444905
+ filePath = ejs.resolveInclude(name, v, true);
444906
+ return fs_1.default.existsSync(filePath);
444949
444907
  })) {
444950
444908
  return filePath;
444951
444909
  }
444952
444910
  }
444953
- function getIncludePath(path2, options) {
444911
+ function getIncludePath(path, options) {
444954
444912
  var includePath;
444955
444913
  var filePath;
444956
444914
  var views = options.views;
444957
- var match = /^[A-Za-z]+:\\|^\//.exec(path2);
444915
+ var match = /^[A-Za-z]+:\\|^\//.exec(path);
444958
444916
  if (match && match.length) {
444959
- path2 = path2.replace(/^\/*/, "");
444917
+ path = path.replace(/^\/*/, "");
444960
444918
  if (Array.isArray(options.root)) {
444961
- includePath = resolvePaths(path2, options.root);
444919
+ includePath = resolvePaths(path, options.root);
444962
444920
  } else {
444963
- includePath = exports2.resolveInclude(path2, options.root || "/", true);
444921
+ includePath = ejs.resolveInclude(path, options.root || "/", true);
444964
444922
  }
444965
444923
  } else {
444966
444924
  if (options.filename) {
444967
- filePath = exports2.resolveInclude(path2, options.filename);
444968
- if (fs.existsSync(filePath)) {
444925
+ filePath = ejs.resolveInclude(path, options.filename);
444926
+ if (fs_1.default.existsSync(filePath)) {
444969
444927
  includePath = filePath;
444970
444928
  }
444971
444929
  }
444972
444930
  if (!includePath && Array.isArray(views)) {
444973
- includePath = resolvePaths(path2, views);
444931
+ includePath = resolvePaths(path, views);
444974
444932
  }
444975
444933
  if (!includePath && typeof options.includer !== "function") {
444976
- throw new Error('Could not find the include file "' + options.escapeFunction(path2) + '"');
444934
+ throw new Error('Could not find the include file "' + options.escapeFunction(path) + '"');
444977
444935
  }
444978
444936
  }
444979
444937
  return includePath;
@@ -444986,7 +444944,7 @@ var require_ejs = __commonJS({
444986
444944
  if (!filename) {
444987
444945
  throw new Error("cache option requires a filename");
444988
444946
  }
444989
- func = exports2.cache.get(filename);
444947
+ func = ejs.cache.get(filename);
444990
444948
  if (func) {
444991
444949
  return func;
444992
444950
  }
@@ -444999,17 +444957,17 @@ var require_ejs = __commonJS({
444999
444957
  }
445000
444958
  template = fileLoader(filename).toString().replace(_BOM, "");
445001
444959
  }
445002
- func = exports2.compile(template, options);
444960
+ func = ejs.compile(template, options);
445003
444961
  if (options.cache) {
445004
- exports2.cache.set(filename, func);
444962
+ ejs.cache.set(filename, func);
445005
444963
  }
445006
444964
  return func;
445007
444965
  }
445008
444966
  function tryHandleCache(options, data, cb) {
445009
444967
  var result;
445010
444968
  if (!cb) {
445011
- if (typeof exports2.promiseImpl == "function") {
445012
- return new exports2.promiseImpl(function(resolve, reject) {
444969
+ if (typeof ejs.promiseImpl == "function") {
444970
+ return new ejs.promiseImpl(function(resolve, reject) {
445013
444971
  try {
445014
444972
  result = handleCache(options)(data);
445015
444973
  resolve(result);
@@ -445030,13 +444988,13 @@ var require_ejs = __commonJS({
445030
444988
  }
445031
444989
  }
445032
444990
  function fileLoader(filePath) {
445033
- return exports2.fileLoader(filePath);
444991
+ return ejs.fileLoader(filePath);
445034
444992
  }
445035
- function includeFile(path2, options) {
445036
- var opts = utils.shallowCopy(utils.createNullProtoObjWherePossible(), options);
445037
- opts.filename = getIncludePath(path2, opts);
444993
+ function includeFile(path, options) {
444994
+ var opts = utils_js_1.default.shallowCopy(utils_js_1.default.createNullProtoObjWherePossible(), options);
444995
+ opts.filename = getIncludePath(path, opts);
445038
444996
  if (typeof options.includer === "function") {
445039
- var includerResult = options.includer(path2, opts.filename);
444997
+ var includerResult = options.includer(path, opts.filename);
445040
444998
  if (includerResult) {
445041
444999
  if (includerResult.filename) {
445042
445000
  opts.filename = includerResult.filename;
@@ -445064,13 +445022,10 @@ var require_ejs = __commonJS({
445064
445022
  function stripSemi(str) {
445065
445023
  return str.replace(/;(\s*$)/, "$1");
445066
445024
  }
445067
- exports2.compile = function compile(template, opts) {
445025
+ ejs.compile = function compile(template, opts) {
445068
445026
  var templ;
445069
445027
  if (opts && opts.scope) {
445070
- if (!scopeOptionWarned) {
445071
- console.warn("`scope` option is deprecated and will be removed in EJS 3");
445072
- scopeOptionWarned = true;
445073
- }
445028
+ console.warn("`scope` option is deprecated and will be removed in future EJS");
445074
445029
  if (!opts.context) {
445075
445030
  opts.context = opts.scope;
445076
445031
  }
@@ -445079,15 +445034,15 @@ var require_ejs = __commonJS({
445079
445034
  templ = new Template(template, opts);
445080
445035
  return templ.compile();
445081
445036
  };
445082
- exports2.render = function(template, d, o) {
445083
- var data = d || utils.createNullProtoObjWherePossible();
445084
- var opts = o || utils.createNullProtoObjWherePossible();
445037
+ ejs.render = function(template, d, o) {
445038
+ var data = d || utils_js_1.default.createNullProtoObjWherePossible();
445039
+ var opts = o || utils_js_1.default.createNullProtoObjWherePossible();
445085
445040
  if (arguments.length == 2) {
445086
- utils.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA);
445041
+ utils_js_1.default.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA);
445087
445042
  }
445088
445043
  return handleCache(opts, template)(data);
445089
445044
  };
445090
- exports2.renderFile = function() {
445045
+ ejs.renderFile = function() {
445091
445046
  var args = Array.prototype.slice.call(arguments);
445092
445047
  var filename = args.shift();
445093
445048
  var cb;
@@ -445100,7 +445055,7 @@ var require_ejs = __commonJS({
445100
445055
  if (args.length) {
445101
445056
  data = args.shift();
445102
445057
  if (args.length) {
445103
- utils.shallowCopy(opts, args.pop());
445058
+ utils_js_1.default.shallowCopy(opts, args.pop());
445104
445059
  } else {
445105
445060
  if (data.settings) {
445106
445061
  if (data.settings.views) {
@@ -445111,37 +445066,36 @@ var require_ejs = __commonJS({
445111
445066
  }
445112
445067
  viewOpts = data.settings["view options"];
445113
445068
  if (viewOpts) {
445114
- utils.shallowCopy(opts, viewOpts);
445069
+ utils_js_1.default.shallowCopy(opts, viewOpts);
445115
445070
  }
445116
445071
  }
445117
- utils.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA_EXPRESS);
445072
+ utils_js_1.default.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA_EXPRESS);
445118
445073
  }
445119
445074
  opts.filename = filename;
445120
445075
  } else {
445121
- data = utils.createNullProtoObjWherePossible();
445076
+ data = utils_js_1.default.createNullProtoObjWherePossible();
445122
445077
  }
445123
445078
  return tryHandleCache(opts, data, cb);
445124
445079
  };
445125
- exports2.Template = Template;
445126
- exports2.clearCache = function() {
445127
- exports2.cache.reset();
445080
+ ejs.Template = Template;
445081
+ ejs.clearCache = function() {
445082
+ ejs.cache.reset();
445128
445083
  };
445129
445084
  function Template(text, optsParam) {
445130
- var opts = utils.hasOwnOnlyObject(optsParam);
445131
- var options = utils.createNullProtoObjWherePossible();
445085
+ var opts = utils_js_1.default.hasOwnOnlyObject(optsParam);
445086
+ var options = utils_js_1.default.createNullProtoObjWherePossible();
445132
445087
  this.templateText = text;
445133
445088
  this.mode = null;
445134
445089
  this.truncate = false;
445135
445090
  this.currentLine = 1;
445136
445091
  this.source = "";
445137
- options.client = opts.client || false;
445138
- options.escapeFunction = opts.escape || opts.escapeFunction || utils.escapeXML;
445092
+ options.escapeFunction = opts.escape || opts.escapeFunction || utils_js_1.default.escapeXML;
445139
445093
  options.compileDebug = opts.compileDebug !== false;
445140
445094
  options.debug = !!opts.debug;
445141
445095
  options.filename = opts.filename;
445142
- options.openDelimiter = opts.openDelimiter || exports2.openDelimiter || _DEFAULT_OPEN_DELIMITER;
445143
- options.closeDelimiter = opts.closeDelimiter || exports2.closeDelimiter || _DEFAULT_CLOSE_DELIMITER;
445144
- options.delimiter = opts.delimiter || exports2.delimiter || _DEFAULT_DELIMITER;
445096
+ options.openDelimiter = opts.openDelimiter || ejs.openDelimiter || _DEFAULT_OPEN_DELIMITER;
445097
+ options.closeDelimiter = opts.closeDelimiter || ejs.closeDelimiter || _DEFAULT_CLOSE_DELIMITER;
445098
+ options.delimiter = opts.delimiter || ejs.delimiter || _DEFAULT_DELIMITER;
445145
445099
  options.strict = opts.strict || false;
445146
445100
  options.context = opts.context;
445147
445101
  options.cache = opts.cache || false;
@@ -445149,7 +445103,7 @@ var require_ejs = __commonJS({
445149
445103
  options.root = opts.root;
445150
445104
  options.includer = opts.includer;
445151
445105
  options.outputFunctionName = opts.outputFunctionName;
445152
- options.localsName = opts.localsName || exports2.localsName || _DEFAULT_LOCALS_NAME;
445106
+ options.localsName = opts.localsName || ejs.localsName || _DEFAULT_LOCALS_NAME;
445153
445107
  options.views = opts.views;
445154
445108
  options.async = opts.async;
445155
445109
  options.destructuredLocals = opts.destructuredLocals;
@@ -445172,9 +445126,9 @@ var require_ejs = __commonJS({
445172
445126
  Template.prototype = {
445173
445127
  createRegex: function() {
445174
445128
  var str = _REGEX_STRING;
445175
- var delim = utils.escapeRegExpChars(this.opts.delimiter);
445176
- var open = utils.escapeRegExpChars(this.opts.openDelimiter);
445177
- var close = utils.escapeRegExpChars(this.opts.closeDelimiter);
445129
+ var delim = utils_js_1.default.escapeRegExpChars(this.opts.delimiter);
445130
+ var open = utils_js_1.default.escapeRegExpChars(this.opts.openDelimiter);
445131
+ var close = utils_js_1.default.escapeRegExpChars(this.opts.closeDelimiter);
445178
445132
  str = str.replace(/%/g, delim).replace(/</g, open).replace(/>/g, close);
445179
445133
  return new RegExp(str);
445180
445134
  },
@@ -445189,27 +445143,27 @@ var require_ejs = __commonJS({
445189
445143
  var sanitizedFilename = opts.filename ? JSON.stringify(opts.filename) : "undefined";
445190
445144
  if (!this.source) {
445191
445145
  this.generateSource();
445192
- prepended += ' var __output = "";\n function __append(s) { if (s !== undefined && s !== null) __output += s }\n';
445146
+ prepended += " ".concat(DECLARATION_KEYWORD, ' __output = "";\n') + " function __append(s) { if (s !== undefined && s !== null) __output += s }\n";
445193
445147
  if (opts.outputFunctionName) {
445194
445148
  if (!_JS_IDENTIFIER.test(opts.outputFunctionName)) {
445195
445149
  throw new Error("outputFunctionName is not a valid JS identifier.");
445196
445150
  }
445197
- prepended += " var " + opts.outputFunctionName + " = __append;\n";
445151
+ prepended += " ".concat(DECLARATION_KEYWORD, " ") + opts.outputFunctionName + " = __append;\n";
445198
445152
  }
445199
445153
  if (opts.localsName && !_JS_IDENTIFIER.test(opts.localsName)) {
445200
445154
  throw new Error("localsName is not a valid JS identifier.");
445201
445155
  }
445202
445156
  if (opts.destructuredLocals && opts.destructuredLocals.length) {
445203
- var destructuring = " var __locals = (" + opts.localsName + " || {}),\n";
445157
+ var destructuring = " ".concat(DECLARATION_KEYWORD, " __locals = (") + opts.localsName + " || {}),\n";
445204
445158
  for (var i = 0; i < opts.destructuredLocals.length; i++) {
445205
- var name = opts.destructuredLocals[i];
445206
- if (!_JS_IDENTIFIER.test(name)) {
445159
+ var name_1 = opts.destructuredLocals[i];
445160
+ if (!_JS_IDENTIFIER.test(name_1)) {
445207
445161
  throw new Error("destructuredLocals[" + i + "] is not a valid JS identifier.");
445208
445162
  }
445209
445163
  if (i > 0) {
445210
445164
  destructuring += ",\n ";
445211
445165
  }
445212
- destructuring += name + " = __locals." + name;
445166
+ destructuring += name_1 + " = __locals." + name_1;
445213
445167
  }
445214
445168
  prepended += destructuring + ";\n";
445215
445169
  }
@@ -445221,16 +445175,10 @@ var require_ejs = __commonJS({
445221
445175
  this.source = prepended + this.source + appended;
445222
445176
  }
445223
445177
  if (opts.compileDebug) {
445224
- src = "var __line = 1\n , __lines = " + JSON.stringify(this.templateText) + "\n , __filename = " + sanitizedFilename + ";\ntry {\n" + this.source + "} catch (e) {\n rethrow(e, __lines, __filename, __line, escapeFn);\n}\n";
445178
+ src = "".concat(DECLARATION_KEYWORD, " __line = 1") + "\n , __lines = " + JSON.stringify(this.templateText) + "\n , __filename = " + sanitizedFilename + ";\ntry {\n" + this.source + "} catch (e) {\n rethrow(e, __lines, __filename, __line, escapeFn);\n}\n";
445225
445179
  } else {
445226
445180
  src = this.source;
445227
445181
  }
445228
- if (opts.client) {
445229
- src = "escapeFn = escapeFn || " + escapeFn.toString() + ";\n" + src;
445230
- if (opts.compileDebug) {
445231
- src = "rethrow = rethrow || " + rethrow.toString() + ";\n" + src;
445232
- }
445233
- }
445234
445182
  if (opts.strict) {
445235
445183
  src = '"use strict";\n' + src;
445236
445184
  }
@@ -445270,22 +445218,19 @@ var require_ejs = __commonJS({
445270
445218
  }
445271
445219
  throw e;
445272
445220
  }
445273
- var returnedFn = opts.client ? fn : function anonymous(data) {
445274
- var include = function(path2, includeData) {
445275
- var d = utils.shallowCopy(utils.createNullProtoObjWherePossible(), data);
445221
+ var returnedFn = function anonymous(data) {
445222
+ var include = function(path, includeData) {
445223
+ var d = utils_js_1.default.shallowCopy(utils_js_1.default.createNullProtoObjWherePossible(), data);
445276
445224
  if (includeData) {
445277
- d = utils.shallowCopy(d, includeData);
445225
+ d = utils_js_1.default.shallowCopy(d, includeData);
445278
445226
  }
445279
- return includeFile(path2, opts)(d);
445227
+ return includeFile(path, opts)(d);
445280
445228
  };
445281
- return fn.apply(
445282
- opts.context,
445283
- [data || utils.createNullProtoObjWherePossible(), escapeFn, include, rethrow]
445284
- );
445229
+ return fn.apply(opts.context, [data || utils_js_1.default.createNullProtoObjWherePossible(), escapeFn, include, rethrow]);
445285
445230
  };
445286
445231
  if (opts.filename && typeof Object.defineProperty === "function") {
445287
445232
  var filename = opts.filename;
445288
- var basename = path.basename(filename, path.extname(filename));
445233
+ var basename = path_1.default.basename(filename, path_1.default.extname(filename));
445289
445234
  try {
445290
445235
  Object.defineProperty(returnedFn, "name", {
445291
445236
  value: basename,
@@ -445303,12 +445248,16 @@ var require_ejs = __commonJS({
445303
445248
  if (opts.rmWhitespace) {
445304
445249
  this.templateText = this.templateText.replace(/[\r\n]+/g, "\n").replace(/^\s+|\s+$/gm, "");
445305
445250
  }
445306
- this.templateText = this.templateText.replace(/[ \t]*<%_/gm, "<%_").replace(/_%>[ \t]*/gm, "_%>");
445307
445251
  var self2 = this;
445308
- var matches = this.parseTemplateText();
445309
445252
  var d = this.opts.delimiter;
445310
445253
  var o = this.opts.openDelimiter;
445311
445254
  var c = this.opts.closeDelimiter;
445255
+ var openWhitespaceSlurpTag = utils_js_1.default.escapeRegExpChars(o + d + "_");
445256
+ var closeWhitespaceSlurpTag = utils_js_1.default.escapeRegExpChars("_" + d + c);
445257
+ var openWhitespaceSlurpReplacement = o + d + "_";
445258
+ var closeWhitespaceSlurpReplacement = "_" + d + c;
445259
+ this.templateText = this.templateText.replace(new RegExp("[ \\t]*" + openWhitespaceSlurpTag, "gm"), openWhitespaceSlurpReplacement).replace(new RegExp(closeWhitespaceSlurpTag + "[ \\t]*", "gm"), closeWhitespaceSlurpReplacement);
445260
+ var matches = this.parseTemplateText();
445312
445261
  if (matches && matches.length) {
445313
445262
  matches.forEach(function(line, index) {
445314
445263
  var closing;
@@ -445435,13 +445384,15 @@ var require_ejs = __commonJS({
445435
445384
  }
445436
445385
  }
445437
445386
  };
445438
- exports2.escapeXML = utils.escapeXML;
445439
- exports2.__express = exports2.renderFile;
445440
- exports2.VERSION = _VERSION_STRING;
445441
- exports2.name = _NAME;
445387
+ ejs.escapeXML = utils_js_1.default.escapeXML;
445388
+ ejs.__express = ejs.renderFile;
445442
445389
  if (typeof window != "undefined") {
445443
- window.ejs = exports2;
445390
+ window.ejs = ejs;
445444
445391
  }
445392
+ if (typeof module2 != "undefined") {
445393
+ module2.exports = ejs;
445394
+ }
445395
+ exports2.default = ejs;
445445
445396
  }
445446
445397
  });
445447
445398
 
@@ -445452,8 +445403,9 @@ var require_generate_files = __commonJS({
445452
445403
  Object.defineProperty(exports2, "__esModule", { value: true });
445453
445404
  exports2.OverwriteStrategy = void 0;
445454
445405
  exports2.generateFiles = generateFiles;
445406
+ var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
445455
445407
  var fs_1 = require("fs");
445456
- var path = require("path");
445408
+ var path = tslib_1.__importStar(require("path"));
445457
445409
  var binary_extensions_1 = require_binary_extensions();
445458
445410
  var devkit_exports_1 = require("nx/src/devkit-exports");
445459
445411
  var OverwriteStrategy;
@@ -445725,6 +445677,18 @@ var require_semver = __commonJS({
445725
445677
  var { safeRe: re, t } = require_re();
445726
445678
  var parseOptions = require_parse_options();
445727
445679
  var { compareIdentifiers } = require_identifiers();
445680
+ var isPrereleaseIdentifier = (prerelease, identifier) => {
445681
+ const identifiers = identifier.split(".");
445682
+ if (identifiers.length > prerelease.length) {
445683
+ return false;
445684
+ }
445685
+ for (let i = 0; i < identifiers.length; i++) {
445686
+ if (compareIdentifiers(prerelease[i], identifiers[i]) !== 0) {
445687
+ return false;
445688
+ }
445689
+ }
445690
+ return true;
445691
+ };
445728
445692
  var SemVer = class _SemVer {
445729
445693
  constructor(version, options) {
445730
445694
  options = parseOptions(options);
@@ -445971,8 +445935,9 @@ var require_semver = __commonJS({
445971
445935
  if (identifierBase === false) {
445972
445936
  prerelease = [identifier];
445973
445937
  }
445974
- if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
445975
- if (isNaN(this.prerelease[1])) {
445938
+ if (isPrereleaseIdentifier(this.prerelease, identifier)) {
445939
+ const prereleaseBase = this.prerelease[identifier.split(".").length];
445940
+ if (isNaN(prereleaseBase)) {
445976
445941
  this.prerelease = prerelease;
445977
445942
  }
445978
445943
  } else {
@@ -446374,6 +446339,47 @@ var require_coerce = __commonJS({
446374
446339
  }
446375
446340
  });
446376
446341
 
446342
+ // node_modules/@nx/devkit/node_modules/semver/functions/truncate.js
446343
+ var require_truncate = __commonJS({
446344
+ "node_modules/@nx/devkit/node_modules/semver/functions/truncate.js"(exports2, module2) {
446345
+ "use strict";
446346
+ var parse2 = require_parse();
446347
+ var constants = require_constants();
446348
+ var SemVer = require_semver();
446349
+ var truncate = (version, truncation, options) => {
446350
+ if (!constants.RELEASE_TYPES.includes(truncation)) {
446351
+ return null;
446352
+ }
446353
+ const clonedVersion = cloneInputVersion(version, options);
446354
+ return clonedVersion && doTruncation(clonedVersion, truncation);
446355
+ };
446356
+ var cloneInputVersion = (version, options) => {
446357
+ const versionStringToParse = version instanceof SemVer ? version.version : version;
446358
+ return parse2(versionStringToParse, options);
446359
+ };
446360
+ var doTruncation = (version, truncation) => {
446361
+ if (isPrerelease(truncation)) {
446362
+ return version.version;
446363
+ }
446364
+ version.prerelease = [];
446365
+ switch (truncation) {
446366
+ case "major":
446367
+ version.minor = 0;
446368
+ version.patch = 0;
446369
+ break;
446370
+ case "minor":
446371
+ version.patch = 0;
446372
+ break;
446373
+ }
446374
+ return version.format();
446375
+ };
446376
+ var isPrerelease = (type) => {
446377
+ return type.startsWith("pre");
446378
+ };
446379
+ module2.exports = truncate;
446380
+ }
446381
+ });
446382
+
446377
446383
  // node_modules/@nx/devkit/node_modules/semver/internal/lrucache.js
446378
446384
  var require_lrucache = __commonJS({
446379
446385
  "node_modules/@nx/devkit/node_modules/semver/internal/lrucache.js"(exports2, module2) {
@@ -446482,6 +446488,7 @@ var require_range2 = __commonJS({
446482
446488
  return this.range;
446483
446489
  }
446484
446490
  parseRange(range) {
446491
+ range = range.replace(BUILDSTRIPRE, "");
446485
446492
  const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
446486
446493
  const memoKey = memoOpts + ":" + range;
446487
446494
  const cached = cache.get(memoKey);
@@ -446564,12 +446571,14 @@ var require_range2 = __commonJS({
446564
446571
  var SemVer = require_semver();
446565
446572
  var {
446566
446573
  safeRe: re,
446574
+ src,
446567
446575
  t,
446568
446576
  comparatorTrimReplace,
446569
446577
  tildeTrimReplace,
446570
446578
  caretTrimReplace
446571
446579
  } = require_re();
446572
446580
  var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
446581
+ var BUILDSTRIPRE = new RegExp(src[t.BUILD], "g");
446573
446582
  var isNullSet = (c) => c.value === "<0.0.0-0";
446574
446583
  var isAny = (c) => c.value === "";
446575
446584
  var isSatisfiable = (comparators, options) => {
@@ -446598,20 +446607,22 @@ var require_range2 = __commonJS({
446598
446607
  return comp;
446599
446608
  };
446600
446609
  var isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
446610
+ var invalidXRangeOrder = (M, m, p) => isX(M) && !isX(m) || isX(m) && p && !isX(p);
446601
446611
  var replaceTildes = (comp, options) => {
446602
446612
  return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
446603
446613
  };
446604
446614
  var replaceTilde = (comp, options) => {
446605
446615
  const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
446616
+ const z = options.includePrerelease ? "-0" : "";
446606
446617
  return comp.replace(r, (_, M, m, p, pr) => {
446607
446618
  debug("tilde", comp, _, M, m, p, pr);
446608
446619
  let ret;
446609
446620
  if (isX(M)) {
446610
446621
  ret = "";
446611
446622
  } else if (isX(m)) {
446612
- ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
446623
+ ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
446613
446624
  } else if (isX(p)) {
446614
- ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
446625
+ ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
446615
446626
  } else if (pr) {
446616
446627
  debug("replaceTilde pr", pr);
446617
446628
  ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
@@ -446657,9 +446668,9 @@ var require_range2 = __commonJS({
446657
446668
  debug("no pr");
446658
446669
  if (M === "0") {
446659
446670
  if (m === "0") {
446660
- ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`;
446671
+ ret = `>=${M}.${m}.${p} <${M}.${m}.${+p + 1}-0`;
446661
446672
  } else {
446662
- ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`;
446673
+ ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
446663
446674
  }
446664
446675
  } else {
446665
446676
  ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
@@ -446678,6 +446689,9 @@ var require_range2 = __commonJS({
446678
446689
  const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
446679
446690
  return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
446680
446691
  debug("xRange", comp, ret, gtlt, M, m, p, pr);
446692
+ if (invalidXRangeOrder(M, m, p)) {
446693
+ return comp;
446694
+ }
446681
446695
  const xM = isX(M);
446682
446696
  const xm = xM || isX(m);
446683
446697
  const xp = xm || isX(p);
@@ -447325,7 +447339,7 @@ var require_subset = __commonJS({
447325
447339
  if (higher === c && higher !== gt) {
447326
447340
  return false;
447327
447341
  }
447328
- } else if (gt.operator === ">=" && !satisfies(gt.semver, String(c), options)) {
447342
+ } else if (gt.operator === ">=" && !c.test(gt.semver)) {
447329
447343
  return false;
447330
447344
  }
447331
447345
  }
@@ -447340,7 +447354,7 @@ var require_subset = __commonJS({
447340
447354
  if (lower === c && lower !== lt) {
447341
447355
  return false;
447342
447356
  }
447343
- } else if (lt.operator === "<=" && !satisfies(lt.semver, String(c), options)) {
447357
+ } else if (lt.operator === "<=" && !c.test(lt.semver)) {
447344
447358
  return false;
447345
447359
  }
447346
447360
  }
@@ -447408,6 +447422,7 @@ var require_semver2 = __commonJS({
447408
447422
  var lte = require_lte();
447409
447423
  var cmp = require_cmp();
447410
447424
  var coerce = require_coerce();
447425
+ var truncate = require_truncate();
447411
447426
  var Comparator = require_comparator();
447412
447427
  var Range = require_range2();
447413
447428
  var satisfies = require_satisfies();
@@ -447446,6 +447461,7 @@ var require_semver2 = __commonJS({
447446
447461
  lte,
447447
447462
  cmp,
447448
447463
  coerce,
447464
+ truncate,
447449
447465
  Comparator,
447450
447466
  Range,
447451
447467
  satisfies,
@@ -447481,19 +447497,23 @@ var require_install_packages_task = __commonJS({
447481
447497
  var child_process_1 = require("child_process");
447482
447498
  var path_1 = require("path");
447483
447499
  var devkit_exports_1 = require("nx/src/devkit-exports");
447484
- function installPackagesTask(tree, alwaysRun = false, cwd = "", packageManager = (0, devkit_exports_1.detectPackageManager)((0, path_1.join)(tree.root, cwd))) {
447485
- if (!tree.listChanges().find((f) => f.path === (0, devkit_exports_1.joinPathFragments)(cwd, "package.json")) && !alwaysRun) {
447500
+ function installPackagesTask(tree, ensureInstall = false, cwd = "", packageManager = (0, devkit_exports_1.detectPackageManager)((0, path_1.join)(tree.root, cwd))) {
447501
+ const packageJsonPath = (0, devkit_exports_1.joinPathFragments)(cwd, "package.json");
447502
+ const packageJsonChanged = tree.listChanges().some((f) => f.path === packageJsonPath);
447503
+ if (!packageJsonChanged && !ensureInstall) {
447486
447504
  return;
447487
447505
  }
447488
- const packageJsonValue = tree.read((0, devkit_exports_1.joinPathFragments)(cwd, "package.json"), "utf-8");
447489
- let storedPackageJsonValue = global["__packageJsonInstallCache__"];
447490
- if (storedPackageJsonValue != packageJsonValue || alwaysRun) {
447506
+ const packageJsonValue = tree.read(packageJsonPath, "utf-8");
447507
+ const storedPackageJsonValue = global["__packageJsonInstallCache__"];
447508
+ const installAlreadyRan = storedPackageJsonValue != null;
447509
+ const packageJsonDiffers = storedPackageJsonValue != packageJsonValue;
447510
+ if (packageJsonDiffers || ensureInstall && !installAlreadyRan) {
447491
447511
  global["__packageJsonInstallCache__"] = packageJsonValue;
447492
447512
  const pmc = (0, devkit_exports_1.getPackageManagerCommand)(packageManager);
447493
447513
  const execSyncOptions = {
447494
447514
  cwd: (0, path_1.join)(tree.root, cwd),
447495
447515
  stdio: process.env.NX_GENERATE_QUIET === "true" ? "ignore" : "inherit",
447496
- windowsHide: false
447516
+ windowsHide: true
447497
447517
  };
447498
447518
  if (process.env.npm_config_registry && process.env.npm_config_registry.match(/^https:\/\/registry\.(npmjs\.org|yarnpkg\.com)/)) {
447499
447519
  delete process.env.npm_config_registry;
@@ -450292,6 +450312,26 @@ var require_js_yaml = __commonJS({
450292
450312
  }
450293
450313
  });
450294
450314
 
450315
+ // node_modules/@nx/devkit/src/utils/catalog/manager.js
450316
+ var require_manager = __commonJS({
450317
+ "node_modules/@nx/devkit/src/utils/catalog/manager.js"(exports2) {
450318
+ "use strict";
450319
+ Object.defineProperty(exports2, "__esModule", { value: true });
450320
+ exports2.formatCatalogError = formatCatalogError;
450321
+ function formatCatalogError(error2, suggestions) {
450322
+ let message = error2;
450323
+ if (suggestions.length > 0) {
450324
+ message += "\n\nSuggestions:";
450325
+ suggestions.forEach((suggestion) => {
450326
+ message += `
450327
+ \u2022 ${suggestion}`;
450328
+ });
450329
+ }
450330
+ return message;
450331
+ }
450332
+ }
450333
+ });
450334
+
450295
450335
  // node_modules/@nx/devkit/src/utils/catalog/pnpm-manager.js
450296
450336
  var require_pnpm_manager = __commonJS({
450297
450337
  "node_modules/@nx/devkit/src/utils/catalog/pnpm-manager.js"(exports2) {
@@ -450303,6 +450343,8 @@ var require_pnpm_manager = __commonJS({
450303
450343
  var node_path_1 = require("node:path");
450304
450344
  var devkit_exports_1 = require("nx/src/devkit-exports");
450305
450345
  var devkit_internals_1 = require("nx/src/devkit-internals");
450346
+ var manager_1 = require_manager();
450347
+ var PNPM_WORKSPACE_FILENAME = "pnpm-workspace.yaml";
450306
450348
  var PnpmCatalogManager = class {
450307
450349
  constructor() {
450308
450350
  this.name = "pnpm";
@@ -450322,18 +450364,21 @@ var require_pnpm_manager = __commonJS({
450322
450364
  isDefaultCatalog: isDefault
450323
450365
  };
450324
450366
  }
450367
+ getCatalogDefinitionFilePaths() {
450368
+ return [PNPM_WORKSPACE_FILENAME];
450369
+ }
450325
450370
  getCatalogDefinitions(treeOrRoot) {
450326
450371
  if (typeof treeOrRoot === "string") {
450327
- const pnpmWorkspacePath = (0, node_path_1.join)(treeOrRoot, "pnpm-workspace.yaml");
450328
- if (!(0, node_fs_1.existsSync)(pnpmWorkspacePath)) {
450372
+ const configPath = (0, node_path_1.join)(treeOrRoot, PNPM_WORKSPACE_FILENAME);
450373
+ if (!(0, node_fs_1.existsSync)(configPath)) {
450329
450374
  return null;
450330
450375
  }
450331
- return readYamlFileFromFs(pnpmWorkspacePath);
450376
+ return readConfigFromFs(configPath);
450332
450377
  } else {
450333
- if (!treeOrRoot.exists("pnpm-workspace.yaml")) {
450378
+ if (!treeOrRoot.exists(PNPM_WORKSPACE_FILENAME)) {
450334
450379
  return null;
450335
450380
  }
450336
- return readYamlFileFromTree(treeOrRoot, "pnpm-workspace.yaml");
450381
+ return readConfigFromTree(treeOrRoot, PNPM_WORKSPACE_FILENAME);
450337
450382
  }
450338
450383
  }
450339
450384
  resolveCatalogReference(treeOrRoot, packageName, version) {
@@ -450341,15 +450386,15 @@ var require_pnpm_manager = __commonJS({
450341
450386
  if (!catalogRef) {
450342
450387
  return null;
450343
450388
  }
450344
- const workspaceConfig = this.getCatalogDefinitions(treeOrRoot);
450345
- if (!workspaceConfig) {
450389
+ const catalogDefs = this.getCatalogDefinitions(treeOrRoot);
450390
+ if (!catalogDefs) {
450346
450391
  return null;
450347
450392
  }
450348
450393
  let catalogToUse;
450349
450394
  if (catalogRef.isDefaultCatalog) {
450350
- catalogToUse = workspaceConfig.catalog ?? workspaceConfig.catalogs?.default;
450395
+ catalogToUse = catalogDefs.catalog ?? catalogDefs.catalogs?.default;
450351
450396
  } else if (catalogRef.catalogName) {
450352
- catalogToUse = workspaceConfig.catalogs?.[catalogRef.catalogName];
450397
+ catalogToUse = catalogDefs.catalogs?.[catalogRef.catalogName];
450353
450398
  }
450354
450399
  return catalogToUse?.[packageName] || null;
450355
450400
  }
@@ -450358,35 +450403,35 @@ var require_pnpm_manager = __commonJS({
450358
450403
  if (!catalogRef) {
450359
450404
  throw new Error(`Invalid catalog reference syntax: "${version}". Expected format: "catalog:" or "catalog:name"`);
450360
450405
  }
450361
- const workspaceConfig = this.getCatalogDefinitions(treeOrRoot);
450362
- if (!workspaceConfig) {
450363
- throw new Error(formatCatalogError("Cannot get Pnpm Catalog definitions. No pnpm-workspace.yaml found in workspace root.", ["Create a pnpm-workspace.yaml file in your workspace root"]));
450406
+ const catalogDefs = this.getCatalogDefinitions(treeOrRoot);
450407
+ if (!catalogDefs) {
450408
+ throw new Error((0, manager_1.formatCatalogError)(`Cannot get Pnpm catalog definitions. No ${PNPM_WORKSPACE_FILENAME} found in workspace root.`, [`Create a ${PNPM_WORKSPACE_FILENAME} file in your workspace root`]));
450364
450409
  }
450365
450410
  let catalogToUse;
450366
450411
  if (catalogRef.isDefaultCatalog) {
450367
- const hasCatalog = !!workspaceConfig.catalog;
450368
- const hasCatalogsDefault = !!workspaceConfig.catalogs?.default;
450412
+ const hasCatalog = !!catalogDefs.catalog;
450413
+ const hasCatalogsDefault = !!catalogDefs.catalogs?.default;
450369
450414
  if (hasCatalog && hasCatalogsDefault) {
450370
450415
  throw new Error("The 'default' catalog was defined multiple times. Use the 'catalog' field or 'catalogs.default', but not both.");
450371
450416
  }
450372
- catalogToUse = workspaceConfig.catalog ?? workspaceConfig.catalogs?.default;
450417
+ catalogToUse = catalogDefs.catalog ?? catalogDefs.catalogs?.default;
450373
450418
  if (!catalogToUse) {
450374
- const availableCatalogs = Object.keys(workspaceConfig.catalogs || {});
450419
+ const availableCatalogs = Object.keys(catalogDefs.catalogs || {});
450375
450420
  const suggestions = [
450376
- 'Define a default catalog in pnpm-workspace.yaml under the "catalog" key'
450421
+ `Define a default catalog in ${PNPM_WORKSPACE_FILENAME} under the "catalog" key`
450377
450422
  ];
450378
450423
  if (availableCatalogs.length > 0) {
450379
450424
  suggestions.push(`Or select from the available named catalogs: ${availableCatalogs.map((c) => `"catalog:${c}"`).join(", ")}`);
450380
450425
  }
450381
- throw new Error(formatCatalogError("No default catalog defined in pnpm-workspace.yaml", suggestions));
450426
+ throw new Error((0, manager_1.formatCatalogError)(`No default catalog defined in ${PNPM_WORKSPACE_FILENAME}`, suggestions));
450382
450427
  }
450383
450428
  } else if (catalogRef.catalogName) {
450384
- catalogToUse = workspaceConfig.catalogs?.[catalogRef.catalogName];
450429
+ catalogToUse = catalogDefs.catalogs?.[catalogRef.catalogName];
450385
450430
  if (!catalogToUse) {
450386
- const availableCatalogs = Object.keys(workspaceConfig.catalogs || {}).filter((c) => c !== "default");
450387
- const defaultCatalog = !!workspaceConfig.catalog ? "catalog" : !workspaceConfig.catalogs?.default ? "catalogs.default" : null;
450431
+ const availableCatalogs = Object.keys(catalogDefs.catalogs || {}).filter((c) => c !== "default");
450432
+ const defaultCatalog = !!catalogDefs.catalog ? "catalog" : !catalogDefs.catalogs?.default ? "catalogs.default" : null;
450388
450433
  const suggestions = [
450389
- 'Define the catalog in pnpm-workspace.yaml under the "catalogs" key'
450434
+ `Define the catalog in ${PNPM_WORKSPACE_FILENAME} under the "catalogs" key`
450390
450435
  ];
450391
450436
  if (availableCatalogs.length > 0) {
450392
450437
  suggestions.push(`Or select from the available named catalogs: ${availableCatalogs.map((c) => `"catalog:${c}"`).join(", ")}`);
@@ -450394,25 +450439,25 @@ var require_pnpm_manager = __commonJS({
450394
450439
  if (defaultCatalog) {
450395
450440
  suggestions.push(`Or use the default catalog ("${defaultCatalog}")`);
450396
450441
  }
450397
- throw new Error(formatCatalogError(`Catalog "${catalogRef.catalogName}" not found in pnpm-workspace.yaml`, suggestions));
450442
+ throw new Error((0, manager_1.formatCatalogError)(`Catalog "${catalogRef.catalogName}" not found in ${PNPM_WORKSPACE_FILENAME}`, suggestions));
450398
450443
  }
450399
450444
  }
450400
450445
  if (!catalogToUse[packageName]) {
450401
450446
  let catalogName;
450402
450447
  if (catalogRef.isDefaultCatalog) {
450403
- const hasCatalog = !!workspaceConfig.catalog;
450448
+ const hasCatalog = !!catalogDefs.catalog;
450404
450449
  catalogName = hasCatalog ? 'default catalog ("catalog")' : 'default catalog ("catalogs.default")';
450405
450450
  } else {
450406
450451
  catalogName = `catalog '${catalogRef.catalogName}'`;
450407
450452
  }
450408
450453
  const availablePackages = Object.keys(catalogToUse);
450409
450454
  const suggestions = [
450410
- `Add "${packageName}" to ${catalogName} in pnpm-workspace.yaml`
450455
+ `Add "${packageName}" to ${catalogName} in ${PNPM_WORKSPACE_FILENAME}`
450411
450456
  ];
450412
450457
  if (availablePackages.length > 0) {
450413
450458
  suggestions.push(`Or select from the available packages in ${catalogName}: ${availablePackages.map((p) => `"${p}"`).join(", ")}`);
450414
450459
  }
450415
- throw new Error(formatCatalogError(`Package "${packageName}" not found in ${catalogName}`, suggestions));
450460
+ throw new Error((0, manager_1.formatCatalogError)(`Package "${packageName}" not found in ${catalogName}`, suggestions));
450416
450461
  }
450417
450462
  }
450418
450463
  updateCatalogVersions(treeOrRoot, updates) {
@@ -450420,46 +450465,46 @@ var require_pnpm_manager = __commonJS({
450420
450465
  let readYaml;
450421
450466
  let writeYaml;
450422
450467
  if (typeof treeOrRoot === "string") {
450423
- const workspaceYamlPath = (0, node_path_1.join)(treeOrRoot, "pnpm-workspace.yaml");
450424
- checkExists = () => (0, node_fs_1.existsSync)(workspaceYamlPath);
450425
- readYaml = () => (0, node_fs_1.readFileSync)(workspaceYamlPath, "utf-8");
450426
- writeYaml = (content) => (0, node_fs_1.writeFileSync)(workspaceYamlPath, content, "utf-8");
450468
+ const configPath = (0, node_path_1.join)(treeOrRoot, PNPM_WORKSPACE_FILENAME);
450469
+ checkExists = () => (0, node_fs_1.existsSync)(configPath);
450470
+ readYaml = () => (0, node_fs_1.readFileSync)(configPath, "utf-8");
450471
+ writeYaml = (content) => (0, node_fs_1.writeFileSync)(configPath, content, "utf-8");
450427
450472
  } else {
450428
- checkExists = () => treeOrRoot.exists("pnpm-workspace.yaml");
450429
- readYaml = () => treeOrRoot.read("pnpm-workspace.yaml", "utf-8");
450430
- writeYaml = (content) => treeOrRoot.write("pnpm-workspace.yaml", content);
450473
+ checkExists = () => treeOrRoot.exists(PNPM_WORKSPACE_FILENAME);
450474
+ readYaml = () => treeOrRoot.read(PNPM_WORKSPACE_FILENAME, "utf-8");
450475
+ writeYaml = (content) => treeOrRoot.write(PNPM_WORKSPACE_FILENAME, content);
450431
450476
  }
450432
450477
  if (!checkExists()) {
450433
450478
  devkit_exports_1.output.warn({
450434
- title: "No pnpm-workspace.yaml found",
450479
+ title: `No ${PNPM_WORKSPACE_FILENAME} found`,
450435
450480
  bodyLines: [
450436
- "Cannot update catalog versions without a pnpm-workspace.yaml file.",
450437
- "Create a pnpm-workspace.yaml file to use catalogs."
450481
+ `Cannot update catalog versions without a ${PNPM_WORKSPACE_FILENAME} file.`,
450482
+ `Create a ${PNPM_WORKSPACE_FILENAME} file to use catalogs.`
450438
450483
  ]
450439
450484
  });
450440
450485
  return;
450441
450486
  }
450442
450487
  try {
450443
- const workspaceContent = readYaml();
450444
- const workspaceData = (0, js_yaml_1.load)(workspaceContent) || {};
450488
+ const configContent = readYaml();
450489
+ const configData = (0, js_yaml_1.load)(configContent) || {};
450445
450490
  let hasChanges = false;
450446
450491
  for (const update of updates) {
450447
450492
  const { packageName, version, catalogName } = update;
450448
450493
  const normalizedCatalogName = catalogName === "default" ? void 0 : catalogName;
450449
450494
  let targetCatalog;
450450
450495
  if (!normalizedCatalogName) {
450451
- if (workspaceData.catalog) {
450452
- targetCatalog = workspaceData.catalog;
450453
- } else if (workspaceData.catalogs?.default) {
450454
- targetCatalog = workspaceData.catalogs.default;
450496
+ if (configData.catalog) {
450497
+ targetCatalog = configData.catalog;
450498
+ } else if (configData.catalogs?.default) {
450499
+ targetCatalog = configData.catalogs.default;
450455
450500
  } else {
450456
- workspaceData.catalog ??= {};
450457
- targetCatalog = workspaceData.catalog;
450501
+ configData.catalog ??= {};
450502
+ targetCatalog = configData.catalog;
450458
450503
  }
450459
450504
  } else {
450460
- workspaceData.catalogs ??= {};
450461
- workspaceData.catalogs[normalizedCatalogName] ??= {};
450462
- targetCatalog = workspaceData.catalogs[normalizedCatalogName];
450505
+ configData.catalogs ??= {};
450506
+ configData.catalogs[normalizedCatalogName] ??= {};
450507
+ targetCatalog = configData.catalogs[normalizedCatalogName];
450463
450508
  }
450464
450509
  if (targetCatalog[packageName] !== version) {
450465
450510
  targetCatalog[packageName] = version;
@@ -450467,7 +450512,7 @@ var require_pnpm_manager = __commonJS({
450467
450512
  }
450468
450513
  }
450469
450514
  if (hasChanges) {
450470
- writeYaml((0, js_yaml_1.dump)(workspaceData, {
450515
+ writeYaml((0, js_yaml_1.dump)(configData, {
450471
450516
  indent: 2,
450472
450517
  quotingType: '"',
450473
450518
  forceQuotes: true
@@ -450483,40 +450528,250 @@ var require_pnpm_manager = __commonJS({
450483
450528
  }
450484
450529
  };
450485
450530
  exports2.PnpmCatalogManager = PnpmCatalogManager;
450486
- function readYamlFileFromFs(path) {
450531
+ function readConfigFromFs(path) {
450487
450532
  try {
450488
450533
  return (0, devkit_internals_1.readYamlFile)(path);
450489
450534
  } catch (error2) {
450490
450535
  devkit_exports_1.output.warn({
450491
- title: "Unable to parse pnpm-workspace.yaml",
450536
+ title: `Unable to parse ${PNPM_WORKSPACE_FILENAME}`,
450492
450537
  bodyLines: [error2.toString()]
450493
450538
  });
450494
450539
  return null;
450495
450540
  }
450496
450541
  }
450497
- function readYamlFileFromTree(tree, path) {
450542
+ function readConfigFromTree(tree, path) {
450498
450543
  const content = tree.read(path, "utf-8");
450499
- const { load: load2 } = require_js_yaml();
450500
450544
  try {
450501
- return load2(content, { filename: path });
450545
+ return (0, js_yaml_1.load)(content, { filename: path });
450502
450546
  } catch (error2) {
450503
450547
  devkit_exports_1.output.warn({
450504
- title: "Unable to parse pnpm-workspace.yaml",
450548
+ title: `Unable to parse ${PNPM_WORKSPACE_FILENAME}`,
450505
450549
  bodyLines: [error2.toString()]
450506
450550
  });
450507
450551
  return null;
450508
450552
  }
450509
450553
  }
450510
- function formatCatalogError(error2, suggestions) {
450511
- let message = error2;
450512
- if (suggestions && suggestions.length > 0) {
450513
- message += "\n\nSuggestions:";
450514
- suggestions.forEach((suggestion) => {
450515
- message += `
450516
- \u2022 ${suggestion}`;
450554
+ }
450555
+ });
450556
+
450557
+ // node_modules/@nx/devkit/src/utils/catalog/yarn-manager.js
450558
+ var require_yarn_manager = __commonJS({
450559
+ "node_modules/@nx/devkit/src/utils/catalog/yarn-manager.js"(exports2) {
450560
+ "use strict";
450561
+ Object.defineProperty(exports2, "__esModule", { value: true });
450562
+ exports2.YarnCatalogManager = void 0;
450563
+ var js_yaml_1 = require_js_yaml();
450564
+ var node_fs_1 = require("node:fs");
450565
+ var node_path_1 = require("node:path");
450566
+ var devkit_exports_1 = require("nx/src/devkit-exports");
450567
+ var devkit_internals_1 = require("nx/src/devkit-internals");
450568
+ var manager_1 = require_manager();
450569
+ var YARNRC_FILENAME = ".yarnrc.yml";
450570
+ var YarnCatalogManager = class {
450571
+ constructor() {
450572
+ this.name = "yarn";
450573
+ this.catalogProtocol = "catalog:";
450574
+ }
450575
+ isCatalogReference(version) {
450576
+ return version.startsWith(this.catalogProtocol);
450577
+ }
450578
+ parseCatalogReference(version) {
450579
+ if (!this.isCatalogReference(version)) {
450580
+ return null;
450581
+ }
450582
+ const catalogName = version.substring(this.catalogProtocol.length);
450583
+ const isDefault = !catalogName || catalogName === "default";
450584
+ return {
450585
+ catalogName: isDefault ? void 0 : catalogName,
450586
+ isDefaultCatalog: isDefault
450587
+ };
450588
+ }
450589
+ getCatalogDefinitionFilePaths() {
450590
+ return [YARNRC_FILENAME];
450591
+ }
450592
+ getCatalogDefinitions(treeOrRoot) {
450593
+ if (typeof treeOrRoot === "string") {
450594
+ const configPath = (0, node_path_1.join)(treeOrRoot, YARNRC_FILENAME);
450595
+ if (!(0, node_fs_1.existsSync)(configPath)) {
450596
+ return null;
450597
+ }
450598
+ return readConfigFromFs(configPath);
450599
+ } else {
450600
+ if (!treeOrRoot.exists(YARNRC_FILENAME)) {
450601
+ return null;
450602
+ }
450603
+ return readConfigFromTree(treeOrRoot, YARNRC_FILENAME);
450604
+ }
450605
+ }
450606
+ resolveCatalogReference(treeOrRoot, packageName, version) {
450607
+ const catalogRef = this.parseCatalogReference(version);
450608
+ if (!catalogRef) {
450609
+ return null;
450610
+ }
450611
+ const catalogDefs = this.getCatalogDefinitions(treeOrRoot);
450612
+ if (!catalogDefs) {
450613
+ return null;
450614
+ }
450615
+ let catalogToUse;
450616
+ if (catalogRef.isDefaultCatalog) {
450617
+ catalogToUse = catalogDefs.catalog ?? catalogDefs.catalogs?.default;
450618
+ } else if (catalogRef.catalogName) {
450619
+ catalogToUse = catalogDefs.catalogs?.[catalogRef.catalogName];
450620
+ }
450621
+ return catalogToUse?.[packageName] || null;
450622
+ }
450623
+ validateCatalogReference(treeOrRoot, packageName, version) {
450624
+ const catalogRef = this.parseCatalogReference(version);
450625
+ if (!catalogRef) {
450626
+ throw new Error(`Invalid catalog reference syntax: "${version}". Expected format: "catalog:" or "catalog:name"`);
450627
+ }
450628
+ const catalogDefs = this.getCatalogDefinitions(treeOrRoot);
450629
+ if (!catalogDefs) {
450630
+ throw new Error((0, manager_1.formatCatalogError)(`Cannot get Yarn catalog definitions. No ${YARNRC_FILENAME} found in workspace root.`, [`Create a ${YARNRC_FILENAME} file in your workspace root`]));
450631
+ }
450632
+ let catalogToUse;
450633
+ if (catalogRef.isDefaultCatalog) {
450634
+ const hasCatalog = !!catalogDefs.catalog;
450635
+ const hasCatalogsDefault = !!catalogDefs.catalogs?.default;
450636
+ if (hasCatalog && hasCatalogsDefault) {
450637
+ throw new Error("The 'default' catalog was defined multiple times. Use the 'catalog' field or 'catalogs.default', but not both.");
450638
+ }
450639
+ catalogToUse = catalogDefs.catalog ?? catalogDefs.catalogs?.default;
450640
+ if (!catalogToUse) {
450641
+ const availableCatalogs = Object.keys(catalogDefs.catalogs || {});
450642
+ const suggestions = [
450643
+ `Define a default catalog in ${YARNRC_FILENAME} under the "catalog" key`
450644
+ ];
450645
+ if (availableCatalogs.length > 0) {
450646
+ suggestions.push(`Or select from the available named catalogs: ${availableCatalogs.map((c) => `"catalog:${c}"`).join(", ")}`);
450647
+ }
450648
+ throw new Error((0, manager_1.formatCatalogError)(`No default catalog defined in ${YARNRC_FILENAME}`, suggestions));
450649
+ }
450650
+ } else if (catalogRef.catalogName) {
450651
+ catalogToUse = catalogDefs.catalogs?.[catalogRef.catalogName];
450652
+ if (!catalogToUse) {
450653
+ const availableCatalogs = Object.keys(catalogDefs.catalogs || {}).filter((c) => c !== "default");
450654
+ const defaultCatalog = !!catalogDefs.catalog ? "catalog" : !catalogDefs.catalogs?.default ? "catalogs.default" : null;
450655
+ const suggestions = [
450656
+ `Define the catalog in ${YARNRC_FILENAME} under the "catalogs" key`
450657
+ ];
450658
+ if (availableCatalogs.length > 0) {
450659
+ suggestions.push(`Or select from the available named catalogs: ${availableCatalogs.map((c) => `"catalog:${c}"`).join(", ")}`);
450660
+ }
450661
+ if (defaultCatalog) {
450662
+ suggestions.push(`Or use the default catalog ("${defaultCatalog}")`);
450663
+ }
450664
+ throw new Error((0, manager_1.formatCatalogError)(`Catalog "${catalogRef.catalogName}" not found in ${YARNRC_FILENAME}`, suggestions));
450665
+ }
450666
+ }
450667
+ if (!catalogToUse[packageName]) {
450668
+ let catalogName;
450669
+ if (catalogRef.isDefaultCatalog) {
450670
+ const hasCatalog = !!catalogDefs.catalog;
450671
+ catalogName = hasCatalog ? 'default catalog ("catalog")' : 'default catalog ("catalogs.default")';
450672
+ } else {
450673
+ catalogName = `catalog '${catalogRef.catalogName}'`;
450674
+ }
450675
+ const availablePackages = Object.keys(catalogToUse);
450676
+ const suggestions = [
450677
+ `Add "${packageName}" to ${catalogName} in ${YARNRC_FILENAME}`
450678
+ ];
450679
+ if (availablePackages.length > 0) {
450680
+ suggestions.push(`Or select from the available packages in ${catalogName}: ${availablePackages.map((p) => `"${p}"`).join(", ")}`);
450681
+ }
450682
+ throw new Error((0, manager_1.formatCatalogError)(`Package "${packageName}" not found in ${catalogName}`, suggestions));
450683
+ }
450684
+ }
450685
+ updateCatalogVersions(treeOrRoot, updates) {
450686
+ let checkExists;
450687
+ let readYaml;
450688
+ let writeYaml;
450689
+ if (typeof treeOrRoot === "string") {
450690
+ const configPath = (0, node_path_1.join)(treeOrRoot, YARNRC_FILENAME);
450691
+ checkExists = () => (0, node_fs_1.existsSync)(configPath);
450692
+ readYaml = () => (0, node_fs_1.readFileSync)(configPath, "utf-8");
450693
+ writeYaml = (content) => (0, node_fs_1.writeFileSync)(configPath, content, "utf-8");
450694
+ } else {
450695
+ checkExists = () => treeOrRoot.exists(YARNRC_FILENAME);
450696
+ readYaml = () => treeOrRoot.read(YARNRC_FILENAME, "utf-8");
450697
+ writeYaml = (content) => treeOrRoot.write(YARNRC_FILENAME, content);
450698
+ }
450699
+ if (!checkExists()) {
450700
+ devkit_exports_1.output.warn({
450701
+ title: `No ${YARNRC_FILENAME} found`,
450702
+ bodyLines: [
450703
+ `Cannot update catalog versions without a ${YARNRC_FILENAME} file.`,
450704
+ `Create a ${YARNRC_FILENAME} file to use catalogs.`
450705
+ ]
450706
+ });
450707
+ return;
450708
+ }
450709
+ try {
450710
+ const configContent = readYaml();
450711
+ const configData = (0, js_yaml_1.load)(configContent) || {};
450712
+ let hasChanges = false;
450713
+ for (const update of updates) {
450714
+ const { packageName, version, catalogName } = update;
450715
+ const normalizedCatalogName = catalogName === "default" ? void 0 : catalogName;
450716
+ let targetCatalog;
450717
+ if (!normalizedCatalogName) {
450718
+ if (configData.catalog) {
450719
+ targetCatalog = configData.catalog;
450720
+ } else if (configData.catalogs?.default) {
450721
+ targetCatalog = configData.catalogs.default;
450722
+ } else {
450723
+ configData.catalog ??= {};
450724
+ targetCatalog = configData.catalog;
450725
+ }
450726
+ } else {
450727
+ configData.catalogs ??= {};
450728
+ configData.catalogs[normalizedCatalogName] ??= {};
450729
+ targetCatalog = configData.catalogs[normalizedCatalogName];
450730
+ }
450731
+ if (targetCatalog[packageName] !== version) {
450732
+ targetCatalog[packageName] = version;
450733
+ hasChanges = true;
450734
+ }
450735
+ }
450736
+ if (hasChanges) {
450737
+ writeYaml((0, js_yaml_1.dump)(configData, {
450738
+ indent: 2,
450739
+ quotingType: '"',
450740
+ forceQuotes: true
450741
+ }));
450742
+ }
450743
+ } catch (error2) {
450744
+ devkit_exports_1.output.error({
450745
+ title: "Failed to update catalog versions",
450746
+ bodyLines: [error2 instanceof Error ? error2.message : String(error2)]
450747
+ });
450748
+ throw error2;
450749
+ }
450750
+ }
450751
+ };
450752
+ exports2.YarnCatalogManager = YarnCatalogManager;
450753
+ function readConfigFromFs(path) {
450754
+ try {
450755
+ return (0, devkit_internals_1.readYamlFile)(path);
450756
+ } catch (error2) {
450757
+ devkit_exports_1.output.warn({
450758
+ title: `Unable to parse ${YARNRC_FILENAME}`,
450759
+ bodyLines: [error2.toString()]
450517
450760
  });
450761
+ return null;
450762
+ }
450763
+ }
450764
+ function readConfigFromTree(tree, path) {
450765
+ const content = tree.read(path, "utf-8");
450766
+ try {
450767
+ return (0, js_yaml_1.load)(content, { filename: path });
450768
+ } catch (error2) {
450769
+ devkit_exports_1.output.warn({
450770
+ title: `Unable to parse ${YARNRC_FILENAME}`,
450771
+ bodyLines: [error2.toString()]
450772
+ });
450773
+ return null;
450518
450774
  }
450519
- return message;
450520
450775
  }
450521
450776
  }
450522
450777
  });
@@ -450529,11 +450784,14 @@ var require_manager_factory = __commonJS({
450529
450784
  exports2.getCatalogManager = getCatalogManager;
450530
450785
  var devkit_exports_1 = require("nx/src/devkit-exports");
450531
450786
  var pnpm_manager_1 = require_pnpm_manager();
450787
+ var yarn_manager_1 = require_yarn_manager();
450532
450788
  function getCatalogManager(workspaceRoot) {
450533
450789
  const packageManager = (0, devkit_exports_1.detectPackageManager)(workspaceRoot);
450534
450790
  switch (packageManager) {
450535
450791
  case "pnpm":
450536
450792
  return new pnpm_manager_1.PnpmCatalogManager();
450793
+ case "yarn":
450794
+ return new yarn_manager_1.YarnCatalogManager();
450537
450795
  default:
450538
450796
  return null;
450539
450797
  }
@@ -450951,7 +451209,7 @@ var require_package_json = __commonJS({
450951
451209
  if (process.env.NX_DRY_RUN && process.env.NX_DRY_RUN !== "false") {
450952
451210
  throw new Error('NOTE: This generator does not support --dry-run. If you are running this in Nx Console, it should execute fine once you hit the "Generate" button.\n');
450953
451211
  }
450954
- const { tempDir } = (0, devkit_internals_1.installPackageToTmp)(pkg, requiredVersion);
451212
+ const { tempDir } = (0, devkit_internals_1.installPackageToTmp)(pkg, requiredVersion, (0, devkit_exports_1.detectPackageManager)(devkit_exports_1.workspaceRoot));
450955
451213
  addToNodePath((0, path_1.join)(devkit_exports_1.workspaceRoot, "node_modules"));
450956
451214
  addToNodePath((0, path_1.join)(tempDir, "node_modules"));
450957
451215
  module_1.Module._initPaths();
@@ -451131,7 +451389,8 @@ var require_parse_target_string = __commonJS({
451131
451389
  if (!projectGraph.nodes[maybeProject] && projectGraphOrCtx && "projectName" in projectGraphOrCtx && maybeProject !== projectGraphOrCtx.projectName) {
451132
451390
  targetString = `${projectGraphOrCtx.projectName}:${targetString}`;
451133
451391
  }
451134
- const [project, target, configuration] = (0, devkit_internals_1.splitTarget)(targetString, projectGraph);
451392
+ const currentProject = projectGraphOrCtx && "projectName" in projectGraphOrCtx ? projectGraphOrCtx.projectName : void 0;
451393
+ const [project, target, configuration] = (0, devkit_internals_1.splitTarget)(targetString, projectGraph, { currentProject });
451135
451394
  if (!project || !target) {
451136
451395
  throw new Error(`Invalid Target String: ${targetString}`);
451137
451396
  }
@@ -454084,7 +454343,7 @@ var init_yoctocolors = __esm({
454084
454343
  }
454085
454344
  });
454086
454345
 
454087
- // node_modules/is-unicode-supported/index.js
454346
+ // node_modules/ora/node_modules/is-unicode-supported/index.js
454088
454347
  function isUnicodeSupported() {
454089
454348
  const { env: env2 } = import_node_process4.default;
454090
454349
  const { TERM, TERM_PROGRAM } = env2;
@@ -454095,7 +454354,7 @@ function isUnicodeSupported() {
454095
454354
  }
454096
454355
  var import_node_process4;
454097
454356
  var init_is_unicode_supported = __esm({
454098
- "node_modules/is-unicode-supported/index.js"() {
454357
+ "node_modules/ora/node_modules/is-unicode-supported/index.js"() {
454099
454358
  "use strict";
454100
454359
  import_node_process4 = __toESM(require("node:process"), 1);
454101
454360
  }
@@ -454131,7 +454390,7 @@ var init_log_symbols = __esm({
454131
454390
  }
454132
454391
  });
454133
454392
 
454134
- // node_modules/ora/node_modules/strip-ansi/node_modules/ansi-regex/index.js
454393
+ // node_modules/ora/node_modules/string-width/node_modules/strip-ansi/node_modules/ansi-regex/index.js
454135
454394
  function ansiRegex({ onlyFirst = false } = {}) {
454136
454395
  const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
454137
454396
  const osc = `(?:\\u001B\\][\\s\\S]*?${ST})`;
@@ -454140,12 +454399,12 @@ function ansiRegex({ onlyFirst = false } = {}) {
454140
454399
  return new RegExp(pattern, onlyFirst ? void 0 : "g");
454141
454400
  }
454142
454401
  var init_ansi_regex = __esm({
454143
- "node_modules/ora/node_modules/strip-ansi/node_modules/ansi-regex/index.js"() {
454402
+ "node_modules/ora/node_modules/string-width/node_modules/strip-ansi/node_modules/ansi-regex/index.js"() {
454144
454403
  "use strict";
454145
454404
  }
454146
454405
  });
454147
454406
 
454148
- // node_modules/ora/node_modules/strip-ansi/index.js
454407
+ // node_modules/ora/node_modules/string-width/node_modules/strip-ansi/index.js
454149
454408
  function stripAnsi(string) {
454150
454409
  if (typeof string !== "string") {
454151
454410
  throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
@@ -454154,7 +454413,7 @@ function stripAnsi(string) {
454154
454413
  }
454155
454414
  var regex;
454156
454415
  var init_strip_ansi = __esm({
454157
- "node_modules/ora/node_modules/strip-ansi/index.js"() {
454416
+ "node_modules/ora/node_modules/string-width/node_modules/strip-ansi/index.js"() {
454158
454417
  "use strict";
454159
454418
  init_ansi_regex();
454160
454419
  regex = ansiRegex();
@@ -454357,14 +454616,14 @@ var init_string_width = __esm({
454357
454616
  }
454358
454617
  });
454359
454618
 
454360
- // node_modules/is-interactive/index.js
454619
+ // node_modules/ora/node_modules/is-interactive/index.js
454361
454620
  function isInteractive({ stream = process.stdout } = {}) {
454362
454621
  return Boolean(
454363
454622
  stream && stream.isTTY && process.env.TERM !== "dumb" && !("CI" in process.env)
454364
454623
  );
454365
454624
  }
454366
454625
  var init_is_interactive = __esm({
454367
- "node_modules/is-interactive/index.js"() {
454626
+ "node_modules/ora/node_modules/is-interactive/index.js"() {
454368
454627
  "use strict";
454369
454628
  }
454370
454629
  });
@@ -454378,6 +454637,18 @@ var init_stdin_discarder = __esm({
454378
454637
  ASCII_ETX_CODE = 3;
454379
454638
  StdinDiscarder = class {
454380
454639
  #activeCount = 0;
454640
+ #stdin;
454641
+ #stdinWasPaused = false;
454642
+ #stdinWasRaw = false;
454643
+ #handleInputBound = (chunk) => {
454644
+ if (!chunk?.length) {
454645
+ return;
454646
+ }
454647
+ const code = typeof chunk === "string" ? chunk.codePointAt(0) : chunk[0];
454648
+ if (code === ASCII_ETX_CODE) {
454649
+ import_node_process5.default.kill(import_node_process5.default.pid, "SIGINT");
454650
+ }
454651
+ };
454381
454652
  start() {
454382
454653
  this.#activeCount++;
454383
454654
  if (this.#activeCount === 1) {
@@ -454385,38 +454656,47 @@ var init_stdin_discarder = __esm({
454385
454656
  }
454386
454657
  }
454387
454658
  stop() {
454388
- if (this.#activeCount <= 0) {
454389
- throw new Error("`stop` called more times than `start`");
454390
- }
454391
- this.#activeCount--;
454392
454659
  if (this.#activeCount === 0) {
454660
+ return;
454661
+ }
454662
+ if (--this.#activeCount === 0) {
454393
454663
  this.#realStop();
454394
454664
  }
454395
454665
  }
454396
454666
  #realStart() {
454397
- if (import_node_process5.default.platform === "win32" || !import_node_process5.default.stdin.isTTY) {
454667
+ const { stdin } = import_node_process5.default;
454668
+ if (import_node_process5.default.platform === "win32" || !stdin?.isTTY || typeof stdin.setRawMode !== "function") {
454669
+ this.#stdin = void 0;
454398
454670
  return;
454399
454671
  }
454400
- import_node_process5.default.stdin.setRawMode(true);
454401
- import_node_process5.default.stdin.on("data", this.#handleInput);
454402
- import_node_process5.default.stdin.resume();
454672
+ this.#stdin = stdin;
454673
+ this.#stdinWasPaused = stdin.isPaused();
454674
+ this.#stdinWasRaw = Boolean(stdin.isRaw);
454675
+ stdin.setRawMode(true);
454676
+ stdin.prependListener("data", this.#handleInputBound);
454677
+ if (this.#stdinWasPaused) {
454678
+ stdin.resume();
454679
+ }
454403
454680
  }
454404
454681
  #realStop() {
454405
- if (!import_node_process5.default.stdin.isTTY) {
454682
+ if (!this.#stdin) {
454406
454683
  return;
454407
454684
  }
454408
- import_node_process5.default.stdin.off("data", this.#handleInput);
454409
- import_node_process5.default.stdin.pause();
454410
- import_node_process5.default.stdin.setRawMode(false);
454411
- }
454412
- #handleInput(chunk) {
454413
- if (chunk[0] === ASCII_ETX_CODE) {
454414
- import_node_process5.default.emit("SIGINT");
454685
+ const stdin = this.#stdin;
454686
+ stdin.off("data", this.#handleInputBound);
454687
+ if (stdin.isTTY) {
454688
+ stdin.setRawMode?.(this.#stdinWasRaw);
454415
454689
  }
454690
+ if (this.#stdinWasPaused) {
454691
+ stdin.pause();
454692
+ }
454693
+ this.#stdin = void 0;
454694
+ this.#stdinWasPaused = false;
454695
+ this.#stdinWasRaw = false;
454416
454696
  }
454417
454697
  };
454418
454698
  stdinDiscarder = new StdinDiscarder();
454419
- stdin_discarder_default = stdinDiscarder;
454699
+ stdin_discarder_default = Object.freeze(stdinDiscarder);
454420
454700
  }
454421
454701
  });
454422
454702
 
@@ -454448,40 +454728,102 @@ async function oraPromise(action, options) {
454448
454728
  throw error2;
454449
454729
  }
454450
454730
  }
454451
- var import_node_process6, Ora;
454731
+ var import_node_process6, import_node_util, RENDER_DEFERRAL_TIMEOUT, SYNCHRONIZED_OUTPUT_ENABLE, SYNCHRONIZED_OUTPUT_DISABLE, activeHooksPerStream, Ora;
454452
454732
  var init_ora = __esm({
454453
454733
  "node_modules/ora/index.js"() {
454454
454734
  "use strict";
454455
454735
  import_node_process6 = __toESM(require("node:process"), 1);
454736
+ import_node_util = require("node:util");
454456
454737
  init_source();
454457
454738
  init_cli_cursor();
454458
454739
  init_cli_spinners();
454459
454740
  init_log_symbols();
454460
- init_strip_ansi();
454461
454741
  init_string_width();
454462
454742
  init_is_interactive();
454463
454743
  init_is_unicode_supported();
454464
454744
  init_stdin_discarder();
454465
454745
  init_cli_spinners();
454746
+ RENDER_DEFERRAL_TIMEOUT = 200;
454747
+ SYNCHRONIZED_OUTPUT_ENABLE = "\x1B[?2026h";
454748
+ SYNCHRONIZED_OUTPUT_DISABLE = "\x1B[?2026l";
454749
+ activeHooksPerStream = /* @__PURE__ */ new Map();
454466
454750
  Ora = class {
454467
454751
  #linesToClear = 0;
454468
- #isDiscardingStdin = false;
454469
- #lineCount = 0;
454470
454752
  #frameIndex = -1;
454471
- #lastSpinnerFrameTime = 0;
454472
- #lastIndent = 0;
454753
+ #lastFrameTime = 0;
454473
454754
  #options;
454474
454755
  #spinner;
454475
454756
  #stream;
454476
454757
  #id;
454477
- #initialInterval;
454478
- #isEnabled;
454479
- #isSilent;
454480
- #indent;
454481
- #text;
454482
- #prefixText;
454483
- #suffixText;
454758
+ #hookedStreams = /* @__PURE__ */ new Map();
454759
+ #isInternalWrite = false;
454760
+ #drainHandler;
454761
+ #deferRenderTimer;
454762
+ #isDiscardingStdin = false;
454484
454763
  color;
454764
+ // Helper to execute writes while preventing hook recursion
454765
+ #internalWrite(fn) {
454766
+ this.#isInternalWrite = true;
454767
+ try {
454768
+ return fn();
454769
+ } finally {
454770
+ this.#isInternalWrite = false;
454771
+ }
454772
+ }
454773
+ // Helper to render if still spinning
454774
+ #tryRender() {
454775
+ if (this.isSpinning) {
454776
+ this.render();
454777
+ }
454778
+ }
454779
+ #stringifyChunk(chunk, encoding) {
454780
+ if (chunk === void 0 || chunk === null) {
454781
+ return "";
454782
+ }
454783
+ if (typeof chunk === "string") {
454784
+ return chunk;
454785
+ }
454786
+ if (Buffer.isBuffer(chunk) || ArrayBuffer.isView(chunk)) {
454787
+ const normalizedEncoding = typeof encoding === "string" && encoding && encoding !== "buffer" ? encoding : "utf8";
454788
+ return Buffer.from(chunk).toString(normalizedEncoding);
454789
+ }
454790
+ return String(chunk);
454791
+ }
454792
+ #chunkTerminatesLine(chunkString) {
454793
+ if (!chunkString) {
454794
+ return false;
454795
+ }
454796
+ const lastCharacter = chunkString.at(-1);
454797
+ return lastCharacter === "\n" || lastCharacter === "\r";
454798
+ }
454799
+ #scheduleRenderDeferral() {
454800
+ if (this.#deferRenderTimer) {
454801
+ return;
454802
+ }
454803
+ this.#deferRenderTimer = setTimeout(() => {
454804
+ this.#deferRenderTimer = void 0;
454805
+ if (this.isSpinning) {
454806
+ this.#tryRender();
454807
+ }
454808
+ }, RENDER_DEFERRAL_TIMEOUT);
454809
+ if (typeof this.#deferRenderTimer?.unref === "function") {
454810
+ this.#deferRenderTimer.unref();
454811
+ }
454812
+ }
454813
+ #clearRenderDeferral() {
454814
+ if (this.#deferRenderTimer) {
454815
+ clearTimeout(this.#deferRenderTimer);
454816
+ this.#deferRenderTimer = void 0;
454817
+ }
454818
+ }
454819
+ // Helper to build complete line with symbol, text, prefix, and suffix
454820
+ #buildOutputLine(symbol, text, prefixText, suffixText) {
454821
+ const fullPrefixText = this.#getFullPrefixText(prefixText, " ");
454822
+ const separatorText = symbol ? " " : "";
454823
+ const fullText = typeof text === "string" ? separatorText + text : "";
454824
+ const fullSuffixText = this.#getFullSuffixText(suffixText, " ");
454825
+ return fullPrefixText + symbol + fullText + fullSuffixText;
454826
+ }
454485
454827
  constructor(options) {
454486
454828
  if (typeof options === "string") {
454487
454829
  options = {
@@ -454496,18 +454838,23 @@ var init_ora = __esm({
454496
454838
  ...options
454497
454839
  };
454498
454840
  this.color = this.#options.color;
454499
- this.spinner = this.#options.spinner;
454500
- this.#initialInterval = this.#options.interval;
454501
454841
  this.#stream = this.#options.stream;
454502
- this.#isEnabled = typeof this.#options.isEnabled === "boolean" ? this.#options.isEnabled : isInteractive({ stream: this.#stream });
454503
- this.#isSilent = typeof this.#options.isSilent === "boolean" ? this.#options.isSilent : false;
454842
+ if (typeof this.#options.isEnabled !== "boolean") {
454843
+ this.#options.isEnabled = isInteractive({ stream: this.#stream });
454844
+ }
454845
+ if (typeof this.#options.isSilent !== "boolean") {
454846
+ this.#options.isSilent = false;
454847
+ }
454848
+ const userInterval = this.#options.interval;
454849
+ this.spinner = this.#options.spinner;
454850
+ this.#options.interval = userInterval;
454504
454851
  this.text = this.#options.text;
454505
454852
  this.prefixText = this.#options.prefixText;
454506
454853
  this.suffixText = this.#options.suffixText;
454507
454854
  this.indent = this.#options.indent;
454508
454855
  if (import_node_process6.default.env.NODE_ENV === "test") {
454509
454856
  this._stream = this.#stream;
454510
- this._isEnabled = this.#isEnabled;
454857
+ this._isEnabled = this.#options.isEnabled;
454511
454858
  Object.defineProperty(this, "_linesToClear", {
454512
454859
  get() {
454513
454860
  return this.#linesToClear;
@@ -454523,30 +454870,36 @@ var init_ora = __esm({
454523
454870
  });
454524
454871
  Object.defineProperty(this, "_lineCount", {
454525
454872
  get() {
454526
- return this.#lineCount;
454873
+ const columns = this.#stream.columns ?? 80;
454874
+ const prefixText = typeof this.#options.prefixText === "function" ? "" : this.#options.prefixText;
454875
+ const suffixText = typeof this.#options.suffixText === "function" ? "" : this.#options.suffixText;
454876
+ const fullPrefixText = typeof prefixText === "string" && prefixText !== "" ? prefixText + " " : "";
454877
+ const fullSuffixText = typeof suffixText === "string" && suffixText !== "" ? " " + suffixText : "";
454878
+ const spinnerChar = "-";
454879
+ const fullText = " ".repeat(this.#options.indent) + fullPrefixText + spinnerChar + (typeof this.#options.text === "string" ? " " + this.#options.text : "") + fullSuffixText;
454880
+ return this.#computeLineCountFrom(fullText, columns);
454527
454881
  }
454528
454882
  });
454529
454883
  }
454530
454884
  }
454531
454885
  get indent() {
454532
- return this.#indent;
454886
+ return this.#options.indent;
454533
454887
  }
454534
454888
  set indent(indent = 0) {
454535
454889
  if (!(indent >= 0 && Number.isInteger(indent))) {
454536
454890
  throw new Error("The `indent` option must be an integer from 0 and up");
454537
454891
  }
454538
- this.#indent = indent;
454539
- this.#updateLineCount();
454892
+ this.#options.indent = indent;
454540
454893
  }
454541
454894
  get interval() {
454542
- return this.#initialInterval ?? this.#spinner.interval ?? 100;
454895
+ return this.#options.interval ?? this.#spinner.interval ?? 100;
454543
454896
  }
454544
454897
  get spinner() {
454545
454898
  return this.#spinner;
454546
454899
  }
454547
454900
  set spinner(spinner) {
454548
454901
  this.#frameIndex = -1;
454549
- this.#initialInterval = void 0;
454902
+ this.#options.interval = void 0;
454550
454903
  if (typeof spinner === "object") {
454551
454904
  if (!Array.isArray(spinner.frames) || spinner.frames.length === 0 || spinner.frames.some((frame) => typeof frame !== "string")) {
454552
454905
  throw new Error("The given spinner must have a non-empty `frames` array of strings");
@@ -454566,25 +454919,22 @@ var init_ora = __esm({
454566
454919
  }
454567
454920
  }
454568
454921
  get text() {
454569
- return this.#text;
454922
+ return this.#options.text;
454570
454923
  }
454571
454924
  set text(value = "") {
454572
- this.#text = value;
454573
- this.#updateLineCount();
454925
+ this.#options.text = value;
454574
454926
  }
454575
454927
  get prefixText() {
454576
- return this.#prefixText;
454928
+ return this.#options.prefixText;
454577
454929
  }
454578
454930
  set prefixText(value = "") {
454579
- this.#prefixText = value;
454580
- this.#updateLineCount();
454931
+ this.#options.prefixText = value;
454581
454932
  }
454582
454933
  get suffixText() {
454583
- return this.#suffixText;
454934
+ return this.#options.suffixText;
454584
454935
  }
454585
454936
  set suffixText(value = "") {
454586
- this.#suffixText = value;
454587
- this.#updateLineCount();
454937
+ this.#options.suffixText = value;
454588
454938
  }
454589
454939
  get isSpinning() {
454590
454940
  return this.#id !== void 0;
@@ -454596,110 +454946,179 @@ var init_ora = __esm({
454596
454946
  }
454597
454947
  return "";
454598
454948
  }
454599
- #getFullPrefixText(prefixText = this.#prefixText, postfix = " ") {
454949
+ #getFullPrefixText(prefixText = this.#options.prefixText, postfix = " ") {
454600
454950
  return this.#formatAffix(prefixText, postfix, false);
454601
454951
  }
454602
- #getFullSuffixText(suffixText = this.#suffixText, prefix = " ") {
454952
+ #getFullSuffixText(suffixText = this.#options.suffixText, prefix = " ") {
454603
454953
  return this.#formatAffix(suffixText, prefix, true);
454604
454954
  }
454605
454955
  #computeLineCountFrom(text, columns) {
454606
454956
  let count = 0;
454607
- for (const line of stripAnsi(text).split("\n")) {
454957
+ for (const line of (0, import_node_util.stripVTControlCharacters)(text).split("\n")) {
454608
454958
  count += Math.max(1, Math.ceil(stringWidth(line) / columns));
454609
454959
  }
454610
454960
  return count;
454611
454961
  }
454612
- #updateLineCount() {
454613
- const columns = this.#stream.columns ?? 80;
454614
- const prefixText = typeof this.#prefixText === "function" ? "" : this.#prefixText;
454615
- const suffixText = typeof this.#suffixText === "function" ? "" : this.#suffixText;
454616
- const fullPrefixText = typeof prefixText === "string" && prefixText !== "" ? prefixText + " " : "";
454617
- const fullSuffixText = typeof suffixText === "string" && suffixText !== "" ? " " + suffixText : "";
454618
- const spinnerChar = "-";
454619
- const fullText = " ".repeat(this.#indent) + fullPrefixText + spinnerChar + (typeof this.#text === "string" ? " " + this.#text : "") + fullSuffixText;
454620
- this.#lineCount = this.#computeLineCountFrom(fullText, columns);
454621
- }
454622
454962
  get isEnabled() {
454623
- return this.#isEnabled && !this.#isSilent;
454963
+ return this.#options.isEnabled && !this.#options.isSilent;
454624
454964
  }
454625
454965
  set isEnabled(value) {
454626
454966
  if (typeof value !== "boolean") {
454627
454967
  throw new TypeError("The `isEnabled` option must be a boolean");
454628
454968
  }
454629
- this.#isEnabled = value;
454969
+ this.#options.isEnabled = value;
454630
454970
  }
454631
454971
  get isSilent() {
454632
- return this.#isSilent;
454972
+ return this.#options.isSilent;
454633
454973
  }
454634
454974
  set isSilent(value) {
454635
454975
  if (typeof value !== "boolean") {
454636
454976
  throw new TypeError("The `isSilent` option must be a boolean");
454637
454977
  }
454638
- this.#isSilent = value;
454978
+ this.#options.isSilent = value;
454639
454979
  }
454640
454980
  frame() {
454641
454981
  const now = Date.now();
454642
- if (this.#frameIndex === -1 || now - this.#lastSpinnerFrameTime >= this.interval) {
454643
- this.#frameIndex = ++this.#frameIndex % this.#spinner.frames.length;
454644
- this.#lastSpinnerFrameTime = now;
454982
+ if (this.#frameIndex === -1 || now - this.#lastFrameTime >= this.interval) {
454983
+ this.#frameIndex = (this.#frameIndex + 1) % this.#spinner.frames.length;
454984
+ this.#lastFrameTime = now;
454645
454985
  }
454646
454986
  const { frames } = this.#spinner;
454647
454987
  let frame = frames[this.#frameIndex];
454648
454988
  if (this.color) {
454649
454989
  frame = source_default[this.color](frame);
454650
454990
  }
454651
- const fullPrefixText = this.#getFullPrefixText(this.#prefixText, " ");
454991
+ const fullPrefixText = this.#getFullPrefixText(this.#options.prefixText, " ");
454652
454992
  const fullText = typeof this.text === "string" ? " " + this.text : "";
454653
- const fullSuffixText = this.#getFullSuffixText(this.#suffixText, " ");
454993
+ const fullSuffixText = this.#getFullSuffixText(this.#options.suffixText, " ");
454654
454994
  return fullPrefixText + frame + fullText + fullSuffixText;
454655
454995
  }
454656
454996
  clear() {
454657
- if (!this.#isEnabled || !this.#stream.isTTY) {
454997
+ if (!this.isEnabled || !this.#stream.isTTY) {
454658
454998
  return this;
454659
454999
  }
454660
- this.#stream.cursorTo(0);
454661
- for (let index = 0; index < this.#linesToClear; index++) {
454662
- if (index > 0) {
454663
- this.#stream.moveCursor(0, -1);
455000
+ this.#internalWrite(() => {
455001
+ this.#stream.cursorTo(0);
455002
+ for (let index = 0; index < this.#linesToClear; index++) {
455003
+ if (index > 0) {
455004
+ this.#stream.moveCursor(0, -1);
455005
+ }
455006
+ this.#stream.clearLine(1);
454664
455007
  }
454665
- this.#stream.clearLine(1);
454666
- }
454667
- if (this.#indent || this.#lastIndent !== this.#indent) {
454668
- this.#stream.cursorTo(this.#indent);
454669
- }
454670
- this.#lastIndent = this.#indent;
455008
+ if (this.#options.indent) {
455009
+ this.#stream.cursorTo(this.#options.indent);
455010
+ }
455011
+ });
454671
455012
  this.#linesToClear = 0;
454672
455013
  return this;
454673
455014
  }
455015
+ // Helper to hook a single stream
455016
+ #hookStream(stream) {
455017
+ if (!stream || this.#hookedStreams.has(stream) || !stream.isTTY || typeof stream.write !== "function") {
455018
+ return;
455019
+ }
455020
+ if (activeHooksPerStream.has(stream)) {
455021
+ console.warn("[ora] Multiple concurrent spinners detected. This may cause visual corruption. Use one spinner at a time.");
455022
+ }
455023
+ const originalWrite = stream.write;
455024
+ this.#hookedStreams.set(stream, originalWrite);
455025
+ activeHooksPerStream.set(stream, this);
455026
+ stream.write = (chunk, encoding, callback) => this.#hookedWrite(stream, originalWrite, chunk, encoding, callback);
455027
+ }
455028
+ /**
455029
+ Intercept stream writes while spinner is active to handle external writes cleanly without visual corruption.
455030
+ Hooks process stdio streams and the active spinner stream so console.log(), console.error(), and direct writes stay tidy.
455031
+ */
455032
+ #installHook() {
455033
+ if (!this.isEnabled || this.#hookedStreams.size > 0) {
455034
+ return;
455035
+ }
455036
+ const streamsToHook = /* @__PURE__ */ new Set([this.#stream, import_node_process6.default.stdout, import_node_process6.default.stderr]);
455037
+ for (const stream of streamsToHook) {
455038
+ this.#hookStream(stream);
455039
+ }
455040
+ }
455041
+ #uninstallHook() {
455042
+ for (const [stream, originalWrite] of this.#hookedStreams) {
455043
+ stream.write = originalWrite;
455044
+ if (activeHooksPerStream.get(stream) === this) {
455045
+ activeHooksPerStream.delete(stream);
455046
+ }
455047
+ }
455048
+ this.#hookedStreams.clear();
455049
+ }
455050
+ // eslint-disable-next-line max-params -- Need stream and originalWrite for multi-stream support
455051
+ #hookedWrite(stream, originalWrite, chunk, encoding, callback) {
455052
+ if (typeof encoding === "function") {
455053
+ callback = encoding;
455054
+ encoding = void 0;
455055
+ }
455056
+ if (this.#isInternalWrite) {
455057
+ return originalWrite.call(stream, chunk, encoding, callback);
455058
+ }
455059
+ this.clear();
455060
+ const chunkString = this.#stringifyChunk(chunk, encoding);
455061
+ const chunkTerminatesLine = this.#chunkTerminatesLine(chunkString);
455062
+ const writeResult = originalWrite.call(stream, chunk, encoding, callback);
455063
+ if (chunkTerminatesLine) {
455064
+ this.#clearRenderDeferral();
455065
+ } else if (chunkString.length > 0) {
455066
+ this.#scheduleRenderDeferral();
455067
+ }
455068
+ if (this.isSpinning && !this.#deferRenderTimer) {
455069
+ this.render();
455070
+ }
455071
+ return writeResult;
455072
+ }
454674
455073
  render() {
454675
- if (!this.#isEnabled || this.#isSilent) {
455074
+ if (!this.isEnabled || this.#drainHandler || this.#deferRenderTimer) {
454676
455075
  return this;
454677
455076
  }
454678
- this.clear();
454679
- let frameContent = this.frame();
454680
- const columns = this.#stream.columns ?? 80;
454681
- const actualLineCount = this.#computeLineCountFrom(frameContent, columns);
454682
- const consoleHeight = this.#stream.rows;
454683
- if (consoleHeight && consoleHeight > 1 && actualLineCount > consoleHeight) {
454684
- const lines = frameContent.split("\n");
454685
- const maxLines = consoleHeight - 1;
454686
- frameContent = [...lines.slice(0, maxLines), "... (content truncated to fit terminal)"].join("\n");
454687
- }
454688
- this.#stream.write(frameContent);
454689
- this.#linesToClear = this.#computeLineCountFrom(frameContent, columns);
455077
+ const useSynchronizedOutput = this.#stream.isTTY;
455078
+ let shouldDisableSynchronizedOutput = false;
455079
+ try {
455080
+ if (useSynchronizedOutput) {
455081
+ this.#internalWrite(() => this.#stream.write(SYNCHRONIZED_OUTPUT_ENABLE));
455082
+ shouldDisableSynchronizedOutput = true;
455083
+ }
455084
+ this.clear();
455085
+ let frameContent = this.frame();
455086
+ const columns = this.#stream.columns ?? 80;
455087
+ const actualLineCount = this.#computeLineCountFrom(frameContent, columns);
455088
+ const consoleHeight = this.#stream.rows;
455089
+ if (consoleHeight && consoleHeight > 1 && actualLineCount > consoleHeight) {
455090
+ const lines = frameContent.split("\n");
455091
+ const maxLines = consoleHeight - 1;
455092
+ frameContent = [...lines.slice(0, maxLines), "... (content truncated to fit terminal)"].join("\n");
455093
+ }
455094
+ const canContinue = this.#internalWrite(() => this.#stream.write(frameContent));
455095
+ if (canContinue === false && this.#stream.isTTY) {
455096
+ this.#drainHandler = () => {
455097
+ this.#drainHandler = void 0;
455098
+ this.#tryRender();
455099
+ };
455100
+ this.#stream.once("drain", this.#drainHandler);
455101
+ }
455102
+ this.#linesToClear = this.#computeLineCountFrom(frameContent, columns);
455103
+ } finally {
455104
+ if (shouldDisableSynchronizedOutput) {
455105
+ this.#internalWrite(() => this.#stream.write(SYNCHRONIZED_OUTPUT_DISABLE));
455106
+ }
455107
+ }
454690
455108
  return this;
454691
455109
  }
454692
455110
  start(text) {
454693
455111
  if (text) {
454694
455112
  this.text = text;
454695
455113
  }
454696
- if (this.#isSilent) {
455114
+ if (this.isSilent) {
454697
455115
  return this;
454698
455116
  }
454699
- if (!this.#isEnabled) {
454700
- const line = " ".repeat(this.#indent) + this.#getFullPrefixText(this.#prefixText, " ") + (this.text ? `- ${this.text}` : "") + this.#getFullSuffixText(this.#suffixText, " ");
455117
+ if (!this.isEnabled) {
455118
+ const symbol = this.text ? "-" : "";
455119
+ const line = " ".repeat(this.#options.indent) + this.#buildOutputLine(symbol, this.text, this.#options.prefixText, this.#options.suffixText);
454701
455120
  if (line.trim() !== "") {
454702
- this.#stream.write(line + "\n");
455121
+ this.#internalWrite(() => this.#stream.write(line + "\n"));
454703
455122
  }
454704
455123
  return this;
454705
455124
  }
@@ -454710,9 +455129,10 @@ var init_ora = __esm({
454710
455129
  cli_cursor_default.hide(this.#stream);
454711
455130
  }
454712
455131
  if (this.#options.discardStdin && import_node_process6.default.stdin.isTTY) {
454713
- this.#isDiscardingStdin = true;
454714
455132
  stdin_discarder_default.start();
455133
+ this.#isDiscardingStdin = true;
454715
455134
  }
455135
+ this.#installHook();
454716
455136
  this.render();
454717
455137
  this.#id = setInterval(this.render.bind(this), this.interval);
454718
455138
  return this;
@@ -454720,16 +455140,23 @@ var init_ora = __esm({
454720
455140
  stop() {
454721
455141
  clearInterval(this.#id);
454722
455142
  this.#id = void 0;
454723
- this.#frameIndex = 0;
454724
- if (this.#isEnabled) {
455143
+ this.#frameIndex = -1;
455144
+ this.#lastFrameTime = 0;
455145
+ this.#clearRenderDeferral();
455146
+ this.#uninstallHook();
455147
+ if (this.#drainHandler) {
455148
+ this.#stream.removeListener("drain", this.#drainHandler);
455149
+ this.#drainHandler = void 0;
455150
+ }
455151
+ if (this.isEnabled) {
454725
455152
  this.clear();
454726
455153
  if (this.#options.hideCursor) {
454727
455154
  cli_cursor_default.show(this.#stream);
454728
455155
  }
454729
455156
  }
454730
- if (this.#options.discardStdin && import_node_process6.default.stdin.isTTY && this.#isDiscardingStdin) {
454731
- stdin_discarder_default.stop();
455157
+ if (this.#isDiscardingStdin) {
454732
455158
  this.#isDiscardingStdin = false;
455159
+ stdin_discarder_default.stop();
454733
455160
  }
454734
455161
  return this;
454735
455162
  }
@@ -454746,20 +455173,16 @@ var init_ora = __esm({
454746
455173
  return this.stopAndPersist({ symbol: symbols_exports.info, text });
454747
455174
  }
454748
455175
  stopAndPersist(options = {}) {
454749
- if (this.#isSilent) {
455176
+ if (this.isSilent) {
454750
455177
  return this;
454751
455178
  }
454752
- const prefixText = options.prefixText ?? this.#prefixText;
454753
- const fullPrefixText = this.#getFullPrefixText(prefixText, " ");
454754
- const symbolText = options.symbol ?? " ";
455179
+ const symbol = options.symbol ?? " ";
454755
455180
  const text = options.text ?? this.text;
454756
- const separatorText = symbolText ? " " : "";
454757
- const fullText = typeof text === "string" ? separatorText + text : "";
454758
- const suffixText = options.suffixText ?? this.#suffixText;
454759
- const fullSuffixText = this.#getFullSuffixText(suffixText, " ");
454760
- const textToWrite = fullPrefixText + symbolText + fullText + fullSuffixText + "\n";
455181
+ const prefixText = options.prefixText ?? this.#options.prefixText;
455182
+ const suffixText = options.suffixText ?? this.#options.suffixText;
455183
+ const textToWrite = this.#buildOutputLine(symbol, text, prefixText, suffixText) + "\n";
454761
455184
  this.stop();
454762
- this.#stream.write(textToWrite);
455185
+ this.#internalWrite(() => this.#stream.write(textToWrite));
454763
455186
  return this;
454764
455187
  }
454765
455188
  };
@@ -455000,7 +455423,6 @@ var require_executor2 = __commonJS({
455000
455423
  const errorStream = ignoreErrorStream ? "ignore" : process.stderr;
455001
455424
  const spawnOptions = {
455002
455425
  stdio: [process.stdin, outputStream, errorStream],
455003
- shell: true,
455004
455426
  cwd: path.join(rootDirectory, options.workingDirectory || ""),
455005
455427
  env: {
455006
455428
  ...process.env,
@@ -455009,7 +455431,7 @@ var require_executor2 = __commonJS({
455009
455431
  }
455010
455432
  };
455011
455433
  return new Promise((resolve, reject) => {
455012
- (0, node_child_process_1.spawn)(`git ${args.join(" ")}`, spawnOptions).on("close", (code) => {
455434
+ (0, node_child_process_1.spawn)("git", args, spawnOptions).on("close", (code) => {
455013
455435
  if (code === 0) {
455014
455436
  resolve();
455015
455437
  } else {
@@ -455035,7 +455457,7 @@ var require_executor2 = __commonJS({
455035
455457
  await execute(["add", "."]);
455036
455458
  if (options.commit) {
455037
455459
  const message = options.message || "initial commit";
455038
- await execute(["commit", `-m "${message}"`]);
455460
+ await execute(["commit", "-m", message]);
455039
455461
  }
455040
455462
  context.logger.info("Successfully initialized git.");
455041
455463
  } catch {
@@ -458001,20 +458423,20 @@ var require_internal = __commonJS({
458001
458423
  });
458002
458424
 
458003
458425
  // node_modules/@angular-devkit/architect/package.json
458004
- var require_package3 = __commonJS({
458426
+ var require_package2 = __commonJS({
458005
458427
  "node_modules/@angular-devkit/architect/package.json"(exports2, module2) {
458006
458428
  module2.exports = {
458007
458429
  name: "@angular-devkit/architect",
458008
- version: "0.2101.5",
458430
+ version: "0.2102.28",
458009
458431
  description: "Angular Build Facade",
458010
458432
  experimental: true,
458011
458433
  bin: {
458012
- architect: "./bin/cli.js"
458434
+ architect: "bin/cli.js"
458013
458435
  },
458014
458436
  main: "src/index.js",
458015
458437
  typings: "src/index.d.ts",
458016
458438
  dependencies: {
458017
- "@angular-devkit/core": "21.1.5",
458439
+ "@angular-devkit/core": "21.2.28",
458018
458440
  rxjs: "7.8.2"
458019
458441
  },
458020
458442
  builders: "./builders/builders.json",
@@ -458027,9 +458449,9 @@ var require_package3 = __commonJS({
458027
458449
  ],
458028
458450
  repository: {
458029
458451
  type: "git",
458030
- url: "https://github.com/angular/angular-cli.git"
458452
+ url: "git+https://github.com/angular/angular-cli.git"
458031
458453
  },
458032
- packageManager: "pnpm@10.29.3",
458454
+ packageManager: "pnpm@10.33.2",
458033
458455
  engines: {
458034
458456
  node: "^20.19.0 || ^22.12.0 || >=24.0.0",
458035
458457
  npm: "^6.11.0 || ^7.5.6 || >=8.0.0",
@@ -458201,7 +458623,7 @@ var require_create_builder = __commonJS({
458201
458623
  return {
458202
458624
  handler,
458203
458625
  [internal_1.BuilderSymbol]: true,
458204
- [internal_1.BuilderVersionSymbol]: require_package3().version,
458626
+ [internal_1.BuilderVersionSymbol]: require_package2().version,
458205
458627
  // Only needed for type safety around `Builder` types.
458206
458628
  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
458207
458629
  __OptionT: null
@@ -458924,11 +459346,10 @@ typescript/lib/typescript.js:
458924
459346
  and limitations under the License.
458925
459347
  ***************************************************************************** *)
458926
459348
 
458927
- ejs/lib/ejs.js:
459349
+ ejs/lib/cjs/ejs.js:
458928
459350
  (**
458929
459351
  * @file Embedded JavaScript templating engine. {@link http://ejs.co}
458930
459352
  * @author Matthew Eernisse <mde@fleegix.org>
458931
- * @author Tiancheng "Timothy" Gu <timothygu99@gmail.com>
458932
459353
  * @project EJS
458933
459354
  * @license {@link http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0}
458934
459355
  *)