numenor/lib/Compiler/Evaluator/Lambda.js

Customizable, safe evaluator of JavaScript-like expressions.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Lambda = void 0;

var _ = require("./");

var _Parser = require("../../Parser");

var _Error = require("../Error");

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

var Lambda = function Lambda(expr, options, compile) {
  if (expr.type !== _Parser.ExpressionType.Lambda) {
    throw new TypeError((0, _Error.UnknownExpression)(expr));
  }

  var body = compile(expr.body, options, compile);
  var isConst = (0, _.hasConstValue)(body);
  var isAsync = (0, _.hasAsyncValue)(body);
  var args = expr.args.map(function (arg) {
    var defaultValue;

    if (arg.variadic) {
      defaultValue = function defaultValue() {
        return [];
      };
    } else if (arg.default) {
      defaultValue = compile(arg.default, options, compile);
      isConst = !isConst && (0, _.hasConstValue)(defaultValue);
      isAsync = !isAsync && (0, _.hasAsyncValue)(defaultValue);
    } else {
      defaultValue = function defaultValue() {
        return undefined;
      };
    }

    return {
      name: arg.name,
      variadic: !!arg.variadic,
      defaultValue: defaultValue
    };
  });
  return (0, _.mark)({
    isAsync: isAsync,
    isConst: isConst
  }, function (context, stack) {
    return function () {
      var invocationContext = _objectSpread({}, context);

      for (var _len = arguments.length, params = new Array(_len), _key = 0; _key < _len; _key++) {
        params[_key] = arguments[_key];
      }

      for (var i = 0; i < args.length; i++) {
        if (args[i].variadic) {
          invocationContext[args[i].name] = params.slice(i);
        } else {
          invocationContext[args[i].name] = i < params.length ? params[i] : args[i].defaultValue(invocationContext, stack);
        }
      }

      return body(invocationContext, stack);
    };
  });
};

exports.Lambda = Lambda;