@phema/cql-execution/lib/elm/overloaded.js

An execution framework for the Clinical Quality Language (CQL)

"use strict";

function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

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

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; 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; }

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }

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

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }

function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }

var _require = require('./expression'),
    Expression = _require.Expression;

var _require2 = require('../datatypes/logic'),
    ThreeValuedLogic = _require2.ThreeValuedLogic;

var _require3 = require('../datatypes/datetime'),
    DateTime = _require3.DateTime;

var _require4 = require('../util/util'),
    typeIsArray = _require4.typeIsArray;

var _require5 = require('../util/comparison'),
    equals = _require5.equals,
    equivalent = _require5.equivalent;

var DT = require('./datetime');

var LIST = require('./list');

var IVL = require('./interval');

var Equal = /*#__PURE__*/function (_Expression) {
  _inherits(Equal, _Expression);

  var _super = _createSuper(Equal);

  function Equal(json) {
    _classCallCheck(this, Equal);

    return _super.call(this, json);
  }

  _createClass(Equal, [{
    key: "exec",
    value: function exec(ctx) {
      var args = this.execArgs(ctx);

      if (args[0] == null || args[1] == null) {
        return null;
      }

      return equals.apply(void 0, _toConsumableArray(args));
    }
  }]);

  return Equal;
}(Expression);

var Equivalent = /*#__PURE__*/function (_Expression2) {
  _inherits(Equivalent, _Expression2);

  var _super2 = _createSuper(Equivalent);

  function Equivalent(json) {
    _classCallCheck(this, Equivalent);

    return _super2.call(this, json);
  }

  _createClass(Equivalent, [{
    key: "exec",
    value: function exec(ctx) {
      var _this$execArgs = this.execArgs(ctx),
          _this$execArgs2 = _slicedToArray(_this$execArgs, 2),
          a = _this$execArgs2[0],
          b = _this$execArgs2[1];

      if (a == null && b == null) {
        return true;
      } else if (a == null || b == null) {
        return false;
      } else {
        return equivalent(a, b);
      }
    }
  }]);

  return Equivalent;
}(Expression);

var NotEqual = /*#__PURE__*/function (_Expression3) {
  _inherits(NotEqual, _Expression3);

  var _super3 = _createSuper(NotEqual);

  function NotEqual(json) {
    _classCallCheck(this, NotEqual);

    return _super3.call(this, json);
  }

  _createClass(NotEqual, [{
    key: "exec",
    value: function exec(ctx) {
      var args = this.execArgs(ctx);

      if (args[0] == null || args[1] == null) {
        return null;
      }

      return ThreeValuedLogic.not(equals.apply(void 0, _toConsumableArray(this.execArgs(ctx))));
    }
  }]);

  return NotEqual;
}(Expression);

var Union = /*#__PURE__*/function (_Expression4) {
  _inherits(Union, _Expression4);

  var _super4 = _createSuper(Union);

  function Union(json) {
    _classCallCheck(this, Union);

    return _super4.call(this, json);
  }

  _createClass(Union, [{
    key: "exec",
    value: function exec(ctx) {
      var _this$execArgs3 = this.execArgs(ctx),
          _this$execArgs4 = _slicedToArray(_this$execArgs3, 2),
          a = _this$execArgs4[0],
          b = _this$execArgs4[1];

      if (a == null || b == null) {
        return null;
      }

      var lib = typeIsArray(a) ? LIST : IVL;
      return lib.doUnion(a, b);
    }
  }]);

  return Union;
}(Expression);

var Except = /*#__PURE__*/function (_Expression5) {
  _inherits(Except, _Expression5);

  var _super5 = _createSuper(Except);

  function Except(json) {
    _classCallCheck(this, Except);

    return _super5.call(this, json);
  }

  _createClass(Except, [{
    key: "exec",
    value: function exec(ctx) {
      var _this$execArgs5 = this.execArgs(ctx),
          _this$execArgs6 = _slicedToArray(_this$execArgs5, 2),
          a = _this$execArgs6[0],
          b = _this$execArgs6[1];

      if (a == null) {
        return null;
      }

      if (b == null) {
        return typeIsArray(a) ? a : null;
      }

      var lib = typeIsArray(a) ? LIST : IVL;
      return lib.doExcept(a, b);
    }
  }]);

  return Except;
}(Expression);

