source: trip-planner-front/node_modules/@angular/compiler/src/output/output_jit.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/compiler/src/output/output_jit", ["require", "exports", "tslib", "@angular/compiler/src/parse_util", "@angular/compiler/src/output/abstract_emitter", "@angular/compiler/src/output/abstract_js_emitter", "@angular/compiler/src/output/output_ast", "@angular/compiler/src/output/output_jit_trusted_types"], factory);
    }
})(function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.JitEmitterVisitor = exports.JitEvaluator = void 0;
    var tslib_1 = require("tslib");
    var parse_util_1 = require("@angular/compiler/src/parse_util");
    var abstract_emitter_1 = require("@angular/compiler/src/output/abstract_emitter");
    var abstract_js_emitter_1 = require("@angular/compiler/src/output/abstract_js_emitter");
    var o = require("@angular/compiler/src/output/output_ast");
    var output_jit_trusted_types_1 = require("@angular/compiler/src/output/output_jit_trusted_types");
    /**
     * A helper class to manage the evaluation of JIT generated code.
     */
    var JitEvaluator = /** @class */ (function () {
        function JitEvaluator() {
        }
        /**
         *
         * @param sourceUrl The URL of the generated code.
         * @param statements An array of Angular statement AST nodes to be evaluated.
         * @param reflector A helper used when converting the statements to executable code.
         * @param createSourceMaps If true then create a source-map for the generated code and include it
         * inline as a source-map comment.
         * @returns A map of all the variables in the generated code.
         */
        JitEvaluator.prototype.evaluateStatements = function (sourceUrl, statements, reflector, createSourceMaps) {
            var converter = new JitEmitterVisitor(reflector);
            var ctx = abstract_emitter_1.EmitterVisitorContext.createRoot();
            // Ensure generated code is in strict mode
            if (statements.length > 0 && !isUseStrictStatement(statements[0])) {
                statements = tslib_1.__spreadArray([
                    o.literal('use strict').toStmt()
                ], tslib_1.__read(statements));
            }
            converter.visitAllStatements(statements, ctx);
            converter.createReturnStmt(ctx);
            return this.evaluateCode(sourceUrl, ctx, converter.getArgs(), createSourceMaps);
        };
        /**
         * Evaluate a piece of JIT generated code.
         * @param sourceUrl The URL of this generated code.
         * @param ctx A context object that contains an AST of the code to be evaluated.
         * @param vars A map containing the names and values of variables that the evaluated code might
         * reference.
         * @param createSourceMap If true then create a source-map for the generated code and include it
         * inline as a source-map comment.
         * @returns The result of evaluating the code.
         */
        JitEvaluator.prototype.evaluateCode = function (sourceUrl, ctx, vars, createSourceMap) {
            var fnBody = "\"use strict\";" + ctx.toSource() + "\n//# sourceURL=" + sourceUrl;
            var fnArgNames = [];
            var fnArgValues = [];
            for (var argName in vars) {
                fnArgValues.push(vars[argName]);
                fnArgNames.push(argName);
            }
            if (createSourceMap) {
                // using `new Function(...)` generates a header, 1 line of no arguments, 2 lines otherwise
                // E.g. ```
                // function anonymous(a,b,c
                // /**/) { ... }```
                // We don't want to hard code this fact, so we auto detect it via an empty function first.
                var emptyFn = output_jit_trusted_types_1.newTrustedFunctionForJIT.apply(void 0, tslib_1.__spreadArray([], tslib_1.__read(fnArgNames.concat('return null;')))).toString();
                var headerLines = emptyFn.slice(0, emptyFn.indexOf('return null;')).split('\n').length - 1;
                fnBody += "\n" + ctx.toSourceMapGenerator(sourceUrl, headerLines).toJsComment();
            }
            var fn = output_jit_trusted_types_1.newTrustedFunctionForJIT.apply(void 0, tslib_1.__spreadArray([], tslib_1.__read(fnArgNames.concat(fnBody))));
            return this.executeFunction(fn, fnArgValues);
        };
        /**
         * Execute a JIT generated function by calling it.
         *
         * This method can be overridden in tests to capture the functions that are generated
         * by this `JitEvaluator` class.
         *
         * @param fn A function to execute.
         * @param args The arguments to pass to the function being executed.
         * @returns The return value of the executed function.
         */
        JitEvaluator.prototype.executeFunction = function (fn, args) {
            return fn.apply(void 0, tslib_1.__spreadArray([], tslib_1.__read(args)));
        };
        return JitEvaluator;
    }());
    exports.JitEvaluator = JitEvaluator;
    /**
     * An Angular AST visitor that converts AST nodes into executable JavaScript code.
     */
    var JitEmitterVisitor = /** @class */ (function (_super) {
        tslib_1.__extends(JitEmitterVisitor, _super);
        function JitEmitterVisitor(reflector) {
            var _this = _super.call(this) || this;
            _this.reflector = reflector;
            _this._evalArgNames = [];
            _this._evalArgValues = [];
            _this._evalExportedVars = [];
            return _this;
        }
        JitEmitterVisitor.prototype.createReturnStmt = function (ctx) {
            var stmt = new o.ReturnStatement(new o.LiteralMapExpr(this._evalExportedVars.map(function (resultVar) { return new o.LiteralMapEntry(resultVar, o.variable(resultVar), false); })));
            stmt.visitStatement(this, ctx);
        };
        JitEmitterVisitor.prototype.getArgs = function () {
            var result = {};
            for (var i = 0; i < this._evalArgNames.length; i++) {
                result[this._evalArgNames[i]] = this._evalArgValues[i];
            }
            return result;
        };
        JitEmitterVisitor.prototype.visitExternalExpr = function (ast, ctx) {
            this._emitReferenceToExternal(ast, this.reflector.resolveExternalReference(ast.value), ctx);
            return null;
        };
        JitEmitterVisitor.prototype.visitWrappedNodeExpr = function (ast, ctx) {
            this._emitReferenceToExternal(ast, ast.node, ctx);
            return null;
        };
        JitEmitterVisitor.prototype.visitDeclareVarStmt = function (stmt, ctx) {
            if (stmt.hasModifier(o.StmtModifier.Exported)) {
                this._evalExportedVars.push(stmt.name);
            }
            return _super.prototype.visitDeclareVarStmt.call(this, stmt, ctx);
        };
        JitEmitterVisitor.prototype.visitDeclareFunctionStmt = function (stmt, ctx) {
            if (stmt.hasModifier(o.StmtModifier.Exported)) {
                this._evalExportedVars.push(stmt.name);
            }
            return _super.prototype.visitDeclareFunctionStmt.call(this, stmt, ctx);
        };
        JitEmitterVisitor.prototype.visitDeclareClassStmt = function (stmt, ctx) {
            if (stmt.hasModifier(o.StmtModifier.Exported)) {
                this._evalExportedVars.push(stmt.name);
            }
            return _super.prototype.visitDeclareClassStmt.call(this, stmt, ctx);
        };
        JitEmitterVisitor.prototype._emitReferenceToExternal = function (ast, value, ctx) {
            var id = this._evalArgValues.indexOf(value);
            if (id === -1) {
                id = this._evalArgValues.length;
                this._evalArgValues.push(value);
                var name_1 = parse_util_1.identifierName({ reference: value }) || 'val';
                this._evalArgNames.push("jit_" + name_1 + "_" + id);
            }
            ctx.print(ast, this._evalArgNames[id]);
        };
        return JitEmitterVisitor;
    }(abstract_js_emitter_1.AbstractJsEmitterVisitor));
    exports.JitEmitterVisitor = JitEmitterVisitor;
    function isUseStrictStatement(statement) {
        return statement.isEquivalent(o.literal('use strict').toStmt());
    }
});
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"output_jit.js","sourceRoot":"","sources":["../../../../../../../packages/compiler/src/output/output_jit.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 {CompileReflector} from '../compile_reflector';\nimport {identifierName} from '../parse_util';\n\nimport {EmitterVisitorContext} from './abstract_emitter';\nimport {AbstractJsEmitterVisitor} from './abstract_js_emitter';\nimport * as o from './output_ast';\nimport {newTrustedFunctionForJIT} from './output_jit_trusted_types';\n\n/**\n * A helper class to manage the evaluation of JIT generated code.\n */\nexport class JitEvaluator {\n  /**\n   *\n   * @param sourceUrl The URL of the generated code.\n   * @param statements An array of Angular statement AST nodes to be evaluated.\n   * @param reflector A helper used when converting the statements to executable code.\n   * @param createSourceMaps If true then create a source-map for the generated code and include it\n   * inline as a source-map comment.\n   * @returns A map of all the variables in the generated code.\n   */\n  evaluateStatements(\n      sourceUrl: string, statements: o.Statement[], reflector: CompileReflector,\n      createSourceMaps: boolean): {[key: string]: any} {\n    const converter = new JitEmitterVisitor(reflector);\n    const ctx = EmitterVisitorContext.createRoot();\n    // Ensure generated code is in strict mode\n    if (statements.length > 0 && !isUseStrictStatement(statements[0])) {\n      statements = [\n        o.literal('use strict').toStmt(),\n        ...statements,\n      ];\n    }\n    converter.visitAllStatements(statements, ctx);\n    converter.createReturnStmt(ctx);\n    return this.evaluateCode(sourceUrl, ctx, converter.getArgs(), createSourceMaps);\n  }\n\n  /**\n   * Evaluate a piece of JIT generated code.\n   * @param sourceUrl The URL of this generated code.\n   * @param ctx A context object that contains an AST of the code to be evaluated.\n   * @param vars A map containing the names and values of variables that the evaluated code might\n   * reference.\n   * @param createSourceMap If true then create a source-map for the generated code and include it\n   * inline as a source-map comment.\n   * @returns The result of evaluating the code.\n   */\n  evaluateCode(\n      sourceUrl: string, ctx: EmitterVisitorContext, vars: {[key: string]: any},\n      createSourceMap: boolean): any {\n    let fnBody = `\"use strict\";${ctx.toSource()}\\n//# sourceURL=${sourceUrl}`;\n    const fnArgNames: string[] = [];\n    const fnArgValues: any[] = [];\n    for (const argName in vars) {\n      fnArgValues.push(vars[argName]);\n      fnArgNames.push(argName);\n    }\n    if (createSourceMap) {\n      // using `new Function(...)` generates a header, 1 line of no arguments, 2 lines otherwise\n      // E.g. ```\n      // function anonymous(a,b,c\n      // /**/) { ... }```\n      // We don't want to hard code this fact, so we auto detect it via an empty function first.\n      const emptyFn = newTrustedFunctionForJIT(...fnArgNames.concat('return null;')).toString();\n      const headerLines = emptyFn.slice(0, emptyFn.indexOf('return null;')).split('\\n').length - 1;\n      fnBody += `\\n${ctx.toSourceMapGenerator(sourceUrl, headerLines).toJsComment()}`;\n    }\n    const fn = newTrustedFunctionForJIT(...fnArgNames.concat(fnBody));\n    return this.executeFunction(fn, fnArgValues);\n  }\n\n  /**\n   * Execute a JIT generated function by calling it.\n   *\n   * This method can be overridden in tests to capture the functions that are generated\n   * by this `JitEvaluator` class.\n   *\n   * @param fn A function to execute.\n   * @param args The arguments to pass to the function being executed.\n   * @returns The return value of the executed function.\n   */\n  executeFunction(fn: Function, args: any[]) {\n    return fn(...args);\n  }\n}\n\n/**\n * An Angular AST visitor that converts AST nodes into executable JavaScript code.\n */\nexport class JitEmitterVisitor extends AbstractJsEmitterVisitor {\n  private _evalArgNames: string[] = [];\n  private _evalArgValues: any[] = [];\n  private _evalExportedVars: string[] = [];\n\n  constructor(private reflector: CompileReflector) {\n    super();\n  }\n\n  createReturnStmt(ctx: EmitterVisitorContext) {\n    const stmt = new o.ReturnStatement(new o.LiteralMapExpr(this._evalExportedVars.map(\n        resultVar => new o.LiteralMapEntry(resultVar, o.variable(resultVar), false))));\n    stmt.visitStatement(this, ctx);\n  }\n\n  getArgs(): {[key: string]: any} {\n    const result: {[key: string]: any} = {};\n    for (let i = 0; i < this._evalArgNames.length; i++) {\n      result[this._evalArgNames[i]] = this._evalArgValues[i];\n    }\n    return result;\n  }\n\n  override visitExternalExpr(ast: o.ExternalExpr, ctx: EmitterVisitorContext): any {\n    this._emitReferenceToExternal(ast, this.reflector.resolveExternalReference(ast.value), ctx);\n    return null;\n  }\n\n  override visitWrappedNodeExpr(ast: o.WrappedNodeExpr<any>, ctx: EmitterVisitorContext): any {\n    this._emitReferenceToExternal(ast, ast.node, ctx);\n    return null;\n  }\n\n  override visitDeclareVarStmt(stmt: o.DeclareVarStmt, ctx: EmitterVisitorContext): any {\n    if (stmt.hasModifier(o.StmtModifier.Exported)) {\n      this._evalExportedVars.push(stmt.name);\n    }\n    return super.visitDeclareVarStmt(stmt, ctx);\n  }\n\n  override visitDeclareFunctionStmt(stmt: o.DeclareFunctionStmt, ctx: EmitterVisitorContext): any {\n    if (stmt.hasModifier(o.StmtModifier.Exported)) {\n      this._evalExportedVars.push(stmt.name);\n    }\n    return super.visitDeclareFunctionStmt(stmt, ctx);\n  }\n\n  override visitDeclareClassStmt(stmt: o.ClassStmt, ctx: EmitterVisitorContext): any {\n    if (stmt.hasModifier(o.StmtModifier.Exported)) {\n      this._evalExportedVars.push(stmt.name);\n    }\n    return super.visitDeclareClassStmt(stmt, ctx);\n  }\n\n  private _emitReferenceToExternal(ast: o.Expression, value: any, ctx: EmitterVisitorContext):\n      void {\n    let id = this._evalArgValues.indexOf(value);\n    if (id === -1) {\n      id = this._evalArgValues.length;\n      this._evalArgValues.push(value);\n      const name = identifierName({reference: value}) || 'val';\n      this._evalArgNames.push(`jit_${name}_${id}`);\n    }\n    ctx.print(ast, this._evalArgNames[id]);\n  }\n}\n\n\nfunction isUseStrictStatement(statement: o.Statement): boolean {\n  return statement.isEquivalent(o.literal('use strict').toStmt());\n}\n"]}