@schematics/angular 16.0.0-next.5 → 16.0.0-next.7

package/private/standalone.d.ts

@@ -14,6 +14,13 @@ import ts from '../third_party/github.com/Microsoft/TypeScript/lib/typescript';
  * @param className Class name of the module to search for.
  */
 export declare function importsProvidersFrom(tree: Tree, filePath: string, className: string): boolean;
+/**
+ * Checks whether a providers function is being called in a `bootstrapApplication` call.
+ * @param tree File tree of the project.
+ * @param filePath Path of the file in which to check.
+ * @param functionName Name of the function to search for.
+ */
+export declare function callsProvidersFunction(tree: Tree, filePath: string, functionName: string): boolean;
 /**
  * Adds an `importProvidersFrom` call to the `bootstrapApplication` call.
  * @param tree File tree of the project.
@@ -22,5 +29,15 @@ export declare function importsProvidersFrom(tree: Tree, filePath: string, class
  * @param modulePath Path from which to import the module.
  */
 export declare function addModuleImportToStandaloneBootstrap(tree: Tree, filePath: string, moduleName: string, modulePath: string): void;
+/**
+ * Adds a providers function call to the `bootstrapApplication` call.
+ * @param tree File tree of the project.
+ * @param filePath Path to the file that should be updated.
+ * @param functionName Name of the function that should be called.
+ * @param importPath Path from which to import the function.
+ * @param args Arguments to use when calling the function.
+ * @returns The file path that the provider was added to.
+ */
+export declare function addFunctionalProvidersToStandaloneBootstrap(tree: Tree, filePath: string, functionName: string, importPath: string, args?: ts.Expression[]): string;
 /** Finds the call to `bootstrapApplication` within a file. */
 export declare function findBootstrapApplicationCall(sourceFile: ts.SourceFile): ts.CallExpression | null;

package/private/standalone.js

@@ -10,8 +10,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findBootstrapApplicationCall = exports.addModuleImportToStandaloneBootstrap = exports.importsProvidersFrom = void 0;
+exports.findBootstrapApplicationCall = exports.addFunctionalProvidersToStandaloneBootstrap = exports.addModuleImportToStandaloneBootstrap = exports.callsProvidersFunction = exports.importsProvidersFrom = void 0;
 const schematics_1 = require("@angular-devkit/schematics");
+const path_1 = require("path");
 const typescript_1 = __importDefault(require("../third_party/github.com/Microsoft/TypeScript/lib/typescript"));
 const ast_utils_1 = require("../utility/ast-utils");
 const change_1 = require("../utility/change");
@@ -22,13 +23,29 @@ const change_1 = require("../utility/change");
  * @param className Class name of the module to search for.
  */
 function importsProvidersFrom(tree, filePath, className) {
-    const sourceFile = typescript_1.default.createSourceFile(filePath, tree.readText(filePath), typescript_1.default.ScriptTarget.Latest, true);
+    const sourceFile = createSourceFile(tree, filePath);
     const bootstrapCall = findBootstrapApplicationCall(sourceFile);
-    const importProvidersFromCall = bootstrapCall ? findImportProvidersFromCall(bootstrapCall) : null;
-    return (!!importProvidersFromCall &&
-        importProvidersFromCall.arguments.some((arg) => typescript_1.default.isIdentifier(arg) && arg.text === className));
+    const appConfig = bootstrapCall ? findAppConfig(bootstrapCall, tree, filePath) : null;
+    const importProvidersFromCall = appConfig ? findImportProvidersFromCall(appConfig.node) : null;
+    return !!importProvidersFromCall?.arguments.some((arg) => typescript_1.default.isIdentifier(arg) && arg.text === className);
 }
 exports.importsProvidersFrom = importsProvidersFrom;
