@sudoo/marked/evaluate/object-expression.js

JavaScript & TypeScript code runner in JavaScript, safe with marked territory, asynchronous

"use strict";
/**
 * @author WMXPY
 * @namespace Evaluate
 * @description Object Expression
 */
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.objectExpressionEvaluator = exports.mountObjectExpression = void 0;
const error_code_1 = require("../declare/error-code");
const error_1 = require("../util/error/error");
const validator_1 = require("../util/node/validator");
const sand_map_1 = require("../variable/sand-map");
const mountObjectExpression = (sandbox) => {
    sandbox.mount("ObjectExpression", exports.objectExpressionEvaluator);
};
exports.mountObjectExpression = mountObjectExpression;
const objectExpressionEvaluator = function (node, scope, trace) {
    return __awaiter(this, void 0, void 0, function* () {
        const nextTrace = trace.stack(node);
        const map = sand_map_1.SandMap.fromScratch();
        outer: for (const property of node.properties) {
            if (property.type === "SpreadElement") {
                const spreadArgument = yield this.execute(property.argument, scope, nextTrace);
                if (!(spreadArgument instanceof sand_map_1.SandMap)) {
                    throw (0, error_1.error)(error_code_1.ERROR_CODE.CANNOT_SPREAD_OTHER_THAN_MAP, typeof spreadArgument, property, nextTrace);
                }
                else {
                    map.concat(spreadArgument);
                }
                continue outer;
            }
            const keyNode = property.key;
            if (!(0, validator_1.validateLiteralOrIdentifier)(keyNode)) {
                throw (0, error_1.error)(error_code_1.ERROR_CODE.UNKNOWN_ERROR, keyNode.type, keyNode, trace);
            }
            const key = keyNode.type === "Literal" || property.computed
                ? yield this.execute(keyNode, scope, nextTrace)
                : keyNode.name;
            if (property.kind !== "init") {
                throw (0, error_1.error)(error_code_1.ERROR_CODE.PROPERTY_KIND_NOT_INIT_NOT_SUPPORT, property.kind, property, trace);
            }
            map.set(key, yield this.execute(property.value, scope, nextTrace));
        }
        return map;
    });
};
exports.objectExpressionEvaluator = objectExpressionEvaluator;