| /** |
| * @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":"AAAA;;;;;;GAMG;;;;;;;;;;;;;IAEH,iCAAiC;IAOjC;;;OAGG;IACH,SAAgB,iBAAiB,CAAC,IAAuB,EAAE,WAA2B;QAEpF,IAAI,8BAA8B,CAAC,IAAI,CAAC,EAAE;YACxC,QAAQ,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE;gBACtC,KAAK,oBAAoB;oBACvB,OAAO,EAAC,IAAI,EAAE,gBAAgB,CAAC,IAAI,EAAE,aAAa,CAAC,EAAC,CAAC;gBACvD,KAAK,SAAS;oBACZ,OAAO,EAAC,IAAI,EAAE,gBAAgB,CAAC,IAAI,EAAE,UAAU,CAAC,EAAC,CAAC;gBACpD,KAAK,cAAc;oBACjB,OAAO,EAAC,IAAI,EAAE,gBAAgB,CAAC,IAAI,EAAE,QAAQ,CAAC,EAAC,CAAC;gBAClD,KAAK,mBAAmB;oBACtB,OAAO,EAAC,IAAI,EAAE,wBAAwB,CAAC,IAAI,CAAC,EAAC,CAAC;gBAChD,KAAK,iBAAiB;oBACpB,OAAO,EAAC,IAAI,EAAE,sBAAsB,CAAC,IAAI,CAAC,EAAC,CAAC;gBAC9C,KAAK,iBAAiB;oBACpB,OAAO,EAAC,IAAI,EAAE,sBAAsB,CAAC,IAAI,EAAE,WAAW,CAAC,EAAC,CAAC;gBAC3D,KAAK,qBAAqB;oBACxB,OAAO,EAAC,IAAI,EAAE,0BAA0B,CAAC,IAAI,CAAC,EAAC,CAAC;gBAClD,KAAK,qBAAqB;oBACxB,OAAO,EAAC,IAAI,EAAE,IAAI,EAAC,CAAC;gBACtB,KAAK,gBAAgB;oBACnB,OAAO,EAAC,IAAI,EAAE,qBAAqB,CAAC,IAAI,CAAC,EAAC,CAAC;gBAC7C,KAAK,qBAAqB;oBACxB,OAAO;wBACL,IAAI,EAAE,kBAAkB,CAAC,IAAI,qEAAsC,IAAI,CAAC,SAAS,CAAC;wBAClF,eAAe,EAAE;;yBAEhB;qBACF,CAAC;gBACJ,KAAK,eAAe;oBAClB,OAAO;wBACL,IAAI,EAAE,kBAAkB,CAAC,IAAI,yDAAgC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;wBACxF,eAAe,EACX,wJAAiF;qBACtF,CAAC;gBACJ,KAAK,YAAY;oBACf,OAAO;wBACL,IAAI,EAAE,kBAAkB,CAAC,IAAI,mDAA6B,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;wBACrF,eAAe,EAAE,yFAA+C;qBACjE,CAAC;gBACJ,KAAK,sBAAsB;oBACzB,OAAO;wBACL,IAAI,EAAE,kBAAkB,CACpB,IAAI,uEAAuC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;wBAC1E,eAAe,EAAE,6GAAyD;qBAC3E,CAAC;gBACJ,KAAK,cAAc;oBACjB,OAAO;wBACL,IAAI,EAAE,kBAAkB,CAAC,IAAI,uDAA+B,IAAI,CAAC,SAAS,CAAC;wBAC3E,eAAe,EAAE,6FAAiD;qBACnE,CAAC;gBACJ,KAAK,SAAS;oBACZ,OAAO;wBACL,IAAI,EAAE,kBAAkB,EAAE;wBAC1B,eAAe,EAAE,mFAA4C;qBAC9D,CAAC;gBACJ,KAAK,aAAa;oBAChB,OAAO;wBACL,IAAI,EAAE,kBAAkB,CAAC,IAAI,qDAA8B,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;wBAC/E,eAAe,EAAE,2FAAgD;qBAClE,CAAC;gBACJ,KAAK,YAAY;oBACf,OAAO;wBACL,IAAI,EAAE,kBAAkB,CAAC,IAAI,mDAA6B,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;wBAC9E,eAAe,EAAE,yFAA+C;qBACjE,CAAC;gBACJ,KAAK,iBAAiB;oBACpB,OAAO;wBACL,IAAI,EAAE,kBAAkB,CAAC,IAAI,6DAAkC,IAAI,CAAC,SAAS,CAAC;wBAC9E,eAAe,EAAE,mGAAoD;qBACtE,CAAC;aACL;SACF;QAED,OAAO,EAAC,IAAI,EAAC,CAAC;IAChB,CAAC;IA3ED,8CA2EC;IAED,2DAA2D;IAC3D,SAAS,8BAA8B,CAAC,IAAa;QACnD,OAAO,EAAE,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,0BAA0B,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IACrF,CAAC;IAED,0EAA0E;IAC1E,SAAS,gBAAgB,CAAC,IAAkC,EAAE,OAAe;QAC3E,MAAM,aAAa,GAAG,EAAE,CAAC,oBAAoB,CACzC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,EAAE,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC;QAE/E,OAAO,EAAE,CAAC,UAAU,CAAC,IAAI,EAAE,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;IAChF,CAAC;IAED;;OAEG;IACH,SAAS,wBAAwB,CAAC,IAAuB;QACvD,4DAA4D;QAC5D,oDAAoD;QACpD,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE;YAC7B,OAAO,EAAE,CAAC,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,aAAa,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;SACtF;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;OAGG;IACH,SAAS,sBAAsB,CAAC,IAAkC;QAChE,iEAAiE;QACjE,6DAA6D;QAC7D,MAAM,gBAAgB,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;QAChD,MAAM,aAAa,GAAG,gBAAgB,CAAC,GAAG,EAAG,CAAC;QAC9C,MAAM,kBAAkB,GAAG,CAAC,KAAc,EAAE,EAAE;YAC5C,MAAM,eAAe,GAAG,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC;YACnD,MAAM,aAAa,GACf,EAAE,CAAC,oBAAoB,CAAC,eAAe,EAAE,KAAK,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC;YACjF,OAAO,EAAE,CAAC,UAAU,CAAC,aAAa,EAAE,EAAE,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QACtE,CAAC,CAAC;QAEF,uFAAuF;QACvF,wFAAwF;QACxF,6DAA6D;QAC7D,IAAI,aAAa,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW;YAChD,aAAa,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,YAAY,EAAE;YACrD,OAAO,kBAAkB,CAAC,aAAa,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;SAC7E;QAED,8CAA8C;QAC9C,OAAO,EAAE,CAAC,iBAAiB,CAAC,aAAa,EAAE,kBAAkB,CAAC,IAAI,CAAC,EAAE,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC;IAClG,CAAC;IAED;;;;OAIG;IACH,SAAS,sBAAsB,CAC3B,IAAkC,EAAE,WAA2B;QACjE,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC;QAC5B,MAAM,aAAa,GAAG,UAAU,CAAC;QACjC,MAAM,gBAAgB,GAAG,aAAa,CAAC;QACvC,MAAM,WAAW,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;YACzB,WAAW,CAAC,YAAY,CACpB,WAAW,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CAAC;YACpF,IAAI,CAAC;QAET,iEAAiE;QACjE,uDAAuD;QACvD,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,IAAI,WAAW,KAAK,MAAM,IAAI,WAAW,KAAK,WAAW,EAAE;YAC9E,4FAA4F;YAC5F,uEAAuE;YACvE,MAAM,eAAe,GAAG,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC;YACnD,MAAM,aAAa,GAAG,EAAE,CAAC,oBAAoB,CAAC,eAAe,EAAE,gBAAgB,CAAC,CAAC;YACjF,OAAO,EAAE,CAAC,UAAU,CAAC,aAAa,EAAE,EAAE,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;SAC3D;aAAM,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE;YAC5B,wEAAwE;YACxE,qDAAqD;YACrD,IAAI,WAAW,KAAK,QAAQ,IAAI,WAAW,KAAK,QAAQ,IAAI,EAAE,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;gBACnF,EAAE,CAAC,+BAA+B,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE;gBAC/E,oFAAoF;gBACpF,mCAAmC;gBACnC,OAAO,gBAAgB,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC;aAC9C;iBAAM;gBACL,kDAAkD;gBAClD,oEAAoE;gBACpE,MAAM,SAAS,GAAG,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,iBAAiB,EAAE,EAAE,CAAC,UAAU,EAAE,CAAC,CAAC;gBAC7F,MAAM,YAAY,GAAG,gBAAgB,CACjC,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,EAAE,EAAE,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAiC,EACpF,gBAAgB,CAAC,CAAC;gBACtB,OAAO,EAAE,CAAC,iBAAiB,CAAC,SAAS,EAAE,YAAY,EAAE,gBAAgB,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC;aAC7F;SACF;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;OAGG;IACH,SAAS,0BAA0B,CAAC,IAAuB;QACzD,MAAM,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC;QAC5C,MAAM,YAAY,GAAG,EAAE,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,+BAA+B,CAAC,IAAI,CAAC,CAAC;QAC1F,MAAM,YAAY,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC,wBAAwB,CAAC,IAAI,CAAC,CAAC;QAEhE,IAAI,YAAY,IAAI,YAAY,EAAE;YAChC,yEAAyE;YACzE,yDAAyD;YACzD,MAAM,UAAU,GAAG,EAAE,CAAC,oBAAoB,CACtC,MAAM,EAAG,IAA4D,CAAC,IAAI,CAAC,CAAC;YAChF,MAAM,aAAa,GAAG,IAAI,CAAC,CAAC,CAAE,IAAkC,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;YAC/E,OAAO,EAAE,CAAC,UAAU,CAAC,UAAU,EAAE,EAAE,EAAE,aAAa,CAAC,CAAC;SACrD;aAAM;YACL,6FAA6F;YAC7F,MAAM,YAAY,GAAG,EAAE,CAAC,WAAW,CAC/B,EAAE,CAAC,kBAAkB,CAAC,MAAM,EAAE,EAAE,CAAC,qBAAqB,CAAC,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;YACvF,MAAM,aAAa,GAAG,EAAE,CAAC,mBAAmB,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC;YACjE,MAAM,eAAe,GAAG,EAAE,CAAC,oBAAoB,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;YACxE,OAAO,EAAE,CAAC,UAAU,CAAC,eAAe,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;SAC7E;IACH,CAAC;IAED,gGAAgG;IAChG,SAAS,qBAAqB,CAAC,IAAuB;QACpD,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IAC3B,CAAC;IAED,gEAAgE;IAChE,SAAS,kBAAkB;QACzB,OAAO,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,gBAAgB,2CAAwB,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IAC5E,CAAC;IAED;;;;;;;OAOG;IACH,SAAS,kBAAkB,CACvB,IAAkC,EAAE,MAAsB,EAC1D,IAAiD;QACnD,OAAO,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,gBAAgB,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC;IAC/F,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 {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"]} |
