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

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

@@ -1,238 +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/helpers", ["require", "exports", "typescript"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.getHelper = void 0;
-    const ts = require("typescript");
-    /** Gets the string representation of a helper function. */
-    function getHelper(name, sourceFile, printer) {
-        const helperDeclaration = getHelperDeclaration(name);
-        return '\n' + printer.printNode(ts.EmitHint.Unspecified, helperDeclaration, sourceFile) + '\n';
-    }
-    exports.getHelper = getHelper;
-    /** Creates a function declaration for the specified helper name. */
-    function getHelperDeclaration(name) {
-        switch (name) {
-            case "AnyDuringRendererMigration" /* any */:
-                return createAnyTypeHelper();
-            case "__ngRendererCreateElementHelper" /* createElement */:
-                return getCreateElementHelper();
-            case "__ngRendererCreateTextHelper" /* createText */:
-                return getCreateTextHelper();
-            case "__ngRendererCreateTemplateAnchorHelper" /* createTemplateAnchor */:
-                return getCreateTemplateAnchorHelper();
-            case "__ngRendererProjectNodesHelper" /* projectNodes */:
-                return getProjectNodesHelper();
-            case "__ngRendererAnimateHelper" /* animate */:
-                return getAnimateHelper();
-            case "__ngRendererDestroyViewHelper" /* destroyView */:
-                return getDestroyViewHelper();
-            case "__ngRendererDetachViewHelper" /* detachView */:
-                return getDetachViewHelper();
-            case "__ngRendererAttachViewAfterHelper" /* attachViewAfter */:
-                return getAttachViewAfterHelper();
-            case "__ngRendererSetElementAttributeHelper" /* setElementAttribute */:
-                return getSetElementAttributeHelper();
-            case "__ngRendererSplitNamespaceHelper" /* splitNamespace */:
-                return getSplitNamespaceHelper();
-        }
-    }
-    /** Creates a helper for a custom `any` type during the migration. */
-    function createAnyTypeHelper() {
-        // type AnyDuringRendererMigration = any;
-        return ts.createTypeAliasDeclaration([], [], "AnyDuringRendererMigration" /* any */, [], ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword));
-    }
-    /** Creates a function parameter that is typed as `any`. */
-    function getAnyTypedParameter(parameterName, isRequired = true) {
-        // Declare the parameter as `any` so we don't have to add extra logic to ensure that the
-        // generated code will pass type checking. Use our custom `any` type so people have an incentive
-        // to clean it up afterwards and to avoid potentially introducing lint warnings in G3.
-        const type = ts.createTypeReferenceNode("AnyDuringRendererMigration" /* any */, []);
-        return ts.createParameter([], [], undefined, parameterName, isRequired ? undefined : ts.createToken(ts.SyntaxKind.QuestionToken), type);
-    }
-    /** Creates a helper for `createElement`. */
-    function getCreateElementHelper() {
-        const renderer = ts.createIdentifier('renderer');
-        const parent = ts.createIdentifier('parent');
-        const namespaceAndName = ts.createIdentifier('namespaceAndName');
-        const name = ts.createIdentifier('name');
-        const namespace = ts.createIdentifier('namespace');
-        // [namespace, name] = splitNamespace(namespaceAndName);
-        const namespaceAndNameVariable = ts.createVariableDeclaration(ts.createArrayBindingPattern([namespace, name].map(id => ts.createBindingElement(undefined, undefined, id))), undefined, ts.createCall(ts.createIdentifier("__ngRendererSplitNamespaceHelper" /* splitNamespace */), [], [namespaceAndName]));
-        // `renderer.createElement(name, namespace)`.
-        const creationCall = ts.createCall(ts.createPropertyAccess(renderer, 'createElement'), [], [name, namespace]);
-        return getCreationHelper("__ngRendererCreateElementHelper" /* createElement */, creationCall, renderer, parent, [namespaceAndName], [ts.createVariableStatement(undefined, ts.createVariableDeclarationList([namespaceAndNameVariable], ts.NodeFlags.Const))]);
-    }
-    /** Creates a helper for `createText`. */
-    function getCreateTextHelper() {
-        const renderer = ts.createIdentifier('renderer');
-        const parent = ts.createIdentifier('parent');
-        const value = ts.createIdentifier('value');
-        // `renderer.createText(value)`.
-        const creationCall = ts.createCall(ts.createPropertyAccess(renderer, 'createText'), [], [value]);
-        return getCreationHelper("__ngRendererCreateTextHelper" /* createText */, creationCall, renderer, parent, [value]);
-    }
-    /** Creates a helper for `createTemplateAnchor`. */
-    function getCreateTemplateAnchorHelper() {
-        const renderer = ts.createIdentifier('renderer');
-        const parent = ts.createIdentifier('parent');
-        // `renderer.createComment('')`.
-        const creationCall = ts.createCall(ts.createPropertyAccess(renderer, 'createComment'), [], [ts.createStringLiteral('')]);
-        return getCreationHelper("__ngRendererCreateTemplateAnchorHelper" /* createTemplateAnchor */, creationCall, renderer, parent);
-    }
-    /**
-     * Gets the function declaration for a creation helper. This is reused between `createElement`,
-     * `createText` and `createTemplateAnchor` which follow a very similar pattern.
-     * @param functionName Function that the helper should have.
-     * @param creationCall Expression that is used to create a node inside the function.
-     * @param rendererParameter Parameter for the `renderer`.
-     * @param parentParameter Parameter for the `parent` inside the function.
-     * @param extraParameters Extra parameters to be added to the end.
-     * @param precedingVariables Extra variables to be added before the one that creates the `node`.
-     */
-    function getCreationHelper(functionName, creationCall, renderer, parent, extraParameters = [], precedingVariables = []) {
-        const node = ts.createIdentifier('node');
-        // `const node = {{creationCall}}`.
-        const nodeVariableStatement = ts.createVariableStatement(undefined, ts.createVariableDeclarationList([ts.createVariableDeclaration(node, undefined, creationCall)], ts.NodeFlags.Const));
-        // `if (parent) { renderer.appendChild(parent, node) }`.
-        const guardedAppendChildCall = ts.createIf(parent, ts.createBlock([ts.createExpressionStatement(ts.createCall(ts.createPropertyAccess(renderer, 'appendChild'), [], [parent, node]))], true));
-        return ts.createFunctionDeclaration([], [], undefined, functionName, [], [renderer, parent, ...extraParameters].map(name => getAnyTypedParameter(name)), undefined, ts.createBlock([
-            ...precedingVariables, nodeVariableStatement, guardedAppendChildCall,
-            ts.createReturn(node)
-        ], true));
-    }
-    /** Creates a helper for `projectNodes`. */
-    function getProjectNodesHelper() {
-        const renderer = ts.createIdentifier('renderer');
-        const parent = ts.createIdentifier('parent');
-        const nodes = ts.createIdentifier('nodes');
-        const incrementor = ts.createIdentifier('i');
-        // for (let i = 0; i < nodes.length; i++) {
-        //   renderer.appendChild(parent, nodes[i]);
-        // }
-        const loopInitializer = ts.createVariableDeclarationList([ts.createVariableDeclaration(incrementor, undefined, ts.createNumericLiteral('0'))], ts.NodeFlags.Let);
-        const loopCondition = ts.createBinary(incrementor, ts.SyntaxKind.LessThanToken, ts.createPropertyAccess(nodes, ts.createIdentifier('length')));
-        const appendStatement = ts.createExpressionStatement(ts.createCall(ts.createPropertyAccess(renderer, 'appendChild'), [], [parent, ts.createElementAccess(nodes, incrementor)]));
-        const loop = ts.createFor(loopInitializer, loopCondition, ts.createPostfix(incrementor, ts.SyntaxKind.PlusPlusToken), ts.createBlock([appendStatement]));
-        return ts.createFunctionDeclaration([], [], undefined, "__ngRendererProjectNodesHelper" /* projectNodes */, [], [renderer, parent, nodes].map(name => getAnyTypedParameter(name)), undefined, ts.createBlock([loop], true));
-    }
-    /** Creates a helper for `animate`. */
-    function getAnimateHelper() {
-        // throw new Error('...');
-        const throwStatement = ts.createThrow(ts.createNew(ts.createIdentifier('Error'), [], [ts.createStringLiteral('Renderer.animate is no longer supported!')]));
-        return ts.createFunctionDeclaration([], [], undefined, "__ngRendererAnimateHelper" /* animate */, [], [], undefined, ts.createBlock([throwStatement], true));
-    }
-    /** Creates a helper for `destroyView`. */
-    function getDestroyViewHelper() {
-        const renderer = ts.createIdentifier('renderer');
-        const allNodes = ts.createIdentifier('allNodes');
-        const incrementor = ts.createIdentifier('i');
-        // for (let i = 0; i < allNodes.length; i++) {
-        //   renderer.destroyNode(allNodes[i]);
-        // }
-        const loopInitializer = ts.createVariableDeclarationList([ts.createVariableDeclaration(incrementor, undefined, ts.createNumericLiteral('0'))], ts.NodeFlags.Let);
-        const loopCondition = ts.createBinary(incrementor, ts.SyntaxKind.LessThanToken, ts.createPropertyAccess(allNodes, ts.createIdentifier('length')));
-        const destroyStatement = ts.createExpressionStatement(ts.createCall(ts.createPropertyAccess(renderer, 'destroyNode'), [], [ts.createElementAccess(allNodes, incrementor)]));
-        const loop = ts.createFor(loopInitializer, loopCondition, ts.createPostfix(incrementor, ts.SyntaxKind.PlusPlusToken), ts.createBlock([destroyStatement]));
-        return ts.createFunctionDeclaration([], [], undefined, "__ngRendererDestroyViewHelper" /* destroyView */, [], [renderer, allNodes].map(name => getAnyTypedParameter(name)), undefined, ts.createBlock([loop], true));
-    }
-    /** Creates a helper for `detachView`. */
-    function getDetachViewHelper() {
-        const renderer = ts.createIdentifier('renderer');
-        const rootNodes = ts.createIdentifier('rootNodes');
-        const incrementor = ts.createIdentifier('i');
-        const node = ts.createIdentifier('node');
-        // for (let i = 0; i < rootNodes.length; i++) {
-        //   const node = rootNodes[i];
-        //   renderer.removeChild(renderer.parentNode(node), node);
-        // }
-        const loopInitializer = ts.createVariableDeclarationList([ts.createVariableDeclaration(incrementor, undefined, ts.createNumericLiteral('0'))], ts.NodeFlags.Let);
-        const loopCondition = ts.createBinary(incrementor, ts.SyntaxKind.LessThanToken, ts.createPropertyAccess(rootNodes, ts.createIdentifier('length')));
-        // const node = rootNodes[i];
-        const nodeVariableStatement = ts.createVariableStatement(undefined, ts.createVariableDeclarationList([ts.createVariableDeclaration(node, undefined, ts.createElementAccess(rootNodes, incrementor))], ts.NodeFlags.Const));
-        // renderer.removeChild(renderer.parentNode(node), node);
-        const removeCall = ts.createCall(ts.createPropertyAccess(renderer, 'removeChild'), [], [ts.createCall(ts.createPropertyAccess(renderer, 'parentNode'), [], [node]), node]);
-        const loop = ts.createFor(loopInitializer, loopCondition, ts.createPostfix(incrementor, ts.SyntaxKind.PlusPlusToken), ts.createBlock([nodeVariableStatement, ts.createExpressionStatement(removeCall)]));
-        return ts.createFunctionDeclaration([], [], undefined, "__ngRendererDetachViewHelper" /* detachView */, [], [renderer, rootNodes].map(name => getAnyTypedParameter(name)), undefined, ts.createBlock([loop], true));
-    }
-    /** Creates a helper for `attachViewAfter` */
-    function getAttachViewAfterHelper() {
-        const renderer = ts.createIdentifier('renderer');
-        const node = ts.createIdentifier('node');
-        const rootNodes = ts.createIdentifier('rootNodes');
-        const parent = ts.createIdentifier('parent');
-        const nextSibling = ts.createIdentifier('nextSibling');
-        const incrementor = ts.createIdentifier('i');
-        const createConstWithMethodCallInitializer = (constName, methodToCall) => {
-            return ts.createVariableStatement(undefined, ts.createVariableDeclarationList([ts.createVariableDeclaration(constName, undefined, ts.createCall(ts.createPropertyAccess(renderer, methodToCall), [], [node]))], ts.NodeFlags.Const));
-        };
-        // const parent = renderer.parentNode(node);
-        const parentVariableStatement = createConstWithMethodCallInitializer(parent, 'parentNode');
-        // const nextSibling = renderer.nextSibling(node);
-        const nextSiblingVariableStatement = createConstWithMethodCallInitializer(nextSibling, 'nextSibling');
-        // for (let i = 0; i < rootNodes.length; i++) {
-        //   renderer.insertBefore(parentElement, rootNodes[i], nextSibling);
-        // }
-        const loopInitializer = ts.createVariableDeclarationList([ts.createVariableDeclaration(incrementor, undefined, ts.createNumericLiteral('0'))], ts.NodeFlags.Let);
-        const loopCondition = ts.createBinary(incrementor, ts.SyntaxKind.LessThanToken, ts.createPropertyAccess(rootNodes, ts.createIdentifier('length')));
-        const insertBeforeCall = ts.createCall(ts.createPropertyAccess(renderer, 'insertBefore'), [], [parent, ts.createElementAccess(rootNodes, incrementor), nextSibling]);
-        const loop = ts.createFor(loopInitializer, loopCondition, ts.createPostfix(incrementor, ts.SyntaxKind.PlusPlusToken), ts.createBlock([ts.createExpressionStatement(insertBeforeCall)]));
-        return ts.createFunctionDeclaration([], [], undefined, "__ngRendererAttachViewAfterHelper" /* attachViewAfter */, [], [renderer, node, rootNodes].map(name => getAnyTypedParameter(name)), undefined, ts.createBlock([parentVariableStatement, nextSiblingVariableStatement, loop], true));
-    }
-    /** Creates a helper for `setElementAttribute` */
-    function getSetElementAttributeHelper() {
-        const renderer = ts.createIdentifier('renderer');
-        const element = ts.createIdentifier('element');
-        const namespaceAndName = ts.createIdentifier('namespaceAndName');
-        const value = ts.createIdentifier('value');
-        const name = ts.createIdentifier('name');
-        const namespace = ts.createIdentifier('namespace');
-        // [namespace, name] = splitNamespace(namespaceAndName);
-        const namespaceAndNameVariable = ts.createVariableDeclaration(ts.createArrayBindingPattern([namespace, name].map(id => ts.createBindingElement(undefined, undefined, id))), undefined, ts.createCall(ts.createIdentifier("__ngRendererSplitNamespaceHelper" /* splitNamespace */), [], [namespaceAndName]));
-        // renderer.setAttribute(element, name, value, namespace);
-        const setCall = ts.createCall(ts.createPropertyAccess(renderer, 'setAttribute'), [], [element, name, value, namespace]);
-        // renderer.removeAttribute(element, name, namespace);
-        const removeCall = ts.createCall(ts.createPropertyAccess(renderer, 'removeAttribute'), [], [element, name, namespace]);
-        // if (value != null) { setCall() } else { removeCall }
-        const ifStatement = ts.createIf(ts.createBinary(value, ts.SyntaxKind.ExclamationEqualsToken, ts.createNull()), ts.createBlock([ts.createExpressionStatement(setCall)], true), ts.createBlock([ts.createExpressionStatement(removeCall)], true));
-        const functionBody = ts.createBlock([
-            ts.createVariableStatement(undefined, ts.createVariableDeclarationList([namespaceAndNameVariable], ts.NodeFlags.Const)),
-            ifStatement
-        ], true);
-        return ts.createFunctionDeclaration([], [], undefined, "__ngRendererSetElementAttributeHelper" /* setElementAttribute */, [], [
-            getAnyTypedParameter(renderer), getAnyTypedParameter(element),
-            getAnyTypedParameter(namespaceAndName), getAnyTypedParameter(value, false)
-        ], undefined, functionBody);
-    }
-    /** Creates a helper for splitting a name that might contain a namespace. */
-    function getSplitNamespaceHelper() {
-        const name = ts.createIdentifier('name');
-        const match = ts.createIdentifier('match');
-        const regex = ts.createRegularExpressionLiteral('/^:([^:]+):(.+)$/');
-        const matchCall = ts.createCall(ts.createPropertyAccess(name, 'match'), [], [regex]);
-        // const match = name.split(regex);
-        const matchVariable = ts.createVariableDeclarationList([ts.createVariableDeclaration(match, undefined, matchCall)], ts.NodeFlags.Const);
-        // return [match[1], match[2]];
-        const matchReturn = ts.createReturn(ts.createArrayLiteral([ts.createElementAccess(match, 1), ts.createElementAccess(match, 2)]));
-        // if (name[0] === ':') { const match = ...; return ...; }
-        const ifStatement = ts.createIf(ts.createBinary(ts.createElementAccess(name, 0), ts.SyntaxKind.EqualsEqualsEqualsToken, ts.createStringLiteral(':')), ts.createBlock([ts.createVariableStatement([], matchVariable), matchReturn], true));
-        // return ['', name];
-        const elseReturn = ts.createReturn(ts.createArrayLiteral([ts.createStringLiteral(''), name]));
-        return ts.createFunctionDeclaration([], [], undefined, "__ngRendererSplitNamespaceHelper" /* splitNamespace */, [], [getAnyTypedParameter(name)], undefined, ts.createBlock([ifStatement, elseReturn], true));
-    }
-});
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../../../../../../../packages/core/schematics/migrations/renderer-to-renderer2/helpers.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\n/** Names of the helper functions that are supported for this migration. */\nexport const enum HelperFunction {\n  any = 'AnyDuringRendererMigration',\n  createElement = '__ngRendererCreateElementHelper',\n  createText = '__ngRendererCreateTextHelper',\n  createTemplateAnchor = '__ngRendererCreateTemplateAnchorHelper',\n  projectNodes = '__ngRendererProjectNodesHelper',\n  animate = '__ngRendererAnimateHelper',\n  destroyView = '__ngRendererDestroyViewHelper',\n  detachView = '__ngRendererDetachViewHelper',\n  attachViewAfter = '__ngRendererAttachViewAfterHelper',\n  splitNamespace = '__ngRendererSplitNamespaceHelper',\n  setElementAttribute = '__ngRendererSetElementAttributeHelper'\n}\n\n/** Gets the string representation of a helper function. */\nexport function getHelper(\n    name: HelperFunction, sourceFile: ts.SourceFile, printer: ts.Printer): string {\n  const helperDeclaration = getHelperDeclaration(name);\n  return '\\n' + printer.printNode(ts.EmitHint.Unspecified, helperDeclaration, sourceFile) + '\\n';\n}\n\n/** Creates a function declaration for the specified helper name. */\nfunction getHelperDeclaration(name: HelperFunction): ts.Node {\n  switch (name) {\n    case HelperFunction.any:\n      return createAnyTypeHelper();\n    case HelperFunction.createElement:\n      return getCreateElementHelper();\n    case HelperFunction.createText:\n      return getCreateTextHelper();\n    case HelperFunction.createTemplateAnchor:\n      return getCreateTemplateAnchorHelper();\n    case HelperFunction.projectNodes:\n      return getProjectNodesHelper();\n    case HelperFunction.animate:\n      return getAnimateHelper();\n    case HelperFunction.destroyView:\n      return getDestroyViewHelper();\n    case HelperFunction.detachView:\n      return getDetachViewHelper();\n    case HelperFunction.attachViewAfter:\n      return getAttachViewAfterHelper();\n    case HelperFunction.setElementAttribute:\n      return getSetElementAttributeHelper();\n    case HelperFunction.splitNamespace:\n      return getSplitNamespaceHelper();\n  }\n}\n\n/** Creates a helper for a custom `any` type during the migration. */\nfunction createAnyTypeHelper(): ts.TypeAliasDeclaration {\n  // type AnyDuringRendererMigration = any;\n  return ts.createTypeAliasDeclaration(\n      [], [], HelperFunction.any, [], ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword));\n}\n\n/** Creates a function parameter that is typed as `any`. */\nfunction getAnyTypedParameter(\n    parameterName: string|ts.Identifier, isRequired = true): ts.ParameterDeclaration {\n  // Declare the parameter as `any` so we don't have to add extra logic to ensure that the\n  // generated code will pass type checking. Use our custom `any` type so people have an incentive\n  // to clean it up afterwards and to avoid potentially introducing lint warnings in G3.\n  const type = ts.createTypeReferenceNode(HelperFunction.any, []);\n  return ts.createParameter(\n      [], [], undefined, parameterName,\n      isRequired ? undefined : ts.createToken(ts.SyntaxKind.QuestionToken), type);\n}\n\n/** Creates a helper for `createElement`. */\nfunction getCreateElementHelper(): ts.FunctionDeclaration {\n  const renderer = ts.createIdentifier('renderer');\n  const parent = ts.createIdentifier('parent');\n  const namespaceAndName = ts.createIdentifier('namespaceAndName');\n  const name = ts.createIdentifier('name');\n  const namespace = ts.createIdentifier('namespace');\n\n  // [namespace, name] = splitNamespace(namespaceAndName);\n  const namespaceAndNameVariable = ts.createVariableDeclaration(\n      ts.createArrayBindingPattern(\n          [namespace, name].map(id => ts.createBindingElement(undefined, undefined, id))),\n      undefined,\n      ts.createCall(ts.createIdentifier(HelperFunction.splitNamespace), [], [namespaceAndName]));\n\n  // `renderer.createElement(name, namespace)`.\n  const creationCall =\n      ts.createCall(ts.createPropertyAccess(renderer, 'createElement'), [], [name, namespace]);\n\n  return getCreationHelper(\n      HelperFunction.createElement, creationCall, renderer, parent, [namespaceAndName],\n      [ts.createVariableStatement(\n          undefined,\n          ts.createVariableDeclarationList([namespaceAndNameVariable], ts.NodeFlags.Const))]);\n}\n\n/** Creates a helper for `createText`. */\nfunction getCreateTextHelper(): ts.FunctionDeclaration {\n  const renderer = ts.createIdentifier('renderer');\n  const parent = ts.createIdentifier('parent');\n  const value = ts.createIdentifier('value');\n\n  // `renderer.createText(value)`.\n  const creationCall = ts.createCall(ts.createPropertyAccess(renderer, 'createText'), [], [value]);\n\n  return getCreationHelper(HelperFunction.createText, creationCall, renderer, parent, [value]);\n}\n\n/** Creates a helper for `createTemplateAnchor`. */\nfunction getCreateTemplateAnchorHelper(): ts.FunctionDeclaration {\n  const renderer = ts.createIdentifier('renderer');\n  const parent = ts.createIdentifier('parent');\n\n  // `renderer.createComment('')`.\n  const creationCall = ts.createCall(\n      ts.createPropertyAccess(renderer, 'createComment'), [], [ts.createStringLiteral('')]);\n\n  return getCreationHelper(HelperFunction.createTemplateAnchor, creationCall, renderer, parent);\n}\n\n/**\n * Gets the function declaration for a creation helper. This is reused between `createElement`,\n * `createText` and `createTemplateAnchor` which follow a very similar pattern.\n * @param functionName Function that the helper should have.\n * @param creationCall Expression that is used to create a node inside the function.\n * @param rendererParameter Parameter for the `renderer`.\n * @param parentParameter Parameter for the `parent` inside the function.\n * @param extraParameters Extra parameters to be added to the end.\n * @param precedingVariables Extra variables to be added before the one that creates the `node`.\n */\nfunction getCreationHelper(\n    functionName: HelperFunction, creationCall: ts.CallExpression, renderer: ts.Identifier,\n    parent: ts.Identifier, extraParameters: ts.Identifier[] = [],\n    precedingVariables: ts.VariableStatement[] = []): ts.FunctionDeclaration {\n  const node = ts.createIdentifier('node');\n\n  // `const node = {{creationCall}}`.\n  const nodeVariableStatement = ts.createVariableStatement(\n      undefined,\n      ts.createVariableDeclarationList(\n          [ts.createVariableDeclaration(node, undefined, creationCall)], ts.NodeFlags.Const));\n\n  // `if (parent) { renderer.appendChild(parent, node) }`.\n  const guardedAppendChildCall = ts.createIf(\n      parent,\n      ts.createBlock(\n          [ts.createExpressionStatement(\n              ts.createCall(ts.createPropertyAccess(renderer, 'appendChild'), [], [parent, node]))],\n          true));\n\n  return ts.createFunctionDeclaration(\n      [], [], undefined, functionName, [],\n      [renderer, parent, ...extraParameters].map(name => getAnyTypedParameter(name)), undefined,\n      ts.createBlock(\n          [\n            ...precedingVariables, nodeVariableStatement, guardedAppendChildCall,\n            ts.createReturn(node)\n          ],\n          true));\n}\n\n/** Creates a helper for `projectNodes`. */\nfunction getProjectNodesHelper(): ts.FunctionDeclaration {\n  const renderer = ts.createIdentifier('renderer');\n  const parent = ts.createIdentifier('parent');\n  const nodes = ts.createIdentifier('nodes');\n  const incrementor = ts.createIdentifier('i');\n\n  // for (let i = 0; i < nodes.length; i++) {\n  //   renderer.appendChild(parent, nodes[i]);\n  // }\n  const loopInitializer = ts.createVariableDeclarationList(\n      [ts.createVariableDeclaration(incrementor, undefined, ts.createNumericLiteral('0'))],\n      ts.NodeFlags.Let);\n  const loopCondition = ts.createBinary(\n      incrementor, ts.SyntaxKind.LessThanToken,\n      ts.createPropertyAccess(nodes, ts.createIdentifier('length')));\n  const appendStatement = ts.createExpressionStatement(ts.createCall(\n      ts.createPropertyAccess(renderer, 'appendChild'), [],\n      [parent, ts.createElementAccess(nodes, incrementor)]));\n  const loop = ts.createFor(\n      loopInitializer, loopCondition, ts.createPostfix(incrementor, ts.SyntaxKind.PlusPlusToken),\n      ts.createBlock([appendStatement]));\n\n  return ts.createFunctionDeclaration(\n      [], [], undefined, HelperFunction.projectNodes, [],\n      [renderer, parent, nodes].map(name => getAnyTypedParameter(name)), undefined,\n      ts.createBlock([loop], true));\n}\n\n/** Creates a helper for `animate`. */\nfunction getAnimateHelper(): ts.FunctionDeclaration {\n  // throw new Error('...');\n  const throwStatement = ts.createThrow(ts.createNew(\n      ts.createIdentifier('Error'), [],\n      [ts.createStringLiteral('Renderer.animate is no longer supported!')]));\n\n  return ts.createFunctionDeclaration(\n      [], [], undefined, HelperFunction.animate, [], [], undefined,\n      ts.createBlock([throwStatement], true));\n}\n\n/** Creates a helper for `destroyView`. */\nfunction getDestroyViewHelper(): ts.FunctionDeclaration {\n  const renderer = ts.createIdentifier('renderer');\n  const allNodes = ts.createIdentifier('allNodes');\n  const incrementor = ts.createIdentifier('i');\n\n  // for (let i = 0; i < allNodes.length; i++) {\n  //   renderer.destroyNode(allNodes[i]);\n  // }\n  const loopInitializer = ts.createVariableDeclarationList(\n      [ts.createVariableDeclaration(incrementor, undefined, ts.createNumericLiteral('0'))],\n      ts.NodeFlags.Let);\n  const loopCondition = ts.createBinary(\n      incrementor, ts.SyntaxKind.LessThanToken,\n      ts.createPropertyAccess(allNodes, ts.createIdentifier('length')));\n  const destroyStatement = ts.createExpressionStatement(ts.createCall(\n      ts.createPropertyAccess(renderer, 'destroyNode'), [],\n      [ts.createElementAccess(allNodes, incrementor)]));\n  const loop = ts.createFor(\n      loopInitializer, loopCondition, ts.createPostfix(incrementor, ts.SyntaxKind.PlusPlusToken),\n      ts.createBlock([destroyStatement]));\n\n  return ts.createFunctionDeclaration(\n      [], [], undefined, HelperFunction.destroyView, [],\n      [renderer, allNodes].map(name => getAnyTypedParameter(name)), undefined,\n      ts.createBlock([loop], true));\n}\n\n/** Creates a helper for `detachView`. */\nfunction getDetachViewHelper(): ts.FunctionDeclaration {\n  const renderer = ts.createIdentifier('renderer');\n  const rootNodes = ts.createIdentifier('rootNodes');\n  const incrementor = ts.createIdentifier('i');\n  const node = ts.createIdentifier('node');\n\n  // for (let i = 0; i < rootNodes.length; i++) {\n  //   const node = rootNodes[i];\n  //   renderer.removeChild(renderer.parentNode(node), node);\n  // }\n  const loopInitializer = ts.createVariableDeclarationList(\n      [ts.createVariableDeclaration(incrementor, undefined, ts.createNumericLiteral('0'))],\n      ts.NodeFlags.Let);\n  const loopCondition = ts.createBinary(\n      incrementor, ts.SyntaxKind.LessThanToken,\n      ts.createPropertyAccess(rootNodes, ts.createIdentifier('length')));\n\n  // const node = rootNodes[i];\n  const nodeVariableStatement = ts.createVariableStatement(\n      undefined,\n      ts.createVariableDeclarationList(\n          [ts.createVariableDeclaration(\n              node, undefined, ts.createElementAccess(rootNodes, incrementor))],\n          ts.NodeFlags.Const));\n  // renderer.removeChild(renderer.parentNode(node), node);\n  const removeCall = ts.createCall(\n      ts.createPropertyAccess(renderer, 'removeChild'), [],\n      [ts.createCall(ts.createPropertyAccess(renderer, 'parentNode'), [], [node]), node]);\n\n  const loop = ts.createFor(\n      loopInitializer, loopCondition, ts.createPostfix(incrementor, ts.SyntaxKind.PlusPlusToken),\n      ts.createBlock([nodeVariableStatement, ts.createExpressionStatement(removeCall)]));\n\n  return ts.createFunctionDeclaration(\n      [], [], undefined, HelperFunction.detachView, [],\n      [renderer, rootNodes].map(name => getAnyTypedParameter(name)), undefined,\n      ts.createBlock([loop], true));\n}\n\n/** Creates a helper for `attachViewAfter` */\nfunction getAttachViewAfterHelper(): ts.FunctionDeclaration {\n  const renderer = ts.createIdentifier('renderer');\n  const node = ts.createIdentifier('node');\n  const rootNodes = ts.createIdentifier('rootNodes');\n  const parent = ts.createIdentifier('parent');\n  const nextSibling = ts.createIdentifier('nextSibling');\n  const incrementor = ts.createIdentifier('i');\n  const createConstWithMethodCallInitializer = (constName: ts.Identifier, methodToCall: string) => {\n    return ts.createVariableStatement(\n        undefined,\n        ts.createVariableDeclarationList(\n            [ts.createVariableDeclaration(\n                constName, undefined,\n                ts.createCall(ts.createPropertyAccess(renderer, methodToCall), [], [node]))],\n            ts.NodeFlags.Const));\n  };\n\n  // const parent = renderer.parentNode(node);\n  const parentVariableStatement = createConstWithMethodCallInitializer(parent, 'parentNode');\n\n  // const nextSibling = renderer.nextSibling(node);\n  const nextSiblingVariableStatement =\n      createConstWithMethodCallInitializer(nextSibling, 'nextSibling');\n\n  // for (let i = 0; i < rootNodes.length; i++) {\n  //   renderer.insertBefore(parentElement, rootNodes[i], nextSibling);\n  // }\n  const loopInitializer = ts.createVariableDeclarationList(\n      [ts.createVariableDeclaration(incrementor, undefined, ts.createNumericLiteral('0'))],\n      ts.NodeFlags.Let);\n  const loopCondition = ts.createBinary(\n      incrementor, ts.SyntaxKind.LessThanToken,\n      ts.createPropertyAccess(rootNodes, ts.createIdentifier('length')));\n  const insertBeforeCall = ts.createCall(\n      ts.createPropertyAccess(renderer, 'insertBefore'), [],\n      [parent, ts.createElementAccess(rootNodes, incrementor), nextSibling]);\n  const loop = ts.createFor(\n      loopInitializer, loopCondition, ts.createPostfix(incrementor, ts.SyntaxKind.PlusPlusToken),\n      ts.createBlock([ts.createExpressionStatement(insertBeforeCall)]));\n\n  return ts.createFunctionDeclaration(\n      [], [], undefined, HelperFunction.attachViewAfter, [],\n      [renderer, node, rootNodes].map(name => getAnyTypedParameter(name)), undefined,\n      ts.createBlock([parentVariableStatement, nextSiblingVariableStatement, loop], true));\n}\n\n/** Creates a helper for `setElementAttribute` */\nfunction getSetElementAttributeHelper(): ts.FunctionDeclaration {\n  const renderer = ts.createIdentifier('renderer');\n  const element = ts.createIdentifier('element');\n  const namespaceAndName = ts.createIdentifier('namespaceAndName');\n  const value = ts.createIdentifier('value');\n  const name = ts.createIdentifier('name');\n  const namespace = ts.createIdentifier('namespace');\n\n  // [namespace, name] = splitNamespace(namespaceAndName);\n  const namespaceAndNameVariable = ts.createVariableDeclaration(\n      ts.createArrayBindingPattern(\n          [namespace, name].map(id => ts.createBindingElement(undefined, undefined, id))),\n      undefined,\n      ts.createCall(ts.createIdentifier(HelperFunction.splitNamespace), [], [namespaceAndName]));\n\n  // renderer.setAttribute(element, name, value, namespace);\n  const setCall = ts.createCall(\n      ts.createPropertyAccess(renderer, 'setAttribute'), [], [element, name, value, namespace]);\n\n  // renderer.removeAttribute(element, name, namespace);\n  const removeCall = ts.createCall(\n      ts.createPropertyAccess(renderer, 'removeAttribute'), [], [element, name, namespace]);\n\n  // if (value != null) { setCall() } else { removeCall }\n  const ifStatement = ts.createIf(\n      ts.createBinary(value, ts.SyntaxKind.ExclamationEqualsToken, ts.createNull()),\n      ts.createBlock([ts.createExpressionStatement(setCall)], true),\n      ts.createBlock([ts.createExpressionStatement(removeCall)], true));\n\n  const functionBody = ts.createBlock(\n      [\n        ts.createVariableStatement(\n            undefined,\n            ts.createVariableDeclarationList([namespaceAndNameVariable], ts.NodeFlags.Const)),\n        ifStatement\n      ],\n      true);\n\n  return ts.createFunctionDeclaration(\n      [], [], undefined, HelperFunction.setElementAttribute, [],\n      [\n        getAnyTypedParameter(renderer), getAnyTypedParameter(element),\n        getAnyTypedParameter(namespaceAndName), getAnyTypedParameter(value, false)\n      ],\n      undefined, functionBody);\n}\n\n/** Creates a helper for splitting a name that might contain a namespace. */\nfunction getSplitNamespaceHelper(): ts.FunctionDeclaration {\n  const name = ts.createIdentifier('name');\n  const match = ts.createIdentifier('match');\n  const regex = ts.createRegularExpressionLiteral('/^:([^:]+):(.+)$/');\n  const matchCall = ts.createCall(ts.createPropertyAccess(name, 'match'), [], [regex]);\n\n  // const match = name.split(regex);\n  const matchVariable = ts.createVariableDeclarationList(\n      [ts.createVariableDeclaration(match, undefined, matchCall)], ts.NodeFlags.Const);\n\n  // return [match[1], match[2]];\n  const matchReturn = ts.createReturn(\n      ts.createArrayLiteral([ts.createElementAccess(match, 1), ts.createElementAccess(match, 2)]));\n\n  // if (name[0] === ':') { const match = ...; return ...; }\n  const ifStatement = ts.createIf(\n      ts.createBinary(\n          ts.createElementAccess(name, 0), ts.SyntaxKind.EqualsEqualsEqualsToken,\n          ts.createStringLiteral(':')),\n      ts.createBlock([ts.createVariableStatement([], matchVariable), matchReturn], true));\n\n  // return ['', name];\n  const elseReturn = ts.createReturn(ts.createArrayLiteral([ts.createStringLiteral(''), name]));\n\n  return ts.createFunctionDeclaration(\n      [], [], undefined, HelperFunction.splitNamespace, [], [getAnyTypedParameter(name)], undefined,\n      ts.createBlock([ifStatement, elseReturn], true));\n}\n"]}

package/schematics/migrations/renderer-to-renderer2/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/renderer-to-renderer2" />
-import { Rule } from '@angular-devkit/schematics';
-/**
- * Migration that switches from `Renderer` to `Renderer2`. More information on how it works:
- * https://hackmd.angular.io/UTzUZTnPRA-cSa_4mHyfYw
- */
-export default function (): Rule;

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

@@ -1,135 +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/renderer-to-renderer2", ["require", "exports", "@angular-devkit/schematics", "path", "typescript", "@angular/core/schematics/utils/project_tsconfig_paths", "@angular/core/schematics/utils/typescript/compiler_host", "@angular/core/schematics/utils/typescript/imports", "@angular/core/schematics/utils/typescript/nodes", "@angular/core/schematics/migrations/renderer-to-renderer2/helpers", "@angular/core/schematics/migrations/renderer-to-renderer2/migration", "@angular/core/schematics/migrations/renderer-to-renderer2/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 imports_1 = require("@angular/core/schematics/utils/typescript/imports");
-    const nodes_1 = require("@angular/core/schematics/utils/typescript/nodes");
-    const helpers_1 = require("@angular/core/schematics/migrations/renderer-to-renderer2/helpers");
-    const migration_1 = require("@angular/core/schematics/migrations/renderer-to-renderer2/migration");
-    const util_1 = require("@angular/core/schematics/migrations/renderer-to-renderer2/util");
-    const MODULE_AUGMENTATION_FILENAME = 'ɵɵRENDERER_MIGRATION_CORE_AUGMENTATION.d.ts';
-    /**
-     * Migration that switches from `Renderer` to `Renderer2`. More information on how it works:
-     * https://hackmd.angular.io/UTzUZTnPRA-cSa_4mHyfYw
-     */
-    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 Renderer usages to Renderer2.');
-            }
-            for (const tsconfigPath of allPaths) {
-                runRendererToRenderer2Migration(tree, tsconfigPath, basePath);
-            }
-        });
-    }
-    exports.default = default_1;
-    function runRendererToRenderer2Migration(tree, tsconfigPath, basePath) {
-        // Technically we can get away with using `MODULE_AUGMENTATION_FILENAME` as the path, but as of
-        // TS 4.2, the module resolution caching seems to be more aggressive which causes the file to be
-        // retained between test runs. We can avoid it by using the full path.
-        const augmentedFilePath = (0, path_1.join)(basePath, MODULE_AUGMENTATION_FILENAME);
-        const { program } = (0, compiler_host_1.createMigrationProgram)(tree, tsconfigPath, basePath, fileName => {
-            // In case the module augmentation file has been requested, we return a source file that
-            // augments "@angular/core" to include a named export called "Renderer". This ensures that
-            // we can rely on the type checker for this migration in v9 where "Renderer" has been removed.
-            if ((0, path_1.basename)(fileName) === MODULE_AUGMENTATION_FILENAME) {
-                return `
-        import '@angular/core';
-        declare module "@angular/core" {
-          class Renderer {}
-        }
-      `;
-            }
-            return undefined;
-        }, [augmentedFilePath]);
-        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 rendererImportSpecifier = (0, imports_1.getImportSpecifier)(sourceFile, '@angular/core', 'Renderer');
-            const rendererImport = rendererImportSpecifier ?
-                (0, nodes_1.closestNode)(rendererImportSpecifier, ts.SyntaxKind.NamedImports) :
-                null;
-            // If there are no imports for the `Renderer`, we can exit early.
-            if (!rendererImportSpecifier || !rendererImport) {
-                return;
-            }
-            const { typedNodes, methodCalls, forwardRefs } = (0, util_1.findRendererReferences)(sourceFile, typeChecker, rendererImportSpecifier);
-            const update = tree.beginUpdate((0, path_1.relative)(basePath, sourceFile.fileName));
-            const helpersToAdd = new Set();
-            // Change the `Renderer` import to `Renderer2`.
-            update.remove(rendererImport.getStart(), rendererImport.getWidth());
-            update.insertRight(rendererImport.getStart(), printer.printNode(ts.EmitHint.Unspecified, (0, imports_1.replaceImport)(rendererImport, 'Renderer', 'Renderer2'), sourceFile));
-            // Change the method parameter and property types to `Renderer2`.
-            typedNodes.forEach(node => {
-                const type = node.type;
-                if (type) {
-                    update.remove(type.getStart(), type.getWidth());
-                    update.insertRight(type.getStart(), 'Renderer2');
-                }
-            });
-            // Change all identifiers inside `forwardRef` referring to the `Renderer`.
-            forwardRefs.forEach(identifier => {
-                update.remove(identifier.getStart(), identifier.getWidth());
-                update.insertRight(identifier.getStart(), 'Renderer2');
-            });
-            // Migrate all of the method calls.
-            methodCalls.forEach(call => {
-                const { node, requiredHelpers } = (0, migration_1.migrateExpression)(call, typeChecker);
-                if (node) {
-                    // If we migrated the node to a new expression, replace only the call expression.
-                    update.remove(call.getStart(), call.getWidth());
-                    update.insertRight(call.getStart(), printer.printNode(ts.EmitHint.Unspecified, node, sourceFile));
-                }
-                else if (call.parent && ts.isExpressionStatement(call.parent)) {
-                    // Otherwise if the call is inside an expression statement, drop the entire statement.
-                    // This takes care of any trailing semicolons. We only need to drop nodes for cases like
-                    // `setBindingDebugInfo` which have been noop for a while so they can be removed safely.
-                    update.remove(call.parent.getStart(), call.parent.getWidth());
-                }
-                if (requiredHelpers) {
-                    requiredHelpers.forEach(helperName => helpersToAdd.add(helperName));
-                }
-            });
-            // Some of the methods can't be mapped directly to `Renderer2` and need extra logic around them.
-            // The safest way to do so is to declare helper functions similar to the ones emitted by TS
-            // which encapsulate the extra "glue" logic. We should only emit these functions once per file.
-            helpersToAdd.forEach(helperName => {
-                update.insertLeft(sourceFile.endOfFileToken.getStart(), (0, helpers_1.getHelper)(helperName, sourceFile, printer));
-            });
-            tree.commitUpdate(update);
-        });
-    }
-});
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../../../packages/core/schematics/migrations/renderer-to-renderer2/index.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 {Rule, SchematicsException, Tree} from '@angular-devkit/schematics';\nimport {basename, join, relative} from 'path';\nimport * as ts from 'typescript';\n\nimport {getProjectTsConfigPaths} from '../../utils/project_tsconfig_paths';\nimport {canMigrateFile, createMigrationProgram} from '../../utils/typescript/compiler_host';\nimport {getImportSpecifier, replaceImport} from '../../utils/typescript/imports';\nimport {closestNode} from '../../utils/typescript/nodes';\n\nimport {getHelper, HelperFunction} from './helpers';\nimport {migrateExpression} from './migration';\nimport {findRendererReferences} from './util';\n\nconst MODULE_AUGMENTATION_FILENAME = 'ɵɵRENDERER_MIGRATION_CORE_AUGMENTATION.d.ts';\n\n/**\n * Migration that switches from `Renderer` to `Renderer2`. More information on how it works:\n * https://hackmd.angular.io/UTzUZTnPRA-cSa_4mHyfYw\n */\nexport default function(): Rule {\n  return async (tree: Tree) => {\n    const {buildPaths, testPaths} = await getProjectTsConfigPaths(tree);\n    const basePath = process.cwd();\n    const allPaths = [...buildPaths, ...testPaths];\n\n    if (!allPaths.length) {\n      throw new SchematicsException(\n          'Could not find any tsconfig file. Cannot migrate Renderer usages to Renderer2.');\n    }\n\n    for (const tsconfigPath of allPaths) {\n      runRendererToRenderer2Migration(tree, tsconfigPath, basePath);\n    }\n  };\n}\n\nfunction runRendererToRenderer2Migration(tree: Tree, tsconfigPath: string, basePath: string) {\n  // Technically we can get away with using `MODULE_AUGMENTATION_FILENAME` as the path, but as of\n  // TS 4.2, the module resolution caching seems to be more aggressive which causes the file to be\n  // retained between test runs. We can avoid it by using the full path.\n  const augmentedFilePath = join(basePath, MODULE_AUGMENTATION_FILENAME);\n  const {program} = createMigrationProgram(tree, tsconfigPath, basePath, fileName => {\n    // In case the module augmentation file has been requested, we return a source file that\n    // augments \"@angular/core\" to include a named export called \"Renderer\". This ensures that\n    // we can rely on the type checker for this migration in v9 where \"Renderer\" has been removed.\n    if (basename(fileName) === MODULE_AUGMENTATION_FILENAME) {\n      return `\n        import '@angular/core';\n        declare module \"@angular/core\" {\n          class Renderer {}\n        }\n      `;\n    }\n    return undefined;\n  }, [augmentedFilePath]);\n  const typeChecker = program.getTypeChecker();\n  const printer = ts.createPrinter();\n  const sourceFiles =\n      program.getSourceFiles().filter(sourceFile => canMigrateFile(basePath, sourceFile, program));\n\n  sourceFiles.forEach(sourceFile => {\n    const rendererImportSpecifier = getImportSpecifier(sourceFile, '@angular/core', 'Renderer');\n    const rendererImport = rendererImportSpecifier ?\n        closestNode<ts.NamedImports>(rendererImportSpecifier, ts.SyntaxKind.NamedImports) :\n        null;\n\n    // If there are no imports for the `Renderer`, we can exit early.\n    if (!rendererImportSpecifier || !rendererImport) {\n      return;\n    }\n\n    const {typedNodes, methodCalls, forwardRefs} =\n        findRendererReferences(sourceFile, typeChecker, rendererImportSpecifier);\n    const update = tree.beginUpdate(relative(basePath, sourceFile.fileName));\n    const helpersToAdd = new Set<HelperFunction>();\n\n    // Change the `Renderer` import to `Renderer2`.\n    update.remove(rendererImport.getStart(), rendererImport.getWidth());\n    update.insertRight(\n        rendererImport.getStart(),\n        printer.printNode(\n            ts.EmitHint.Unspecified, replaceImport(rendererImport, 'Renderer', 'Renderer2'),\n            sourceFile));\n\n    // Change the method parameter and property types to `Renderer2`.\n    typedNodes.forEach(node => {\n      const type = node.type;\n\n      if (type) {\n        update.remove(type.getStart(), type.getWidth());\n        update.insertRight(type.getStart(), 'Renderer2');\n      }\n    });\n\n    // Change all identifiers inside `forwardRef` referring to the `Renderer`.\n    forwardRefs.forEach(identifier => {\n      update.remove(identifier.getStart(), identifier.getWidth());\n      update.insertRight(identifier.getStart(), 'Renderer2');\n    });\n\n    // Migrate all of the method calls.\n    methodCalls.forEach(call => {\n      const {node, requiredHelpers} = migrateExpression(call, typeChecker);\n\n      if (node) {\n        // If we migrated the node to a new expression, replace only the call expression.\n        update.remove(call.getStart(), call.getWidth());\n        update.insertRight(\n            call.getStart(), printer.printNode(ts.EmitHint.Unspecified, node, sourceFile));\n      } else if (call.parent && ts.isExpressionStatement(call.parent)) {\n        // Otherwise if the call is inside an expression statement, drop the entire statement.\n        // This takes care of any trailing semicolons. We only need to drop nodes for cases like\n        // `setBindingDebugInfo` which have been noop for a while so they can be removed safely.\n        update.remove(call.parent.getStart(), call.parent.getWidth());\n      }\n\n      if (requiredHelpers) {\n        requiredHelpers.forEach(helperName => helpersToAdd.add(helperName));\n      }\n    });\n\n    // Some of the methods can't be mapped directly to `Renderer2` and need extra logic around them.\n    // The safest way to do so is to declare helper functions similar to the ones emitted by TS\n    // which encapsulate the extra \"glue\" logic. We should only emit these functions once per file.\n    helpersToAdd.forEach(helperName => {\n      update.insertLeft(\n          sourceFile.endOfFileToken.getStart(), getHelper(helperName, sourceFile, printer));\n    });\n\n    tree.commitUpdate(update);\n  });\n}\n"]}

package/schematics/migrations/renderer-to-renderer2/migration.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/migration" />
-import * as ts from 'typescript';
-import { HelperFunction } from './helpers';
-/**
- * Migrates a function call expression from `Renderer` to `Renderer2`.
- * Returns null if the expression should be dropped.
- */
-export declare function migrateExpression(node: ts.CallExpression, typeChecker: ts.TypeChecker): {
-    node: ts.Node | null;
-    requiredHelpers?: HelperFunction[];
-};