var Intersect = /*#__PURE__*/function (_Expression6) {
  _inherits(Intersect, _Expression6);

  var _super6 = _createSuper(Intersect);

  function Intersect(json) {
    _classCallCheck(this, Intersect);

    return _super6.call(this, json);
  }

  _createClass(Intersect, [{
    key: "exec",
    value: function exec(ctx) {
      var _this$execArgs7 = this.execArgs(ctx),
          _this$execArgs8 = _slicedToArray(_this$execArgs7, 2),
          a = _this$execArgs8[0],
          b = _this$execArgs8[1];

      if (a == null || b == null) {
        return null;
      }

      var lib = typeIsArray(a) ? LIST : IVL;
      return lib.doIntersect(a, b);
    }
  }]);

  return Intersect;
}(Expression);

var Indexer = /*#__PURE__*/function (_Expression7) {
  _inherits(Indexer, _Expression7);

  var _super7 = _createSuper(Indexer);

  function Indexer(json) {
    _classCallCheck(this, Indexer);

    return _super7.call(this, json);
  }

  _createClass(Indexer, [{
    key: "exec",
    value: function exec(ctx) {
      var _this$execArgs9 = this.execArgs(ctx),
          _this$execArgs10 = _slicedToArray(_this$execArgs9, 2),
          operand = _this$execArgs10[0],
          index = _this$execArgs10[1];

      if (operand == null || index == null) {
        return null;
      }

      if (index < 0 || index >= operand.length) {
        return null;
      }

      return operand[index];
    }
  }]);

  return Indexer;
}(Expression);

var In = /*#__PURE__*/function (_Expression8) {
  _inherits(In, _Expression8);

  var _super8 = _createSuper(In);

  function In(json) {
    var _this;

    _classCallCheck(this, In);

    _this = _super8.call(this, json);
    _this.precision = json.precision != null ? json.precision.toLowerCase() : undefined;
    return _this;
  }

  _createClass(In, [{
    key: "exec",
    value: function exec(ctx) {
      var _this$execArgs11 = this.execArgs(ctx),
          _this$execArgs12 = _slicedToArray(_this$execArgs11, 2),
          item = _this$execArgs12[0],
          container = _this$execArgs12[1];

      if (item == null) {
        return null;
      }

      if (container == null) {
        return false;
      }

      var lib = typeIsArray(container) ? LIST : IVL;
      return lib.doContains(container, item, this.precision);
    }
  }]);

  return In;
}(Expression);

var Contains = /*#__PURE__*/function (_Expression9) {
  _inherits(Contains, _Expression9);

  var _super9 = _createSuper(Contains);

  function Contains(json) {
    var _this2;

    _classCallCheck(this, Contains);

    _this2 = _super9.call(this, json);
    _this2.precision = json.precision != null ? json.precision.toLowerCase() : undefined;
    return _this2;
  }

  _createClass(Contains, [{
    key: "exec",
    value: function exec(ctx) {
      var _this$execArgs13 = this.execArgs(ctx),
          _this$execArgs14 = _slicedToArray(_this$execArgs13, 2),
          container = _this$execArgs14[0],
          item = _this$execArgs14[1];

      if (container == null) {
        return false;
      }

      if (item == null) {
        return null;
      }

      var lib = typeIsArray(container) ? LIST : IVL;
      return lib.doContains(container, item, this.precision);
    }
  }]);

  return Contains;
}(Expression);

var Includes = /*#__PURE__*/function (_Expression10) {
  _inherits(Includes, _Expression10);

  var _super10 = _createSuper(Includes);

  function Includes(json) {
    var _this3;

    _classCallCheck(this, Includes);

    _this3 = _super10.call(this, json);
    _this3.precision = json.precision != null ? json.precision.toLowerCase() : undefined;
    return _this3;
  }

  _createClass(Includes, [{
    key: "exec",
    value: function exec(ctx) {
      var _this$execArgs15 = this.execArgs(ctx),
          _this$execArgs16 = _slicedToArray(_this$execArgs15, 2),
          container = _this$execArgs16[0],
          contained = _this$execArgs16[1];

      if (container == null || contained == null) {
        return null;
      }

      var lib = typeIsArray(container) ? LIST : IVL;
      return lib.doIncludes(container, contained, this.precision);
    }
  }]);

  return Includes;
}(Expression);

