source: trip-planner-front/node_modules/@angular/compiler-cli/linker/src/ast/typescript/typescript_ast_host.js@ 6a3a178

/**
 * @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/compiler-cli/linker/src/ast/typescript/typescript_ast_host", ["require", "exports", "tslib", "typescript", "@angular/compiler-cli/linker/src/fatal_linker_error", "@angular/compiler-cli/linker/src/ast/utils"], factory);
    }
})(function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.TypeScriptAstHost = void 0;
    var tslib_1 = require("tslib");
    var ts = require("typescript");
    var fatal_linker_error_1 = require("@angular/compiler-cli/linker/src/fatal_linker_error");
    var utils_1 = require("@angular/compiler-cli/linker/src/ast/utils");
    /**
     * This implementation of `AstHost` is able to get information from TypeScript AST nodes.
     *
     * This host is not actually used at runtime in the current code.
     *
     * It is implemented here to ensure that the `AstHost` abstraction is not unfairly skewed towards
     * the Babel implementation. It could also provide a basis for a 3rd TypeScript compiler plugin to
     * do linking in the future.
     */
    var TypeScriptAstHost = /** @class */ (function () {
        function TypeScriptAstHost() {
            this.isStringLiteral = ts.isStringLiteral;
            this.isNumericLiteral = ts.isNumericLiteral;
            this.isArrayLiteral = ts.isArrayLiteralExpression;
            this.isObjectLiteral = ts.isObjectLiteralExpression;
            this.isCallExpression = ts.isCallExpression;
        }
        TypeScriptAstHost.prototype.getSymbolName = function (node) {
            if (ts.isIdentifier(node)) {
                return node.text;
            }
            else if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.name)) {
                return node.name.text;
            }
            else {
                return null;
            }
        };
        TypeScriptAstHost.prototype.parseStringLiteral = function (str) {
            utils_1.assert(str, this.isStringLiteral, 'a string literal');
            return str.text;
        };
        TypeScriptAstHost.prototype.parseNumericLiteral = function (num) {
            utils_1.assert(num, this.isNumericLiteral, 'a numeric literal');
            return parseInt(num.text);
        };
        TypeScriptAstHost.prototype.isBooleanLiteral = function (node) {
            return isBooleanLiteral(node) || isMinifiedBooleanLiteral(node);
        };
        TypeScriptAstHost.prototype.parseBooleanLiteral = function (bool) {
            if (isBooleanLiteral(bool)) {
                return bool.kind === ts.SyntaxKind.TrueKeyword;
            }
            else if (isMinifiedBooleanLiteral(bool)) {
                return !(+bool.operand.text);
            }
            else {
                throw new fatal_linker_error_1.FatalLinkerError(bool, 'Unsupported syntax, expected a boolean literal.');
            }
        };
        TypeScriptAstHost.prototype.parseArrayLiteral = function (array) {
            utils_1.assert(array, this.isArrayLiteral, 'an array literal');
            return array.elements.map(function (element) {
                utils_1.assert(element, isNotEmptyElement, 'element in array not to be empty');
                utils_1.assert(element, isNotSpreadElement, 'element in array not to use spread syntax');
                return element;
            });
        };
        TypeScriptAstHost.prototype.parseObjectLiteral = function (obj) {
            var e_1, _a;
            utils_1.assert(obj, this.isObjectLiteral, 'an object literal');
            var result = new Map();
            try {
                for (var _b = tslib_1.__values(obj.properties), _c = _b.next(); !_c.done; _c = _b.next()) {
                    var property = _c.value;
                    utils_1.assert(property, ts.isPropertyAssignment, 'a property assignment');
                    utils_1.assert(property.name, isPropertyName, 'a property name');
                    result.set(property.name.text, property.initializer);
                }
            }
            catch (e_1_1) { e_1 = { error: e_1_1 }; }
            finally {
                try {
                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                }
                finally { if (e_1) throw e_1.error; }
            }
            return result;
        };
        TypeScriptAstHost.prototype.isFunctionExpression = function (node) {
            return ts.isFunctionExpression(node) || ts.isArrowFunction(node);
        };
        TypeScriptAstHost.prototype.parseReturnValue = function (fn) {
            utils_1.assert(fn, this.isFunctionExpression, 'a function');
            if (!ts.isBlock(fn.body)) {
                // it is a simple array function expression: `(...) => expr`
                return fn.body;
            }
            // it is a function (arrow or normal) with a body. E.g.:
            // * `(...) => { stmt; ... }`
            // * `function(...) { stmt; ... }`
            if (fn.body.statements.length !== 1) {
                throw new fatal_linker_error_1.FatalLinkerError(fn.body, 'Unsupported syntax, expected a function body with a single return statement.');
            }
            var stmt = fn.body.statements[0];
            utils_1.assert(stmt, ts.isReturnStatement, 'a function body with a single return statement');
            if (stmt.expression === undefined) {
                throw new fatal_linker_error_1.FatalLinkerError(stmt, 'Unsupported syntax, expected function to return a value.');
            }
            return stmt.expression;
        };
        TypeScriptAstHost.prototype.parseCallee = function (call) {
            utils_1.assert(call, ts.isCallExpression, 'a call expression');
            return call.expression;
        };
        TypeScriptAstHost.prototype.parseArguments = function (call) {
            utils_1.assert(call, ts.isCallExpression, 'a call expression');
            return call.arguments.map(function (arg) {
                utils_1.assert(arg, isNotSpreadElement, 'argument not to use spread syntax');
                return arg;
            });
        };
        TypeScriptAstHost.prototype.getRange = function (node) {
            var file = node.getSourceFile();
            if (file === undefined) {
                throw new fatal_linker_error_1.FatalLinkerError(node, 'Unable to read range for node - it is missing parent information.');
            }
            var startPos = node.getStart();
            var endPos = node.getEnd();
            var _a = ts.getLineAndCharacterOfPosition(file, startPos), startLine = _a.line, startCol = _a.character;
            return { startLine: startLine, startCol: startCol, startPos: startPos, endPos: endPos };
        };
        return TypeScriptAstHost;
    }());
    exports.TypeScriptAstHost = TypeScriptAstHost;
    /**
     * Return true if the expression does not represent an empty element in an array literal.
     * For example in `[,foo]` the first element is "empty".
     */
    function isNotEmptyElement(e) {
        return !ts.isOmittedExpression(e);
    }
    /**
     * Return true if the expression is not a spread element of an array literal.
     * For example in `[x, ...rest]` the `...rest` expression is a spread element.
     */
    function isNotSpreadElement(e) {
        return !ts.isSpreadElement(e);
    }
    /**
     * Return true if the expression can be considered a text based property name.
     */
    function isPropertyName(e) {
        return ts.isIdentifier(e) || ts.isStringLiteral(e) || ts.isNumericLiteral(e);
    }
    /**
     * Return true if the node is either `true` or `false` literals.
     */
    function isBooleanLiteral(node) {
        return node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword;
    }
    /**
     * Return true if the node is either `!0` or `!1`.
     */
    function isMinifiedBooleanLiteral(node) {
        return ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.ExclamationToken &&
            ts.isNumericLiteral(node.operand) && (node.operand.text === '0' || node.operand.text === '1');
    }
});
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"typescript_ast_host.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/linker/src/ast/typescript/typescript_ast_host.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport * as ts from 'typescript';\n\nimport {FatalLinkerError} from '../../fatal_linker_error';\nimport {AstHost, Range} from '../ast_host';\nimport {assert} from '../utils';\n\n\n/**\n * This implementation of `AstHost` is able to get information from TypeScript AST nodes.\n *\n * This host is not actually used at runtime in the current code.\n *\n * It is implemented here to ensure that the `AstHost` abstraction is not unfairly skewed towards\n * the Babel implementation. It could also provide a basis for a 3rd TypeScript compiler plugin to\n * do linking in the future.\n */\nexport class TypeScriptAstHost implements AstHost<ts.Expression> {\n  getSymbolName(node: ts.Expression): string|null {\n    if (ts.isIdentifier(node)) {\n      return node.text;\n    } else if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.name)) {\n      return node.name.text;\n    } else {\n      return null;\n    }\n  }\n\n  isStringLiteral = ts.isStringLiteral;\n\n  parseStringLiteral(str: ts.Expression): string {\n    assert(str, this.isStringLiteral, 'a string literal');\n    return str.text;\n  }\n\n  isNumericLiteral = ts.isNumericLiteral;\n\n  parseNumericLiteral(num: ts.Expression): number {\n    assert(num, this.isNumericLiteral, 'a numeric literal');\n    return parseInt(num.text);\n  }\n\n  isBooleanLiteral(node: ts.Expression): boolean {\n    return isBooleanLiteral(node) || isMinifiedBooleanLiteral(node);\n  }\n\n  parseBooleanLiteral(bool: ts.Expression): boolean {\n    if (isBooleanLiteral(bool)) {\n      return bool.kind === ts.SyntaxKind.TrueKeyword;\n    } else if (isMinifiedBooleanLiteral(bool)) {\n      return !(+bool.operand.text);\n    } else {\n      throw new FatalLinkerError(bool, 'Unsupported syntax, expected a boolean literal.');\n    }\n  }\n\n  isArrayLiteral = ts.isArrayLiteralExpression;\n\n  parseArrayLiteral(array: ts.Expression): ts.Expression[] {\n    assert(array, this.isArrayLiteral, 'an array literal');\n    return array.elements.map(element => {\n      assert(element, isNotEmptyElement, 'element in array not to be empty');\n      assert(element, isNotSpreadElement, 'element in array not to use spread syntax');\n      return element;\n    });\n  }\n\n  isObjectLiteral = ts.isObjectLiteralExpression;\n\n  parseObjectLiteral(obj: ts.Expression): Map<string, ts.Expression> {\n    assert(obj, this.isObjectLiteral, 'an object literal');\n\n    const result = new Map<string, ts.Expression>();\n    for (const property of obj.properties) {\n      assert(property, ts.isPropertyAssignment, 'a property assignment');\n      assert(property.name, isPropertyName, 'a property name');\n      result.set(property.name.text, property.initializer);\n    }\n    return result;\n  }\n\n  isFunctionExpression(node: ts.Expression): node is ts.FunctionExpression|ts.ArrowFunction {\n    return ts.isFunctionExpression(node) || ts.isArrowFunction(node);\n  }\n\n  parseReturnValue(fn: ts.Expression): ts.Expression {\n    assert(fn, this.isFunctionExpression, 'a function');\n    if (!ts.isBlock(fn.body)) {\n      // it is a simple array function expression: `(...) => expr`\n      return fn.body;\n    }\n\n    // it is a function (arrow or normal) with a body. E.g.:\n    // * `(...) => { stmt; ... }`\n    // * `function(...) { stmt; ... }`\n\n    if (fn.body.statements.length !== 1) {\n      throw new FatalLinkerError(\n          fn.body, 'Unsupported syntax, expected a function body with a single return statement.');\n    }\n    const stmt = fn.body.statements[0];\n    assert(stmt, ts.isReturnStatement, 'a function body with a single return statement');\n    if (stmt.expression === undefined) {\n      throw new FatalLinkerError(stmt, 'Unsupported syntax, expected function to return a value.');\n    }\n\n    return stmt.expression;\n  }\n\n  isCallExpression = ts.isCallExpression;\n\n  parseCallee(call: ts.Expression): ts.Expression {\n    assert(call, ts.isCallExpression, 'a call expression');\n    return call.expression;\n  }\n\n  parseArguments(call: ts.Expression): ts.Expression[] {\n    assert(call, ts.isCallExpression, 'a call expression');\n    return call.arguments.map(arg => {\n      assert(arg, isNotSpreadElement, 'argument not to use spread syntax');\n      return arg;\n    });\n  }\n\n  getRange(node: ts.Expression): Range {\n    const file = node.getSourceFile();\n    if (file === undefined) {\n      throw new FatalLinkerError(\n          node, 'Unable to read range for node - it is missing parent information.');\n    }\n    const startPos = node.getStart();\n    const endPos = node.getEnd();\n    const {line: startLine, character: startCol} = ts.getLineAndCharacterOfPosition(file, startPos);\n    return {startLine, startCol, startPos, endPos};\n  }\n}\n\n/**\n * Return true if the expression does not represent an empty element in an array literal.\n * For example in `[,foo]` the first element is \"empty\".\n */\nfunction isNotEmptyElement(e: ts.Expression|ts.SpreadElement|\n                           ts.OmittedExpression): e is ts.Expression|ts.SpreadElement {\n  return !ts.isOmittedExpression(e);\n}\n\n/**\n * Return true if the expression is not a spread element of an array literal.\n * For example in `[x, ...rest]` the `...rest` expression is a spread element.\n */\nfunction isNotSpreadElement(e: ts.Expression|ts.SpreadElement): e is ts.Expression {\n  return !ts.isSpreadElement(e);\n}\n\n/**\n * Return true if the expression can be considered a text based property name.\n */\nfunction isPropertyName(e: ts.PropertyName): e is ts.Identifier|ts.StringLiteral|ts.NumericLiteral {\n  return ts.isIdentifier(e) || ts.isStringLiteral(e) || ts.isNumericLiteral(e);\n}\n\n/**\n * Return true if the node is either `true` or `false` literals.\n */\nfunction isBooleanLiteral(node: ts.Expression): node is ts.TrueLiteral|ts.FalseLiteral {\n  return node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword;\n}\n\ntype MinifiedBooleanLiteral = ts.PrefixUnaryExpression&{operand: ts.NumericLiteral};\n\n/**\n * Return true if the node is either `!0` or `!1`.\n */\nfunction isMinifiedBooleanLiteral(node: ts.Expression): node is MinifiedBooleanLiteral {\n  return ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.ExclamationToken &&\n      ts.isNumericLiteral(node.operand) && (node.operand.text === '0' || node.operand.text === '1');\n}\n"]}