node_modules/@angular/core/schematics/migrations/static-queries/transform.js

/**
 * @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/static-queries/transform", ["require", "exports", "typescript", "@angular/core/schematics/utils/typescript/property_name", "@angular/core/schematics/migrations/static-queries/angular/query-definition"], factory);
    }
})(function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.getTransformedQueryCallExpr = void 0;
    const ts = require("typescript");
    const property_name_1 = require("@angular/core/schematics/utils/typescript/property_name");
    const query_definition_1 = require("@angular/core/schematics/migrations/static-queries/angular/query-definition");
    const TODO_SPECIFY_COMMENT = 'TODO: add static flag';
    const TODO_CHECK_COMMENT = 'TODO: check static flag';
    /**
     * Transforms the given query decorator by explicitly specifying the timing based on the
     * determined timing. The updated decorator call expression node will be returned.
     */
    function getTransformedQueryCallExpr(query, timing, createTodo) {
        const queryExpr = query.decorator.node.expression;
        const queryArguments = queryExpr.arguments;
        const queryPropertyAssignments = timing === null ?
            [] :
            [ts.createPropertyAssignment('static', timing === query_definition_1.QueryTiming.STATIC ? ts.createTrue() : ts.createFalse())];
        // If the query decorator is already called with two arguments, we need to
        // keep the existing options untouched and just add the new property if possible.
        if (queryArguments.length === 2) {
            const existingOptions = queryArguments[1];
            const existingOptionsText = existingOptions.getFullText();
            const hasTodoComment = existingOptionsText.includes(TODO_SPECIFY_COMMENT) ||
                existingOptionsText.includes(TODO_CHECK_COMMENT);
            let newOptionsNode;
            let failureMessage = null;
            if (ts.isObjectLiteralExpression(existingOptions)) {
                // In case the options already contains a property for the "static" flag,
                // we just skip this query and leave it untouched.
                if (existingOptions.properties.some(p => !!p.name && property_name_1.getPropertyNameText(p.name) === 'static')) {
                    return null;
                }
                newOptionsNode = ts.updateObjectLiteral(existingOptions, existingOptions.properties.concat(queryPropertyAssignments));
                // In case we want to add a todo and the options do not have the todo
                // yet, we add the query timing todo as synthetic multi-line comment.
                if (createTodo && !hasTodoComment) {
                    addQueryTimingTodoToNode(newOptionsNode, timing === null);
                }
            }
            else {
                // In case the options query parameter is not an object literal expression, and
                // we want to set the query timing, we just preserve the existing query parameter.
                newOptionsNode = existingOptions;
                // We always want to add a TODO in case the query options cannot be updated.
                if (!hasTodoComment) {
                    addQueryTimingTodoToNode(existingOptions, true);
                }
                // If there is a new explicit timing that has been determined for the given query,
                // we create a transformation failure message that shows developers that they need
                // to set the query timing manually to the determined query timing.
                if (timing !== null) {
                    failureMessage = 'Cannot update query to set explicit timing. Please manually ' +
                        `set the query timing to: "{static: ${(timing === query_definition_1.QueryTiming.STATIC).toString()}}"`;
                }
            }
            return {
                failureMessage,
                node: ts.updateCall(queryExpr, queryExpr.expression, queryExpr.typeArguments, [queryArguments[0], newOptionsNode])
            };
        }
        const optionsNode = ts.createObjectLiteral(queryPropertyAssignments);
        if (createTodo) {
            addQueryTimingTodoToNode(optionsNode, timing === null);
        }
        return {
            failureMessage: null,
            node: ts.updateCall(queryExpr, queryExpr.expression, queryExpr.typeArguments, [queryArguments[0], optionsNode])
        };
    }
    exports.getTransformedQueryCallExpr = getTransformedQueryCallExpr;
    /**
     * Adds a to-do to the given TypeScript node which reminds developers to specify
     * an explicit query timing or to double-check the updated timing.
     */
    function addQueryTimingTodoToNode(node, addSpecifyTimingTodo) {
        ts.setSyntheticLeadingComments(node, [{
                pos: -1,
                end: -1,
                hasTrailingNewLine: false,
                kind: ts.SyntaxKind.MultiLineCommentTrivia,
                text: ` ${addSpecifyTimingTodo ? TODO_SPECIFY_COMMENT : TODO_CHECK_COMMENT} `
            }]);
    }
});
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transform.js","sourceRoot":"","sources":["../../../../../../../../packages/core/schematics/migrations/static-queries/transform.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';\nimport {getPropertyNameText} from '../../utils/typescript/property_name';\nimport {NgQueryDefinition, QueryTiming} from './angular/query-definition';\n\nexport type TransformedQueryResult = null|{\n  /** Transformed call expression. */\n  node: ts.CallExpression;\n  /** Failure message which is set when the query could not be transformed successfully. */\n  failureMessage: string|null;\n};\n\nconst TODO_SPECIFY_COMMENT = 'TODO: add static flag';\nconst TODO_CHECK_COMMENT = 'TODO: check static flag';\n\n/**\n * Transforms the given query decorator by explicitly specifying the timing based on the\n * determined timing. The updated decorator call expression node will be returned.\n */\nexport function getTransformedQueryCallExpr(\n    query: NgQueryDefinition, timing: QueryTiming|null,\n    createTodo: boolean): TransformedQueryResult {\n  const queryExpr = query.decorator.node.expression;\n  const queryArguments = queryExpr.arguments;\n  const queryPropertyAssignments = timing === null ?\n      [] :\n      [ts.createPropertyAssignment(\n          'static', timing === QueryTiming.STATIC ? ts.createTrue() : ts.createFalse())];\n\n  // If the query decorator is already called with two arguments, we need to\n  // keep the existing options untouched and just add the new property if possible.\n  if (queryArguments.length === 2) {\n    const existingOptions = queryArguments[1];\n    const existingOptionsText = existingOptions.getFullText();\n    const hasTodoComment = existingOptionsText.includes(TODO_SPECIFY_COMMENT) ||\n        existingOptionsText.includes(TODO_CHECK_COMMENT);\n    let newOptionsNode: ts.Expression;\n    let failureMessage: string|null = null;\n\n    if (ts.isObjectLiteralExpression(existingOptions)) {\n      // In case the options already contains a property for the \"static\" flag,\n      // we just skip this query and leave it untouched.\n      if (existingOptions.properties.some(\n              p => !!p.name && getPropertyNameText(p.name) === 'static')) {\n        return null;\n      }\n\n      newOptionsNode = ts.updateObjectLiteral(\n          existingOptions, existingOptions.properties.concat(queryPropertyAssignments));\n\n      // In case we want to add a todo and the options do not have the todo\n      // yet, we add the query timing todo as synthetic multi-line comment.\n      if (createTodo && !hasTodoComment) {\n        addQueryTimingTodoToNode(newOptionsNode, timing === null);\n      }\n    } else {\n      // In case the options query parameter is not an object literal expression, and\n      // we want to set the query timing, we just preserve the existing query parameter.\n      newOptionsNode = existingOptions;\n      // We always want to add a TODO in case the query options cannot be updated.\n      if (!hasTodoComment) {\n        addQueryTimingTodoToNode(existingOptions, true);\n      }\n      // If there is a new explicit timing that has been determined for the given query,\n      // we create a transformation failure message that shows developers that they need\n      // to set the query timing manually to the determined query timing.\n      if (timing !== null) {\n        failureMessage = 'Cannot update query to set explicit timing. Please manually ' +\n            `set the query timing to: \"{static: ${(timing === QueryTiming.STATIC).toString()}}\"`;\n      }\n    }\n\n    return {\n      failureMessage,\n      node: ts.updateCall(\n          queryExpr, queryExpr.expression, queryExpr.typeArguments,\n          [queryArguments[0], newOptionsNode!])\n    };\n  }\n\n  const optionsNode = ts.createObjectLiteral(queryPropertyAssignments);\n\n  if (createTodo) {\n    addQueryTimingTodoToNode(optionsNode, timing === null);\n  }\n\n  return {\n    failureMessage: null,\n    node: ts.updateCall(\n        queryExpr, queryExpr.expression, queryExpr.typeArguments, [queryArguments[0], optionsNode])\n  };\n}\n\n/**\n * Adds a to-do to the given TypeScript node which reminds developers to specify\n * an explicit query timing or to double-check the updated timing.\n */\nfunction addQueryTimingTodoToNode(node: ts.Node, addSpecifyTimingTodo: boolean) {\n  ts.setSyntheticLeadingComments(\n      node, [{\n        pos: -1,\n        end: -1,\n        hasTrailingNewLine: false,\n        kind: ts.SyntaxKind.MultiLineCommentTrivia,\n        text: ` ${addSpecifyTimingTodo ? TODO_SPECIFY_COMMENT : TODO_CHECK_COMMENT} `\n      }]);\n}\n"]}