@schematics/angular 16.1.0-next.2 → 16.1.0-rc.0

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;

package/utility/standalone/rules.js

@@ -0,0 +1,190 @@
+"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;
+const core_1 = require("@angular-devkit/core");
+const schematics_1 = require("@angular-devkit/schematics");
+const ast_utils_1 = require("../ast-utils");
+const change_1 = require("../change");
+const ng_ast_utils_1 = require("../ng-ast-utils");
+const app_config_1 = require("./app_config");
+const code_block_1 = require("./code_block");
+const util_1 = require("./util");
+/**
+ * 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({})`;
+ *   });
+ * }
+ * ```
+ */
+function addRootImport(project, callback) {
+    return getRootInsertionRule(project, callback, 'imports', {
+        name: 'importProvidersFrom',
+        module: '@angular/core',
+    });
+}
+exports.addRootImport = addRootImport;
+/**
+ * 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')}({})`;
+ *   });
+ * }
+ * ```
+ */
+function addRootProvider(project, callback) {
+    return getRootInsertionRule(project, callback, 'providers');
+}
+exports.addRootProvider = addRootProvider;
+/**
+ * Creates a rule that inserts code at the root of either a standalone or NgModule-based project.
+ * @param project Name of the project into which to inser tthe code.
+ * @param callback Function that generates the code block which should be inserted.
+ * @param ngModuleField Field of the root NgModule into which the code should be inserted, if the
+ * app is based on NgModule
+ * @param standaloneWrapperFunction Function with which to wrap the code if the app is standalone.
+ */
+function getRootInsertionRule(project, callback, ngModuleField, standaloneWrapperFunction) {
+    return async (host) => {
+        const mainFilePath = await (0, util_1.getMainFilePath)(host, project);
+        const codeBlock = new code_block_1.CodeBlock();
+        if ((0, ng_ast_utils_1.isStandaloneApp)(host, mainFilePath)) {
+            return (tree) => addProviderToStandaloneBootstrap(tree, callback(codeBlock), mainFilePath, standaloneWrapperFunction);
+        }
+        const modulePath = (0, ng_ast_utils_1.getAppModulePath)(host, mainFilePath);
+        const pendingCode = code_block_1.CodeBlock.transformPendingCode(callback(codeBlock), modulePath);
+        return (0, schematics_1.chain)([
+            ...pendingCode.rules,
+            (tree) => {
+                const changes = (0, ast_utils_1.addSymbolToNgModuleMetadata)((0, util_1.getSourceFile)(tree, modulePath), modulePath, ngModuleField, pendingCode.code.expression, 
+                // Explicitly set the import path to null since we deal with imports here separately.
+                null);
+                (0, util_1.applyChangesToFile)(tree, modulePath, changes);
+            },
+        ]);
+    };
+}
+/**
+ * Adds a provider to the root of a standalone project.
+ * @param host Tree of the root rule.
+ * @param pendingCode Code that should be inserted.
+ * @param mainFilePath Path to the project's main file.
+ * @param wrapperFunction Optional function with which to wrap the provider.
+ */
+function addProviderToStandaloneBootstrap(host, pendingCode, mainFilePath, wrapperFunction) {
+    const bootstrapCall = (0, util_1.findBootstrapApplicationCall)(host, mainFilePath);
+    const fileToEdit = (0, app_config_1.findAppConfig)(bootstrapCall, host, mainFilePath)?.filePath || mainFilePath;
+    const { code, rules } = code_block_1.CodeBlock.transformPendingCode(pendingCode, fileToEdit);
+    return (0, schematics_1.chain)([
+        ...rules,
+        () => {
+            let wrapped;
+            let additionalRules;
+            if (wrapperFunction) {
+                const block = new code_block_1.CodeBlock();
+                const result = code_block_1.CodeBlock.transformPendingCode(block.code `${block.external(wrapperFunction.name, wrapperFunction.module)}(${code.expression})`, fileToEdit);
+                wrapped = result.code;
+                additionalRules = result.rules;
+            }
+            else {
+                wrapped = code;
+                additionalRules = [];
+            }
+            return (0, schematics_1.chain)([
+                ...additionalRules,
+                (tree) => insertStandaloneRootProvider(tree, mainFilePath, wrapped.expression),
+            ]);
+        },
+    ]);
+}
+/**
+ * Inserts a string expression into the root of a standalone project.
+ * @param tree File tree used to modify the project.
+ * @param mainFilePath Path to the main file of the project.
+ * @param expression Code expression to be inserted.
+ */
+function insertStandaloneRootProvider(tree, mainFilePath, expression) {
+    const bootstrapCall = (0, util_1.findBootstrapApplicationCall)(tree, mainFilePath);
+    const appConfig = (0, app_config_1.findAppConfig)(bootstrapCall, tree, mainFilePath);
+    if (bootstrapCall.arguments.length === 0) {
+        throw new schematics_1.SchematicsException(`Cannot add provider to invalid bootstrapApplication call in ${bootstrapCall.getSourceFile().fileName}`);
+    }
+    if (appConfig) {
+        addProvidersExpressionToAppConfig(tree, appConfig, expression);
+        return;
+    }
+    const newAppConfig = `, {\n${core_1.tags.indentBy(2) `providers: [${expression}]`}\n}`;
+    let targetCall;
+    if (bootstrapCall.arguments.length === 1) {
+        targetCall = bootstrapCall;
+    }
+    else if ((0, util_1.isMergeAppConfigCall)(bootstrapCall.arguments[1])) {
+        targetCall = bootstrapCall.arguments[1];
+    }
+    else {
+        throw new schematics_1.SchematicsException(`Cannot statically analyze bootstrapApplication call in ${bootstrapCall.getSourceFile().fileName}`);
+    }
+    (0, util_1.applyChangesToFile)(tree, mainFilePath, [
+        (0, ast_utils_1.insertAfterLastOccurrence)(targetCall.arguments, newAppConfig, mainFilePath, targetCall.getEnd() - 1),
+    ]);
+}
+/**
+ * Adds a string expression to an app config object.
+ * @param tree File tree used to modify the project.
+ * @param appConfig Resolved configuration object of the project.
+ * @param expression Code expression to be inserted.
+ */
+function addProvidersExpressionToAppConfig(tree, appConfig, expression) {
+    const { node, filePath } = appConfig;
+    const configProps = node.properties;
+    const providersLiteral = (0, util_1.findProvidersLiteral)(node);
+    // If there's a `providers` property, we can add the provider
+    // to it, otherwise we need to declare it ourselves.
+    if (providersLiteral) {
+        const hasTrailingComma = providersLiteral.elements.hasTrailingComma;
+        (0, util_1.applyChangesToFile)(tree, filePath, [
+            (0, ast_utils_1.insertAfterLastOccurrence)(providersLiteral.elements, (hasTrailingComma || providersLiteral.elements.length === 0 ? '' : ', ') + expression, filePath, providersLiteral.getStart() + 1),
+        ]);
+    }
+    else {
+        const prop = core_1.tags.indentBy(2) `providers: [${expression}]`;
+        let toInsert;
+        let insertPosition;
+        if (configProps.length === 0) {
+            toInsert = '\n' + prop + '\n';
+            insertPosition = node.getEnd() - 1;
+        }
+        else {
+            const hasTrailingComma = configProps.hasTrailingComma;
+            toInsert = (hasTrailingComma ? '' : ',') + '\n' + prop;
+            insertPosition = configProps[configProps.length - 1].getEnd() + (hasTrailingComma ? 1 : 0);
+        }
+        (0, util_1.applyChangesToFile)(tree, filePath, [new change_1.InsertChange(filePath, insertPosition, toInsert)]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rules.js","sourceRoot":"","sources":["../../../../../../../../packages/schematics/angular/utility/standalone/rules.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;AAEH,+CAA4C;AAC5C,2DAAoF;AAEpF,4CAAsF;AACtF,sCAAyC;AACzC,kDAAoE;AACpE,6CAAgE;AAChE,6CAAyE;AACzE,iCAOgB;AAEhB;;;;;;;;;;;;;;;;GAgBG;AACH,SAAgB,aAAa,CAAC,OAAe,EAAE,QAA2B;IACxE,OAAO,oBAAoB,CAAC,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE;QACxD,IAAI,EAAE,qBAAqB;QAC3B,MAAM,EAAE,eAAe;KACxB,CAAC,CAAC;AACL,CAAC;AALD,sCAKC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,SAAgB,eAAe,CAAC,OAAe,EAAE,QAA2B;IAC1E,OAAO,oBAAoB,CAAC,OAAO,EAAE,QAAQ,EAAE,WAAW,CAAC,CAAC;AAC9D,CAAC;AAFD,0CAEC;AAED;;;;;;;GAOG;AACH,SAAS,oBAAoB,CAC3B,OAAe,EACf,QAA2B,EAC3B,aAAqB,EACrB,yBAA4D;IAE5D,OAAO,KAAK,EAAE,IAAI,EAAE,EAAE;QACpB,MAAM,YAAY,GAAG,MAAM,IAAA,sBAAe,EAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QAC1D,MAAM,SAAS,GAAG,IAAI,sBAAS,EAAE,CAAC;QAElC,IAAI,IAAA,8BAAe,EAAC,IAAI,EAAE,YAAY,CAAC,EAAE;YACvC,OAAO,CAAC,IAAI,EAAE,EAAE,CACd,gCAAgC,CAC9B,IAAI,EACJ,QAAQ,CAAC,SAAS,CAAC,EACnB,YAAY,EACZ,yBAAyB,CAC1B,CAAC;SACL;QAED,MAAM,UAAU,GAAG,IAAA,+BAAgB,EAAC,IAAI,EAAE,YAAY,CAAC,CAAC;QACxD,MAAM,WAAW,GAAG,sBAAS,CAAC,oBAAoB,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,UAAU,CAAC,CAAC;QAEpF,OAAO,IAAA,kBAAK,EAAC;YACX,GAAG,WAAW,CAAC,KAAK;YACpB,CAAC,IAAI,EAAE,EAAE;gBACP,MAAM,OAAO,GAAG,IAAA,uCAA2B,EACzC,IAAA,oBAAa,EAAC,IAAI,EAAE,UAAU,CAAC,EAC/B,UAAU,EACV,aAAa,EACb,WAAW,CAAC,IAAI,CAAC,UAAU;gBAC3B,qFAAqF;gBACrF,IAAI,CACL,CAAC;gBAEF,IAAA,yBAAkB,EAAC,IAAI,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;YAChD,CAAC;SACF,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,SAAS,gCAAgC,CACvC,IAAU,EACV,WAAwB,EACxB,YAAoB,EACpB,eAAkD;IAElD,MAAM,aAAa,GAAG,IAAA,mCAA4B,EAAC,IAAI,EAAE,YAAY,CAAC,CAAC;IACvE,MAAM,UAAU,GAAG,IAAA,0BAAa,EAAC,aAAa,EAAE,IAAI,EAAE,YAAY,CAAC,EAAE,QAAQ,IAAI,YAAY,CAAC;IAC9F,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,sBAAS,CAAC,oBAAoB,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC;IAEhF,OAAO,IAAA,kBAAK,EAAC;QACX,GAAG,KAAK;QACR,GAAG,EAAE;YACH,IAAI,OAAoB,CAAC;YACzB,IAAI,eAAuB,CAAC;YAE5B,IAAI,eAAe,EAAE;gBACnB,MAAM,KAAK,GAAG,IAAI,sBAAS,EAAE,CAAC;gBAC9B,MAAM,MAAM,GAAG,sBAAS,CAAC,oBAAoB,CAC3C,KAAK,CAAC,IAAI,CAAA,GAAG,KAAK,CAAC,QAAQ,CAAC,eAAe,CAAC,IAAI,EAAE,eAAe,CAAC,MAAM,CAAC,IACvE,IAAI,CAAC,UACP,GAAG,EACH,UAAU,CACX,CAAC;gBAEF,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC;gBACtB,eAAe,GAAG,MAAM,CAAC,KAAK,CAAC;aAChC;iBAAM;gBACL,OAAO,GAAG,IAAI,CAAC;gBACf,eAAe,GAAG,EAAE,CAAC;aACtB;YAED,OAAO,IAAA,kBAAK,EAAC;gBACX,GAAG,eAAe;gBAClB,CAAC,IAAI,EAAE,EAAE,CAAC,4BAA4B,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,CAAC,UAAU,CAAC;aAC/E,CAAC,CAAC;QACL,CAAC;KACF,CAAC,CAAC;AACL,CAAC;AAED;;;;;GAKG;AACH,SAAS,4BAA4B,CAAC,IAAU,EAAE,YAAoB,EAAE,UAAkB;IACxF,MAAM,aAAa,GAAG,IAAA,mCAA4B,EAAC,IAAI,EAAE,YAAY,CAAC,CAAC;IACvE,MAAM,SAAS,GAAG,IAAA,0BAAa,EAAC,aAAa,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC;IAEnE,IAAI,aAAa,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE;QACxC,MAAM,IAAI,gCAAmB,CAC3B,+DACE,aAAa,CAAC,aAAa,EAAE,CAAC,QAChC,EAAE,CACH,CAAC;KACH;IAED,IAAI,SAAS,EAAE;QACb,iCAAiC,CAAC,IAAI,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;QAE/D,OAAO;KACR;IAED,MAAM,YAAY,GAAG,QAAQ,WAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAA,eAAe,UAAU,GAAG,KAAK,CAAC;IAC/E,IAAI,UAA6B,CAAC;IAElC,IAAI,aAAa,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE;QACxC,UAAU,GAAG,aAAa,CAAC;KAC5B;SAAM,IAAI,IAAA,2BAAoB,EAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,EAAE;QAC3D,UAAU,GAAG,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;KACzC;SAAM;QACL,MAAM,IAAI,gCAAmB,CAC3B,0DACE,aAAa,CAAC,aAAa,EAAE,CAAC,QAChC,EAAE,CACH,CAAC;KACH;IAED,IAAA,yBAAkB,EAAC,IAAI,EAAE,YAAY,EAAE;QACrC,IAAA,qCAAyB,EACvB,UAAU,CAAC,SAAS,EACpB,YAAY,EACZ,YAAY,EACZ,UAAU,CAAC,MAAM,EAAE,GAAG,CAAC,CACxB;KACF,CAAC,CAAC;AACL,CAAC;AAED;;;;;GAKG;AACH,SAAS,iCAAiC,CACxC,IAAU,EACV,SAA4B,EAC5B,UAAkB;IAElB,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,SAAS,CAAC;IACrC,MAAM,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC;IACpC,MAAM,gBAAgB,GAAG,IAAA,2BAAoB,EAAC,IAAI,CAAC,CAAC;IAEpD,6DAA6D;IAC7D,oDAAoD;IACpD,IAAI,gBAAgB,EAAE;QACpB,MAAM,gBAAgB,GAAG,gBAAgB,CAAC,QAAQ,CAAC,gBAAgB,CAAC;QAEpE,IAAA,yBAAkB,EAAC,IAAI,EAAE,QAAQ,EAAE;YACjC,IAAA,qCAAyB,EACvB,gBAAgB,CAAC,QAAQ,EACzB,CAAC,gBAAgB,IAAI,gBAAgB,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,UAAU,EACrF,QAAQ,EACR,gBAAgB,CAAC,QAAQ,EAAE,GAAG,CAAC,CAChC;SACF,CAAC,CAAC;KACJ;SAAM;QACL,MAAM,IAAI,GAAG,WAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAA,eAAe,UAAU,GAAG,CAAC;QAC1D,IAAI,QAAgB,CAAC;QACrB,IAAI,cAAsB,CAAC;QAE3B,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE;YAC5B,QAAQ,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;YAC9B,cAAc,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;SACpC;aAAM;YACL,MAAM,gBAAgB,GAAG,WAAW,CAAC,gBAAgB,CAAC;YACtD,QAAQ,GAAG,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC;YACvD,cAAc,GAAG,WAAW,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,MAAM,EAAE,GAAG,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;SAC5F;QAED,IAAA,yBAAkB,EAAC,IAAI,EAAE,QAAQ,EAAE,CAAC,IAAI,qBAAY,CAAC,QAAQ,EAAE,cAAc,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;KAC5F;AACH,CAAC","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 { tags } from '@angular-devkit/core';\nimport { Rule, SchematicsException, Tree, chain } from '@angular-devkit/schematics';\nimport ts from '../../third_party/github.com/Microsoft/TypeScript/lib/typescript';\nimport { addSymbolToNgModuleMetadata, insertAfterLastOccurrence } from '../ast-utils';\nimport { InsertChange } from '../change';\nimport { getAppModulePath, isStandaloneApp } from '../ng-ast-utils';\nimport { ResolvedAppConfig, findAppConfig } from './app_config';\nimport { CodeBlock, CodeBlockCallback, PendingCode } from './code_block';\nimport {\n  applyChangesToFile,\n  findBootstrapApplicationCall,\n  findProvidersLiteral,\n  getMainFilePath,\n  getSourceFile,\n  isMergeAppConfigCall,\n} from './util';\n\n/**\n * Adds an import to the root of the project.\n * @param project Name of the project to which to add the import.\n * @param callback Function that generates the code block which should be inserted.\n * @example\n *\n * ```ts\n * import { Rule } from '@angular-devkit/schematics';\n * import { addRootImport } from '@schematics/angular/utility';\n *\n * export default function(): Rule {\n *   return addRootImport('default', ({code, external}) => {\n *     return code`${external('MyModule', '@my/module')}.forRoot({})`;\n *   });\n * }\n * ```\n */\nexport function addRootImport(project: string, callback: CodeBlockCallback): Rule {\n  return getRootInsertionRule(project, callback, 'imports', {\n    name: 'importProvidersFrom',\n    module: '@angular/core',\n  });\n}\n\n/**\n * Adds a provider to the root of the project.\n * @param project Name of the project to which to add the import.\n * @param callback Function that generates the code block which should be inserted.\n * @example\n *\n * ```ts\n * import { Rule } from '@angular-devkit/schematics';\n * import { addRootProvider } from '@schematics/angular/utility';\n *\n * export default function(): Rule {\n *   return addRootProvider('default', ({code, external}) => {\n *     return code`${external('provideLibrary', '@my/library')}({})`;\n *   });\n * }\n * ```\n */\nexport function addRootProvider(project: string, callback: CodeBlockCallback): Rule {\n  return getRootInsertionRule(project, callback, 'providers');\n}\n\n/**\n * Creates a rule that inserts code at the root of either a standalone or NgModule-based project.\n * @param project Name of the project into which to inser tthe code.\n * @param callback Function that generates the code block which should be inserted.\n * @param ngModuleField Field of the root NgModule into which the code should be inserted, if the\n * app is based on NgModule\n * @param standaloneWrapperFunction Function with which to wrap the code if the app is standalone.\n */\nfunction getRootInsertionRule(\n  project: string,\n  callback: CodeBlockCallback,\n  ngModuleField: string,\n  standaloneWrapperFunction?: { name: string; module: string },\n): Rule {\n  return async (host) => {\n    const mainFilePath = await getMainFilePath(host, project);\n    const codeBlock = new CodeBlock();\n\n    if (isStandaloneApp(host, mainFilePath)) {\n      return (tree) =>\n        addProviderToStandaloneBootstrap(\n          tree,\n          callback(codeBlock),\n          mainFilePath,\n          standaloneWrapperFunction,\n        );\n    }\n\n    const modulePath = getAppModulePath(host, mainFilePath);\n    const pendingCode = CodeBlock.transformPendingCode(callback(codeBlock), modulePath);\n\n    return chain([\n      ...pendingCode.rules,\n      (tree) => {\n        const changes = addSymbolToNgModuleMetadata(\n          getSourceFile(tree, modulePath),\n          modulePath,\n          ngModuleField,\n          pendingCode.code.expression,\n          // Explicitly set the import path to null since we deal with imports here separately.\n          null,\n        );\n\n        applyChangesToFile(tree, modulePath, changes);\n      },\n    ]);\n  };\n}\n\n/**\n * Adds a provider to the root of a standalone project.\n * @param host Tree of the root rule.\n * @param pendingCode Code that should be inserted.\n * @param mainFilePath Path to the project's main file.\n * @param wrapperFunction Optional function with which to wrap the provider.\n */\nfunction addProviderToStandaloneBootstrap(\n  host: Tree,\n  pendingCode: PendingCode,\n  mainFilePath: string,\n  wrapperFunction?: { name: string; module: string },\n): Rule {\n  const bootstrapCall = findBootstrapApplicationCall(host, mainFilePath);\n  const fileToEdit = findAppConfig(bootstrapCall, host, mainFilePath)?.filePath || mainFilePath;\n  const { code, rules } = CodeBlock.transformPendingCode(pendingCode, fileToEdit);\n\n  return chain([\n    ...rules,\n    () => {\n      let wrapped: PendingCode;\n      let additionalRules: Rule[];\n\n      if (wrapperFunction) {\n        const block = new CodeBlock();\n        const result = CodeBlock.transformPendingCode(\n          block.code`${block.external(wrapperFunction.name, wrapperFunction.module)}(${\n            code.expression\n          })`,\n          fileToEdit,\n        );\n\n        wrapped = result.code;\n        additionalRules = result.rules;\n      } else {\n        wrapped = code;\n        additionalRules = [];\n      }\n\n      return chain([\n        ...additionalRules,\n        (tree) => insertStandaloneRootProvider(tree, mainFilePath, wrapped.expression),\n      ]);\n    },\n  ]);\n}\n\n/**\n * Inserts a string expression into the root of a standalone project.\n * @param tree File tree used to modify the project.\n * @param mainFilePath Path to the main file of the project.\n * @param expression Code expression to be inserted.\n */\nfunction insertStandaloneRootProvider(tree: Tree, mainFilePath: string, expression: string): void {\n  const bootstrapCall = findBootstrapApplicationCall(tree, mainFilePath);\n  const appConfig = findAppConfig(bootstrapCall, tree, mainFilePath);\n\n  if (bootstrapCall.arguments.length === 0) {\n    throw new SchematicsException(\n      `Cannot add provider to invalid bootstrapApplication call in ${\n        bootstrapCall.getSourceFile().fileName\n      }`,\n    );\n  }\n\n  if (appConfig) {\n    addProvidersExpressionToAppConfig(tree, appConfig, expression);\n\n    return;\n  }\n\n  const newAppConfig = `, {\\n${tags.indentBy(2)`providers: [${expression}]`}\\n}`;\n  let targetCall: ts.CallExpression;\n\n  if (bootstrapCall.arguments.length === 1) {\n    targetCall = bootstrapCall;\n  } else if (isMergeAppConfigCall(bootstrapCall.arguments[1])) {\n    targetCall = bootstrapCall.arguments[1];\n  } else {\n    throw new SchematicsException(\n      `Cannot statically analyze bootstrapApplication call in ${\n        bootstrapCall.getSourceFile().fileName\n      }`,\n    );\n  }\n\n  applyChangesToFile(tree, mainFilePath, [\n    insertAfterLastOccurrence(\n      targetCall.arguments,\n      newAppConfig,\n      mainFilePath,\n      targetCall.getEnd() - 1,\n    ),\n  ]);\n}\n\n/**\n * Adds a string expression to an app config object.\n * @param tree File tree used to modify the project.\n * @param appConfig Resolved configuration object of the project.\n * @param expression Code expression to be inserted.\n */\nfunction addProvidersExpressionToAppConfig(\n  tree: Tree,\n  appConfig: ResolvedAppConfig,\n  expression: string,\n): void {\n  const { node, filePath } = appConfig;\n  const configProps = node.properties;\n  const providersLiteral = findProvidersLiteral(node);\n\n  // If there's a `providers` property, we can add the provider\n  // to it, otherwise we need to declare it ourselves.\n  if (providersLiteral) {\n    const hasTrailingComma = providersLiteral.elements.hasTrailingComma;\n\n    applyChangesToFile(tree, filePath, [\n      insertAfterLastOccurrence(\n        providersLiteral.elements,\n        (hasTrailingComma || providersLiteral.elements.length === 0 ? '' : ', ') + expression,\n        filePath,\n        providersLiteral.getStart() + 1,\n      ),\n    ]);\n  } else {\n    const prop = tags.indentBy(2)`providers: [${expression}]`;\n    let toInsert: string;\n    let insertPosition: number;\n\n    if (configProps.length === 0) {\n      toInsert = '\\n' + prop + '\\n';\n      insertPosition = node.getEnd() - 1;\n    } else {\n      const hasTrailingComma = configProps.hasTrailingComma;\n      toInsert = (hasTrailingComma ? '' : ',') + '\\n' + prop;\n      insertPosition = configProps[configProps.length - 1].getEnd() + (hasTrailingComma ? 1 : 0);\n    }\n\n    applyChangesToFile(tree, filePath, [new InsertChange(filePath, insertPosition, toInsert)]);\n  }\n}\n"]}

package/utility/standalone/util.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @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';
+import { Change } from '../change';
+/**
+ * Finds the main file of a project.
+ * @param tree File tree for the project.
+ * @param projectName Name of the project in which to search.
+ */
+export declare function getMainFilePath(tree: Tree, projectName: string): Promise<string>;
+/**
+ * Gets a TypeScript source file at a specific path.
+ * @param tree File tree of a project.
+ * @param path Path to the file.
+ */
+export declare function getSourceFile(tree: Tree, path: string): ts.SourceFile;
+/** Finds the call to `bootstrapApplication` within a file. */
+export declare function findBootstrapApplicationCall(tree: Tree, mainFilePath: string): ts.CallExpression;
+/**
+ * Applies a set of changes to a file.
+ * @param tree File tree of the project.
+ * @param path Path to the file that is being changed.
+ * @param changes Changes that should be applied to the file.
+ */
+export declare function applyChangesToFile(tree: Tree, path: string, changes: Change[]): void;
+/** Checks whether a node is a call to `mergeApplicationConfig`. */
+export declare function isMergeAppConfigCall(node: ts.Node): node is ts.CallExpression;
+/** Finds the `providers` array literal within an application config. */
+export declare function findProvidersLiteral(config: ts.ObjectLiteralExpression): ts.ArrayLiteralExpression | null;