@angular/core 15.0.0-next.4 → 15.0.0-next.6

package/schematics/migrations/router-link-with-href/util.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @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
+ */
+/// <amd-module name="@angular/core/schematics/migrations/router-link-with-href/util" />
+import ts from 'typescript';
+export declare const routerLink = "RouterLink";
+export declare const routerLinkWithHref = "RouterLinkWithHref";
+export declare const routerModule = "@angular/router";
+export interface RewriteEntity {
+    startPos: number;
+    width: number;
+    replacement: string;
+}
+export declare type RewriteFn = (startPos: number, width: number, text: string) => void;
+export declare function migrateFile(sourceFile: ts.SourceFile, typeChecker: ts.TypeChecker, rewrite: RewriteFn): void;

package/schematics/migrations/router-link-with-href/util.js

@@ -0,0 +1,111 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/core/schematics/migrations/router-link-with-href/util", ["require", "exports", "typescript", "@angular/core/schematics/utils/typescript/imports", "@angular/core/schematics/utils/typescript/nodes"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.migrateFile = exports.routerModule = exports.routerLinkWithHref = exports.routerLink = void 0;
+    const typescript_1 = __importDefault(require("typescript"));
+    const imports_1 = require("@angular/core/schematics/utils/typescript/imports");
+    const nodes_1 = require("@angular/core/schematics/utils/typescript/nodes");
+    exports.routerLink = 'RouterLink';
+    exports.routerLinkWithHref = 'RouterLinkWithHref';
+    exports.routerModule = '@angular/router';
+    function migrateFile(sourceFile, typeChecker, rewrite) {
+        const routerLinkWithHrefSpec = (0, imports_1.getImportSpecifier)(sourceFile, exports.routerModule, exports.routerLinkWithHref);
+        // No `RouterLinkWithHref` found, nothing to migrate, exit early.
+        if (routerLinkWithHrefSpec === null)
+            return;
+        let rewrites = findUsages(sourceFile, typeChecker);
+        // There are some usages of the `RouterLinkWithHref` symbol, which need to
+        // be rewritten to `RouterLink` instead. Let's check if the `RouterLink` is
+        // already imported.
+        const routerLinkSpec = (0, imports_1.getImportSpecifier)(sourceFile, exports.routerModule, exports.routerLink);
+        if (routerLinkSpec) {
+            // The `RouterLink` symbol is already imported, just drop the `RouterLinkWithHref` one.
+            const routerLinkNamedImports = routerLinkWithHrefSpec ?
+                (0, nodes_1.closestNode)(routerLinkWithHrefSpec, typescript_1.default.SyntaxKind.NamedImports) :
+                null;
+            if (routerLinkNamedImports !== null) {
+                // Given an original import like this one:
+                // ```
+                // import {RouterModule, RouterLinkWithHref, RouterLink} from '@angular/router';
+                // ```
+                // The code below removes the `RouterLinkWithHref` from the named imports section
+                // (i.e. `{RouterModule, RouterLinkWithHref, RouterLink}`) and prints an updated
+                // version (`{RouterModule, RouterLink}`) to a string, which is used as a
+                // replacement.
+                const rewrittenNamedImports = (0, imports_1.removeSymbolFromNamedImports)(routerLinkNamedImports, routerLinkWithHrefSpec);
+                const printer = typescript_1.default.createPrinter();
+                const replacement = printer.printNode(typescript_1.default.EmitHint.Unspecified, rewrittenNamedImports, sourceFile);
+                rewrites.push({
+                    startPos: routerLinkNamedImports.getStart(),
+                    width: routerLinkNamedImports.getWidth(),
+                    replacement: replacement,
+                });
+            }
+        }
+        else {
+            // The `RouterLink` symbol is not imported, but the `RouterLinkWithHref` is imported,
+            // so rewrite `RouterLinkWithHref` -> `RouterLink`.
+            rewrites.push({
+                startPos: routerLinkWithHrefSpec.getStart(),
+                width: routerLinkWithHrefSpec.getWidth(),
+                replacement: exports.routerLink,
+            });
+        }
+        // Process rewrites last-to-first (based on start pos) to avoid offset shifts during rewrites.
+        rewrites = sortByStartPosDescending(rewrites);
+        for (const usage of rewrites) {
+            rewrite(usage.startPos, usage.width, usage.replacement);
+        }
+    }
+    exports.migrateFile = migrateFile;
+    function findUsages(sourceFile, typeChecker) {
+        const usages = [];
+        const visitNode = (node) => {
+            if (typescript_1.default.isImportSpecifier(node)) {
+                // Skip this node and all of its children; imports are a special case.
+                return;
+            }
+            if (typescript_1.default.isIdentifier(node)) {
+                const importIdentifier = (0, imports_1.getImportOfIdentifier)(typeChecker, node);
+                if ((importIdentifier === null || importIdentifier === void 0 ? void 0 : importIdentifier.importModule) === exports.routerModule &&
+                    importIdentifier.name === exports.routerLinkWithHref) {
+                    usages.push({
+                        startPos: node.getStart(),
+                        width: node.getWidth(),
+                        replacement: exports.routerLink,
+                    });
+                }
+            }
+            typescript_1.default.forEachChild(node, visitNode);
+        };
+        typescript_1.default.forEachChild(sourceFile, visitNode);
+        return usages;
+    }
+    /**
+     * Sort all found usages based on their start positions in the source file in descending order (i.e.
+     * last usage goes first on the list, etc). This is needed to avoid shifting offsets in the source
+     * file (in case there are multiple usages) as we rewrite symbols.
+     */
+    function sortByStartPosDescending(rewrites) {
+        return rewrites.sort((entityA, entityB) => entityB.startPos - entityA.startPos);
+    }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../../../../../../packages/core/schematics/migrations/router-link-with-href/util.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 ts from 'typescript';\n\nimport {getImportOfIdentifier, getImportSpecifier, removeSymbolFromNamedImports} from '../../utils/typescript/imports';\nimport {closestNode} from '../../utils/typescript/nodes';\n\nexport const routerLink = 'RouterLink';\nexport const routerLinkWithHref = 'RouterLinkWithHref';\nexport const routerModule = '@angular/router';\n\nexport interface RewriteEntity {\n  startPos: number;\n  width: number;\n  replacement: string;\n}\n\nexport type RewriteFn = (startPos: number, width: number, text: string) => void;\n\nexport function migrateFile(\n    sourceFile: ts.SourceFile, typeChecker: ts.TypeChecker, rewrite: RewriteFn) {\n  const routerLinkWithHrefSpec = getImportSpecifier(sourceFile, routerModule, routerLinkWithHref);\n\n  // No `RouterLinkWithHref` found, nothing to migrate, exit early.\n  if (routerLinkWithHrefSpec === null) return;\n\n  let rewrites = findUsages(sourceFile, typeChecker);\n\n  // There are some usages of the `RouterLinkWithHref` symbol, which need to\n  // be rewritten to `RouterLink` instead. Let's check if the `RouterLink` is\n  // already imported.\n  const routerLinkSpec = getImportSpecifier(sourceFile, routerModule, routerLink);\n\n  if (routerLinkSpec) {\n    // The `RouterLink` symbol is already imported, just drop the `RouterLinkWithHref` one.\n    const routerLinkNamedImports = routerLinkWithHrefSpec ?\n        closestNode<ts.NamedImports>(routerLinkWithHrefSpec, ts.SyntaxKind.NamedImports) :\n        null;\n    if (routerLinkNamedImports !== null) {\n      // Given an original import like this one:\n      // ```\n      // import {RouterModule, RouterLinkWithHref, RouterLink} from '@angular/router';\n      // ```\n      // The code below removes the `RouterLinkWithHref` from the named imports section\n      // (i.e. `{RouterModule, RouterLinkWithHref, RouterLink}`) and prints an updated\n      // version (`{RouterModule, RouterLink}`) to a string, which is used as a\n      // replacement.\n      const rewrittenNamedImports =\n          removeSymbolFromNamedImports(routerLinkNamedImports, routerLinkWithHrefSpec);\n      const printer = ts.createPrinter();\n      const replacement =\n          printer.printNode(ts.EmitHint.Unspecified, rewrittenNamedImports, sourceFile);\n      rewrites.push({\n        startPos: routerLinkNamedImports.getStart(),\n        width: routerLinkNamedImports.getWidth(),\n        replacement: replacement,\n      });\n    }\n  } else {\n    // The `RouterLink` symbol is not imported, but the `RouterLinkWithHref` is imported,\n    // so rewrite `RouterLinkWithHref` -> `RouterLink`.\n    rewrites.push({\n      startPos: routerLinkWithHrefSpec.getStart(),\n      width: routerLinkWithHrefSpec.getWidth(),\n      replacement: routerLink,\n    });\n  }\n\n  // Process rewrites last-to-first (based on start pos) to avoid offset shifts during rewrites.\n  rewrites = sortByStartPosDescending(rewrites);\n  for (const usage of rewrites) {\n    rewrite(usage.startPos, usage.width, usage.replacement);\n  }\n}\n\nfunction findUsages(sourceFile: ts.SourceFile, typeChecker: ts.TypeChecker): RewriteEntity[] {\n  const usages: RewriteEntity[] = [];\n  const visitNode = (node: ts.Node) => {\n    if (ts.isImportSpecifier(node)) {\n      // Skip this node and all of its children; imports are a special case.\n      return;\n    }\n    if (ts.isIdentifier(node)) {\n      const importIdentifier = getImportOfIdentifier(typeChecker, node);\n      if (importIdentifier?.importModule === routerModule &&\n          importIdentifier.name === routerLinkWithHref) {\n        usages.push({\n          startPos: node.getStart(),\n          width: node.getWidth(),\n          replacement: routerLink,\n        });\n      }\n    }\n    ts.forEachChild(node, visitNode);\n  };\n  ts.forEachChild(sourceFile, visitNode);\n  return usages;\n}\n\n/**\n * Sort all found usages based on their start positions in the source file in descending order (i.e.\n * last usage goes first on the list, etc). This is needed to avoid shifting offsets in the source\n * file (in case there are multiple usages) as we rewrite symbols.\n */\nfunction sortByStartPosDescending(rewrites: RewriteEntity[]): RewriteEntity[] {\n  return rewrites.sort((entityA, entityB) => entityB.startPos - entityA.startPos);\n}\n"]}

package/schematics/migrations.json

@@ -14,6 +14,16 @@
       "version": "14.0.0-beta",
       "description": "In Angular version 14, the `pathMatch` property of `Routes` was updated to be a strict union of the two valid options: `'full'|'prefix'`. `Routes` and `Route` variables need an explicit type so TypeScript does not infer the property as the looser `string`.",
       "factory": "./migrations/path-match-type/index"
+    },
+    "migration-v15-router-link-with-href": {
+      "version": "15.0.0-beta",
+      "description": "Since Angular v15, the `RouterLink` contains the logic of the `RouterLinkWithHref` directive. This migration replaces all `RouterLinkWithHref` references with `RouterLink`.",
+      "factory": "./migrations/router-link-with-href/index"
+    },
+    "migration-v15-relative-link-resolution": {
+      "version": "15.0.0-beta",
+      "description": "In Angular version 15, the deprecated `relativeLinkResolution` config parameter of the Router is removed. This migration removes all `relativeLinkResolution` fields from the Router config objects.",
+      "factory": "./migrations/relative-link-resolution/index"
     }
   }
 }