var IncludedIn = /*#__PURE__*/function (_Expression11) {
  _inherits(IncludedIn, _Expression11);

  var _super11 = _createSuper(IncludedIn);

  function IncludedIn(json) {
    var _this4;

    _classCallCheck(this, IncludedIn);

    _this4 = _super11.call(this, json);
    _this4.precision = json.precision != null ? json.precision.toLowerCase() : undefined;
    return _this4;
  }

  _createClass(IncludedIn, [{
    key: "exec",
    value: function exec(ctx) {
      var _this$execArgs17 = this.execArgs(ctx),
          _this$execArgs18 = _slicedToArray(_this$execArgs17, 2),
          contained = _this$execArgs18[0],
          container = _this$execArgs18[1];

      if (container == null || contained == null) {
        return null;
      }

      var lib = typeIsArray(container) ? LIST : IVL;
      return lib.doIncludes(container, contained, this.precision);
    }
  }]);

  return IncludedIn;
}(Expression);

var ProperIncludes = /*#__PURE__*/function (_Expression12) {
  _inherits(ProperIncludes, _Expression12);

  var _super12 = _createSuper(ProperIncludes);

  function ProperIncludes(json) {
    var _this5;

    _classCallCheck(this, ProperIncludes);

    _this5 = _super12.call(this, json);
    _this5.precision = json.precision != null ? json.precision.toLowerCase() : undefined;
    return _this5;
  }

  _createClass(ProperIncludes, [{
    key: "exec",
    value: function exec(ctx) {
      var _this$execArgs19 = this.execArgs(ctx),
          _this$execArgs20 = _slicedToArray(_this$execArgs19, 2),
          container = _this$execArgs20[0],
          contained = _this$execArgs20[1];

      if (container == null || contained == null) {
        return null;
      }

      var lib = typeIsArray(container) ? LIST : IVL;
      return lib.doProperIncludes(container, contained, this.precision);
    }
  }]);

  return ProperIncludes;
}(Expression);

var ProperIncludedIn = /*#__PURE__*/function (_Expression13) {
  _inherits(ProperIncludedIn, _Expression13);

  var _super13 = _createSuper(ProperIncludedIn);

  function ProperIncludedIn(json) {
    var _this6;

    _classCallCheck(this, ProperIncludedIn);

    _this6 = _super13.call(this, json);
    _this6.precision = json.precision != null ? json.precision.toLowerCase() : undefined;
    return _this6;
  }

  _createClass(ProperIncludedIn, [{
    key: "exec",
    value: function exec(ctx) {
      var _this$execArgs21 = this.execArgs(ctx),
          _this$execArgs22 = _slicedToArray(_this$execArgs21, 2),
          contained = _this$execArgs22[0],
          container = _this$execArgs22[1];

      if (container == null || contained == null) {
        return null;
      }

      var lib = typeIsArray(container) ? LIST : IVL;
      return lib.doProperIncludes(container, contained, this.precision);
    }
  }]);

  return ProperIncludedIn;
}(Expression);

var Length = /*#__PURE__*/function (_Expression14) {
  _inherits(Length, _Expression14);

  var _super14 = _createSuper(Length);

  function Length(json) {
    _classCallCheck(this, Length);

    return _super14.call(this, json);
  }

  _createClass(Length, [{
    key: "exec",
    value: function exec(ctx) {
      var arg = this.execArgs(ctx);

      if (arg != null) {
        return arg.length;
      } else if (this.arg.asTypeSpecifier.type === 'ListTypeSpecifier') {
        return 0;
      } else {
        return null;
      }
    }
  }]);

  return Length;
}(Expression);

var After = /*#__PURE__*/function (_Expression15) {
  _inherits(After, _Expression15);

  var _super15 = _createSuper(After);

  function After(json) {
    var _this7;

    _classCallCheck(this, After);

    _this7 = _super15.call(this, json);
    _this7.precision = json.precision != null ? json.precision.toLowerCase() : undefined;
    return _this7;
  }

  _createClass(After, [{
    key: "exec",
    value: function exec(ctx) {
      var _this$execArgs23 = this.execArgs(ctx),
          _this$execArgs24 = _slicedToArray(_this$execArgs23, 2),
          a = _this$execArgs24[0],
          b = _this$execArgs24[1];

      if (a == null || b == null) {
        return null;
      }

      var lib = a instanceof DateTime ? DT : IVL;
      return lib.doAfter(a, b, this.precision);
    }
  }]);

  return After;
}(Expression);