+/**
+ * Checks whether a providers function is being called in a `bootstrapApplication` call.
+ * @param tree File tree of the project.
+ * @param filePath Path of the file in which to check.
+ * @param functionName Name of the function to search for.
+ */
+function callsProvidersFunction(tree, filePath, functionName) {
+    const sourceFile = createSourceFile(tree, filePath);
+    const bootstrapCall = findBootstrapApplicationCall(sourceFile);
+    const appConfig = bootstrapCall ? findAppConfig(bootstrapCall, tree, filePath) : null;
+    const providersLiteral = appConfig ? findProvidersLiteral(appConfig.node) : null;
+    return !!providersLiteral?.elements.some((el) => typescript_1.default.isCallExpression(el) &&
+        typescript_1.default.isIdentifier(el.expression) &&
+        el.expression.text === functionName);
+}
+exports.callsProvidersFunction = callsProvidersFunction;
 /**
  * Adds an `importProvidersFrom` call to the `bootstrapApplication` call.
  * @param tree File tree of the project.
@@ -37,74 +54,149 @@ exports.importsProvidersFrom = importsProvidersFrom;
  * @param modulePath Path from which to import the module.
  */
 function addModuleImportToStandaloneBootstrap(tree, filePath, moduleName, modulePath) {
-    const sourceFile = typescript_1.default.createSourceFile(filePath, tree.readText(filePath), typescript_1.default.ScriptTarget.Latest, true);
+    const sourceFile = createSourceFile(tree, filePath);
     const bootstrapCall = findBootstrapApplicationCall(sourceFile);
+    const addImports = (file, recorder) => {
+        const sourceText = file.getText();
+        [
+            (0, ast_utils_1.insertImport)(file, sourceText, moduleName, modulePath),
+            (0, ast_utils_1.insertImport)(file, sourceText, 'importProvidersFrom', '@angular/core'),
+        ].forEach((change) => {
+            if (change instanceof change_1.InsertChange) {
+                recorder.insertLeft(change.pos, change.toAdd);
+            }
+        });
+    };
     if (!bootstrapCall) {
         throw new schematics_1.SchematicsException(`Could not find bootstrapApplication call in ${filePath}`);
     }
-    const recorder = tree.beginUpdate(filePath);
-    const importCall = findImportProvidersFromCall(bootstrapCall);
-    const printer = typescript_1.default.createPrinter();
-    const sourceText = sourceFile.getText();
-    // Add imports to the module being added and `importProvidersFrom`. We don't
-    // have to worry about duplicates, because `insertImport` handles them.
-    [
-        (0, ast_utils_1.insertImport)(sourceFile, sourceText, moduleName, modulePath),
-        (0, ast_utils_1.insertImport)(sourceFile, sourceText, 'importProvidersFrom', '@angular/core'),
-    ].forEach((change) => {
-        if (change instanceof change_1.InsertChange) {
-            recorder.insertLeft(change.pos, change.toAdd);
-        }
-    });
-    // If there is an `importProvidersFrom` call already, reuse it.
+    const importProvidersCall = typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier('importProvidersFrom'), [], [typescript_1.default.factory.createIdentifier(moduleName)]);
+    // If there's only one argument, we have to create a new object literal.
+    if (bootstrapCall.arguments.length === 1) {
+        const recorder = tree.beginUpdate(filePath);
+        addNewAppConfigToCall(bootstrapCall, importProvidersCall, recorder);
+        addImports(sourceFile, recorder);
+        tree.commitUpdate(recorder);
+        return;
+    }
+    // If the config is a `mergeApplicationProviders` call, add another config to it.
+    if (isMergeAppConfigCall(bootstrapCall.arguments[1])) {
+        const recorder = tree.beginUpdate(filePath);
+        addNewAppConfigToCall(bootstrapCall.arguments[1], importProvidersCall, recorder);
+        addImports(sourceFile, recorder);
+        tree.commitUpdate(recorder);
+        return;
+    }
+    // Otherwise attempt to merge into the current config.
+    const appConfig = findAppConfig(bootstrapCall, tree, filePath);
+    if (!appConfig) {
+        throw new schematics_1.SchematicsException(`Could not statically analyze config in bootstrapApplication call in ${filePath}`);
+    }
+    const { filePath: configFilePath, node: config } = appConfig;
+    const recorder = tree.beginUpdate(configFilePath);
+    const importCall = findImportProvidersFromCall(config);
+    addImports(config.getSourceFile(), recorder);
     if (importCall) {
+        // If there's an `importProvidersFrom` call already, add the module to it.
         recorder.insertRight(importCall.arguments[importCall.arguments.length - 1].getEnd(), `, ${moduleName}`);
     }
-    else if (bootstrapCall.arguments.length === 1) {
-        // Otherwise if there is no options parameter to `bootstrapApplication`,
-        // create an object literal with a `providers` array and the import.
-        const newCall = typescript_1.default.factory.updateCallExpression(bootstrapCall, bootstrapCall.expression, bootstrapCall.typeArguments, [
-            ...bootstrapCall.arguments,
-            typescript_1.default.factory.createObjectLiteralExpression([createProvidersAssignment(moduleName)], true),
-        ]);
-        recorder.remove(bootstrapCall.getStart(), bootstrapCall.getWidth());
-        recorder.insertRight(bootstrapCall.getStart(), printer.printNode(typescript_1.default.EmitHint.Unspecified, newCall, sourceFile));
-    }
     else {
-        const providersLiteral = findProvidersLiteral(bootstrapCall);
+        const providersLiteral = findProvidersLiteral(config);
         if (providersLiteral) {
             // If there's a `providers` array, add the import to it.
-            const newProvidersLiteral = typescript_1.default.factory.updateArrayLiteralExpression(providersLiteral, [
-                ...providersLiteral.elements,
-                createImportProvidersFromCall(moduleName),
-            ]);
-            recorder.remove(providersLiteral.getStart(), providersLiteral.getWidth());
-            recorder.insertRight(providersLiteral.getStart(), printer.printNode(typescript_1.default.EmitHint.Unspecified, newProvidersLiteral, sourceFile));
+            addElementToArray(providersLiteral, importProvidersCall, recorder);
         }
         else {
             // Otherwise add a `providers` array to the existing object literal.
-            const optionsLiteral = bootstrapCall.arguments[1];
-            const newOptionsLiteral = typescript_1.default.factory.updateObjectLiteralExpression(optionsLiteral, [
-                ...optionsLiteral.properties,
-                createProvidersAssignment(moduleName),
-            ]);
-            recorder.remove(optionsLiteral.getStart(), optionsLiteral.getWidth());
-            recorder.insertRight(optionsLiteral.getStart(), printer.printNode(typescript_1.default.EmitHint.Unspecified, newOptionsLiteral, sourceFile));
+            addProvidersToObjectLiteral(config, importProvidersCall, recorder);
         }
     }
     tree.commitUpdate(recorder);
 }
 exports.addModuleImportToStandaloneBootstrap = addModuleImportToStandaloneBootstrap;
