source: trip-planner-front/node_modules/@angular/compiler-cli/linker/babel/src/ast/babel_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/babel/src/ast/babel_ast_host", ["require", "exports", "tslib", "@babel/types", "@angular/compiler-cli/linker"], factory);
    }
})(function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.BabelAstHost = void 0;
    var tslib_1 = require("tslib");
    var t = require("@babel/types");
    var linker_1 = require("@angular/compiler-cli/linker");
    /**
     * This implementation of `AstHost` is able to get information from Babel AST nodes.
     */
    var BabelAstHost = /** @class */ (function () {
        function BabelAstHost() {
            this.isStringLiteral = t.isStringLiteral;
            this.isNumericLiteral = t.isNumericLiteral;
            this.isArrayLiteral = t.isArrayExpression;
            this.isObjectLiteral = t.isObjectExpression;
            this.isCallExpression = t.isCallExpression;
        }
        BabelAstHost.prototype.getSymbolName = function (node) {
            if (t.isIdentifier(node)) {
                return node.name;
            }
            else if (t.isMemberExpression(node) && t.isIdentifier(node.property)) {
                return node.property.name;
            }
            else {
                return null;
            }
        };
        BabelAstHost.prototype.parseStringLiteral = function (str) {
            linker_1.assert(str, t.isStringLiteral, 'a string literal');
            return str.value;
        };
        BabelAstHost.prototype.parseNumericLiteral = function (num) {
            linker_1.assert(num, t.isNumericLiteral, 'a numeric literal');
            return num.value;
        };
        BabelAstHost.prototype.isBooleanLiteral = function (bool) {
            return t.isBooleanLiteral(bool) || isMinifiedBooleanLiteral(bool);
        };
        BabelAstHost.prototype.parseBooleanLiteral = function (bool) {
            if (t.isBooleanLiteral(bool)) {
                return bool.value;
            }
            else if (isMinifiedBooleanLiteral(bool)) {
                return !bool.argument.value;
            }
            else {
                throw new linker_1.FatalLinkerError(bool, 'Unsupported syntax, expected a boolean literal.');
            }
        };
        BabelAstHost.prototype.parseArrayLiteral = function (array) {
            linker_1.assert(array, t.isArrayExpression, 'an array literal');
            return array.elements.map(function (element) {
                linker_1.assert(element, isNotEmptyElement, 'element in array not to be empty');
                linker_1.assert(element, isNotSpreadElement, 'element in array not to use spread syntax');
                return element;
            });
        };
        BabelAstHost.prototype.parseObjectLiteral = function (obj) {
            var e_1, _a;
            linker_1.assert(obj, t.isObjectExpression, '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;
                    linker_1.assert(property, t.isObjectProperty, 'a property assignment');
                    linker_1.assert(property.value, t.isExpression, 'an expression');
                    linker_1.assert(property.key, isPropertyName, 'a property name');
                    var key = t.isIdentifier(property.key) ? property.key.name : property.key.value;
                    result.set(key, property.value);
                }
            }
            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;
        };
        BabelAstHost.prototype.isFunctionExpression = function (node) {
            return t.isFunction(node);
        };
        BabelAstHost.prototype.parseReturnValue = function (fn) {
            linker_1.assert(fn, this.isFunctionExpression, 'a function');
            if (!t.isBlockStatement(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.body.length !== 1) {
                throw new linker_1.FatalLinkerError(fn.body, 'Unsupported syntax, expected a function body with a single return statement.');
            }
            var stmt = fn.body.body[0];
            linker_1.assert(stmt, t.isReturnStatement, 'a function body with a single return statement');
            if (stmt.argument === null) {
                throw new linker_1.FatalLinkerError(stmt, 'Unsupported syntax, expected function to return a value.');
            }
            return stmt.argument;
        };
        BabelAstHost.prototype.parseCallee = function (call) {
            linker_1.assert(call, t.isCallExpression, 'a call expression');
            linker_1.assert(call.callee, t.isExpression, 'an expression');
            return call.callee;
        };
        BabelAstHost.prototype.parseArguments = function (call) {
            linker_1.assert(call, t.isCallExpression, 'a call expression');
            return call.arguments.map(function (arg) {
                linker_1.assert(arg, isNotSpreadArgument, 'argument not to use spread syntax');
                linker_1.assert(arg, t.isExpression, 'argument to be an expression');
                return arg;
            });
        };
        BabelAstHost.prototype.getRange = function (node) {
            if (node.loc == null || node.start === null || node.end === null) {
                throw new linker_1.FatalLinkerError(node, 'Unable to read range for node - it is missing location information.');
            }
            return {
                startLine: node.loc.start.line - 1,
                startCol: node.loc.start.column,
                startPos: node.start,
                endPos: node.end,
            };
        };
        return BabelAstHost;
    }());
    exports.BabelAstHost = BabelAstHost;
    /**
     * 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 e !== null;
    }
    /**
     * 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 !t.isSpreadElement(e);
    }
    /**
     * Return true if the expression can be considered a text based property name.
     */
    function isPropertyName(e) {
        return t.isIdentifier(e) || t.isStringLiteral(e) || t.isNumericLiteral(e);
    }
    /**
     * Return true if the argument is not a spread element.
     */
    function isNotSpreadArgument(arg) {
        return !t.isSpreadElement(arg);
    }
    /**
     * Return true if the node is either `!0` or `!1`.
     */
    function isMinifiedBooleanLiteral(node) {
        return t.isUnaryExpression(node) && node.prefix && node.operator === '!' &&
            t.isNumericLiteral(node.argument) && (node.argument.value === 0 || node.argument.value === 1);
    }
});
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"babel_ast_host.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/linker/babel/src/ast/babel_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 t from '@babel/types';\n\nimport {assert, AstHost, FatalLinkerError, Range} from '../../../../linker';\n\n/**\n * This implementation of `AstHost` is able to get information from Babel AST nodes.\n */\nexport class BabelAstHost implements AstHost<t.Expression> {\n  getSymbolName(node: t.Expression): string|null {\n    if (t.isIdentifier(node)) {\n      return node.name;\n    } else if (t.isMemberExpression(node) && t.isIdentifier(node.property)) {\n      return node.property.name;\n    } else {\n      return null;\n    }\n  }\n\n  isStringLiteral = t.isStringLiteral;\n\n  parseStringLiteral(str: t.Expression): string {\n    assert(str, t.isStringLiteral, 'a string literal');\n    return str.value;\n  }\n\n  isNumericLiteral = t.isNumericLiteral;\n\n  parseNumericLiteral(num: t.Expression): number {\n    assert(num, t.isNumericLiteral, 'a numeric literal');\n    return num.value;\n  }\n\n  isBooleanLiteral(bool: t.Expression): boolean {\n    return t.isBooleanLiteral(bool) || isMinifiedBooleanLiteral(bool);\n  }\n\n  parseBooleanLiteral(bool: t.Expression): boolean {\n    if (t.isBooleanLiteral(bool)) {\n      return bool.value;\n    } else if (isMinifiedBooleanLiteral(bool)) {\n      return !bool.argument.value;\n    } else {\n      throw new FatalLinkerError(bool, 'Unsupported syntax, expected a boolean literal.');\n    }\n  }\n\n  isArrayLiteral = t.isArrayExpression;\n\n  parseArrayLiteral(array: t.Expression): t.Expression[] {\n    assert(array, t.isArrayExpression, '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 = t.isObjectExpression;\n\n  parseObjectLiteral(obj: t.Expression): Map<string, t.Expression> {\n    assert(obj, t.isObjectExpression, 'an object literal');\n\n    const result = new Map<string, t.Expression>();\n    for (const property of obj.properties) {\n      assert(property, t.isObjectProperty, 'a property assignment');\n      assert(property.value, t.isExpression, 'an expression');\n      assert(property.key, isPropertyName, 'a property name');\n      const key = t.isIdentifier(property.key) ? property.key.name : property.key.value;\n      result.set(key, property.value);\n    }\n    return result;\n  }\n\n  isFunctionExpression(node: t.Expression): node is Extract<t.Function, t.Expression> {\n    return t.isFunction(node);\n  }\n\n  parseReturnValue(fn: t.Expression): t.Expression {\n    assert(fn, this.isFunctionExpression, 'a function');\n    if (!t.isBlockStatement(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.body.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.body[0];\n    assert(stmt, t.isReturnStatement, 'a function body with a single return statement');\n    if (stmt.argument === null) {\n      throw new FatalLinkerError(stmt, 'Unsupported syntax, expected function to return a value.');\n    }\n\n    return stmt.argument;\n  }\n\n  isCallExpression = t.isCallExpression;\n  parseCallee(call: t.Expression): t.Expression {\n    assert(call, t.isCallExpression, 'a call expression');\n    assert(call.callee, t.isExpression, 'an expression');\n    return call.callee;\n  }\n  parseArguments(call: t.Expression): t.Expression[] {\n    assert(call, t.isCallExpression, 'a call expression');\n    return call.arguments.map(arg => {\n      assert(arg, isNotSpreadArgument, 'argument not to use spread syntax');\n      assert(arg, t.isExpression, 'argument to be an expression');\n      return arg;\n    });\n  }\n\n  getRange(node: t.Expression): Range {\n    if (node.loc == null || node.start === null || node.end === null) {\n      throw new FatalLinkerError(\n          node, 'Unable to read range for node - it is missing location information.');\n    }\n    return {\n      startLine: node.loc.start.line - 1,  // Babel lines are 1-based\n      startCol: node.loc.start.column,\n      startPos: node.start,\n      endPos: node.end,\n    };\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: t.Expression|t.SpreadElement|null): e is t.Expression|\n    t.SpreadElement {\n  return e !== null;\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: t.Expression|t.SpreadElement): e is t.Expression {\n  return !t.isSpreadElement(e);\n}\n\n\n/**\n * Return true if the expression can be considered a text based property name.\n */\nfunction isPropertyName(e: t.Expression): e is t.Identifier|t.StringLiteral|t.NumericLiteral {\n  return t.isIdentifier(e) || t.isStringLiteral(e) || t.isNumericLiteral(e);\n}\n\n/**\n * The declared type of an argument to a call expression.\n */\ntype ArgumentType = t.CallExpression['arguments'][number];\n\n/**\n * Return true if the argument is not a spread element.\n */\nfunction isNotSpreadArgument(arg: ArgumentType): arg is Exclude<ArgumentType, t.SpreadElement> {\n  return !t.isSpreadElement(arg);\n}\n\ntype MinifiedBooleanLiteral = t.Expression&t.UnaryExpression&{argument: t.NumericLiteral};\n\n/**\n * Return true if the node is either `!0` or `!1`.\n */\nfunction isMinifiedBooleanLiteral(node: t.Expression): node is MinifiedBooleanLiteral {\n  return t.isUnaryExpression(node) && node.prefix && node.operator === '!' &&\n      t.isNumericLiteral(node.argument) && (node.argument.value === 0 || node.argument.value === 1);\n}\n"]}