var Before = /*#__PURE__*/function (_Expression16) {
  _inherits(Before, _Expression16);

  var _super16 = _createSuper(Before);

  function Before(json) {
    var _this8;

    _classCallCheck(this, Before);

    _this8 = _super16.call(this, json);
    _this8.precision = json.precision != null ? json.precision.toLowerCase() : undefined;
    return _this8;
  }

  _createClass(Before, [{
    key: "exec",
    value: function exec(ctx) {
      var _this$execArgs25 = this.execArgs(ctx),
          _this$execArgs26 = _slicedToArray(_this$execArgs25, 2),
          a = _this$execArgs26[0],
          b = _this$execArgs26[1];

      if (a == null || b == null) {
        return null;
      }

      var lib = a instanceof DateTime ? DT : IVL;
      return lib.doBefore(a, b, this.precision);
    }
  }]);

  return Before;
}(Expression);

var SameAs = /*#__PURE__*/function (_Expression17) {
  _inherits(SameAs, _Expression17);

  var _super17 = _createSuper(SameAs);

  function SameAs(json) {
    var _this9;

    _classCallCheck(this, SameAs);

    _this9 = _super17.call(this, json);
    _this9.precision = json.precision;
    return _this9;
  }

  _createClass(SameAs, [{
    key: "exec",
    value: function exec(ctx) {
      var _this$execArgs27 = this.execArgs(ctx),
          _this$execArgs28 = _slicedToArray(_this$execArgs27, 2),
          a = _this$execArgs28[0],
          b = _this$execArgs28[1];

      if (a != null && b != null) {
        return a.sameAs(b, this.precision != null ? this.precision.toLowerCase() : undefined);
      } else {
        return null;
      }
    }
  }]);

  return SameAs;
}(Expression);

var SameOrAfter = /*#__PURE__*/function (_Expression18) {
  _inherits(SameOrAfter, _Expression18);

  var _super18 = _createSuper(SameOrAfter);

  function SameOrAfter(json) {
    var _this10;

    _classCallCheck(this, SameOrAfter);

    _this10 = _super18.call(this, json);
    _this10.precision = json.precision;
    return _this10;
  }

  _createClass(SameOrAfter, [{
    key: "exec",
    value: function exec(ctx) {
      var _this$execArgs29 = this.execArgs(ctx),
          _this$execArgs30 = _slicedToArray(_this$execArgs29, 2),
          d1 = _this$execArgs30[0],
          d2 = _this$execArgs30[1];

      if (d1 != null && d2 != null) {
        return d1.sameOrAfter(d2, this.precision != null ? this.precision.toLowerCase() : undefined);
      } else {
        return null;
      }
    }
  }]);

  return SameOrAfter;
}(Expression);

var SameOrBefore = /*#__PURE__*/function (_Expression19) {
  _inherits(SameOrBefore, _Expression19);

  var _super19 = _createSuper(SameOrBefore);

  function SameOrBefore(json) {
    var _this11;

    _classCallCheck(this, SameOrBefore);

    _this11 = _super19.call(this, json);
    _this11.precision = json.precision;
    return _this11;
  }

  _createClass(SameOrBefore, [{
    key: "exec",
    value: function exec(ctx) {
      var _this$execArgs31 = this.execArgs(ctx),
          _this$execArgs32 = _slicedToArray(_this$execArgs31, 2),
          d1 = _this$execArgs32[0],
          d2 = _this$execArgs32[1];

      if (d1 != null && d2 != null) {
        return d1.sameOrBefore(d2, this.precision != null ? this.precision.toLowerCase() : undefined);
      } else {
        return null;
      }
    }
  }]);

  return SameOrBefore;
}(Expression);

module.exports = {
  After: After,
  Before: Before,
  Contains: Contains,
  Equal: Equal,
  Equivalent: Equivalent,
  Except: Except,
  In: In,
  IncludedIn: IncludedIn,
  Includes: Includes,
  Indexer: Indexer,
  Intersect: Intersect,
  Length: Length,
  NotEqual: NotEqual,
  ProperIncludedIn: ProperIncludedIn,
  ProperIncludes: ProperIncludes,
  SameAs: SameAs,
  SameOrAfter: SameOrAfter,
  SameOrBefore: SameOrBefore,
  Union: Union
};