+/**
+ * Adds a providers function call to the `bootstrapApplication` call.
+ * @param tree File tree of the project.
+ * @param filePath Path to the file that should be updated.
+ * @param functionName Name of the function that should be called.
+ * @param importPath Path from which to import the function.
+ * @param args Arguments to use when calling the function.
+ * @returns The file path that the provider was added to.
+ */
+function addFunctionalProvidersToStandaloneBootstrap(tree, filePath, functionName, importPath, args = []) {
+    const sourceFile = createSourceFile(tree, filePath);
+    const bootstrapCall = findBootstrapApplicationCall(sourceFile);
+    const addImports = (file, recorder) => {
+        const change = (0, ast_utils_1.insertImport)(file, file.getText(), functionName, importPath);
+        if (change instanceof change_1.InsertChange) {
+            recorder.insertLeft(change.pos, change.toAdd);
+        }
+    };
+    if (!bootstrapCall) {
+        throw new schematics_1.SchematicsException(`Could not find bootstrapApplication call in ${filePath}`);
+    }
+    const providersCall = typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(functionName), undefined, args);
+    // If there's only one argument, we have to create a new object literal.
+    if (bootstrapCall.arguments.length === 1) {
+        const recorder = tree.beginUpdate(filePath);
+        addNewAppConfigToCall(bootstrapCall, providersCall, recorder);
+        addImports(sourceFile, recorder);
+        tree.commitUpdate(recorder);
+        return filePath;
+    }
+    // If the config is a `mergeApplicationProviders` call, add another config to it.
+    if (isMergeAppConfigCall(bootstrapCall.arguments[1])) {
+        const recorder = tree.beginUpdate(filePath);
+        addNewAppConfigToCall(bootstrapCall.arguments[1], providersCall, recorder);
+        addImports(sourceFile, recorder);
+        tree.commitUpdate(recorder);
+        return filePath;
+    }
+    // Otherwise attempt to merge into the current config.
+    const appConfig = findAppConfig(bootstrapCall, tree, filePath);
+    if (!appConfig) {
+        throw new schematics_1.SchematicsException(`Could not statically analyze config in bootstrapApplication call in ${filePath}`);
+    }
+    const { filePath: configFilePath, node: config } = appConfig;
+    const recorder = tree.beginUpdate(configFilePath);
+    const providersLiteral = findProvidersLiteral(config);
+    addImports(config.getSourceFile(), recorder);
+    if (providersLiteral) {
+        // If there's a `providers` array, add the import to it.
+        addElementToArray(providersLiteral, providersCall, recorder);
+    }
+    else {
+        // Otherwise add a `providers` array to the existing object literal.
+        addProvidersToObjectLiteral(config, providersCall, recorder);
+    }
+    tree.commitUpdate(recorder);
+    return configFilePath;
+}
+exports.addFunctionalProvidersToStandaloneBootstrap = addFunctionalProvidersToStandaloneBootstrap;
 /** Finds the call to `bootstrapApplication` within a file. */
 function findBootstrapApplicationCall(sourceFile) {
     const localName = findImportLocalName(sourceFile, 'bootstrapApplication', '@angular/platform-browser');
-    return localName ? findCall(sourceFile, localName) : null;
+    if (!localName) {
+        return null;
+    }
+    let result = null;
+    sourceFile.forEachChild(function walk(node) {
+        if (typescript_1.default.isCallExpression(node) &&
+            typescript_1.default.isIdentifier(node.expression) &&
+            node.expression.text === localName) {
+            result = node;
+        }
+        if (!result) {
+            node.forEachChild(walk);
+        }
+    });
+    return result;
 }
 exports.findBootstrapApplicationCall = findBootstrapApplicationCall;
