numenor/lib/Compiler/Evaluator/util.js

Customizable, safe evaluator of JavaScript-like expressions.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.makeProtoPropQuery = makeProtoPropQuery;
exports.makeProtoPropGetter = makeProtoPropGetter;
exports.makeValueMarshaller = makeValueMarshaller;
exports.bindFunction = bindFunction;
exports.evalMaybeAsyncSteps = evalMaybeAsyncSteps;
exports.identity = exports.ownPropGetter = exports.hasOwnProp = void 0;

var _ = require("./");

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }

function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

var ownProp = Object.prototype.hasOwnProperty;
var bind = Function.prototype.bind;

function makeProtoPropQuery(options) {
  return function (obj, prop) {
    if (prop === '__proto__') {
      return false;
    }

    if (hasOwnProp(obj, prop)) {
      return true;
    }

    if (Array.isArray(obj)) {
      return prop in options.ArrayPrototype;
    }

    return prop in obj;
  };
}

var hasOwnProp = function hasOwnProp(obj, prop) {
  return prop !== '__proto__' && ownProp.call(obj, prop);
};

exports.hasOwnProp = hasOwnProp;

function makeProtoPropGetter(options) {
  return function (obj, prop) {
    if (prop === '__proto__') {
      return undefined;
    }

    if (hasOwnProp(obj, prop)) {
      return obj[prop];
    }

    if (Array.isArray(obj)) {
      return options.ArrayPrototype[prop];
    }

    return obj[prop];
  };
}

var ownPropGetter = function ownPropGetter(obj, prop) {
  return hasOwnProp(obj, prop) ? obj[prop] : undefined;
};

exports.ownPropGetter = ownPropGetter;

function makeValueMarshaller(options) {
  return function (value) {
    if (options.EnforceMarshalling && Array.isArray(value)) {
      Object.setPrototypeOf(value, options.ArrayPrototype);
    }

    return value;
  };
}

function bindFunction(fn, thisArg) {
  var boundFunction = bind.call(fn, thisArg);

  var _arr = Object.keys(fn);

  for (var _i = 0; _i < _arr.length; _i++) {
    var key = _arr[_i];
    boundFunction[key] = fn[key];
  }

  return boundFunction;
}

var identity = function identity(value) {
  return value;
};

exports.identity = identity;

function evalMaybeAsyncSteps(context, stack, expressions) {
  var length = expressions.length;
  var values = new Array(length);
  var isAsync = false;
  var current = 0;
  var error;

  while (current < length) {
    var expression = expressions[current];
    var evaluate = void 0;
    var process = identity;

    if (Array.isArray(expression)) {
      var _expression = _slicedToArray(expression, 2);

      evaluate = _expression[0];
      process = _expression[1];
    } else {
      evaluate = expression;
    }

    if ((0, _.hasAsyncValue)(evaluate)) {
      if (error) {
        return Promise.reject(error);
      }

      isAsync = true;
      break;
    }

    if (!error) {
      try {
        values[current] = process(evaluate(context, stack));
      } catch (evalError) {
        error = evalError;
      }
    }

    current++;
  }

  if (!isAsync) {
    if (error) {
      throw error;
    } // a synchronous thenable object


    return {
      then: function then(fn) {
        return fn(values);
      }
    };
  }

  return new Promise(function (resolve, reject) {
    function next() {
      if (++current === length) {
        resolve(values);
        return;
      }

      var expression = expressions[current];
      var evaluate;
      var process = identity;

      if (Array.isArray(expression)) {
        var _expression2 = _slicedToArray(expression, 2);

        evaluate = _expression2[0];
        process = _expression2[1];
      } else {
        evaluate = expression;
      }

      if ((0, _.hasAsyncValue)(evaluate)) {
        evaluate(context, stack).then(function (value) {
          values[current] = process(value);
          next();
        }).catch(reject);
      } else {
        try {
          values[current] = process(evaluate(context, stack));
          next();
        } catch (evalError) {
          reject(evalError);
        }
      }
    }

    current--;
    next();
  });
}