@angular/core 12.1.0-next.6 → 12.1.3

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

@@ -1,224 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import * as ts from 'typescript';
-/** Gets the string representation of a helper function. */
-export function getHelper(name, sourceFile, printer) {
-    const helperDeclaration = getHelperDeclaration(name);
-    return '\n' + printer.printNode(ts.EmitHint.Unspecified, helperDeclaration, sourceFile) + '\n';
-}
-/** 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.mjs

@@ -1,113 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { SchematicsException } from '@angular-devkit/schematics';
-import { basename, join, relative } from 'path';
-import * as ts from 'typescript';
-import { getProjectTsConfigPaths } from '../../utils/project_tsconfig_paths';
-import { canMigrateFile, createMigrationProgram } from '../../utils/typescript/compiler_host';
-import { getImportSpecifier, replaceImport } from '../../utils/typescript/imports';
-import { closestNode } from '../../utils/typescript/nodes';
-import { getHelper } from './helpers';
-import { migrateExpression } from './migration';
-import { findRendererReferences } from './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
- */
-export default function () {
-    return (tree) => {
-        const { buildPaths, testPaths } = getProjectTsConfigPaths(tree);
-        const basePath = process.cwd();
-        const allPaths = [...buildPaths, ...testPaths];
-        if (!allPaths.length) {
-            throw new SchematicsException('Could not find any tsconfig file. Cannot migrate Renderer usages to Renderer2.');
-        }
-        for (const tsconfigPath of allPaths) {
-            runRendererToRenderer2Migration(tree, tsconfigPath, basePath);
-        }
-    };
-}
-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 = join(basePath, MODULE_AUGMENTATION_FILENAME);
-    const { program } = 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 (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 => canMigrateFile(basePath, sourceFile, program));
-    sourceFiles.forEach(sourceFile => {
-        const rendererImportSpecifier = getImportSpecifier(sourceFile, '@angular/core', 'Renderer');
-        const rendererImport = rendererImportSpecifier ?
-            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 } = findRendererReferences(sourceFile, typeChecker, rendererImportSpecifier);
-        const update = tree.beginUpdate(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, 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 } = 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(), 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 (tree: Tree) => {\n    const {buildPaths, testPaths} = 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"]}