-/** Find a call to `importProvidersFrom` within a `bootstrapApplication` call. */
-function findImportProvidersFromCall(bootstrapCall) {
-    const providersLiteral = findProvidersLiteral(bootstrapCall);
-    const importProvidersName = findImportLocalName(bootstrapCall.getSourceFile(), 'importProvidersFrom', '@angular/core');
+/** Find a call to `importProvidersFrom` within an application config. */
+function findImportProvidersFromCall(config) {
+    const importProvidersName = findImportLocalName(config.getSourceFile(), 'importProvidersFrom', '@angular/core');
+    const providersLiteral = findProvidersLiteral(config);
     if (providersLiteral && importProvidersName) {
         for (const element of providersLiteral.elements) {
             // Look for an array element that calls the `importProvidersFrom` function.
@@ -117,18 +209,88 @@ function findImportProvidersFromCall(bootstrapCall) {
     }
     return null;
 }
-/** Finds the `providers` array literal within a `bootstrapApplication` call. */
-function findProvidersLiteral(bootstrapCall) {
-    // The imports have to be in the second argument of
-    // the function which has to be an object literal.
-    if (bootstrapCall.arguments.length > 1 &&
-        typescript_1.default.isObjectLiteralExpression(bootstrapCall.arguments[1])) {
-        for (const prop of bootstrapCall.arguments[1].properties) {
-            if (typescript_1.default.isPropertyAssignment(prop) &&
-                typescript_1.default.isIdentifier(prop.name) &&
-                prop.name.text === 'providers' &&
-                typescript_1.default.isArrayLiteralExpression(prop.initializer)) {
-                return prop.initializer;
+/** Finds the `providers` array literal within an application config. */
+function findProvidersLiteral(config) {
+    for (const prop of config.properties) {
+        if (typescript_1.default.isPropertyAssignment(prop) &&
+            typescript_1.default.isIdentifier(prop.name) &&
+            prop.name.text === 'providers' &&
+            typescript_1.default.isArrayLiteralExpression(prop.initializer)) {
+            return prop.initializer;
+        }
+    }
+    return null;
+}
+/**
+ * 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;
+}
+/**
+ * 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 = createSourceFile(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;
+                }
             }
         }
     }
@@ -164,31 +326,57 @@ function findImportLocalName(sourceFile, name, moduleName) {
     }
     return null;
 }
+/** Creates a source file from a file path within a project. */
+function createSourceFile(tree, filePath) {
+    return typescript_1.default.createSourceFile(filePath, tree.readText(filePath), typescript_1.default.ScriptTarget.Latest, true);
+}
 /**
- * Finds a call to a function with a specific name.
- * @param rootNode Node from which to start searching.
- * @param name Name of the function to search for.
+ * Creates a new app config object literal and adds it to a call expression as an argument.
+ * @param call Call to which to add the config.
+ * @param expression Expression that should inserted into the new config.
+ * @param recorder Recorder to which to log the change.
  */
-function findCall(rootNode, name) {
-    let result = null;
-    rootNode.forEachChild(function walk(node) {
-        if (typescript_1.default.isCallExpression(node) &&
-            typescript_1.default.isIdentifier(node.expression) &&
-            node.expression.text === name) {
-            result = node;
-        }
-        if (!result) {
-            node.forEachChild(walk);
-        }
-    });
-    return result;
+function addNewAppConfigToCall(call, expression, recorder) {
+    const newCall = typescript_1.default.factory.updateCallExpression(call, call.expression, call.typeArguments, [
+        ...call.arguments,
+        typescript_1.default.factory.createObjectLiteralExpression([
+            typescript_1.default.factory.createPropertyAssignment('providers', typescript_1.default.factory.createArrayLiteralExpression([expression])),
+        ], true),
+    ]);
+    recorder.remove(call.getStart(), call.getWidth());
+    recorder.insertRight(call.getStart(), typescript_1.default.createPrinter().printNode(typescript_1.default.EmitHint.Unspecified, newCall, call.getSourceFile()));
 }
-/** Creates an `importProvidersFrom({{moduleName}})` call. */
-function createImportProvidersFromCall(moduleName) {
-    return typescript_1.default.factory.createCallChain(typescript_1.default.factory.createIdentifier('importProvidersFrom'), undefined, undefined, [typescript_1.default.factory.createIdentifier(moduleName)]);
+/**
+ * Adds an element to an array literal expression.
+ * @param node Array to which to add the element.
+ * @param element Element to be added.
+ * @param recorder Recorder to which to log the change.
+ */
+function addElementToArray(node, element, recorder) {
+    const newLiteral = typescript_1.default.factory.updateArrayLiteralExpression(node, [...node.elements, element]);
+    recorder.remove(node.getStart(), node.getWidth());
+    recorder.insertRight(node.getStart(), typescript_1.default.createPrinter().printNode(typescript_1.default.EmitHint.Unspecified, newLiteral, node.getSourceFile()));
 }
-/** Creates a `providers: [importProvidersFrom({{moduleName}})]` property assignment. */
-function createProvidersAssignment(moduleName) {
-    return typescript_1.default.factory.createPropertyAssignment('providers', typescript_1.default.factory.createArrayLiteralExpression([createImportProvidersFromCall(moduleName)]));
+/**
+ * Adds a `providers` property to an object literal.
+ * @param node Literal to which to add the `providers`.
+ * @param expression Provider that should be part of the generated `providers` array.
+ * @param recorder Recorder to which to log the change.
+ */
+function addProvidersToObjectLiteral(node, expression, recorder) {
+    const newOptionsLiteral = typescript_1.default.factory.updateObjectLiteralExpression(node, [
+        ...node.properties,
+        typescript_1.default.factory.createPropertyAssignment('providers', typescript_1.default.factory.createArrayLiteralExpression([expression])),
+    ]);
+    recorder.remove(node.getStart(), node.getWidth());
+    recorder.insertRight(node.getStart(), typescript_1.default.createPrinter().printNode(typescript_1.default.EmitHint.Unspecified, newOptionsLiteral, node.getSourceFile()));
+}
+/** Checks whether a node is a call to `mergeApplicationConfig`. */
+function isMergeAppConfigCall(node) {
+    if (!typescript_1.default.isCallExpression(node)) {
+        return false;
+    }
+    const localName = findImportLocalName(node.getSourceFile(), 'mergeApplicationConfig', '@angular/core');
+    return !!localName && typescript_1.default.isIdentifier(node.expression) && node.expression.text === localName;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"standalone.js","sourceRoot":"","sources":["../../../../../../../packages/schematics/angular/private/standalone.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 { SchematicsException, Tree } from '@angular-devkit/schematics';\nimport ts from '../third_party/github.com/Microsoft/TypeScript/lib/typescript';\nimport { insertImport } from '../utility/ast-utils';\nimport { InsertChange } from '../utility/change';\n\n/**\n * Checks whether the providers from a module are being imported in a `bootstrapApplication` call.\n * @param tree File tree of the project.\n * @param filePath Path of the file in which to check.\n * @param className Class name of the module to search for.\n */\nexport function importsProvidersFrom(tree: Tree, filePath: string, className: string): boolean {\n  const sourceFile = ts.createSourceFile(\n    filePath,\n    tree.readText(filePath),\n    ts.ScriptTarget.Latest,\n    true,\n  );\n\n  const bootstrapCall = findBootstrapApplicationCall(sourceFile);\n  const importProvidersFromCall = bootstrapCall ? findImportProvidersFromCall(bootstrapCall) : null;\n\n  return (\n    !!importProvidersFromCall &&\n    importProvidersFromCall.arguments.some((arg) => ts.isIdentifier(arg) && arg.text === className)\n  );\n}\n\n/**\n * Adds an `importProvidersFrom` call to the `bootstrapApplication` call.\n * @param tree File tree of the project.\n * @param filePath Path to the file that should be updated.\n * @param moduleName Name of the module that should be imported.\n * @param modulePath Path from which to import the module.\n */\nexport function addModuleImportToStandaloneBootstrap(\n  tree: Tree,\n  filePath: string,\n  moduleName: string,\n  modulePath: string,\n) {\n  const sourceFile = ts.createSourceFile(\n    filePath,\n    tree.readText(filePath),\n    ts.ScriptTarget.Latest,\n    true,\n  );\n\n  const bootstrapCall = findBootstrapApplicationCall(sourceFile);\n\n  if (!bootstrapCall) {\n    throw new SchematicsException(`Could not find bootstrapApplication call in ${filePath}`);\n  }\n\n  const recorder = tree.beginUpdate(filePath);\n  const importCall = findImportProvidersFromCall(bootstrapCall);\n  const printer = ts.createPrinter();\n  const sourceText = sourceFile.getText();\n\n  // Add imports to the module being added and `importProvidersFrom`. We don't\n  // have to worry about duplicates, because `insertImport` handles them.\n  [\n    insertImport(sourceFile, sourceText, moduleName, modulePath),\n    insertImport(sourceFile, sourceText, 'importProvidersFrom', '@angular/core'),\n  ].forEach((change) => {\n    if (change instanceof InsertChange) {\n      recorder.insertLeft(change.pos, change.toAdd);\n    }\n  });\n\n  // If there is an `importProvidersFrom` call already, reuse it.\n  if (importCall) {\n    recorder.insertRight(\n      importCall.arguments[importCall.arguments.length - 1].getEnd(),\n      `, ${moduleName}`,\n    );\n  } else if (bootstrapCall.arguments.length === 1) {\n    // Otherwise if there is no options parameter to `bootstrapApplication`,\n    // create an object literal with a `providers` array and the import.\n    const newCall = ts.factory.updateCallExpression(\n      bootstrapCall,\n      bootstrapCall.expression,\n      bootstrapCall.typeArguments,\n      [\n        ...bootstrapCall.arguments,\n        ts.factory.createObjectLiteralExpression([createProvidersAssignment(moduleName)], true),\n      ],\n    );\n\n    recorder.remove(bootstrapCall.getStart(), bootstrapCall.getWidth());\n    recorder.insertRight(\n      bootstrapCall.getStart(),\n      printer.printNode(ts.EmitHint.Unspecified, newCall, sourceFile),\n    );\n  } else {\n    const providersLiteral = findProvidersLiteral(bootstrapCall);\n\n    if (providersLiteral) {\n      // If there's a `providers` array, add the import to it.\n      const newProvidersLiteral = ts.factory.updateArrayLiteralExpression(providersLiteral, [\n        ...providersLiteral.elements,\n        createImportProvidersFromCall(moduleName),\n      ]);\n      recorder.remove(providersLiteral.getStart(), providersLiteral.getWidth());\n      recorder.insertRight(\n        providersLiteral.getStart(),\n        printer.printNode(ts.EmitHint.Unspecified, newProvidersLiteral, sourceFile),\n      );\n    } else {\n      // Otherwise add a `providers` array to the existing object literal.\n      const optionsLiteral = bootstrapCall.arguments[1] as ts.ObjectLiteralExpression;\n      const newOptionsLiteral = ts.factory.updateObjectLiteralExpression(optionsLiteral, [\n        ...optionsLiteral.properties,\n        createProvidersAssignment(moduleName),\n      ]);\n      recorder.remove(optionsLiteral.getStart(), optionsLiteral.getWidth());\n      recorder.insertRight(\n        optionsLiteral.getStart(),\n        printer.printNode(ts.EmitHint.Unspecified, newOptionsLiteral, sourceFile),\n      );\n    }\n  }\n\n  tree.commitUpdate(recorder);\n}\n\n/** Finds the call to `bootstrapApplication` within a file. */\nexport function findBootstrapApplicationCall(sourceFile: ts.SourceFile): ts.CallExpression | null {\n  const localName = findImportLocalName(\n    sourceFile,\n    'bootstrapApplication',\n    '@angular/platform-browser',\n  );\n\n  return localName ? findCall(sourceFile, localName) : null;\n}\n\n/** Find a call to `importProvidersFrom` within a `bootstrapApplication` call. */\nfunction findImportProvidersFromCall(bootstrapCall: ts.CallExpression): ts.CallExpression | null {\n  const providersLiteral = findProvidersLiteral(bootstrapCall);\n  const importProvidersName = findImportLocalName(\n    bootstrapCall.getSourceFile(),\n    'importProvidersFrom',\n    '@angular/core',\n  );\n\n  if (providersLiteral && importProvidersName) {\n    for (const element of providersLiteral.elements) {\n      // Look for an array element that calls the `importProvidersFrom` function.\n      if (\n        ts.isCallExpression(element) &&\n        ts.isIdentifier(element.expression) &&\n        element.expression.text === importProvidersName\n      ) {\n        return element;\n      }\n    }\n  }\n\n  return null;\n}\n\n/** Finds the `providers` array literal within a `bootstrapApplication` call. */\nfunction findProvidersLiteral(bootstrapCall: ts.CallExpression): ts.ArrayLiteralExpression | null {\n  // The imports have to be in the second argument of\n  // the function which has to be an object literal.\n  if (\n    bootstrapCall.arguments.length > 1 &&\n    ts.isObjectLiteralExpression(bootstrapCall.arguments[1])\n  ) {\n    for (const prop of bootstrapCall.arguments[1].properties) {\n      if (\n        ts.isPropertyAssignment(prop) &&\n        ts.isIdentifier(prop.name) &&\n        prop.name.text === 'providers' &&\n        ts.isArrayLiteralExpression(prop.initializer)\n      ) {\n        return prop.initializer;\n      }\n    }\n  }\n\n  return null;\n}\n\n/**\n * Finds the local name of an imported symbol. Could be the symbol name itself or its alias.\n * @param sourceFile File within which to search for the import.\n * @param name Actual name of the import, not its local alias.\n * @param moduleName Name of the module from which the symbol is imported.\n */\nfunction findImportLocalName(\n  sourceFile: ts.SourceFile,\n  name: string,\n  moduleName: string,\n): string | null {\n  for (const node of sourceFile.statements) {\n    // Only look for top-level imports.\n    if (\n      !ts.isImportDeclaration(node) ||\n      !ts.isStringLiteral(node.moduleSpecifier) ||\n      node.moduleSpecifier.text !== moduleName\n    ) {\n      continue;\n    }\n\n    // Filter out imports that don't have the right shape.\n    if (\n      !node.importClause ||\n      !node.importClause.namedBindings ||\n      !ts.isNamedImports(node.importClause.namedBindings)\n    ) {\n      continue;\n    }\n\n    // Look through the elements of the declaration for the specific import.\n    for (const element of node.importClause.namedBindings.elements) {\n      if ((element.propertyName || element.name).text === name) {\n        // The local name is always in `name`.\n        return element.name.text;\n      }\n    }\n  }\n\n  return null;\n}\n\n/**\n * Finds a call to a function with a specific name.\n * @param rootNode Node from which to start searching.\n * @param name Name of the function to search for.\n */\nfunction findCall(rootNode: ts.Node, name: string): ts.CallExpression | null {\n  let result: ts.CallExpression | null = null;\n\n  rootNode.forEachChild(function walk(node) {\n    if (\n      ts.isCallExpression(node) &&\n      ts.isIdentifier(node.expression) &&\n      node.expression.text === name\n    ) {\n      result = node;\n    }\n\n    if (!result) {\n      node.forEachChild(walk);\n    }\n  });\n\n  return result;\n}\n\n/** Creates an `importProvidersFrom({{moduleName}})` call. */\nfunction createImportProvidersFromCall(moduleName: string): ts.CallExpression {\n  return ts.factory.createCallChain(\n    ts.factory.createIdentifier('importProvidersFrom'),\n    undefined,\n    undefined,\n    [ts.factory.createIdentifier(moduleName)],\n  );\n}\n\n/** Creates a `providers: [importProvidersFrom({{moduleName}})]` property assignment. */\nfunction createProvidersAssignment(moduleName: string): ts.PropertyAssignment {\n  return ts.factory.createPropertyAssignment(\n    'providers',\n    ts.factory.createArrayLiteralExpression([createImportProvidersFromCall(moduleName)]),\n  );\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"standalone.js","sourceRoot":"","sources":["../../../../../../../packages/schematics/angular/private/standalone.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 { SchematicsException, Tree, UpdateRecorder } from '@angular-devkit/schematics';\nimport { dirname, join } from 'path';\nimport ts from '../third_party/github.com/Microsoft/TypeScript/lib/typescript';\nimport { insertImport } from '../utility/ast-utils';\nimport { InsertChange } from '../utility/change';\n\n/** App config that was resolved to its source node. */\ninterface 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 * Checks whether the providers from a module are being imported in a `bootstrapApplication` call.\n * @param tree File tree of the project.\n * @param filePath Path of the file in which to check.\n * @param className Class name of the module to search for.\n */\nexport function importsProvidersFrom(tree: Tree, filePath: string, className: string): boolean {\n  const sourceFile = createSourceFile(tree, filePath);\n  const bootstrapCall = findBootstrapApplicationCall(sourceFile);\n  const appConfig = bootstrapCall ? findAppConfig(bootstrapCall, tree, filePath) : null;\n  const importProvidersFromCall = appConfig ? findImportProvidersFromCall(appConfig.node) : null;\n\n  return !!importProvidersFromCall?.arguments.some(\n    (arg) => ts.isIdentifier(arg) && arg.text === className,\n  );\n}\n\n/**\n * Checks whether a providers function is being called in a `bootstrapApplication` call.\n * @param tree File tree of the project.\n * @param filePath Path of the file in which to check.\n * @param functionName Name of the function to search for.\n */\nexport function callsProvidersFunction(\n  tree: Tree,\n  filePath: string,\n  functionName: string,\n): boolean {\n  const sourceFile = createSourceFile(tree, filePath);\n  const bootstrapCall = findBootstrapApplicationCall(sourceFile);\n  const appConfig = bootstrapCall ? findAppConfig(bootstrapCall, tree, filePath) : null;\n  const providersLiteral = appConfig ? findProvidersLiteral(appConfig.node) : null;\n\n  return !!providersLiteral?.elements.some(\n    (el) =>\n      ts.isCallExpression(el) &&\n      ts.isIdentifier(el.expression) &&\n      el.expression.text === functionName,\n  );\n}\n\n/**\n * Adds an `importProvidersFrom` call to the `bootstrapApplication` call.\n * @param tree File tree of the project.\n * @param filePath Path to the file that should be updated.\n * @param moduleName Name of the module that should be imported.\n * @param modulePath Path from which to import the module.\n */\nexport function addModuleImportToStandaloneBootstrap(\n  tree: Tree,\n  filePath: string,\n  moduleName: string,\n  modulePath: string,\n) {\n  const sourceFile = createSourceFile(tree, filePath);\n  const bootstrapCall = findBootstrapApplicationCall(sourceFile);\n  const addImports = (file: ts.SourceFile, recorder: UpdateRecorder) => {\n    const sourceText = file.getText();\n\n    [\n      insertImport(file, sourceText, moduleName, modulePath),\n      insertImport(file, sourceText, 'importProvidersFrom', '@angular/core'),\n    ].forEach((change) => {\n      if (change instanceof InsertChange) {\n        recorder.insertLeft(change.pos, change.toAdd);\n      }\n    });\n  };\n\n  if (!bootstrapCall) {\n    throw new SchematicsException(`Could not find bootstrapApplication call in ${filePath}`);\n  }\n\n  const importProvidersCall = ts.factory.createCallExpression(\n    ts.factory.createIdentifier('importProvidersFrom'),\n    [],\n    [ts.factory.createIdentifier(moduleName)],\n  );\n\n  // If there's only one argument, we have to create a new object literal.\n  if (bootstrapCall.arguments.length === 1) {\n    const recorder = tree.beginUpdate(filePath);\n    addNewAppConfigToCall(bootstrapCall, importProvidersCall, recorder);\n    addImports(sourceFile, recorder);\n    tree.commitUpdate(recorder);\n\n    return;\n  }\n\n  // If the config is a `mergeApplicationProviders` call, add another config to it.\n  if (isMergeAppConfigCall(bootstrapCall.arguments[1])) {\n    const recorder = tree.beginUpdate(filePath);\n    addNewAppConfigToCall(bootstrapCall.arguments[1], importProvidersCall, recorder);\n    addImports(sourceFile, recorder);\n    tree.commitUpdate(recorder);\n\n    return;\n  }\n\n  // Otherwise attempt to merge into the current config.\n  const appConfig = findAppConfig(bootstrapCall, tree, filePath);\n\n  if (!appConfig) {\n    throw new SchematicsException(\n      `Could not statically analyze config in bootstrapApplication call in ${filePath}`,\n    );\n  }\n\n  const { filePath: configFilePath, node: config } = appConfig;\n  const recorder = tree.beginUpdate(configFilePath);\n  const importCall = findImportProvidersFromCall(config);\n\n  addImports(config.getSourceFile(), recorder);\n\n  if (importCall) {\n    // If there's an `importProvidersFrom` call already, add the module to it.\n    recorder.insertRight(\n      importCall.arguments[importCall.arguments.length - 1].getEnd(),\n      `, ${moduleName}`,\n    );\n  } else {\n    const providersLiteral = findProvidersLiteral(config);\n\n    if (providersLiteral) {\n      // If there's a `providers` array, add the import to it.\n      addElementToArray(providersLiteral, importProvidersCall, recorder);\n    } else {\n      // Otherwise add a `providers` array to the existing object literal.\n      addProvidersToObjectLiteral(config, importProvidersCall, recorder);\n    }\n  }\n\n  tree.commitUpdate(recorder);\n}\n\n/**\n * Adds a providers function call to the `bootstrapApplication` call.\n * @param tree File tree of the project.\n * @param filePath Path to the file that should be updated.\n * @param functionName Name of the function that should be called.\n * @param importPath Path from which to import the function.\n * @param args Arguments to use when calling the function.\n * @returns The file path that the provider was added to.\n */\nexport function addFunctionalProvidersToStandaloneBootstrap(\n  tree: Tree,\n  filePath: string,\n  functionName: string,\n  importPath: string,\n  args: ts.Expression[] = [],\n): string {\n  const sourceFile = createSourceFile(tree, filePath);\n  const bootstrapCall = findBootstrapApplicationCall(sourceFile);\n  const addImports = (file: ts.SourceFile, recorder: UpdateRecorder) => {\n    const change = insertImport(file, file.getText(), functionName, importPath);\n\n    if (change instanceof InsertChange) {\n      recorder.insertLeft(change.pos, change.toAdd);\n    }\n  };\n\n  if (!bootstrapCall) {\n    throw new SchematicsException(`Could not find bootstrapApplication call in ${filePath}`);\n  }\n\n  const providersCall = ts.factory.createCallExpression(\n    ts.factory.createIdentifier(functionName),\n    undefined,\n    args,\n  );\n\n  // If there's only one argument, we have to create a new object literal.\n  if (bootstrapCall.arguments.length === 1) {\n    const recorder = tree.beginUpdate(filePath);\n    addNewAppConfigToCall(bootstrapCall, providersCall, recorder);\n    addImports(sourceFile, recorder);\n    tree.commitUpdate(recorder);\n\n    return filePath;\n  }\n\n  // If the config is a `mergeApplicationProviders` call, add another config to it.\n  if (isMergeAppConfigCall(bootstrapCall.arguments[1])) {\n    const recorder = tree.beginUpdate(filePath);\n    addNewAppConfigToCall(bootstrapCall.arguments[1], providersCall, recorder);\n    addImports(sourceFile, recorder);\n    tree.commitUpdate(recorder);\n\n    return filePath;\n  }\n\n  // Otherwise attempt to merge into the current config.\n  const appConfig = findAppConfig(bootstrapCall, tree, filePath);\n\n  if (!appConfig) {\n    throw new SchematicsException(\n      `Could not statically analyze config in bootstrapApplication call in ${filePath}`,\n    );\n  }\n\n  const { filePath: configFilePath, node: config } = appConfig;\n  const recorder = tree.beginUpdate(configFilePath);\n  const providersLiteral = findProvidersLiteral(config);\n\n  addImports(config.getSourceFile(), recorder);\n\n  if (providersLiteral) {\n    // If there's a `providers` array, add the import to it.\n    addElementToArray(providersLiteral, providersCall, recorder);\n  } else {\n    // Otherwise add a `providers` array to the existing object literal.\n    addProvidersToObjectLiteral(config, providersCall, recorder);\n  }\n\n  tree.commitUpdate(recorder);\n\n  return configFilePath;\n}\n\n/** Finds the call to `bootstrapApplication` within a file. */\nexport function findBootstrapApplicationCall(sourceFile: ts.SourceFile): ts.CallExpression | null {\n  const localName = findImportLocalName(\n    sourceFile,\n    'bootstrapApplication',\n    '@angular/platform-browser',\n  );\n\n  if (!localName) {\n    return null;\n  }\n\n  let result: ts.CallExpression | null = null;\n\n  sourceFile.forEachChild(function walk(node) {\n    if (\n      ts.isCallExpression(node) &&\n      ts.isIdentifier(node.expression) &&\n      node.expression.text === localName\n    ) {\n      result = node;\n    }\n\n    if (!result) {\n      node.forEachChild(walk);\n    }\n  });\n\n  return result;\n}\n\n/** Find a call to `importProvidersFrom` within an application config. */\nfunction findImportProvidersFromCall(config: ts.ObjectLiteralExpression): ts.CallExpression | null {\n  const importProvidersName = findImportLocalName(\n    config.getSourceFile(),\n    'importProvidersFrom',\n    '@angular/core',\n  );\n  const providersLiteral = findProvidersLiteral(config);\n\n  if (providersLiteral && importProvidersName) {\n    for (const element of providersLiteral.elements) {\n      // Look for an array element that calls the `importProvidersFrom` function.\n      if (\n        ts.isCallExpression(element) &&\n        ts.isIdentifier(element.expression) &&\n        element.expression.text === importProvidersName\n      ) {\n        return element;\n      }\n    }\n  }\n\n  return null;\n}\n\n/** Finds the `providers` array literal within an application config. */\nfunction findProvidersLiteral(\n  config: ts.ObjectLiteralExpression,\n): ts.ArrayLiteralExpression | null {\n  for (const prop of config.properties) {\n    if (\n      ts.isPropertyAssignment(prop) &&\n      ts.isIdentifier(prop.name) &&\n      prop.name.text === 'providers' &&\n      ts.isArrayLiteralExpression(prop.initializer)\n    ) {\n      return prop.initializer;\n    }\n  }\n\n  return null;\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 */\nfunction 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 = createSourceFile(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\n/**\n * Finds the local name of an imported symbol. Could be the symbol name itself or its alias.\n * @param sourceFile File within which to search for the import.\n * @param name Actual name of the import, not its local alias.\n * @param moduleName Name of the module from which the symbol is imported.\n */\nfunction findImportLocalName(\n  sourceFile: ts.SourceFile,\n  name: string,\n  moduleName: string,\n): string | null {\n  for (const node of sourceFile.statements) {\n    // Only look for top-level imports.\n    if (\n      !ts.isImportDeclaration(node) ||\n      !ts.isStringLiteral(node.moduleSpecifier) ||\n      node.moduleSpecifier.text !== moduleName\n    ) {\n      continue;\n    }\n\n    // Filter out imports that don't have the right shape.\n    if (\n      !node.importClause ||\n      !node.importClause.namedBindings ||\n      !ts.isNamedImports(node.importClause.namedBindings)\n    ) {\n      continue;\n    }\n\n    // Look through the elements of the declaration for the specific import.\n    for (const element of node.importClause.namedBindings.elements) {\n      if ((element.propertyName || element.name).text === name) {\n        // The local name is always in `name`.\n        return element.name.text;\n      }\n    }\n  }\n\n  return null;\n}\n\n/** Creates a source file from a file path within a project. */\nfunction createSourceFile(tree: Tree, filePath: string): ts.SourceFile {\n  return ts.createSourceFile(filePath, tree.readText(filePath), ts.ScriptTarget.Latest, true);\n}\n\n/**\n * Creates a new app config object literal and adds it to a call expression as an argument.\n * @param call Call to which to add the config.\n * @param expression Expression that should inserted into the new config.\n * @param recorder Recorder to which to log the change.\n */\nfunction addNewAppConfigToCall(\n  call: ts.CallExpression,\n  expression: ts.Expression,\n  recorder: UpdateRecorder,\n): void {\n  const newCall = ts.factory.updateCallExpression(call, call.expression, call.typeArguments, [\n    ...call.arguments,\n    ts.factory.createObjectLiteralExpression(\n      [\n        ts.factory.createPropertyAssignment(\n          'providers',\n          ts.factory.createArrayLiteralExpression([expression]),\n        ),\n      ],\n      true,\n    ),\n  ]);\n\n  recorder.remove(call.getStart(), call.getWidth());\n  recorder.insertRight(\n    call.getStart(),\n    ts.createPrinter().printNode(ts.EmitHint.Unspecified, newCall, call.getSourceFile()),\n  );\n}\n\n/**\n * Adds an element to an array literal expression.\n * @param node Array to which to add the element.\n * @param element Element to be added.\n * @param recorder Recorder to which to log the change.\n */\nfunction addElementToArray(\n  node: ts.ArrayLiteralExpression,\n  element: ts.Expression,\n  recorder: UpdateRecorder,\n): void {\n  const newLiteral = ts.factory.updateArrayLiteralExpression(node, [...node.elements, element]);\n  recorder.remove(node.getStart(), node.getWidth());\n  recorder.insertRight(\n    node.getStart(),\n    ts.createPrinter().printNode(ts.EmitHint.Unspecified, newLiteral, node.getSourceFile()),\n  );\n}\n\n/**\n * Adds a `providers` property to an object literal.\n * @param node Literal to which to add the `providers`.\n * @param expression Provider that should be part of the generated `providers` array.\n * @param recorder Recorder to which to log the change.\n */\nfunction addProvidersToObjectLiteral(\n  node: ts.ObjectLiteralExpression,\n  expression: ts.Expression,\n  recorder: UpdateRecorder,\n) {\n  const newOptionsLiteral = ts.factory.updateObjectLiteralExpression(node, [\n    ...node.properties,\n    ts.factory.createPropertyAssignment(\n      'providers',\n      ts.factory.createArrayLiteralExpression([expression]),\n    ),\n  ]);\n  recorder.remove(node.getStart(), node.getWidth());\n  recorder.insertRight(\n    node.getStart(),\n    ts.createPrinter().printNode(ts.EmitHint.Unspecified, newOptionsLiteral, node.getSourceFile()),\n  );\n}\n\n/** Checks whether a node is a call to `mergeApplicationConfig`. */\nfunction isMergeAppConfigCall(node: ts.Node): node is ts.CallExpression {\n  if (!ts.isCallExpression(node)) {\n    return false;\n  }\n\n  const localName = findImportLocalName(\n    node.getSourceFile(),\n    'mergeApplicationConfig',\n    '@angular/core',\n  );\n\n  return !!localName && ts.isIdentifier(node.expression) && node.expression.text === localName;\n}\n"]}