@schematics/angular 16.1.0-next.2 → 16.1.0

package/utility/index.js

@@ -6,6 +6,20 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addDependency = exports.InstallBehavior = exports.ExistingBehavior = exports.DependencyType = exports.AngularBuilder = exports.writeWorkspace = exports.updateWorkspace = exports.readWorkspace = void 0;
 // Workspace related rules and types
@@ -15,10 +29,11 @@ Object.defineProperty(exports, "updateWorkspace", { enumerable: true, get: funct
 Object.defineProperty(exports, "writeWorkspace", { enumerable: true, get: function () { return workspace_1.writeWorkspace; } });
 var workspace_models_1 = require("./workspace-models");
 Object.defineProperty(exports, "AngularBuilder", { enumerable: true, get: function () { return workspace_models_1.Builders; } });
+__exportStar(require("./standalone"), exports);
 // Package dependency related rules and types
 var dependency_1 = require("./dependency");
 Object.defineProperty(exports, "DependencyType", { enumerable: true, get: function () { return dependency_1.DependencyType; } });
 Object.defineProperty(exports, "ExistingBehavior", { enumerable: true, get: function () { return dependency_1.ExistingBehavior; } });
 Object.defineProperty(exports, "InstallBehavior", { enumerable: true, get: function () { return dependency_1.InstallBehavior; } });
 Object.defineProperty(exports, "addDependency", { enumerable: true, get: function () { return dependency_1.addDependency; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9zY2hlbWF0aWNzL2FuZ3VsYXIvdXRpbGl0eS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7OztHQU1HOzs7QUFFSCxvQ0FBb0M7QUFDcEMseUNBT3FCO0FBSG5CLDBHQUFBLFlBQVksT0FBaUI7QUFDN0IsNEdBQUEsZUFBZSxPQUFBO0FBQ2YsMkdBQUEsY0FBYyxPQUFBO0FBRWhCLHVEQUFnRTtBQUF2RCxrSEFBQSxRQUFRLE9BQWtCO0FBRW5DLDZDQUE2QztBQUM3QywyQ0FBZ0c7QUFBdkYsNEdBQUEsY0FBYyxPQUFBO0FBQUUsOEdBQUEsZ0JBQWdCLE9BQUE7QUFBRSw2R0FBQSxlQUFlLE9BQUE7QUFBRSwyR0FBQSxhQUFhLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuLy8gV29ya3NwYWNlIHJlbGF0ZWQgcnVsZXMgYW5kIHR5cGVzXG5leHBvcnQge1xuICBQcm9qZWN0RGVmaW5pdGlvbixcbiAgVGFyZ2V0RGVmaW5pdGlvbixcbiAgV29ya3NwYWNlRGVmaW5pdGlvbixcbiAgZ2V0V29ya3NwYWNlIGFzIHJlYWRXb3Jrc3BhY2UsXG4gIHVwZGF0ZVdvcmtzcGFjZSxcbiAgd3JpdGVXb3Jrc3BhY2UsXG59IGZyb20gJy4vd29ya3NwYWNlJztcbmV4cG9ydCB7IEJ1aWxkZXJzIGFzIEFuZ3VsYXJCdWlsZGVyIH0gZnJvbSAnLi93b3Jrc3BhY2UtbW9kZWxzJztcblxuLy8gUGFja2FnZSBkZXBlbmRlbmN5IHJlbGF0ZWQgcnVsZXMgYW5kIHR5cGVzXG5leHBvcnQgeyBEZXBlbmRlbmN5VHlwZSwgRXhpc3RpbmdCZWhhdmlvciwgSW5zdGFsbEJlaGF2aW9yLCBhZGREZXBlbmRlbmN5IH0gZnJvbSAnLi9kZXBlbmRlbmN5JztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9zY2hlbWF0aWNzL2FuZ3VsYXIvdXRpbGl0eS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7OztHQU1HOzs7Ozs7Ozs7Ozs7Ozs7OztBQUVILG9DQUFvQztBQUNwQyx5Q0FPcUI7QUFIbkIsMEdBQUEsWUFBWSxPQUFpQjtBQUM3Qiw0R0FBQSxlQUFlLE9BQUE7QUFDZiwyR0FBQSxjQUFjLE9BQUE7QUFFaEIsdURBQWdFO0FBQXZELGtIQUFBLFFBQVEsT0FBa0I7QUFDbkMsK0NBQTZCO0FBRTdCLDZDQUE2QztBQUM3QywyQ0FBZ0c7QUFBdkYsNEdBQUEsY0FBYyxPQUFBO0FBQUUsOEdBQUEsZ0JBQWdCLE9BQUE7QUFBRSw2R0FBQSxlQUFlLE9BQUE7QUFBRSwyR0FBQSxhQUFhLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuLy8gV29ya3NwYWNlIHJlbGF0ZWQgcnVsZXMgYW5kIHR5cGVzXG5leHBvcnQge1xuICBQcm9qZWN0RGVmaW5pdGlvbixcbiAgVGFyZ2V0RGVmaW5pdGlvbixcbiAgV29ya3NwYWNlRGVmaW5pdGlvbixcbiAgZ2V0V29ya3NwYWNlIGFzIHJlYWRXb3Jrc3BhY2UsXG4gIHVwZGF0ZVdvcmtzcGFjZSxcbiAgd3JpdGVXb3Jrc3BhY2UsXG59IGZyb20gJy4vd29ya3NwYWNlJztcbmV4cG9ydCB7IEJ1aWxkZXJzIGFzIEFuZ3VsYXJCdWlsZGVyIH0gZnJvbSAnLi93b3Jrc3BhY2UtbW9kZWxzJztcbmV4cG9ydCAqIGZyb20gJy4vc3RhbmRhbG9uZSc7XG5cbi8vIFBhY2thZ2UgZGVwZW5kZW5jeSByZWxhdGVkIHJ1bGVzIGFuZCB0eXBlc1xuZXhwb3J0IHsgRGVwZW5kZW5jeVR5cGUsIEV4aXN0aW5nQmVoYXZpb3IsIEluc3RhbGxCZWhhdmlvciwgYWRkRGVwZW5kZW5jeSB9IGZyb20gJy4vZGVwZW5kZW5jeSc7XG4iXX0=

package/utility/latest-versions/package.json

@@ -9,15 +9,15 @@
     "jasmine-spec-reporter": "~7.0.0",
     "karma-chrome-launcher": "~3.2.0",
     "karma-coverage": "~2.2.0",
-    "karma-jasmine-html-reporter": "~2.0.0",
+    "karma-jasmine-html-reporter": "~2.1.0",
     "karma-jasmine": "~5.1.0",
     "karma": "~6.4.0",
-    "ng-packagr": "^16.1.0-next.0",
+    "ng-packagr": "^16.1.0",
     "protractor": "~7.0.0",
     "rxjs": "~7.8.0",
     "tslib": "^2.3.0",
     "ts-node": "~10.9.0",
-    "typescript": "~5.0.2",
+    "typescript": "~5.1.3",
     "zone.js": "~0.13.0"
   }
 }

package/utility/latest-versions.js

@@ -13,10 +13,10 @@ exports.latestVersions = {
     // but ts_library doesn't support JSON inputs.
     ...require('./latest-versions/package.json')['dependencies'],
     // As Angular CLI works with same minor versions of Angular Framework, a tilde match for the current
-    Angular: '^16.1.0-next.0',
+    Angular: '^16.1.0',
     // Since @angular-devkit/build-angular and @schematics/angular are always
     // published together from the same monorepo, and they are both
     // non-experimental, they will always have the same version.
     DevkitBuildAngular: '^' + require('../package.json')['version'],
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGF0ZXN0LXZlcnNpb25zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvc2NoZW1hdGljcy9hbmd1bGFyL3V0aWxpdHkvbGF0ZXN0LXZlcnNpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7Ozs7O0dBTUc7OztBQUVVLFFBQUEsY0FBYyxHQUd2QjtJQUNGLG1HQUFtRztJQUNuRyw4Q0FBOEM7SUFDOUMsR0FBRyxPQUFPLENBQUMsZ0NBQWdDLENBQUMsQ0FBQyxjQUFjLENBQUM7SUFFNUQsb0dBQW9HO0lBQ3BHLE9BQU8sRUFBRSxnQkFBZ0I7SUFFekIseUVBQXlFO0lBQ3pFLCtEQUErRDtJQUMvRCw0REFBNEQ7SUFDNUQsa0JBQWtCLEVBQUUsR0FBRyxHQUFHLE9BQU8sQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDLFNBQVMsQ0FBQztDQUNoRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmV4cG9ydCBjb25zdCBsYXRlc3RWZXJzaW9uczogUmVjb3JkPHN0cmluZywgc3RyaW5nPiAmIHtcbiAgQW5ndWxhcjogc3RyaW5nO1xuICBEZXZraXRCdWlsZEFuZ3VsYXI6IHN0cmluZztcbn0gPSB7XG4gIC8vIFdlIGNvdWxkIGhhdmUgdXNlZCBUeXBlU2NyaXB0cycgYHJlc29sdmVKc29uTW9kdWxlYCB0byBtYWtlIHRoZSBgbGF0ZXN0VmVyc2lvbmAgb2JqZWN0IHR5cGVzYWZlLFxuICAvLyBidXQgdHNfbGlicmFyeSBkb2Vzbid0IHN1cHBvcnQgSlNPTiBpbnB1dHMuXG4gIC4uLnJlcXVpcmUoJy4vbGF0ZXN0LXZlcnNpb25zL3BhY2thZ2UuanNvbicpWydkZXBlbmRlbmNpZXMnXSxcblxuICAvLyBBcyBBbmd1bGFyIENMSSB3b3JrcyB3aXRoIHNhbWUgbWlub3IgdmVyc2lvbnMgb2YgQW5ndWxhciBGcmFtZXdvcmssIGEgdGlsZGUgbWF0Y2ggZm9yIHRoZSBjdXJyZW50XG4gIEFuZ3VsYXI6ICdeMTYuMS4wLW5leHQuMCcsXG5cbiAgLy8gU2luY2UgQGFuZ3VsYXItZGV2a2l0L2J1aWxkLWFuZ3VsYXIgYW5kIEBzY2hlbWF0aWNzL2FuZ3VsYXIgYXJlIGFsd2F5c1xuICAvLyBwdWJsaXNoZWQgdG9nZXRoZXIgZnJvbSB0aGUgc2FtZSBtb25vcmVwbywgYW5kIHRoZXkgYXJlIGJvdGhcbiAgLy8gbm9uLWV4cGVyaW1lbnRhbCwgdGhleSB3aWxsIGFsd2F5cyBoYXZlIHRoZSBzYW1lIHZlcnNpb24uXG4gIERldmtpdEJ1aWxkQW5ndWxhcjogJ14nICsgcmVxdWlyZSgnLi4vcGFja2FnZS5qc29uJylbJ3ZlcnNpb24nXSxcbn07XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGF0ZXN0LXZlcnNpb25zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvc2NoZW1hdGljcy9hbmd1bGFyL3V0aWxpdHkvbGF0ZXN0LXZlcnNpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7Ozs7O0dBTUc7OztBQUVVLFFBQUEsY0FBYyxHQUd2QjtJQUNGLG1HQUFtRztJQUNuRyw4Q0FBOEM7SUFDOUMsR0FBRyxPQUFPLENBQUMsZ0NBQWdDLENBQUMsQ0FBQyxjQUFjLENBQUM7SUFFNUQsb0dBQW9HO0lBQ3BHLE9BQU8sRUFBRSxTQUFTO0lBRWxCLHlFQUF5RTtJQUN6RSwrREFBK0Q7SUFDL0QsNERBQTREO0lBQzVELGtCQUFrQixFQUFFLEdBQUcsR0FBRyxPQUFPLENBQUMsaUJBQWlCLENBQUMsQ0FBQyxTQUFTLENBQUM7Q0FDaEUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQgY29uc3QgbGF0ZXN0VmVyc2lvbnM6IFJlY29yZDxzdHJpbmcsIHN0cmluZz4gJiB7XG4gIEFuZ3VsYXI6IHN0cmluZztcbiAgRGV2a2l0QnVpbGRBbmd1bGFyOiBzdHJpbmc7XG59ID0ge1xuICAvLyBXZSBjb3VsZCBoYXZlIHVzZWQgVHlwZVNjcmlwdHMnIGByZXNvbHZlSnNvbk1vZHVsZWAgdG8gbWFrZSB0aGUgYGxhdGVzdFZlcnNpb25gIG9iamVjdCB0eXBlc2FmZSxcbiAgLy8gYnV0IHRzX2xpYnJhcnkgZG9lc24ndCBzdXBwb3J0IEpTT04gaW5wdXRzLlxuICAuLi5yZXF1aXJlKCcuL2xhdGVzdC12ZXJzaW9ucy9wYWNrYWdlLmpzb24nKVsnZGVwZW5kZW5jaWVzJ10sXG5cbiAgLy8gQXMgQW5ndWxhciBDTEkgd29ya3Mgd2l0aCBzYW1lIG1pbm9yIHZlcnNpb25zIG9mIEFuZ3VsYXIgRnJhbWV3b3JrLCBhIHRpbGRlIG1hdGNoIGZvciB0aGUgY3VycmVudFxuICBBbmd1bGFyOiAnXjE2LjEuMCcsXG5cbiAgLy8gU2luY2UgQGFuZ3VsYXItZGV2a2l0L2J1aWxkLWFuZ3VsYXIgYW5kIEBzY2hlbWF0aWNzL2FuZ3VsYXIgYXJlIGFsd2F5c1xuICAvLyBwdWJsaXNoZWQgdG9nZXRoZXIgZnJvbSB0aGUgc2FtZSBtb25vcmVwbywgYW5kIHRoZXkgYXJlIGJvdGhcbiAgLy8gbm9uLWV4cGVyaW1lbnRhbCwgdGhleSB3aWxsIGFsd2F5cyBoYXZlIHRoZSBzYW1lIHZlcnNpb24uXG4gIERldmtpdEJ1aWxkQW5ndWxhcjogJ14nICsgcmVxdWlyZSgnLi4vcGFja2FnZS5qc29uJylbJ3ZlcnNpb24nXSxcbn07XG4iXX0=

package/utility/standalone/app_config.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Tree } from '@angular-devkit/schematics';
+import ts from '../../third_party/github.com/Microsoft/TypeScript/lib/typescript';
+/** App config that was resolved to its source node. */
+export interface ResolvedAppConfig {
+    /** Tree-relative path of the file containing the app config. */
+    filePath: string;
+    /** Node defining the app config. */
+    node: ts.ObjectLiteralExpression;
+}
+/**
+ * Resolves the node that defines the app config from a bootstrap call.
+ * @param bootstrapCall Call for which to resolve the config.
+ * @param tree File tree of the project.
+ * @param filePath File path of the bootstrap call.
+ */
+export declare function findAppConfig(bootstrapCall: ts.CallExpression, tree: Tree, filePath: string): ResolvedAppConfig | null;

package/utility/standalone/app_config.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findAppConfig = void 0;
+const path_1 = require("path");
+const typescript_1 = __importDefault(require("../../third_party/github.com/Microsoft/TypeScript/lib/typescript"));
+const util_1 = require("./util");
+/**
+ * Resolves the node that defines the app config from a bootstrap call.
+ * @param bootstrapCall Call for which to resolve the config.
+ * @param tree File tree of the project.
+ * @param filePath File path of the bootstrap call.
+ */
+function findAppConfig(bootstrapCall, tree, filePath) {
+    if (bootstrapCall.arguments.length > 1) {
+        const config = bootstrapCall.arguments[1];
+        if (typescript_1.default.isObjectLiteralExpression(config)) {
+            return { filePath, node: config };
+        }
+        if (typescript_1.default.isIdentifier(config)) {
+            return resolveAppConfigFromIdentifier(config, tree, filePath);
+        }
+    }
+    return null;
+}
+exports.findAppConfig = findAppConfig;
+/**
+ * Resolves the app config from an identifier referring to it.
+ * @param identifier Identifier referring to the app config.
+ * @param tree File tree of the project.
+ * @param bootstapFilePath Path of the bootstrap call.
+ */
+function resolveAppConfigFromIdentifier(identifier, tree, bootstapFilePath) {
+    const sourceFile = identifier.getSourceFile();
+    for (const node of sourceFile.statements) {
+        // Only look at relative imports. This will break if the app uses a path
+        // mapping to refer to the import, but in order to resolve those, we would
+        // need knowledge about the entire program.
+        if (!typescript_1.default.isImportDeclaration(node) ||
+            !node.importClause?.namedBindings ||
+            !typescript_1.default.isNamedImports(node.importClause.namedBindings) ||
+            !typescript_1.default.isStringLiteralLike(node.moduleSpecifier) ||
+            !node.moduleSpecifier.text.startsWith('.')) {
+            continue;
+        }
+        for (const specifier of node.importClause.namedBindings.elements) {
+            if (specifier.name.text !== identifier.text) {
+                continue;
+            }
+            // Look for a variable with the imported name in the file. Note that ideally we would use
+            // the type checker to resolve this, but we can't because these utilities are set up to
+            // operate on individual files, not the entire program.
+            const filePath = (0, path_1.join)((0, path_1.dirname)(bootstapFilePath), node.moduleSpecifier.text + '.ts');
+            const importedSourceFile = (0, util_1.getSourceFile)(tree, filePath);
+            const resolvedVariable = findAppConfigFromVariableName(importedSourceFile, (specifier.propertyName || specifier.name).text);
+            if (resolvedVariable) {
+                return { filePath, node: resolvedVariable };
+            }
+        }
+    }
+    const variableInSameFile = findAppConfigFromVariableName(sourceFile, identifier.text);
+    return variableInSameFile ? { filePath: bootstapFilePath, node: variableInSameFile } : null;
+}
+/**
+ * Finds an app config within the top-level variables of a file.
+ * @param sourceFile File in which to search for the config.
+ * @param variableName Name of the variable containing the config.
+ */
+function findAppConfigFromVariableName(sourceFile, variableName) {
+    for (const node of sourceFile.statements) {
+        if (typescript_1.default.isVariableStatement(node)) {
+            for (const decl of node.declarationList.declarations) {
+                if (typescript_1.default.isIdentifier(decl.name) &&
+                    decl.name.text === variableName &&
+                    decl.initializer &&
+                    typescript_1.default.isObjectLiteralExpression(decl.initializer)) {
+                    return decl.initializer;
+                }
+            }
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app_config.js","sourceRoot":"","sources":["../../../../../../../../packages/schematics/angular/utility/standalone/app_config.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport { Tree } from '@angular-devkit/schematics';\nimport { dirname, join } from 'path';\nimport ts from '../../third_party/github.com/Microsoft/TypeScript/lib/typescript';\nimport { getSourceFile } from './util';\n\n/** App config that was resolved to its source node. */\nexport interface ResolvedAppConfig {\n  /** Tree-relative path of the file containing the app config. */\n  filePath: string;\n\n  /** Node defining the app config. */\n  node: ts.ObjectLiteralExpression;\n}\n\n/**\n * Resolves the node that defines the app config from a bootstrap call.\n * @param bootstrapCall Call for which to resolve the config.\n * @param tree File tree of the project.\n * @param filePath File path of the bootstrap call.\n */\nexport function findAppConfig(\n  bootstrapCall: ts.CallExpression,\n  tree: Tree,\n  filePath: string,\n): ResolvedAppConfig | null {\n  if (bootstrapCall.arguments.length > 1) {\n    const config = bootstrapCall.arguments[1];\n\n    if (ts.isObjectLiteralExpression(config)) {\n      return { filePath, node: config };\n    }\n\n    if (ts.isIdentifier(config)) {\n      return resolveAppConfigFromIdentifier(config, tree, filePath);\n    }\n  }\n\n  return null;\n}\n\n/**\n * Resolves the app config from an identifier referring to it.\n * @param identifier Identifier referring to the app config.\n * @param tree File tree of the project.\n * @param bootstapFilePath Path of the bootstrap call.\n */\nfunction resolveAppConfigFromIdentifier(\n  identifier: ts.Identifier,\n  tree: Tree,\n  bootstapFilePath: string,\n): ResolvedAppConfig | null {\n  const sourceFile = identifier.getSourceFile();\n\n  for (const node of sourceFile.statements) {\n    // Only look at relative imports. This will break if the app uses a path\n    // mapping to refer to the import, but in order to resolve those, we would\n    // need knowledge about the entire program.\n    if (\n      !ts.isImportDeclaration(node) ||\n      !node.importClause?.namedBindings ||\n      !ts.isNamedImports(node.importClause.namedBindings) ||\n      !ts.isStringLiteralLike(node.moduleSpecifier) ||\n      !node.moduleSpecifier.text.startsWith('.')\n    ) {\n      continue;\n    }\n\n    for (const specifier of node.importClause.namedBindings.elements) {\n      if (specifier.name.text !== identifier.text) {\n        continue;\n      }\n\n      // Look for a variable with the imported name in the file. Note that ideally we would use\n      // the type checker to resolve this, but we can't because these utilities are set up to\n      // operate on individual files, not the entire program.\n      const filePath = join(dirname(bootstapFilePath), node.moduleSpecifier.text + '.ts');\n      const importedSourceFile = getSourceFile(tree, filePath);\n      const resolvedVariable = findAppConfigFromVariableName(\n        importedSourceFile,\n        (specifier.propertyName || specifier.name).text,\n      );\n\n      if (resolvedVariable) {\n        return { filePath, node: resolvedVariable };\n      }\n    }\n  }\n\n  const variableInSameFile = findAppConfigFromVariableName(sourceFile, identifier.text);\n\n  return variableInSameFile ? { filePath: bootstapFilePath, node: variableInSameFile } : null;\n}\n\n/**\n * Finds an app config within the top-level variables of a file.\n * @param sourceFile File in which to search for the config.\n * @param variableName Name of the variable containing the config.\n */\nfunction findAppConfigFromVariableName(\n  sourceFile: ts.SourceFile,\n  variableName: string,\n): ts.ObjectLiteralExpression | null {\n  for (const node of sourceFile.statements) {\n    if (ts.isVariableStatement(node)) {\n      for (const decl of node.declarationList.declarations) {\n        if (\n          ts.isIdentifier(decl.name) &&\n          decl.name.text === variableName &&\n          decl.initializer &&\n          ts.isObjectLiteralExpression(decl.initializer)\n        ) {\n          return decl.initializer;\n        }\n      }\n    }\n  }\n\n  return null;\n}\n"]}

package/utility/standalone/code_block.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Rule } from '@angular-devkit/schematics';
+/** Generated code that hasn't been interpolated yet. */
+export interface PendingCode {
+    /** Code that will be inserted. */
+    expression: string;
+    /** Imports that need to be added to the file in which the code is inserted. */
+    imports: PendingImports;
+}
+/** Map keeping track of imports and aliases under which they're referred to in an expresion. */
+type PendingImports = Map<string, Map<string, string>>;
+/**
+ * Callback invoked by a Rule that produces the code
+ * that needs to be inserted somewhere in the app.
+ */
+export type CodeBlockCallback = (block: CodeBlock) => PendingCode;
+/**
+ * Utility class used to generate blocks of code that
+ * can be inserted by the devkit into a user's app.
+ */
+export declare class CodeBlock {
+    private _imports;
+    /** Function used to tag a code block in order to produce a `PendingCode` object. */
+    code: (strings: TemplateStringsArray, ...params: unknown[]) => PendingCode;
+    /**
+     * Used inside of a code block to mark external symbols and which module they should be imported
+     * from. When the code is inserted, the required import statements will be produced automatically.
+     * @param symbolName Name of the external symbol.
+     * @param moduleName Module from which the symbol should be imported.
+     */
+    external: (symbolName: string, moduleName: string) => string;
+    /**
+     * Produces the necessary rules to transform a `PendingCode` object into valid code.
+     * @param initialCode Code pending transformed.
+     * @param filePath Path of the file in which the code will be inserted.
+     */
+    static transformPendingCode(initialCode: PendingCode, filePath: string): {
+        code: {
+            /** Code that will be inserted. */
+            expression: string;
+            /** Imports that need to be added to the file in which the code is inserted. */
+            imports: PendingImports;
+        };
+        rules: Rule[];
+    };
+}
+export {};

package/utility/standalone/code_block.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeBlock = void 0;
+const typescript_1 = __importDefault(require("../../third_party/github.com/Microsoft/TypeScript/lib/typescript"));
+const ast_utils_1 = require("../ast-utils");
+const change_1 = require("../change");
+/** Counter used to generate unique IDs. */
+let uniqueIdCounter = 0;
+/**
+ * Utility class used to generate blocks of code that
+ * can be inserted by the devkit into a user's app.
+ */
+class CodeBlock {
+    constructor() {
+        this._imports = new Map();
+        // Note: the methods here are defined as arrow function so that they can be destructured by
+        // consumers without losing their context. This makes the API more concise.
+        /** Function used to tag a code block in order to produce a `PendingCode` object. */
+        this.code = (strings, ...params) => {
+            return {
+                expression: strings.map((part, index) => part + (params[index] || '')).join(''),
+                imports: this._imports,
+            };
+        };
+        /**
+         * Used inside of a code block to mark external symbols and which module they should be imported
+         * from. When the code is inserted, the required import statements will be produced automatically.
+         * @param symbolName Name of the external symbol.
+         * @param moduleName Module from which the symbol should be imported.
+         */
+        this.external = (symbolName, moduleName) => {
+            if (!this._imports.has(moduleName)) {
+                this._imports.set(moduleName, new Map());
+            }
+            const symbolsPerModule = this._imports.get(moduleName);
+            if (!symbolsPerModule.has(symbolName)) {
+                symbolsPerModule.set(symbolName, `@@__SCHEMATIC_PLACEHOLDER_${uniqueIdCounter++}__@@`);
+            }
+            return symbolsPerModule.get(symbolName);
+        };
+    }
+    /**
+     * Produces the necessary rules to transform a `PendingCode` object into valid code.
+     * @param initialCode Code pending transformed.
+     * @param filePath Path of the file in which the code will be inserted.
+     */
+    static transformPendingCode(initialCode, filePath) {
+        const code = { ...initialCode };
+        const rules = [];
+        code.imports.forEach((symbols, moduleName) => {
+            symbols.forEach((placeholder, symbolName) => {
+                rules.push((tree) => {
+                    const recorder = tree.beginUpdate(filePath);
+                    const sourceFile = typescript_1.default.createSourceFile(filePath, tree.readText(filePath), typescript_1.default.ScriptTarget.Latest, true);
+                    // Note that this could still technically clash if there's a top-level symbol called
+                    // `${symbolName}_alias`, however this is unlikely. We can revisit this if it becomes
+                    // a problem.
+                    const alias = (0, ast_utils_1.hasTopLevelIdentifier)(sourceFile, symbolName, moduleName)
+                        ? symbolName + '_alias'
+                        : undefined;
+                    code.expression = code.expression.replace(new RegExp(placeholder, 'g'), alias || symbolName);
+                    (0, change_1.applyToUpdateRecorder)(recorder, [
+                        (0, ast_utils_1.insertImport)(sourceFile, filePath, symbolName, moduleName, false, alias),
+                    ]);
+                    tree.commitUpdate(recorder);
+                });
+            });
+        });
+        return { code, rules };
+    }
+}
+exports.CodeBlock = CodeBlock;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"code_block.js","sourceRoot":"","sources":["../../../../../../../../packages/schematics/angular/utility/standalone/code_block.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport { Rule, Tree } from '@angular-devkit/schematics';\nimport ts from '../../third_party/github.com/Microsoft/TypeScript/lib/typescript';\nimport { hasTopLevelIdentifier, insertImport } from '../ast-utils';\nimport { applyToUpdateRecorder } from '../change';\n\n/** Generated code that hasn't been interpolated yet. */\nexport interface PendingCode {\n  /** Code that will be inserted. */\n  expression: string;\n\n  /** Imports that need to be added to the file in which the code is inserted. */\n  imports: PendingImports;\n}\n\n/** Map keeping track of imports and aliases under which they're referred to in an expresion. */\ntype PendingImports = Map<string, Map<string, string>>;\n\n/** Counter used to generate unique IDs. */\nlet uniqueIdCounter = 0;\n\n/**\n * Callback invoked by a Rule that produces the code\n * that needs to be inserted somewhere in the app.\n */\nexport type CodeBlockCallback = (block: CodeBlock) => PendingCode;\n\n/**\n * Utility class used to generate blocks of code that\n * can be inserted by the devkit into a user's app.\n */\nexport class CodeBlock {\n  private _imports: PendingImports = new Map<string, Map<string, string>>();\n\n  // Note: the methods here are defined as arrow function so that they can be destructured by\n  // consumers without losing their context. This makes the API more concise.\n\n  /** Function used to tag a code block in order to produce a `PendingCode` object. */\n  code = (strings: TemplateStringsArray, ...params: unknown[]): PendingCode => {\n    return {\n      expression: strings.map((part, index) => part + (params[index] || '')).join(''),\n      imports: this._imports,\n    };\n  };\n\n  /**\n   * Used inside of a code block to mark external symbols and which module they should be imported\n   * from. When the code is inserted, the required import statements will be produced automatically.\n   * @param symbolName Name of the external symbol.\n   * @param moduleName Module from which the symbol should be imported.\n   */\n  external = (symbolName: string, moduleName: string): string => {\n    if (!this._imports.has(moduleName)) {\n      this._imports.set(moduleName, new Map());\n    }\n\n    const symbolsPerModule = this._imports.get(moduleName) as Map<string, string>;\n\n    if (!symbolsPerModule.has(symbolName)) {\n      symbolsPerModule.set(symbolName, `@@__SCHEMATIC_PLACEHOLDER_${uniqueIdCounter++}__@@`);\n    }\n\n    return symbolsPerModule.get(symbolName) as string;\n  };\n\n  /**\n   * Produces the necessary rules to transform a `PendingCode` object into valid code.\n   * @param initialCode Code pending transformed.\n   * @param filePath Path of the file in which the code will be inserted.\n   */\n  static transformPendingCode(initialCode: PendingCode, filePath: string) {\n    const code = { ...initialCode };\n    const rules: Rule[] = [];\n\n    code.imports.forEach((symbols, moduleName) => {\n      symbols.forEach((placeholder, symbolName) => {\n        rules.push((tree: Tree) => {\n          const recorder = tree.beginUpdate(filePath);\n          const sourceFile = ts.createSourceFile(\n            filePath,\n            tree.readText(filePath),\n            ts.ScriptTarget.Latest,\n            true,\n          );\n\n          // Note that this could still technically clash if there's a top-level symbol called\n          // `${symbolName}_alias`, however this is unlikely. We can revisit this if it becomes\n          // a problem.\n          const alias = hasTopLevelIdentifier(sourceFile, symbolName, moduleName)\n            ? symbolName + '_alias'\n            : undefined;\n\n          code.expression = code.expression.replace(\n            new RegExp(placeholder, 'g'),\n            alias || symbolName,\n          );\n\n          applyToUpdateRecorder(recorder, [\n            insertImport(sourceFile, filePath, symbolName, moduleName, false, alias),\n          ]);\n          tree.commitUpdate(recorder);\n        });\n      });\n    });\n\n    return { code, rules };\n  }\n}\n"]}

package/utility/standalone/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export { addRootImport, addRootProvider } from './rules';
+export { PendingCode, CodeBlockCallback, type CodeBlock } from './code_block';

package/utility/standalone/index.js

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addRootProvider = exports.addRootImport = void 0;
+var rules_1 = require("./rules");
+Object.defineProperty(exports, "addRootImport", { enumerable: true, get: function () { return rules_1.addRootImport; } });
+Object.defineProperty(exports, "addRootProvider", { enumerable: true, get: function () { return rules_1.addRootProvider; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9zY2hlbWF0aWNzL2FuZ3VsYXIvdXRpbGl0eS9zdGFuZGFsb25lL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7Ozs7O0dBTUc7OztBQUVILGlDQUF5RDtBQUFoRCxzR0FBQSxhQUFhLE9BQUE7QUFBRSx3R0FBQSxlQUFlLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuZXhwb3J0IHsgYWRkUm9vdEltcG9ydCwgYWRkUm9vdFByb3ZpZGVyIH0gZnJvbSAnLi9ydWxlcyc7XG5leHBvcnQgeyBQZW5kaW5nQ29kZSwgQ29kZUJsb2NrQ2FsbGJhY2ssIHR5cGUgQ29kZUJsb2NrIH0gZnJvbSAnLi9jb2RlX2Jsb2NrJztcbiJdfQ==

package/utility/standalone/rules.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Rule } from '@angular-devkit/schematics';
+import { CodeBlockCallback } from './code_block';
+/**
+ * Adds an import to the root of the project.
+ * @param project Name of the project to which to add the import.
+ * @param callback Function that generates the code block which should be inserted.
+ * @example
+ *
+ * ```ts
+ * import { Rule } from '@angular-devkit/schematics';
+ * import { addRootImport } from '@schematics/angular/utility';
+ *
+ * export default function(): Rule {
+ *   return addRootImport('default', ({code, external}) => {
+ *     return code`${external('MyModule', '@my/module')}.forRoot({})`;
+ *   });
+ * }
+ * ```
+ */
+export declare function addRootImport(project: string, callback: CodeBlockCallback): Rule;
+/**
+ * Adds a provider to the root of the project.
+ * @param project Name of the project to which to add the import.
+ * @param callback Function that generates the code block which should be inserted.
+ * @example
+ *
+ * ```ts
+ * import { Rule } from '@angular-devkit/schematics';
+ * import { addRootProvider } from '@schematics/angular/utility';
+ *
+ * export default function(): Rule {
+ *   return addRootProvider('default', ({code, external}) => {
+ *     return code`${external('provideLibrary', '@my/library')}({})`;
+ *   });
+ * }
+ * ```
+ */
+export declare function addRootProvider(project: string, callback: CodeBlockCallback): Rule;