@angular/cdk 14.0.0-next.9 → 14.0.0-rc.2

package/schematics/index.mjs

@@ -25,13 +25,13 @@ exports.parse5 = void 0;
 __exportStar(require("./utils"), exports);
 __exportStar(require("./ng-update/public-api"), exports);
 __exportStar(require("./update-tool/public-api"), exports);
-// Re-exported so that Angular Material schematic code can consume the
-// vendored "@schematics/angular" AST utils.
-__exportStar(require("./utils/vendored-ast-utils"), exports);
+// Re-exported so that Angular Material schematic code can consume the same AST utils as the CDK.
+__exportStar(require("@schematics/angular/utility/ast-utils"), exports);
+__exportStar(require("@schematics/angular/utility/ng-ast-utils"), exports);
 // Re-export parse5 from the CDK. Material schematics code cannot simply import
 // "parse5" because it could result in a different version. As long as we import
 // it from within the CDK, it will always be the correct version that is specified
 // in the CDK "package.json" as optional dependency.
 const parse5 = require("parse5");
 exports.parse5 = parse5;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrL3NjaGVtYXRpY3MvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7R0FNRzs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFFSCwwQ0FBd0I7QUFDeEIseURBQXVDO0FBQ3ZDLDJEQUF5QztBQUV6QyxzRUFBc0U7QUFDdEUsNENBQTRDO0FBQzVDLDZEQUEyQztBQUUzQywrRUFBK0U7QUFDL0UsZ0ZBQWdGO0FBQ2hGLGtGQUFrRjtBQUNsRixvREFBb0Q7QUFDcEQsaUNBQWlDO0FBQ3pCLHdCQUFNIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vdXRpbHMnO1xuZXhwb3J0ICogZnJvbSAnLi9uZy11cGRhdGUvcHVibGljLWFwaSc7XG5leHBvcnQgKiBmcm9tICcuL3VwZGF0ZS10b29sL3B1YmxpYy1hcGknO1xuXG4vLyBSZS1leHBvcnRlZCBzbyB0aGF0IEFuZ3VsYXIgTWF0ZXJpYWwgc2NoZW1hdGljIGNvZGUgY2FuIGNvbnN1bWUgdGhlXG4vLyB2ZW5kb3JlZCBcIkBzY2hlbWF0aWNzL2FuZ3VsYXJcIiBBU1QgdXRpbHMuXG5leHBvcnQgKiBmcm9tICcuL3V0aWxzL3ZlbmRvcmVkLWFzdC11dGlscyc7XG5cbi8vIFJlLWV4cG9ydCBwYXJzZTUgZnJvbSB0aGUgQ0RLLiBNYXRlcmlhbCBzY2hlbWF0aWNzIGNvZGUgY2Fubm90IHNpbXBseSBpbXBvcnRcbi8vIFwicGFyc2U1XCIgYmVjYXVzZSBpdCBjb3VsZCByZXN1bHQgaW4gYSBkaWZmZXJlbnQgdmVyc2lvbi4gQXMgbG9uZyBhcyB3ZSBpbXBvcnRcbi8vIGl0IGZyb20gd2l0aGluIHRoZSBDREssIGl0IHdpbGwgYWx3YXlzIGJlIHRoZSBjb3JyZWN0IHZlcnNpb24gdGhhdCBpcyBzcGVjaWZpZWRcbi8vIGluIHRoZSBDREsgXCJwYWNrYWdlLmpzb25cIiBhcyBvcHRpb25hbCBkZXBlbmRlbmN5LlxuaW1wb3J0ICogYXMgcGFyc2U1IGZyb20gJ3BhcnNlNSc7XG5leHBvcnQge3BhcnNlNX07XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrL3NjaGVtYXRpY3MvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7R0FNRzs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFFSCwwQ0FBd0I7QUFDeEIseURBQXVDO0FBQ3ZDLDJEQUF5QztBQUV6QyxpR0FBaUc7QUFDakcsd0VBQXNEO0FBQ3RELDJFQUF5RDtBQUV6RCwrRUFBK0U7QUFDL0UsZ0ZBQWdGO0FBQ2hGLGtGQUFrRjtBQUNsRixvREFBb0Q7QUFDcEQsaUNBQWlDO0FBQ3pCLHdCQUFNIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vdXRpbHMnO1xuZXhwb3J0ICogZnJvbSAnLi9uZy11cGRhdGUvcHVibGljLWFwaSc7XG5leHBvcnQgKiBmcm9tICcuL3VwZGF0ZS10b29sL3B1YmxpYy1hcGknO1xuXG4vLyBSZS1leHBvcnRlZCBzbyB0aGF0IEFuZ3VsYXIgTWF0ZXJpYWwgc2NoZW1hdGljIGNvZGUgY2FuIGNvbnN1bWUgdGhlIHNhbWUgQVNUIHV0aWxzIGFzIHRoZSBDREsuXG5leHBvcnQgKiBmcm9tICdAc2NoZW1hdGljcy9hbmd1bGFyL3V0aWxpdHkvYXN0LXV0aWxzJztcbmV4cG9ydCAqIGZyb20gJ0BzY2hlbWF0aWNzL2FuZ3VsYXIvdXRpbGl0eS9uZy1hc3QtdXRpbHMnO1xuXG4vLyBSZS1leHBvcnQgcGFyc2U1IGZyb20gdGhlIENESy4gTWF0ZXJpYWwgc2NoZW1hdGljcyBjb2RlIGNhbm5vdCBzaW1wbHkgaW1wb3J0XG4vLyBcInBhcnNlNVwiIGJlY2F1c2UgaXQgY291bGQgcmVzdWx0IGluIGEgZGlmZmVyZW50IHZlcnNpb24uIEFzIGxvbmcgYXMgd2UgaW1wb3J0XG4vLyBpdCBmcm9tIHdpdGhpbiB0aGUgQ0RLLCBpdCB3aWxsIGFsd2F5cyBiZSB0aGUgY29ycmVjdCB2ZXJzaW9uIHRoYXQgaXMgc3BlY2lmaWVkXG4vLyBpbiB0aGUgQ0RLIFwicGFja2FnZS5qc29uXCIgYXMgb3B0aW9uYWwgZGVwZW5kZW5jeS5cbmltcG9ydCAqIGFzIHBhcnNlNSBmcm9tICdwYXJzZTUnO1xuZXhwb3J0IHtwYXJzZTV9O1xuIl19

package/schematics/ng-add/index.js

@@ -28,7 +28,7 @@ function default_1() {
             // In order to align the CDK version with other Angular dependencies that are setup by
             // `@schematics/angular`, we use tilde instead of caret. This is default for Angular
             // dependencies in new CLI projects.
-            (0, package_config_1.addPackageToPackageJson)(host, '@angular/cdk', `~14.0.0-next.9`);
+            (0, package_config_1.addPackageToPackageJson)(host, '@angular/cdk', `~14.0.0-rc.2`);
             // Add a task to run the package manager. This is necessary because we updated the
             // workspace "package.json" file and we want lock files to reflect the new version range.
             context.addTask(new tasks_1.NodePackageInstallTask());

package/schematics/ng-add/index.mjs

@@ -28,7 +28,7 @@ function default_1() {
             // In order to align the CDK version with other Angular dependencies that are setup by
             // `@schematics/angular`, we use tilde instead of caret. This is default for Angular
             // dependencies in new CLI projects.
-            (0, package_config_1.addPackageToPackageJson)(host, '@angular/cdk', `~14.0.0-next.9`);
+            (0, package_config_1.addPackageToPackageJson)(host, '@angular/cdk', `~14.0.0-rc.2`);
             // Add a task to run the package manager. This is necessary because we updated the
             // workspace "package.json" file and we want lock files to reflect the new version range.
             context.addTask(new tasks_1.NodePackageInstallTask());

package/schematics/ng-generate/drag-drop/schema.json

@@ -7,6 +7,9 @@
     "path": {
       "type": "string",
       "format": "path",
+      "$default": {
+        "$source": "workingDirectory"
+      },
       "description": "The path to create the component.",
       "visible": false
     },

package/schematics/utils/ast/standalone.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @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 * as ts from 'typescript';
+/**
+ * Checks whether the providers from a module are being imported in a `bootstrapApplication` call.
+ * @param tree File tree of the project.
+ * @param filePath Path of the file in which to check.
+ * @param className Class name of the module to search for.
+ */
+export declare function importsProvidersFrom(tree: Tree, filePath: string, className: string): boolean;
+/**
+ * Adds an `importProvidersFrom` call to the `bootstrapApplication` call.
+ * @param tree File tree of the project.
+ * @param filePath Path to the file that should be updated.
+ * @param moduleName Name of the module that should be imported.
+ * @param modulePath Path from which to import the module.
+ */
+export declare function addModuleImportToStandaloneBootstrap(tree: Tree, filePath: string, moduleName: string, modulePath: string): void;
+/** Finds the call to `bootstrapApplication` within a file. */
+export declare function findBootstrapApplicationCall(sourceFile: ts.SourceFile): ts.CallExpression | null;

package/schematics/utils/ast/standalone.js

@@ -0,0 +1,191 @@
+"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.findBootstrapApplicationCall = exports.addModuleImportToStandaloneBootstrap = exports.importsProvidersFrom = void 0;
+const schematics_1 = require("@angular-devkit/schematics");
+const change_1 = require("@schematics/angular/utility/change");
+const ts = require("typescript");
+const ast_utils_1 = require("@schematics/angular/utility/ast-utils");
+/**
+ * Checks whether the providers from a module are being imported in a `bootstrapApplication` call.
+ * @param tree File tree of the project.
+ * @param filePath Path of the file in which to check.
+ * @param className Class name of the module to search for.
+ */
+function importsProvidersFrom(tree, filePath, className) {
+    const sourceFile = ts.createSourceFile(filePath, tree.readText(filePath), ts.ScriptTarget.Latest, true);
+    const bootstrapCall = findBootstrapApplicationCall(sourceFile);
+    const importProvidersFromCall = bootstrapCall ? findImportProvidersFromCall(bootstrapCall) : null;
+    return (!!importProvidersFromCall &&
+        importProvidersFromCall.arguments.some(arg => ts.isIdentifier(arg) && arg.text === className));
+}
+exports.importsProvidersFrom = importsProvidersFrom;
+/**
+ * Adds an `importProvidersFrom` call to the `bootstrapApplication` call.
+ * @param tree File tree of the project.
+ * @param filePath Path to the file that should be updated.
+ * @param moduleName Name of the module that should be imported.
+ * @param modulePath Path from which to import the module.
+ */
+function addModuleImportToStandaloneBootstrap(tree, filePath, moduleName, modulePath) {
+    const sourceFile = ts.createSourceFile(filePath, tree.readText(filePath), ts.ScriptTarget.Latest, true);
+    const bootstrapCall = findBootstrapApplicationCall(sourceFile);
+    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 = ts.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.
+    if (importCall) {
+        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 = ts.factory.updateCallExpression(bootstrapCall, bootstrapCall.expression, bootstrapCall.typeArguments, [
+            ...bootstrapCall.arguments,
+            ts.factory.createObjectLiteralExpression([createProvidersAssignment(moduleName)], true),
+        ]);
+        recorder.remove(bootstrapCall.getStart(), bootstrapCall.getWidth());
+        recorder.insertRight(bootstrapCall.getStart(), printer.printNode(ts.EmitHint.Unspecified, newCall, sourceFile));
+    }
+    else {
+        const providersLiteral = findProvidersLiteral(bootstrapCall);
+        if (providersLiteral) {
+            // If there's a `providers` array, add the import to it.
+            const newProvidersLiteral = ts.factory.updateArrayLiteralExpression(providersLiteral, [
+                ...providersLiteral.elements,
+                createImportProvidersFromCall(moduleName),
+            ]);
+            recorder.remove(providersLiteral.getStart(), providersLiteral.getWidth());
+            recorder.insertRight(providersLiteral.getStart(), printer.printNode(ts.EmitHint.Unspecified, newProvidersLiteral, sourceFile));
+        }
+        else {
+            // Otherwise add a `providers` array to the existing object literal.
+            const optionsLiteral = bootstrapCall.arguments[1];
+            const newOptionsLiteral = ts.factory.updateObjectLiteralExpression(optionsLiteral, [
+                ...optionsLiteral.properties,
+                createProvidersAssignment(moduleName),
+            ]);
+            recorder.remove(optionsLiteral.getStart(), optionsLiteral.getWidth());
+            recorder.insertRight(optionsLiteral.getStart(), printer.printNode(ts.EmitHint.Unspecified, newOptionsLiteral, sourceFile));
+        }
+    }
+    tree.commitUpdate(recorder);
+}
+exports.addModuleImportToStandaloneBootstrap = addModuleImportToStandaloneBootstrap;
+/** 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;
+}
+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');
+    if (providersLiteral && importProvidersName) {
+        for (const element of providersLiteral.elements) {
+            // Look for an array element that calls the `importProvidersFrom` function.
+            if (ts.isCallExpression(element) &&
+                ts.isIdentifier(element.expression) &&
+                element.expression.text === importProvidersName) {
+                return element;
+            }
+        }
+    }
+    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 &&
+        ts.isObjectLiteralExpression(bootstrapCall.arguments[1])) {
+        for (const prop of bootstrapCall.arguments[1].properties) {
+            if (ts.isPropertyAssignment(prop) &&
+                ts.isIdentifier(prop.name) &&
+                prop.name.text === 'providers' &&
+                ts.isArrayLiteralExpression(prop.initializer)) {
+                return prop.initializer;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Finds the local name of an imported symbol. Could be the symbol name itself or its alias.
+ * @param sourceFile File within which to search for the import.
+ * @param name Actual name of the import, not its local alias.
+ * @param moduleName Name of the module from which the symbol is imported.
+ */
+function findImportLocalName(sourceFile, name, moduleName) {
+    for (const node of sourceFile.statements) {
+        // Only look for top-level imports.
+        if (!ts.isImportDeclaration(node) ||
+            !ts.isStringLiteral(node.moduleSpecifier) ||
+            node.moduleSpecifier.text !== moduleName) {
+            continue;
+        }
+        // Filter out imports that don't have the right shape.
+        if (!node.importClause ||
+            !node.importClause.namedBindings ||
+            !ts.isNamedImports(node.importClause.namedBindings)) {
+            continue;
+        }
+        // Look through the elements of the declaration for the specific import.
+        for (const element of node.importClause.namedBindings.elements) {
+            if ((element.propertyName || element.name).text === name) {
+                // The local name is always in `name`.
+                return element.name.text;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * 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.
+ */
+function findCall(rootNode, name) {
+    let result = null;
+    rootNode.forEachChild(function walk(node) {
+        if (ts.isCallExpression(node) &&
+            ts.isIdentifier(node.expression) &&
+            node.expression.text === name) {
+            result = node;
+        }
+        if (!result) {
+            node.forEachChild(walk);
+        }
+    });
+    return result;
+}
+/** Creates an `importProvidersFrom({{moduleName}})` call. */
+function createImportProvidersFromCall(moduleName) {
+    return ts.factory.createCallChain(ts.factory.createIdentifier('importProvidersFrom'), undefined, undefined, [ts.factory.createIdentifier(moduleName)]);
+}
+/** Creates a `providers: [importProvidersFrom({{moduleName}})]` property assignment. */
+function createProvidersAssignment(moduleName) {
+    return ts.factory.createPropertyAssignment('providers', ts.factory.createArrayLiteralExpression([createImportProvidersFromCall(moduleName)]));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"standalone.js","sourceRoot":"","sources":["../../../../../../../../src/cdk/schematics/utils/ast/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 {InsertChange} from '@schematics/angular/utility/change';\nimport * as ts from 'typescript';\nimport {insertImport} from '@schematics/angular/utility/ast-utils';\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"]}

package/schematics/utils/ast/standalone.mjs

@@ -0,0 +1,191 @@
+"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.findBootstrapApplicationCall = exports.addModuleImportToStandaloneBootstrap = exports.importsProvidersFrom = void 0;
+const schematics_1 = require("@angular-devkit/schematics");
+const change_1 = require("@schematics/angular/utility/change");
+const ts = require("typescript");
+const ast_utils_1 = require("@schematics/angular/utility/ast-utils");
+/**
+ * Checks whether the providers from a module are being imported in a `bootstrapApplication` call.
+ * @param tree File tree of the project.
+ * @param filePath Path of the file in which to check.
+ * @param className Class name of the module to search for.
+ */
+function importsProvidersFrom(tree, filePath, className) {
+    const sourceFile = ts.createSourceFile(filePath, tree.readText(filePath), ts.ScriptTarget.Latest, true);
+    const bootstrapCall = findBootstrapApplicationCall(sourceFile);
+    const importProvidersFromCall = bootstrapCall ? findImportProvidersFromCall(bootstrapCall) : null;
+    return (!!importProvidersFromCall &&
+        importProvidersFromCall.arguments.some(arg => ts.isIdentifier(arg) && arg.text === className));
+}
+exports.importsProvidersFrom = importsProvidersFrom;
+/**
+ * Adds an `importProvidersFrom` call to the `bootstrapApplication` call.
+ * @param tree File tree of the project.
+ * @param filePath Path to the file that should be updated.
+ * @param moduleName Name of the module that should be imported.
+ * @param modulePath Path from which to import the module.
+ */
+function addModuleImportToStandaloneBootstrap(tree, filePath, moduleName, modulePath) {
+    const sourceFile = ts.createSourceFile(filePath, tree.readText(filePath), ts.ScriptTarget.Latest, true);
+    const bootstrapCall = findBootstrapApplicationCall(sourceFile);
+    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 = ts.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.
+    if (importCall) {
+        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 = ts.factory.updateCallExpression(bootstrapCall, bootstrapCall.expression, bootstrapCall.typeArguments, [
+            ...bootstrapCall.arguments,
+            ts.factory.createObjectLiteralExpression([createProvidersAssignment(moduleName)], true),
+        ]);
+        recorder.remove(bootstrapCall.getStart(), bootstrapCall.getWidth());
+        recorder.insertRight(bootstrapCall.getStart(), printer.printNode(ts.EmitHint.Unspecified, newCall, sourceFile));
+    }
+    else {
+        const providersLiteral = findProvidersLiteral(bootstrapCall);
+        if (providersLiteral) {
+            // If there's a `providers` array, add the import to it.
+            const newProvidersLiteral = ts.factory.updateArrayLiteralExpression(providersLiteral, [
+                ...providersLiteral.elements,
+                createImportProvidersFromCall(moduleName),
+            ]);
+            recorder.remove(providersLiteral.getStart(), providersLiteral.getWidth());
+            recorder.insertRight(providersLiteral.getStart(), printer.printNode(ts.EmitHint.Unspecified, newProvidersLiteral, sourceFile));
+        }
+        else {
+            // Otherwise add a `providers` array to the existing object literal.
+            const optionsLiteral = bootstrapCall.arguments[1];
+            const newOptionsLiteral = ts.factory.updateObjectLiteralExpression(optionsLiteral, [
+                ...optionsLiteral.properties,
+                createProvidersAssignment(moduleName),
+            ]);
+            recorder.remove(optionsLiteral.getStart(), optionsLiteral.getWidth());
+            recorder.insertRight(optionsLiteral.getStart(), printer.printNode(ts.EmitHint.Unspecified, newOptionsLiteral, sourceFile));
+        }
+    }
+    tree.commitUpdate(recorder);
+}
+exports.addModuleImportToStandaloneBootstrap = addModuleImportToStandaloneBootstrap;
+/** 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;
+}
+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');
+    if (providersLiteral && importProvidersName) {
+        for (const element of providersLiteral.elements) {
+            // Look for an array element that calls the `importProvidersFrom` function.
+            if (ts.isCallExpression(element) &&
+                ts.isIdentifier(element.expression) &&
+                element.expression.text === importProvidersName) {
+                return element;
+            }
+        }
+    }
+    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 &&
+        ts.isObjectLiteralExpression(bootstrapCall.arguments[1])) {
+        for (const prop of bootstrapCall.arguments[1].properties) {
+            if (ts.isPropertyAssignment(prop) &&
+                ts.isIdentifier(prop.name) &&
+                prop.name.text === 'providers' &&
+                ts.isArrayLiteralExpression(prop.initializer)) {
+                return prop.initializer;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Finds the local name of an imported symbol. Could be the symbol name itself or its alias.
+ * @param sourceFile File within which to search for the import.
+ * @param name Actual name of the import, not its local alias.
+ * @param moduleName Name of the module from which the symbol is imported.
+ */
+function findImportLocalName(sourceFile, name, moduleName) {
+    for (const node of sourceFile.statements) {
+        // Only look for top-level imports.
+        if (!ts.isImportDeclaration(node) ||
+            !ts.isStringLiteral(node.moduleSpecifier) ||
+            node.moduleSpecifier.text !== moduleName) {
+            continue;
+        }
+        // Filter out imports that don't have the right shape.
+        if (!node.importClause ||
+            !node.importClause.namedBindings ||
+            !ts.isNamedImports(node.importClause.namedBindings)) {
+            continue;
+        }
+        // Look through the elements of the declaration for the specific import.
+        for (const element of node.importClause.namedBindings.elements) {
+            if ((element.propertyName || element.name).text === name) {
+                // The local name is always in `name`.
+                return element.name.text;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * 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.
+ */
+function findCall(rootNode, name) {
+    let result = null;
+    rootNode.forEachChild(function walk(node) {
+        if (ts.isCallExpression(node) &&
+            ts.isIdentifier(node.expression) &&
+            node.expression.text === name) {
+            result = node;
+        }
+        if (!result) {
+            node.forEachChild(walk);
+        }
+    });
+    return result;
+}
+/** Creates an `importProvidersFrom({{moduleName}})` call. */
+function createImportProvidersFromCall(moduleName) {
+    return ts.factory.createCallChain(ts.factory.createIdentifier('importProvidersFrom'), undefined, undefined, [ts.factory.createIdentifier(moduleName)]);
+}
+/** Creates a `providers: [importProvidersFrom({{moduleName}})]` property assignment. */
+function createProvidersAssignment(moduleName) {
+    return ts.factory.createPropertyAssignment('providers', ts.factory.createArrayLiteralExpression([createImportProvidersFromCall(moduleName)]));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"standalone.js","sourceRoot":"","sources":["../../../../../../../../src/cdk/schematics/utils/ast/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 {InsertChange} from '@schematics/angular/utility/change';\nimport * as ts from 'typescript';\nimport {insertImport} from '@schematics/angular/utility/ast-utils';\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"]}

package/schematics/utils/ast.js

@@ -12,9 +12,10 @@ const schematics_1 = require("@angular-devkit/schematics");
 const change_1 = require("@schematics/angular/utility/change");
 const workspace_1 = require("@schematics/angular/utility/workspace");
 const find_module_1 = require("@schematics/angular/utility/find-module");
+const ast_utils_1 = require("@schematics/angular/utility/ast-utils");
+const ng_ast_utils_1 = require("@schematics/angular/utility/ng-ast-utils");
 const ts = require("typescript");
 const project_main_file_1 = require("./project-main-file");
-const vendored_ast_utils_1 = require("./vendored-ast-utils");
 /** Reads file given path and returns TypeScript source file. */
 function parseSourceFile(host, path) {
     const buffer = host.read(path);
@@ -26,7 +27,7 @@ function parseSourceFile(host, path) {
 exports.parseSourceFile = parseSourceFile;
 /** Import and add module to root app module. */
 function addModuleImportToRootModule(host, moduleName, src, project) {
-    const modulePath = (0, vendored_ast_utils_1.getAppModulePath)(host, (0, project_main_file_1.getProjectMainFile)(project));
+    const modulePath = (0, ng_ast_utils_1.getAppModulePath)(host, (0, project_main_file_1.getProjectMainFile)(project));
     addModuleImportToModule(host, modulePath, moduleName, src);
 }
 exports.addModuleImportToRootModule = addModuleImportToRootModule;
@@ -42,7 +43,7 @@ function addModuleImportToModule(host, modulePath, moduleName, src) {
     if (!moduleSource) {
         throw new schematics_1.SchematicsException(`Module not found: ${modulePath}`);
     }
-    const changes = (0, vendored_ast_utils_1.addImportToModule)(moduleSource, modulePath, moduleName, src);
+    const changes = (0, ast_utils_1.addImportToModule)(moduleSource, modulePath, moduleName, src);
     const recorder = host.beginUpdate(modulePath);
     changes.forEach(change => {
         if (change instanceof change_1.InsertChange) {
@@ -65,4 +66,4 @@ async function findModuleFromOptions(host, options) {
     return (0, find_module_1.findModuleFromOptions)(host, options);
 }
 exports.findModuleFromOptions = findModuleFromOptions;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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