@angular/core 13.0.0-next.8 → 13.0.0-rc.2

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

@@ -1,225 +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
- */
-(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/renderer-to-renderer2/migration", ["require", "exports", "typescript"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.migrateExpression = void 0;
-    const ts = require("typescript");
-    /**
-     * Migrates a function call expression from `Renderer` to `Renderer2`.
-     * Returns null if the expression should be dropped.
-     */
-    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 };
-    }
-    exports.migrateExpression = migrateExpression;
-    /** 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.d.ts

@@ -1,18 +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
- */
-/// <amd-module name="@angular/core/schematics/migrations/renderer-to-renderer2/util" />
-import * as ts from 'typescript';
-/**
- * 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 declare function findRendererReferences(sourceFile: ts.SourceFile, typeChecker: ts.TypeChecker, rendererImportSpecifier: ts.ImportSpecifier): {
-    typedNodes: Set<ts.ParameterDeclaration | ts.AsExpression | ts.PropertyDeclaration>;
-    methodCalls: Set<ts.CallExpression>;
-    forwardRefs: Set<ts.Identifier>;
-};

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

@@ -1,83 +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
- */
-(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/renderer-to-renderer2/util", ["require", "exports", "typescript", "@angular/core/schematics/utils/typescript/imports", "@angular/core/schematics/utils/typescript/symbol"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.findRendererReferences = void 0;
-    const ts = require("typescript");
-    const imports_1 = require("@angular/core/schematics/utils/typescript/imports");
-    const symbol_1 = require("@angular/core/schematics/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.
-     */
-    function findRendererReferences(sourceFile, typeChecker, rendererImportSpecifier) {
-        const typedNodes = new Set();
-        const methodCalls = new Set();
-        const forwardRefs = new Set();
-        const forwardRefSpecifier = (0, imports_1.getImportSpecifier)(sourceFile, '@angular/core', 'forwardRef');
-        ts.forEachChild(sourceFile, function visitNode(node) {
-            if ((ts.isParameter(node) || ts.isPropertyDeclaration(node)) &&
-                (0, symbol_1.isReferenceToImport)(typeChecker, node.name, rendererImportSpecifier)) {
-                typedNodes.add(node);
-            }
-            else if (ts.isAsExpression(node) &&
-                (0, symbol_1.isReferenceToImport)(typeChecker, node.type, rendererImportSpecifier)) {
-                typedNodes.add(node);
-            }
-            else if (ts.isCallExpression(node)) {
-                if (ts.isPropertyAccessExpression(node.expression) &&
-                    (0, symbol_1.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) &&
-                    (0, symbol_1.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 };
-    }
-    exports.findRendererReferences = findRendererReferences;
-    /** 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) &&
-                (0, symbol_1.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) &&
-                    (0, symbol_1.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.d.ts

@@ -1,14 +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
- */
-/// <amd-module name="@angular/core/schematics/migrations/router-preserve-query-params" />
-import { Rule } from '@angular-devkit/schematics';
-/**
- * Migration that switches `NavigationExtras.preserveQueryParams` to set the coresponding value via
- * `NavigationExtras`'s `queryParamsHandling` attribute.
- */
-export default function (): Rule;

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

@@ -1,72 +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
- */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-(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-preserve-query-params", ["require", "exports", "@angular-devkit/schematics", "path", "typescript", "@angular/core/schematics/utils/project_tsconfig_paths", "@angular/core/schematics/utils/typescript/compiler_host", "@angular/core/schematics/migrations/router-preserve-query-params/util"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    const schematics_1 = require("@angular-devkit/schematics");
-    const path_1 = require("path");
-    const ts = require("typescript");
-    const project_tsconfig_paths_1 = require("@angular/core/schematics/utils/project_tsconfig_paths");
-    const compiler_host_1 = require("@angular/core/schematics/utils/typescript/compiler_host");
-    const util_1 = require("@angular/core/schematics/migrations/router-preserve-query-params/util");
-    /**
-     * Migration that switches `NavigationExtras.preserveQueryParams` to set the coresponding value via
-     * `NavigationExtras`'s `queryParamsHandling` attribute.
-     */
-    function default_1() {
-        return (tree) => __awaiter(this, void 0, void 0, function* () {
-            const { buildPaths, testPaths } = yield (0, project_tsconfig_paths_1.getProjectTsConfigPaths)(tree);
-            const basePath = process.cwd();
-            const allPaths = [...buildPaths, ...testPaths];
-            if (!allPaths.length) {
-                throw new schematics_1.SchematicsException('Could not find any tsconfig file. Cannot migrate ' +
-                    'NavigationExtras.preserveQueryParams usages.');
-            }
-            for (const tsconfigPath of allPaths) {
-                runPreserveQueryParamsMigration(tree, tsconfigPath, basePath);
-            }
-        });
-    }
-    exports.default = default_1;
-    function runPreserveQueryParamsMigration(tree, tsconfigPath, basePath) {
-        const { program } = (0, compiler_host_1.createMigrationProgram)(tree, tsconfigPath, basePath);
-        const typeChecker = program.getTypeChecker();
-        const printer = ts.createPrinter();
-        const sourceFiles = program.getSourceFiles().filter(sourceFile => (0, compiler_host_1.canMigrateFile)(basePath, sourceFile, program));
-        sourceFiles.forEach(sourceFile => {
-            const literalsToMigrate = (0, util_1.findLiteralsToMigrate)(sourceFile, typeChecker);
-            const update = tree.beginUpdate((0, path_1.relative)(basePath, sourceFile.fileName));
-            literalsToMigrate.forEach((instances, methodName) => instances.forEach(instance => {
-                const migratedNode = (0, util_1.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.d.ts

@@ -1,11 +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
- */
-/// <amd-module name="@angular/core/schematics/migrations/router-preserve-query-params/util" />
-import * as ts from 'typescript';
-export declare function migrateLiteral(methodName: string, node: ts.ObjectLiteralExpression): ts.ObjectLiteralExpression;
-export declare function findLiteralsToMigrate(sourceFile: ts.SourceFile, typeChecker: ts.TypeChecker): Map<string, Set<ts.ObjectLiteralExpression>>;

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

@@ -1,103 +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
- */
-(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-preserve-query-params/util", ["require", "exports", "typescript", "@angular/core/schematics/utils/typescript/imports", "@angular/core/schematics/utils/typescript/symbol"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.findLiteralsToMigrate = exports.migrateLiteral = void 0;
-    const ts = require("typescript");
-    const imports_1 = require("@angular/core/schematics/utils/typescript/imports");
-    const symbol_1 = require("@angular/core/schematics/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';
-    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);
-    }
-    exports.migrateLiteral = migrateLiteral;
-    function findLiteralsToMigrate(sourceFile, typeChecker) {
-        const results = new Map(Array.from(methodConfig.keys(), key => [key, new Set()]));
-        const routerImport = (0, imports_1.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 ((0, symbol_1.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;
-    }
-    exports.findLiteralsToMigrate = findLiteralsToMigrate;
-});
-//# 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;;;;;;;;;;;;;IAEH,iCAAiC;IAEjC,+EAAkE;IAClE,6EAAkE;IAElE;;;OAGG;IACH,MAAM,YAAY,GAAG,IAAI,GAAG,CAAS,CAAC,UAAU,EAAE,eAAe,CAAC,CAAC,CAAC;IAEpE,MAAM,sBAAsB,GAAG,qBAAqB,CAAC;IAErD,SAAgB,cAAc,CAC1B,UAAkB,EAAE,IAAgC;;QACtD,MAAM,kBAAkB,GAAG,YAAY,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;QAExD,IAAI,CAAC,kBAAkB,EAAE;YACvB,MAAM,KAAK,CAAC,oDAAoD,UAAU,GAAG,CAAC,CAAC;SAChF;QAGD,MAAM,gBAAgB,GAAkC,EAAE,CAAC;QAC3D,IAAI,iBAAiB,GAAmE,SAAS,CAAC;QAElG,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,UAAU,EAAE;YACtC,kFAAkF;YAClF,oEAAoE;YACpE,IAAI,CAAC,EAAE,CAAC,oBAAoB,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,6BAA6B,CAAC,QAAQ,CAAC,CAAC;gBACjF,CAAC,EAAE,CAAC,mBAAmB,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,gBAAgB,CAAC,QAAQ,CAAC,IAAI,CAAC;oBAC3E,EAAE,CAAC,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;gBAChC,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,KAAK,sBAAsB,CAAC,EAAE;gBACnD,iBAAiB,GAAG,QAAQ,CAAC;gBAC7B,SAAS;aACV;YACD,gBAAgB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;SACjC;QAED,uDAAuD;QACvD,IAAI,iBAAiB,KAAK,SAAS,EAAE;YACnC,OAAO,IAAI,CAAC;SACb;QAED,IAAI,CAAC,EAAE,CAAC,6BAA6B,CAAC,iBAAiB,CAAC;YACnD,CAAA,MAAA,iBAAiB,CAAC,2BAA2B,0CAAE,IAAI,MAAK,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC;YACnF,CAAC,EAAE,CAAC,oBAAoB,CAAC,iBAAiB,CAAC;gBAC1C,iBAAiB,CAAC,WAAW,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC,EAAE;YACtE,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;SACjG;QAED,OAAO,EAAE,CAAC,mBAAmB,CAAC,IAAI,EAAE,gBAAgB,CAAC,CAAC;IACxD,CAAC;IAzCD,wCAyCC;IAED,SAAgB,qBAAqB,CAAC,UAAyB,EAAE,WAA2B;QAC1F,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;QAC9D,MAAM,YAAY,GAAG,IAAA,4BAAkB,EAAC,UAAU,EAAE,iBAAiB,EAAE,QAAQ,CAAC,CAAC;QACjF,MAAM,YAAY,GAAG,IAAI,GAAG,EAAsC,CAAC;QAEnE,IAAI,YAAY,EAAE;YAChB,UAAU,CAAC,YAAY,CAAC,SAAS,SAAS,CAAC,IAAa;;gBACtD,wFAAwF;gBACxF,IAAI,EAAE,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC;oBACtD,EAAE,CAAC,0BAA0B,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;oBACvF,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;oBAC/C,oDAAoD;oBACpD,kDAAkD;oBAClD,IAAI,IAAA,4BAAmB,EAAC,WAAW,EAAE,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,YAAY,CAAC,EAAE;wBAC9E,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC;wBAC7C,MAAM,oBAAoB,GACtB,MAAA,WAAW,CAAC,iBAAiB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,EAAE,0CAAE,gBAAgB,CAAC;wBAEnF,yCAAyC;wBACzC,IAAI,oBAAoB,IAAI,EAAE,CAAC,yBAAyB,CAAC,oBAAoB,CAAC,EAAE;4BAC9E,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,oBAAoB,CAAC,EAAE;gCAC3C,OAAO,CAAC,GAAG,CAAC,UAAU,CAAE,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;gCACnD,YAAY,CAAC,GAAG,CAAC,oBAAoB,EAAE,UAAU,CAAC,CAAC;gCACnD,gFAAgF;gCAChF,kFAAkF;gCAClF,qFAAqF;gCACrF,uDAAuD;6BACxD;iCAAM,IAAI,YAAY,CAAC,GAAG,CAAC,oBAAoB,CAAC,KAAK,UAAU,EAAE;gCAChE,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC,CAAC;6BACpE;yBACF;qBACF;iBACF;qBAAM;oBACL,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;iBAC9B;YACH,CAAC,CAAC,CAAC;SACJ;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAxCD,sDAwCC","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"]}