@angular/core 12.1.1 → 12.1.2

package/schematics/migrations/renderer-to-renderer2/migration.mjs

@@ -1,211 +0,0 @@
-/**
- * @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 * as ts from 'typescript';
-/**
- * Migrates a function call expression from `Renderer` to `Renderer2`.
- * Returns null if the expression should be dropped.
- */
-export function migrateExpression(node, typeChecker) {
-    if (isPropertyAccessCallExpression(node)) {
-        switch (node.expression.name.getText()) {
-            case 'setElementProperty':
-                return { node: renameMethodCall(node, 'setProperty') };
-            case 'setText':
-                return { node: renameMethodCall(node, 'setValue') };
-            case 'listenGlobal':
-                return { node: renameMethodCall(node, 'listen') };
-            case 'selectRootElement':
-                return { node: migrateSelectRootElement(node) };
-            case 'setElementClass':
-                return { node: migrateSetElementClass(node) };
-            case 'setElementStyle':
-                return { node: migrateSetElementStyle(node, typeChecker) };
-            case 'invokeElementMethod':
-                return { node: migrateInvokeElementMethod(node) };
-            case 'setBindingDebugInfo':
-                return { node: null };
-            case 'createViewRoot':
-                return { node: migrateCreateViewRoot(node) };
-            case 'setElementAttribute':
-                return {
-                    node: switchToHelperCall(node, "__ngRendererSetElementAttributeHelper" /* setElementAttribute */, node.arguments),
-                    requiredHelpers: [
-                        "AnyDuringRendererMigration" /* any */, "__ngRendererSplitNamespaceHelper" /* splitNamespace */, "__ngRendererSetElementAttributeHelper" /* setElementAttribute */
-                    ]
-                };
-            case 'createElement':
-                return {
-                    node: switchToHelperCall(node, "__ngRendererCreateElementHelper" /* createElement */, node.arguments.slice(0, 2)),
-                    requiredHelpers: ["AnyDuringRendererMigration" /* any */, "__ngRendererSplitNamespaceHelper" /* splitNamespace */, "__ngRendererCreateElementHelper" /* createElement */]
-                };
-            case 'createText':
-                return {
-                    node: switchToHelperCall(node, "__ngRendererCreateTextHelper" /* createText */, node.arguments.slice(0, 2)),
-                    requiredHelpers: ["AnyDuringRendererMigration" /* any */, "__ngRendererCreateTextHelper" /* createText */]
-                };
-            case 'createTemplateAnchor':
-                return {
-                    node: switchToHelperCall(node, "__ngRendererCreateTemplateAnchorHelper" /* createTemplateAnchor */, node.arguments.slice(0, 1)),
-                    requiredHelpers: ["AnyDuringRendererMigration" /* any */, "__ngRendererCreateTemplateAnchorHelper" /* createTemplateAnchor */]
-                };
-            case 'projectNodes':
-                return {
-                    node: switchToHelperCall(node, "__ngRendererProjectNodesHelper" /* projectNodes */, node.arguments),
-                    requiredHelpers: ["AnyDuringRendererMigration" /* any */, "__ngRendererProjectNodesHelper" /* projectNodes */]
-                };
-            case 'animate':
-                return {
-                    node: migrateAnimateCall(),
-                    requiredHelpers: ["AnyDuringRendererMigration" /* any */, "__ngRendererAnimateHelper" /* animate */]
-                };
-            case 'destroyView':
-                return {
-                    node: switchToHelperCall(node, "__ngRendererDestroyViewHelper" /* destroyView */, [node.arguments[1]]),
-                    requiredHelpers: ["AnyDuringRendererMigration" /* any */, "__ngRendererDestroyViewHelper" /* destroyView */]
-                };
-            case 'detachView':
-                return {
-                    node: switchToHelperCall(node, "__ngRendererDetachViewHelper" /* detachView */, [node.arguments[0]]),
-                    requiredHelpers: ["AnyDuringRendererMigration" /* any */, "__ngRendererDetachViewHelper" /* detachView */]
-                };
-            case 'attachViewAfter':
-                return {
-                    node: switchToHelperCall(node, "__ngRendererAttachViewAfterHelper" /* attachViewAfter */, node.arguments),
-                    requiredHelpers: ["AnyDuringRendererMigration" /* any */, "__ngRendererAttachViewAfterHelper" /* attachViewAfter */]
-                };
-        }
-    }
-    return { node };
-}
-/** Checks whether a node is a PropertyAccessExpression. */
-function isPropertyAccessCallExpression(node) {
-    return ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression);
-}
-/** Renames a method call while keeping all of the parameters in place. */
-function renameMethodCall(node, newName) {
-    const newExpression = ts.updatePropertyAccess(node.expression, node.expression.expression, ts.createIdentifier(newName));
-    return ts.updateCall(node, newExpression, node.typeArguments, node.arguments);
-}
-/**
- * Migrates a `selectRootElement` call by removing the last argument which is no longer supported.
- */
-function migrateSelectRootElement(node) {
-    // The only thing we need to do is to drop the last argument
-    // (`debugInfo`), if the consumer was passing it in.
-    if (node.arguments.length > 1) {
-        return ts.updateCall(node, node.expression, node.typeArguments, [node.arguments[0]]);
-    }
-    return node;
-}
-/**
- * Migrates a call to `setElementClass` either to a call to `addClass` or `removeClass`, or
- * to an expression like `isAdd ? addClass(el, className) : removeClass(el, className)`.
- */
-function migrateSetElementClass(node) {
-    // Clone so we don't mutate by accident. Note that we assume that
-    // the user's code is providing all three required arguments.
-    const outputMethodArgs = node.arguments.slice();
-    const isAddArgument = outputMethodArgs.pop();
-    const createRendererCall = (isAdd) => {
-        const innerExpression = node.expression.expression;
-        const topExpression = ts.createPropertyAccess(innerExpression, isAdd ? 'addClass' : 'removeClass');
-        return ts.createCall(topExpression, [], node.arguments.slice(0, 2));
-    };
-    // If the call has the `isAdd` argument as a literal boolean, we can map it directly to
-    // `addClass` or `removeClass`. Note that we can't use the type checker here, because it
-    // won't tell us whether the value resolves to true or false.
-    if (isAddArgument.kind === ts.SyntaxKind.TrueKeyword ||
-        isAddArgument.kind === ts.SyntaxKind.FalseKeyword) {
-        return createRendererCall(isAddArgument.kind === ts.SyntaxKind.TrueKeyword);
-    }
-    // Otherwise create a ternary on the variable.
-    return ts.createConditional(isAddArgument, createRendererCall(true), createRendererCall(false));
-}
-/**
- * Migrates a call to `setElementStyle` call either to a call to
- * `setStyle` or `removeStyle`. or to an expression like
- * `value == null ? removeStyle(el, key) : setStyle(el, key, value)`.
- */
-function migrateSetElementStyle(node, typeChecker) {
-    const args = node.arguments;
-    const addMethodName = 'setStyle';
-    const removeMethodName = 'removeStyle';
-    const lastArgType = args[2] ?
-        typeChecker.typeToString(typeChecker.getTypeAtLocation(args[2]), node, ts.TypeFormatFlags.AddUndefined) :
-        null;
-    // Note that for a literal null, TS considers it a `NullKeyword`,
-    // whereas a literal `undefined` is just an Identifier.
-    if (args.length === 2 || lastArgType === 'null' || lastArgType === 'undefined') {
-        // If we've got a call with two arguments, or one with three arguments where the last one is
-        // `undefined` or `null`, we can safely switch to a `removeStyle` call.
-        const innerExpression = node.expression.expression;
-        const topExpression = ts.createPropertyAccess(innerExpression, removeMethodName);
-        return ts.createCall(topExpression, [], args.slice(0, 2));
-    }
-    else if (args.length === 3) {
-        // We need the checks for string literals, because the type of something
-        // like `"blue"` is the literal `blue`, not `string`.
-        if (lastArgType === 'string' || lastArgType === 'number' || ts.isStringLiteral(args[2]) ||
-            ts.isNoSubstitutionTemplateLiteral(args[2]) || ts.isNumericLiteral(args[2])) {
-            // If we've got three arguments and the last one is a string literal or a number, we
-            // can safely rename to `setStyle`.
-            return renameMethodCall(node, addMethodName);
-        }
-        else {
-            // Otherwise migrate to a ternary that looks like:
-            // `value == null ? removeStyle(el, key) : setStyle(el, key, value)`
-            const condition = ts.createBinary(args[2], ts.SyntaxKind.EqualsEqualsToken, ts.createNull());
-            const whenNullCall = renameMethodCall(ts.createCall(node.expression, [], args.slice(0, 2)), removeMethodName);
-            return ts.createConditional(condition, whenNullCall, renameMethodCall(node, addMethodName));
-        }
-    }
-    return node;
-}
-/**
- * Migrates a call to `invokeElementMethod(target, method, [arg1, arg2])` either to
- * `target.method(arg1, arg2)` or `(target as any)[method].apply(target, [arg1, arg2])`.
- */
-function migrateInvokeElementMethod(node) {
-    const [target, name, args] = node.arguments;
-    const isNameStatic = ts.isStringLiteral(name) || ts.isNoSubstitutionTemplateLiteral(name);
-    const isArgsStatic = !args || ts.isArrayLiteralExpression(args);
-    if (isNameStatic && isArgsStatic) {
-        // If the name is a static string and the arguments are an array literal,
-        // we can safely convert the node into a call expression.
-        const expression = ts.createPropertyAccess(target, name.text);
-        const callArguments = args ? args.elements : [];
-        return ts.createCall(expression, [], callArguments);
-    }
-    else {
-        // Otherwise create an expression in the form of `(target as any)[name].apply(target, args)`.
-        const asExpression = ts.createParen(ts.createAsExpression(target, ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)));
-        const elementAccess = ts.createElementAccess(asExpression, name);
-        const applyExpression = ts.createPropertyAccess(elementAccess, 'apply');
-        return ts.createCall(applyExpression, [], args ? [target, args] : [target]);
-    }
-}
-/** Migrates a call to `createViewRoot` to whatever node was passed in as the first argument. */
-function migrateCreateViewRoot(node) {
-    return node.arguments[0];
-}
-/** Migrates a call to `migrate` a direct call to the helper. */
-function migrateAnimateCall() {
-    return ts.createCall(ts.createIdentifier("__ngRendererAnimateHelper" /* animate */), [], []);
-}
-/**
- * Switches out a call to the `Renderer` to a call to one of our helper functions.
- * Most of the helpers accept an instance of `Renderer2` as the first argument and all
- * subsequent arguments differ.
- * @param node Node of the original method call.
- * @param helper Name of the helper with which to replace the original call.
- * @param args Arguments that should be passed into the helper after the renderer argument.
- */
-function switchToHelperCall(node, helper, args) {
-    return ts.createCall(ts.createIdentifier(helper), [], [node.expression.expression, ...args]);
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"migration.js","sourceRoot":"","sources":["../../../../../../../../packages/core/schematics/migrations/renderer-to-renderer2/migration.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 * as ts from 'typescript';\n\nimport {HelperFunction} from './helpers';\n\n/** A call expression that is based on a property access. */\ntype PropertyAccessCallExpression = ts.CallExpression&{expression: ts.PropertyAccessExpression};\n\n/**\n * Migrates a function call expression from `Renderer` to `Renderer2`.\n * Returns null if the expression should be dropped.\n */\nexport function migrateExpression(node: ts.CallExpression, typeChecker: ts.TypeChecker):\n    {node: ts.Node|null, requiredHelpers?: HelperFunction[]} {\n  if (isPropertyAccessCallExpression(node)) {\n    switch (node.expression.name.getText()) {\n      case 'setElementProperty':\n        return {node: renameMethodCall(node, 'setProperty')};\n      case 'setText':\n        return {node: renameMethodCall(node, 'setValue')};\n      case 'listenGlobal':\n        return {node: renameMethodCall(node, 'listen')};\n      case 'selectRootElement':\n        return {node: migrateSelectRootElement(node)};\n      case 'setElementClass':\n        return {node: migrateSetElementClass(node)};\n      case 'setElementStyle':\n        return {node: migrateSetElementStyle(node, typeChecker)};\n      case 'invokeElementMethod':\n        return {node: migrateInvokeElementMethod(node)};\n      case 'setBindingDebugInfo':\n        return {node: null};\n      case 'createViewRoot':\n        return {node: migrateCreateViewRoot(node)};\n      case 'setElementAttribute':\n        return {\n          node: switchToHelperCall(node, HelperFunction.setElementAttribute, node.arguments),\n          requiredHelpers: [\n            HelperFunction.any, HelperFunction.splitNamespace, HelperFunction.setElementAttribute\n          ]\n        };\n      case 'createElement':\n        return {\n          node: switchToHelperCall(node, HelperFunction.createElement, node.arguments.slice(0, 2)),\n          requiredHelpers:\n              [HelperFunction.any, HelperFunction.splitNamespace, HelperFunction.createElement]\n        };\n      case 'createText':\n        return {\n          node: switchToHelperCall(node, HelperFunction.createText, node.arguments.slice(0, 2)),\n          requiredHelpers: [HelperFunction.any, HelperFunction.createText]\n        };\n      case 'createTemplateAnchor':\n        return {\n          node: switchToHelperCall(\n              node, HelperFunction.createTemplateAnchor, node.arguments.slice(0, 1)),\n          requiredHelpers: [HelperFunction.any, HelperFunction.createTemplateAnchor]\n        };\n      case 'projectNodes':\n        return {\n          node: switchToHelperCall(node, HelperFunction.projectNodes, node.arguments),\n          requiredHelpers: [HelperFunction.any, HelperFunction.projectNodes]\n        };\n      case 'animate':\n        return {\n          node: migrateAnimateCall(),\n          requiredHelpers: [HelperFunction.any, HelperFunction.animate]\n        };\n      case 'destroyView':\n        return {\n          node: switchToHelperCall(node, HelperFunction.destroyView, [node.arguments[1]]),\n          requiredHelpers: [HelperFunction.any, HelperFunction.destroyView]\n        };\n      case 'detachView':\n        return {\n          node: switchToHelperCall(node, HelperFunction.detachView, [node.arguments[0]]),\n          requiredHelpers: [HelperFunction.any, HelperFunction.detachView]\n        };\n      case 'attachViewAfter':\n        return {\n          node: switchToHelperCall(node, HelperFunction.attachViewAfter, node.arguments),\n          requiredHelpers: [HelperFunction.any, HelperFunction.attachViewAfter]\n        };\n    }\n  }\n\n  return {node};\n}\n\n/** Checks whether a node is a PropertyAccessExpression. */\nfunction isPropertyAccessCallExpression(node: ts.Node): node is PropertyAccessCallExpression {\n  return ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression);\n}\n\n/** Renames a method call while keeping all of the parameters in place. */\nfunction renameMethodCall(node: PropertyAccessCallExpression, newName: string): ts.CallExpression {\n  const newExpression = ts.updatePropertyAccess(\n      node.expression, node.expression.expression, ts.createIdentifier(newName));\n\n  return ts.updateCall(node, newExpression, node.typeArguments, node.arguments);\n}\n\n/**\n * Migrates a `selectRootElement` call by removing the last argument which is no longer supported.\n */\nfunction migrateSelectRootElement(node: ts.CallExpression): ts.Node {\n  // The only thing we need to do is to drop the last argument\n  // (`debugInfo`), if the consumer was passing it in.\n  if (node.arguments.length > 1) {\n    return ts.updateCall(node, node.expression, node.typeArguments, [node.arguments[0]]);\n  }\n\n  return node;\n}\n\n/**\n * Migrates a call to `setElementClass` either to a call to `addClass` or `removeClass`, or\n * to an expression like `isAdd ? addClass(el, className) : removeClass(el, className)`.\n */\nfunction migrateSetElementClass(node: PropertyAccessCallExpression): ts.Node {\n  // Clone so we don't mutate by accident. Note that we assume that\n  // the user's code is providing all three required arguments.\n  const outputMethodArgs = node.arguments.slice();\n  const isAddArgument = outputMethodArgs.pop()!;\n  const createRendererCall = (isAdd: boolean) => {\n    const innerExpression = node.expression.expression;\n    const topExpression =\n        ts.createPropertyAccess(innerExpression, isAdd ? 'addClass' : 'removeClass');\n    return ts.createCall(topExpression, [], node.arguments.slice(0, 2));\n  };\n\n  // If the call has the `isAdd` argument as a literal boolean, we can map it directly to\n  // `addClass` or `removeClass`. Note that we can't use the type checker here, because it\n  // won't tell us whether the value resolves to true or false.\n  if (isAddArgument.kind === ts.SyntaxKind.TrueKeyword ||\n      isAddArgument.kind === ts.SyntaxKind.FalseKeyword) {\n    return createRendererCall(isAddArgument.kind === ts.SyntaxKind.TrueKeyword);\n  }\n\n  // Otherwise create a ternary on the variable.\n  return ts.createConditional(isAddArgument, createRendererCall(true), createRendererCall(false));\n}\n\n/**\n * Migrates a call to `setElementStyle` call either to a call to\n * `setStyle` or `removeStyle`. or to an expression like\n * `value == null ? removeStyle(el, key) : setStyle(el, key, value)`.\n */\nfunction migrateSetElementStyle(\n    node: PropertyAccessCallExpression, typeChecker: ts.TypeChecker): ts.Node {\n  const args = node.arguments;\n  const addMethodName = 'setStyle';\n  const removeMethodName = 'removeStyle';\n  const lastArgType = args[2] ?\n      typeChecker.typeToString(\n          typeChecker.getTypeAtLocation(args[2]), node, ts.TypeFormatFlags.AddUndefined) :\n      null;\n\n  // Note that for a literal null, TS considers it a `NullKeyword`,\n  // whereas a literal `undefined` is just an Identifier.\n  if (args.length === 2 || lastArgType === 'null' || lastArgType === 'undefined') {\n    // If we've got a call with two arguments, or one with three arguments where the last one is\n    // `undefined` or `null`, we can safely switch to a `removeStyle` call.\n    const innerExpression = node.expression.expression;\n    const topExpression = ts.createPropertyAccess(innerExpression, removeMethodName);\n    return ts.createCall(topExpression, [], args.slice(0, 2));\n  } else if (args.length === 3) {\n    // We need the checks for string literals, because the type of something\n    // like `\"blue\"` is the literal `blue`, not `string`.\n    if (lastArgType === 'string' || lastArgType === 'number' || ts.isStringLiteral(args[2]) ||\n        ts.isNoSubstitutionTemplateLiteral(args[2]) || ts.isNumericLiteral(args[2])) {\n      // If we've got three arguments and the last one is a string literal or a number, we\n      // can safely rename to `setStyle`.\n      return renameMethodCall(node, addMethodName);\n    } else {\n      // Otherwise migrate to a ternary that looks like:\n      // `value == null ? removeStyle(el, key) : setStyle(el, key, value)`\n      const condition = ts.createBinary(args[2], ts.SyntaxKind.EqualsEqualsToken, ts.createNull());\n      const whenNullCall = renameMethodCall(\n          ts.createCall(node.expression, [], args.slice(0, 2)) as PropertyAccessCallExpression,\n          removeMethodName);\n      return ts.createConditional(condition, whenNullCall, renameMethodCall(node, addMethodName));\n    }\n  }\n\n  return node;\n}\n\n/**\n * Migrates a call to `invokeElementMethod(target, method, [arg1, arg2])` either to\n * `target.method(arg1, arg2)` or `(target as any)[method].apply(target, [arg1, arg2])`.\n */\nfunction migrateInvokeElementMethod(node: ts.CallExpression): ts.Node {\n  const [target, name, args] = node.arguments;\n  const isNameStatic = ts.isStringLiteral(name) || ts.isNoSubstitutionTemplateLiteral(name);\n  const isArgsStatic = !args || ts.isArrayLiteralExpression(args);\n\n  if (isNameStatic && isArgsStatic) {\n    // If the name is a static string and the arguments are an array literal,\n    // we can safely convert the node into a call expression.\n    const expression = ts.createPropertyAccess(\n        target, (name as ts.StringLiteral | ts.NoSubstitutionTemplateLiteral).text);\n    const callArguments = args ? (args as ts.ArrayLiteralExpression).elements : [];\n    return ts.createCall(expression, [], callArguments);\n  } else {\n    // Otherwise create an expression in the form of `(target as any)[name].apply(target, args)`.\n    const asExpression = ts.createParen(\n        ts.createAsExpression(target, ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)));\n    const elementAccess = ts.createElementAccess(asExpression, name);\n    const applyExpression = ts.createPropertyAccess(elementAccess, 'apply');\n    return ts.createCall(applyExpression, [], args ? [target, args] : [target]);\n  }\n}\n\n/** Migrates a call to `createViewRoot` to whatever node was passed in as the first argument. */\nfunction migrateCreateViewRoot(node: ts.CallExpression): ts.Node {\n  return node.arguments[0];\n}\n\n/** Migrates a call to `migrate` a direct call to the helper. */\nfunction migrateAnimateCall() {\n  return ts.createCall(ts.createIdentifier(HelperFunction.animate), [], []);\n}\n\n/**\n * Switches out a call to the `Renderer` to a call to one of our helper functions.\n * Most of the helpers accept an instance of `Renderer2` as the first argument and all\n * subsequent arguments differ.\n * @param node Node of the original method call.\n * @param helper Name of the helper with which to replace the original call.\n * @param args Arguments that should be passed into the helper after the renderer argument.\n */\nfunction switchToHelperCall(\n    node: PropertyAccessCallExpression, helper: HelperFunction,\n    args: ts.Expression[]|ts.NodeArray<ts.Expression>): ts.Node {\n  return ts.createCall(ts.createIdentifier(helper), [], [node.expression.expression, ...args]);\n}\n"]}

package/schematics/migrations/renderer-to-renderer2/util.mjs

@@ -1,69 +0,0 @@
-/**
- * @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 * as ts from 'typescript';
-import { getImportSpecifier } from '../../utils/typescript/imports';
-import { isReferenceToImport } from '../../utils/typescript/symbol';
-/**
- * Finds typed nodes (e.g. function parameters or class properties) that are referencing the old
- * `Renderer`, as well as calls to the `Renderer` methods.
- */
-export function findRendererReferences(sourceFile, typeChecker, rendererImportSpecifier) {
-    const typedNodes = new Set();
-    const methodCalls = new Set();
-    const forwardRefs = new Set();
-    const forwardRefSpecifier = getImportSpecifier(sourceFile, '@angular/core', 'forwardRef');
-    ts.forEachChild(sourceFile, function visitNode(node) {
-        if ((ts.isParameter(node) || ts.isPropertyDeclaration(node)) &&
-            isReferenceToImport(typeChecker, node.name, rendererImportSpecifier)) {
-            typedNodes.add(node);
-        }
-        else if (ts.isAsExpression(node) &&
-            isReferenceToImport(typeChecker, node.type, rendererImportSpecifier)) {
-            typedNodes.add(node);
-        }
-        else if (ts.isCallExpression(node)) {
-            if (ts.isPropertyAccessExpression(node.expression) &&
-                isReferenceToImport(typeChecker, node.expression.expression, rendererImportSpecifier)) {
-                methodCalls.add(node);
-            }
-            else if (
-            // If we're dealing with a forwardRef that's returning a Renderer.
-            forwardRefSpecifier && ts.isIdentifier(node.expression) &&
-                isReferenceToImport(typeChecker, node.expression, forwardRefSpecifier) &&
-                node.arguments.length) {
-                const rendererIdentifier = findRendererIdentifierInForwardRef(typeChecker, node, rendererImportSpecifier);
-                if (rendererIdentifier) {
-                    forwardRefs.add(rendererIdentifier);
-                }
-            }
-        }
-        ts.forEachChild(node, visitNode);
-    });
-    return { typedNodes, methodCalls, forwardRefs };
-}
-/** Finds the identifier referring to the `Renderer` inside a `forwardRef` call expression. */
-function findRendererIdentifierInForwardRef(typeChecker, node, rendererImport) {
-    const firstArg = node.arguments[0];
-    if (ts.isArrowFunction(firstArg) && rendererImport) {
-        // Check if the function is `forwardRef(() => Renderer)`.
-        if (ts.isIdentifier(firstArg.body) &&
-            isReferenceToImport(typeChecker, firstArg.body, rendererImport)) {
-            return firstArg.body;
-        }
-        else if (ts.isBlock(firstArg.body) && ts.isReturnStatement(firstArg.body.statements[0])) {
-            // Otherwise check if the expression is `forwardRef(() => { return Renderer })`.
-            const returnStatement = firstArg.body.statements[0];
-            if (returnStatement.expression && ts.isIdentifier(returnStatement.expression) &&
-                isReferenceToImport(typeChecker, returnStatement.expression, rendererImport)) {
-                return returnStatement.expression;
-            }
-        }
-    }
-    return null;
-}
-//# sourceMappingURL=data:application/json;base64,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

package/schematics/migrations/router-preserve-query-params/index.mjs

@@ -1,50 +0,0 @@
-/**
- * @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 { SchematicsException } from '@angular-devkit/schematics';
-import { relative } from 'path';
-import * as ts from 'typescript';
-import { getProjectTsConfigPaths } from '../../utils/project_tsconfig_paths';
-import { canMigrateFile, createMigrationProgram } from '../../utils/typescript/compiler_host';
-import { findLiteralsToMigrate, migrateLiteral } from './util';
-/**
- * Migration that switches `NavigationExtras.preserveQueryParams` to set the coresponding value via
- * `NavigationExtras`'s `queryParamsHandling` attribute.
- */
-export default function () {
-    return (tree) => {
-        const { buildPaths, testPaths } = getProjectTsConfigPaths(tree);
-        const basePath = process.cwd();
-        const allPaths = [...buildPaths, ...testPaths];
-        if (!allPaths.length) {
-            throw new SchematicsException('Could not find any tsconfig file. Cannot migrate ' +
-                'NavigationExtras.preserveQueryParams usages.');
-        }
-        for (const tsconfigPath of allPaths) {
-            runPreserveQueryParamsMigration(tree, tsconfigPath, basePath);
-        }
-    };
-}
-function runPreserveQueryParamsMigration(tree, tsconfigPath, basePath) {
-    const { program } = createMigrationProgram(tree, tsconfigPath, basePath);
-    const typeChecker = program.getTypeChecker();
-    const printer = ts.createPrinter();
-    const sourceFiles = program.getSourceFiles().filter(sourceFile => canMigrateFile(basePath, sourceFile, program));
-    sourceFiles.forEach(sourceFile => {
-        const literalsToMigrate = findLiteralsToMigrate(sourceFile, typeChecker);
-        const update = tree.beginUpdate(relative(basePath, sourceFile.fileName));
-        literalsToMigrate.forEach((instances, methodName) => instances.forEach(instance => {
-            const migratedNode = migrateLiteral(methodName, instance);
-            if (migratedNode !== instance) {
-                update.remove(instance.getStart(), instance.getWidth());
-                update.insertRight(instance.getStart(), printer.printNode(ts.EmitHint.Unspecified, migratedNode, sourceFile));
-            }
-        }));
-        tree.commitUpdate(update);
-    });
-}
-//# sourceMappingURL=data:application/json;base64,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

package/schematics/migrations/router-preserve-query-params/util.mjs

@@ -1,88 +0,0 @@
-/**
- * @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 * as ts from 'typescript';
-import { getImportSpecifier } from '../../utils/typescript/imports';
-import { isReferenceToImport } from '../../utils/typescript/symbol';
-/**
- * Configures the methods that the migration should be looking for
- * and the properties from `NavigationExtras` that should be preserved.
- */
-const methodConfig = new Set(['navigate', 'createUrlTree']);
-const preserveQueryParamsKey = 'preserveQueryParams';
-export function migrateLiteral(methodName, node) {
-    var _a;
-    const isMigratableMethod = methodConfig.has(methodName);
-    if (!isMigratableMethod) {
-        throw Error(`Attempting to migrate unconfigured method called ${methodName}.`);
-    }
-    const propertiesToKeep = [];
-    let propertyToMigrate = undefined;
-    for (const property of node.properties) {
-        // Only look for regular and shorthand property assignments since resolving things
-        // like spread operators becomes too complicated for this migration.
-        if ((ts.isPropertyAssignment(property) || ts.isShorthandPropertyAssignment(property)) &&
-            (ts.isStringLiteralLike(property.name) || ts.isNumericLiteral(property.name) ||
-                ts.isIdentifier(property.name)) &&
-            (property.name.text === preserveQueryParamsKey)) {
-            propertyToMigrate = property;
-            continue;
-        }
-        propertiesToKeep.push(property);
-    }
-    // Don't modify the node if there's nothing to migrate.
-    if (propertyToMigrate === undefined) {
-        return node;
-    }
-    if ((ts.isShorthandPropertyAssignment(propertyToMigrate) &&
-        ((_a = propertyToMigrate.objectAssignmentInitializer) === null || _a === void 0 ? void 0 : _a.kind) === ts.SyntaxKind.TrueKeyword) ||
-        (ts.isPropertyAssignment(propertyToMigrate) &&
-            propertyToMigrate.initializer.kind === ts.SyntaxKind.TrueKeyword)) {
-        return ts.updateObjectLiteral(node, propertiesToKeep.concat(ts.createPropertyAssignment('queryParamsHandling', ts.createIdentifier(`'preserve'`))));
-    }
-    return ts.updateObjectLiteral(node, propertiesToKeep);
-}
-export function findLiteralsToMigrate(sourceFile, typeChecker) {
-    const results = new Map(Array.from(methodConfig.keys(), key => [key, new Set()]));
-    const routerImport = getImportSpecifier(sourceFile, '@angular/router', 'Router');
-    const seenLiterals = new Map();
-    if (routerImport) {
-        sourceFile.forEachChild(function visitNode(node) {
-            var _a;
-            // Look for calls that look like `foo.<method to migrate>` with more than one parameter.
-            if (ts.isCallExpression(node) && node.arguments.length > 1 &&
-                ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) &&
-                methodConfig.has(node.expression.name.text)) {
-                // Check whether the type of the object on which the
-                // function is called refers to the Router import.
-                if (isReferenceToImport(typeChecker, node.expression.expression, routerImport)) {
-                    const methodName = node.expression.name.text;
-                    const parameterDeclaration = (_a = typeChecker.getTypeAtLocation(node.arguments[1]).getSymbol()) === null || _a === void 0 ? void 0 : _a.valueDeclaration;
-                    // Find the source of the object literal.
-                    if (parameterDeclaration && ts.isObjectLiteralExpression(parameterDeclaration)) {
-                        if (!seenLiterals.has(parameterDeclaration)) {
-                            results.get(methodName).add(parameterDeclaration);
-                            seenLiterals.set(parameterDeclaration, methodName);
-                            // If the same literal has been passed into multiple different methods, we can't
-                            // migrate it, because the supported properties are different. When we detect such
-                            // a case, we drop it from the results so that it gets ignored. If it's used multiple
-                            // times for the same method, it can still be migrated.
-                        }
-                        else if (seenLiterals.get(parameterDeclaration) !== methodName) {
-                            results.forEach(literals => literals.delete(parameterDeclaration));
-                        }
-                    }
-                }
-            }
-            else {
-                node.forEachChild(visitNode);
-            }
-        });
-    }
-    return results;
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../../../../../../packages/core/schematics/migrations/router-preserve-query-params/util.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,EAAC,kBAAkB,EAAC,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAC,mBAAmB,EAAC,MAAM,+BAA+B,CAAC;AAElE;;;GAGG;AACH,MAAM,YAAY,GAAG,IAAI,GAAG,CAAS,CAAC,UAAU,EAAE,eAAe,CAAC,CAAC,CAAC;AAEpE,MAAM,sBAAsB,GAAG,qBAAqB,CAAC;AAErD,MAAM,UAAU,cAAc,CAC1B,UAAkB,EAAE,IAAgC;;IACtD,MAAM,kBAAkB,GAAG,YAAY,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IAExD,IAAI,CAAC,kBAAkB,EAAE;QACvB,MAAM,KAAK,CAAC,oDAAoD,UAAU,GAAG,CAAC,CAAC;KAChF;IAGD,MAAM,gBAAgB,GAAkC,EAAE,CAAC;IAC3D,IAAI,iBAAiB,GAAmE,SAAS,CAAC;IAElG,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,UAAU,EAAE;QACtC,kFAAkF;QAClF,oEAAoE;QACpE,IAAI,CAAC,EAAE,CAAC,oBAAoB,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,6BAA6B,CAAC,QAAQ,CAAC,CAAC;YACjF,CAAC,EAAE,CAAC,mBAAmB,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,gBAAgB,CAAC,QAAQ,CAAC,IAAI,CAAC;gBAC3E,EAAE,CAAC,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;YAChC,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,KAAK,sBAAsB,CAAC,EAAE;YACnD,iBAAiB,GAAG,QAAQ,CAAC;YAC7B,SAAS;SACV;QACD,gBAAgB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;KACjC;IAED,uDAAuD;IACvD,IAAI,iBAAiB,KAAK,SAAS,EAAE;QACnC,OAAO,IAAI,CAAC;KACb;IAED,IAAI,CAAC,EAAE,CAAC,6BAA6B,CAAC,iBAAiB,CAAC;QACnD,CAAA,MAAA,iBAAiB,CAAC,2BAA2B,0CAAE,IAAI,MAAK,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC;QACnF,CAAC,EAAE,CAAC,oBAAoB,CAAC,iBAAiB,CAAC;YAC1C,iBAAiB,CAAC,WAAW,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC,EAAE;QACtE,OAAO,EAAE,CAAC,mBAAmB,CACzB,IAAI,EACJ,gBAAgB,CAAC,MAAM,CACnB,EAAE,CAAC,wBAAwB,CAAC,qBAAqB,EAAE,EAAE,CAAC,gBAAgB,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;KACjG;IAED,OAAO,EAAE,CAAC,mBAAmB,CAAC,IAAI,EAAE,gBAAgB,CAAC,CAAC;AACxD,CAAC;AAED,MAAM,UAAU,qBAAqB,CAAC,UAAyB,EAAE,WAA2B;IAC1F,MAAM,OAAO,GAAG,IAAI,GAAG,CACnB,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,IAAI,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;IAC9D,MAAM,YAAY,GAAG,kBAAkB,CAAC,UAAU,EAAE,iBAAiB,EAAE,QAAQ,CAAC,CAAC;IACjF,MAAM,YAAY,GAAG,IAAI,GAAG,EAAsC,CAAC;IAEnE,IAAI,YAAY,EAAE;QAChB,UAAU,CAAC,YAAY,CAAC,SAAS,SAAS,CAAC,IAAa;;YACtD,wFAAwF;YACxF,IAAI,EAAE,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC;gBACtD,EAAE,CAAC,0BAA0B,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;gBACvF,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;gBAC/C,oDAAoD;gBACpD,kDAAkD;gBAClD,IAAI,mBAAmB,CAAC,WAAW,EAAE,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,YAAY,CAAC,EAAE;oBAC9E,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC;oBAC7C,MAAM,oBAAoB,GACtB,MAAA,WAAW,CAAC,iBAAiB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,EAAE,0CAAE,gBAAgB,CAAC;oBAEnF,yCAAyC;oBACzC,IAAI,oBAAoB,IAAI,EAAE,CAAC,yBAAyB,CAAC,oBAAoB,CAAC,EAAE;wBAC9E,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,oBAAoB,CAAC,EAAE;4BAC3C,OAAO,CAAC,GAAG,CAAC,UAAU,CAAE,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;4BACnD,YAAY,CAAC,GAAG,CAAC,oBAAoB,EAAE,UAAU,CAAC,CAAC;4BACnD,gFAAgF;4BAChF,kFAAkF;4BAClF,qFAAqF;4BACrF,uDAAuD;yBACxD;6BAAM,IAAI,YAAY,CAAC,GAAG,CAAC,oBAAoB,CAAC,KAAK,UAAU,EAAE;4BAChE,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC,CAAC;yBACpE;qBACF;iBACF;aACF;iBAAM;gBACL,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;aAC9B;QACH,CAAC,CAAC,CAAC;KACJ;IAED,OAAO,OAAO,CAAC;AACjB,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport * as ts from 'typescript';\n\nimport {getImportSpecifier} from '../../utils/typescript/imports';\nimport {isReferenceToImport} from '../../utils/typescript/symbol';\n\n/**\n * Configures the methods that the migration should be looking for\n * and the properties from `NavigationExtras` that should be preserved.\n */\nconst methodConfig = new Set<string>(['navigate', 'createUrlTree']);\n\nconst preserveQueryParamsKey = 'preserveQueryParams';\n\nexport function migrateLiteral(\n    methodName: string, node: ts.ObjectLiteralExpression): ts.ObjectLiteralExpression {\n  const isMigratableMethod = methodConfig.has(methodName);\n\n  if (!isMigratableMethod) {\n    throw Error(`Attempting to migrate unconfigured method called ${methodName}.`);\n  }\n\n\n  const propertiesToKeep: ts.ObjectLiteralElementLike[] = [];\n  let propertyToMigrate: ts.PropertyAssignment|ts.ShorthandPropertyAssignment|undefined = undefined;\n\n  for (const property of node.properties) {\n    // Only look for regular and shorthand property assignments since resolving things\n    // like spread operators becomes too complicated for this migration.\n    if ((ts.isPropertyAssignment(property) || ts.isShorthandPropertyAssignment(property)) &&\n        (ts.isStringLiteralLike(property.name) || ts.isNumericLiteral(property.name) ||\n         ts.isIdentifier(property.name)) &&\n        (property.name.text === preserveQueryParamsKey)) {\n      propertyToMigrate = property;\n      continue;\n    }\n    propertiesToKeep.push(property);\n  }\n\n  // Don't modify the node if there's nothing to migrate.\n  if (propertyToMigrate === undefined) {\n    return node;\n  }\n\n  if ((ts.isShorthandPropertyAssignment(propertyToMigrate) &&\n       propertyToMigrate.objectAssignmentInitializer?.kind === ts.SyntaxKind.TrueKeyword) ||\n      (ts.isPropertyAssignment(propertyToMigrate) &&\n       propertyToMigrate.initializer.kind === ts.SyntaxKind.TrueKeyword)) {\n    return ts.updateObjectLiteral(\n        node,\n        propertiesToKeep.concat(\n            ts.createPropertyAssignment('queryParamsHandling', ts.createIdentifier(`'preserve'`))));\n  }\n\n  return ts.updateObjectLiteral(node, propertiesToKeep);\n}\n\nexport function findLiteralsToMigrate(sourceFile: ts.SourceFile, typeChecker: ts.TypeChecker) {\n  const results = new Map<string, Set<ts.ObjectLiteralExpression>>(\n      Array.from(methodConfig.keys(), key => [key, new Set()]));\n  const routerImport = getImportSpecifier(sourceFile, '@angular/router', 'Router');\n  const seenLiterals = new Map<ts.ObjectLiteralExpression, string>();\n\n  if (routerImport) {\n    sourceFile.forEachChild(function visitNode(node: ts.Node) {\n      // Look for calls that look like `foo.<method to migrate>` with more than one parameter.\n      if (ts.isCallExpression(node) && node.arguments.length > 1 &&\n          ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) &&\n          methodConfig.has(node.expression.name.text)) {\n        // Check whether the type of the object on which the\n        // function is called refers to the Router import.\n        if (isReferenceToImport(typeChecker, node.expression.expression, routerImport)) {\n          const methodName = node.expression.name.text;\n          const parameterDeclaration =\n              typeChecker.getTypeAtLocation(node.arguments[1]).getSymbol()?.valueDeclaration;\n\n          // Find the source of the object literal.\n          if (parameterDeclaration && ts.isObjectLiteralExpression(parameterDeclaration)) {\n            if (!seenLiterals.has(parameterDeclaration)) {\n              results.get(methodName)!.add(parameterDeclaration);\n              seenLiterals.set(parameterDeclaration, methodName);\n              // If the same literal has been passed into multiple different methods, we can't\n              // migrate it, because the supported properties are different. When we detect such\n              // a case, we drop it from the results so that it gets ignored. If it's used multiple\n              // times for the same method, it can still be migrated.\n            } else if (seenLiterals.get(parameterDeclaration) !== methodName) {\n              results.forEach(literals => literals.delete(parameterDeclaration));\n            }\n          }\n        }\n      } else {\n        node.forEachChild(visitNode);\n      }\n    });\n  }\n\n  return results;\n}\n"]}

package/schematics/migrations/static-queries/angular/directive_inputs.mjs

@@ -1,70 +0,0 @@
-/**
- * @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 * as ts from 'typescript';
-import { getAngularDecorators } from '../../../utils/ng_decorators';
-import { getPropertyNameText, hasPropertyNameText } from '../../../utils/typescript/property_name';
-/** Analyzes the given class and resolves the name of all inputs which are declared. */
-export function getInputNamesOfClass(node, typeChecker) {
-    const resolvedInputSetters = [];
-    // Determines the names of all inputs defined in the current class declaration by
-    // checking whether a given property/getter/setter has the "@Input" decorator applied.
-    node.members.forEach(m => {
-        if (!m.decorators || !m.decorators.length ||
-            !ts.isPropertyDeclaration(m) && !ts.isSetAccessor(m) && !ts.isGetAccessor(m)) {
-            return;
-        }
-        const inputDecorator = getAngularDecorators(typeChecker, m.decorators).find(d => d.name === 'Input');
-        if (inputDecorator && hasPropertyNameText(m.name)) {
-            resolvedInputSetters.push(m.name.text);
-        }
-    });
-    // Besides looking for immediate setters in the current class declaration, developers
-    // can also define inputs in the directive metadata using the "inputs" property. We
-    // also need to determine these inputs which are declared in the directive metadata.
-    const metadataInputs = getInputNamesFromMetadata(node, typeChecker);
-    if (metadataInputs) {
-        resolvedInputSetters.push(...metadataInputs);
-    }
-    return resolvedInputSetters;
-}
-/**
- * Determines the names of all inputs declared in the directive/component metadata
- * of the given class.
- */
-function getInputNamesFromMetadata(node, typeChecker) {
-    if (!node.decorators || !node.decorators.length) {
-        return null;
-    }
-    const decorator = getAngularDecorators(typeChecker, node.decorators)
-        .find(d => d.name === 'Directive' || d.name === 'Component');
-    // In case no directive/component decorator could be found for this class, just
-    // return null as there is no metadata where an input could be declared.
-    if (!decorator) {
-        return null;
-    }
-    const decoratorCall = decorator.node.expression;
-    // In case the decorator does define any metadata, there is no metadata
-    // where inputs could be declared. This is an edge case because there
-    // always needs to be an object literal, but in case there isn't we just
-    // want to skip the invalid decorator and return null.
-    if (decoratorCall.arguments.length !== 1 ||
-        !ts.isObjectLiteralExpression(decoratorCall.arguments[0])) {
-        return null;
-    }
-    const metadata = decoratorCall.arguments[0];
-    const inputs = metadata.properties.filter(ts.isPropertyAssignment)
-        .find(p => getPropertyNameText(p.name) === 'inputs');
-    // In case there is no "inputs" property in the directive metadata,
-    // just return "null" as no inputs can be declared for this class.
-    if (!inputs || !ts.isArrayLiteralExpression(inputs.initializer)) {
-        return null;
-    }
-    return inputs.initializer.elements.filter(ts.isStringLiteralLike)
-        .map(element => element.text.split(':')[0].trim());
-}
-//# sourceMappingURL=data:application/json;base64,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