package/schematics/utils/typescript/imports.d.ts

@@ -34,10 +34,20 @@ export declare function getImportOfIdentifier(typeChecker: ts.TypeChecker, node:
 export declare function getImportSpecifier(sourceFile: ts.SourceFile, moduleName: string, specifierName: string): ts.ImportSpecifier | null;
 /**
  * Replaces an import inside a named imports node with a different one.
+ *
  * @param node Node that contains the imports.
  * @param existingImport Import that should be replaced.
  * @param newImportName Import that should be inserted.
  */
 export declare function replaceImport(node: ts.NamedImports, existingImport: string, newImportName: string): ts.NamedImports;
+/**
+ * Removes a symbol from the named imports and updates a node
+ * that represents a given named imports.
+ *
+ * @param node Node that contains the imports.
+ * @param symbol Symbol that should be removed.
+ * @returns An updated node (ts.NamedImports).
+ */
+export declare function removeSymbolFromNamedImports(node: ts.NamedImports, symbol: ts.ImportSpecifier): ts.NamedImports;
 /** Finds an import specifier with a particular name. */
 export declare function findImportSpecifier(nodes: ts.NodeArray<ts.ImportSpecifier>, specifierName: string): ts.ImportSpecifier | undefined;

package/schematics/utils/typescript/imports.js

@@ -19,7 +19,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.findImportSpecifier = exports.replaceImport = exports.getImportSpecifier = exports.getImportOfIdentifier = void 0;
+    exports.findImportSpecifier = exports.removeSymbolFromNamedImports = exports.replaceImport = exports.getImportSpecifier = exports.getImportOfIdentifier = void 0;
     const typescript_1 = __importDefault(require("typescript"));
     /** Gets import information about the specified identifier by using the Type checker. */
     function getImportOfIdentifier(typeChecker, node) {
@@ -78,6 +78,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     exports.getImportSpecifier = getImportSpecifier;
     /**
      * Replaces an import inside a named imports node with a different one.
+     *
      * @param node Node that contains the imports.
      * @param existingImport Import that should be replaced.
      * @param newImportName Import that should be inserted.
@@ -101,6 +102,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
         ]);
     }
     exports.replaceImport = replaceImport;
+    /**
+     * Removes a symbol from the named imports and updates a node
+     * that represents a given named imports.
+     *
+     * @param node Node that contains the imports.
+     * @param symbol Symbol that should be removed.
+     * @returns An updated node (ts.NamedImports).
+     */
+    function removeSymbolFromNamedImports(node, symbol) {
+        return typescript_1.default.factory.updateNamedImports(node, [
+            ...node.elements.filter(current => current !== symbol),
+        ]);
+    }
+    exports.removeSymbolFromNamedImports = removeSymbolFromNamedImports;
     /** Finds an import specifier with a particular name. */
     function findImportSpecifier(nodes, specifierName) {
         return nodes.find(element => {
@@ -110,4 +125,4 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     }
     exports.findImportSpecifier = findImportSpecifier;
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"imports.js","sourceRoot":"","sources":["../../../../../../../../packages/core/schematics/utils/typescript/imports.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 ts from 'typescript';\n\nexport type Import = {\n  name: string,\n  importModule: string,\n  node: ts.ImportDeclaration\n};\n\n/** Gets import information about the specified identifier by using the Type checker. */\nexport function getImportOfIdentifier(typeChecker: ts.TypeChecker, node: ts.Identifier): Import|\n    null {\n  const symbol = typeChecker.getSymbolAtLocation(node);\n\n  if (!symbol || symbol.declarations === undefined || !symbol.declarations.length) {\n    return null;\n  }\n\n  const decl = symbol.declarations[0];\n\n  if (!ts.isImportSpecifier(decl)) {\n    return null;\n  }\n\n  const importDecl = decl.parent.parent.parent;\n\n  if (!ts.isStringLiteral(importDecl.moduleSpecifier)) {\n    return null;\n  }\n\n  return {\n    // Handles aliased imports: e.g. \"import {Component as myComp} from ...\";\n    name: decl.propertyName ? decl.propertyName.text : decl.name.text,\n    importModule: importDecl.moduleSpecifier.text,\n    node: importDecl\n  };\n}\n\n\n/**\n * Gets a top-level import specifier with a specific name that is imported from a particular module.\n * E.g. given a file that looks like:\n *\n * ```\n * import { Component, Directive } from '@angular/core';\n * import { Foo } from './foo';\n * ```\n *\n * Calling `getImportSpecifier(sourceFile, '@angular/core', 'Directive')` will yield the node\n * referring to `Directive` in the top import.\n *\n * @param sourceFile File in which to look for imports.\n * @param moduleName Name of the import's module.\n * @param specifierName Original name of the specifier to look for. Aliases will be resolved to\n *    their original name.\n */\nexport function getImportSpecifier(\n    sourceFile: ts.SourceFile, moduleName: string, specifierName: string): ts.ImportSpecifier|null {\n  for (const node of sourceFile.statements) {\n    if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier) &&\n        node.moduleSpecifier.text === moduleName) {\n      const namedBindings = node.importClause && node.importClause.namedBindings;\n      if (namedBindings && ts.isNamedImports(namedBindings)) {\n        const match = findImportSpecifier(namedBindings.elements, specifierName);\n        if (match) {\n          return match;\n        }\n      }\n    }\n  }\n\n  return null;\n}\n\n\n/**\n * Replaces an import inside a named imports node with a different one.\n * @param node Node that contains the imports.\n * @param existingImport Import that should be replaced.\n * @param newImportName Import that should be inserted.\n */\nexport function replaceImport(\n    node: ts.NamedImports, existingImport: string, newImportName: string) {\n  const isAlreadyImported = findImportSpecifier(node.elements, newImportName);\n  if (isAlreadyImported) {\n    return node;\n  }\n\n  const existingImportNode = findImportSpecifier(node.elements, existingImport);\n  if (!existingImportNode) {\n    return node;\n  }\n\n  const importPropertyName =\n      existingImportNode.propertyName ? ts.factory.createIdentifier(newImportName) : undefined;\n  const importName = existingImportNode.propertyName ? existingImportNode.name :\n                                                       ts.factory.createIdentifier(newImportName);\n\n  return ts.factory.updateNamedImports(node, [\n    ...node.elements.filter(current => current !== existingImportNode),\n    // Create a new import while trying to preserve the alias of the old one.\n    ts.factory.createImportSpecifier(false, importPropertyName, importName)\n  ]);\n}\n\n\n/** Finds an import specifier with a particular name. */\nexport function findImportSpecifier(\n    nodes: ts.NodeArray<ts.ImportSpecifier>, specifierName: string): ts.ImportSpecifier|undefined {\n  return nodes.find(element => {\n    const {name, propertyName} = element;\n    return propertyName ? propertyName.text === specifierName : name.text === specifierName;\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"imports.js","sourceRoot":"","sources":["../../../../../../../../packages/core/schematics/utils/typescript/imports.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 ts from 'typescript';\n\nexport type Import = {\n  name: string,\n  importModule: string,\n  node: ts.ImportDeclaration\n};\n\n/** Gets import information about the specified identifier by using the Type checker. */\nexport function getImportOfIdentifier(typeChecker: ts.TypeChecker, node: ts.Identifier): Import|\n    null {\n  const symbol = typeChecker.getSymbolAtLocation(node);\n\n  if (!symbol || symbol.declarations === undefined || !symbol.declarations.length) {\n    return null;\n  }\n\n  const decl = symbol.declarations[0];\n\n  if (!ts.isImportSpecifier(decl)) {\n    return null;\n  }\n\n  const importDecl = decl.parent.parent.parent;\n\n  if (!ts.isStringLiteral(importDecl.moduleSpecifier)) {\n    return null;\n  }\n\n  return {\n    // Handles aliased imports: e.g. \"import {Component as myComp} from ...\";\n    name: decl.propertyName ? decl.propertyName.text : decl.name.text,\n    importModule: importDecl.moduleSpecifier.text,\n    node: importDecl\n  };\n}\n\n\n/**\n * Gets a top-level import specifier with a specific name that is imported from a particular module.\n * E.g. given a file that looks like:\n *\n * ```\n * import { Component, Directive } from '@angular/core';\n * import { Foo } from './foo';\n * ```\n *\n * Calling `getImportSpecifier(sourceFile, '@angular/core', 'Directive')` will yield the node\n * referring to `Directive` in the top import.\n *\n * @param sourceFile File in which to look for imports.\n * @param moduleName Name of the import's module.\n * @param specifierName Original name of the specifier to look for. Aliases will be resolved to\n *    their original name.\n */\nexport function getImportSpecifier(\n    sourceFile: ts.SourceFile, moduleName: string, specifierName: string): ts.ImportSpecifier|null {\n  for (const node of sourceFile.statements) {\n    if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier) &&\n        node.moduleSpecifier.text === moduleName) {\n      const namedBindings = node.importClause && node.importClause.namedBindings;\n      if (namedBindings && ts.isNamedImports(namedBindings)) {\n        const match = findImportSpecifier(namedBindings.elements, specifierName);\n        if (match) {\n          return match;\n        }\n      }\n    }\n  }\n\n  return null;\n}\n\n\n/**\n * Replaces an import inside a named imports node with a different one.\n *\n * @param node Node that contains the imports.\n * @param existingImport Import that should be replaced.\n * @param newImportName Import that should be inserted.\n */\nexport function replaceImport(\n    node: ts.NamedImports, existingImport: string, newImportName: string) {\n  const isAlreadyImported = findImportSpecifier(node.elements, newImportName);\n  if (isAlreadyImported) {\n    return node;\n  }\n\n  const existingImportNode = findImportSpecifier(node.elements, existingImport);\n  if (!existingImportNode) {\n    return node;\n  }\n\n  const importPropertyName =\n      existingImportNode.propertyName ? ts.factory.createIdentifier(newImportName) : undefined;\n  const importName = existingImportNode.propertyName ? existingImportNode.name :\n                                                       ts.factory.createIdentifier(newImportName);\n\n  return ts.factory.updateNamedImports(node, [\n    ...node.elements.filter(current => current !== existingImportNode),\n    // Create a new import while trying to preserve the alias of the old one.\n    ts.factory.createImportSpecifier(false, importPropertyName, importName)\n  ]);\n}\n\n/**\n * Removes a symbol from the named imports and updates a node\n * that represents a given named imports.\n *\n * @param node Node that contains the imports.\n * @param symbol Symbol that should be removed.\n * @returns An updated node (ts.NamedImports).\n */\nexport function removeSymbolFromNamedImports(node: ts.NamedImports, symbol: ts.ImportSpecifier) {\n  return ts.factory.updateNamedImports(node, [\n    ...node.elements.filter(current => current !== symbol),\n  ]);\n}\n\n/** Finds an import specifier with a particular name. */\nexport function findImportSpecifier(\n    nodes: ts.NodeArray<ts.ImportSpecifier>, specifierName: string): ts.ImportSpecifier|undefined {\n  return nodes.find(element => {\n    const {name, propertyName} = element;\n    return propertyName ? propertyName.text === specifierName : name.text === specifierName;\n  });\n}\n"]}

package/testing/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v15.0.0-next.4
+ * @license Angular v15.0.0-next.6
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */