@phema/cql-execution/lib/elm/string.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 _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 _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 _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 _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('./builder'),
    build = _require2.build;

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

  var _super = _createSuper(Concatenate);

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

    return _super.call(this, json);
  }

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

      if (args.some(function (x) {
        return x == null;
      })) {
        return null;
      } else {
        return args.reduce(function (x, y) {
          return x + y;
        });
      }
    }
  }]);

  return Concatenate;
}(Expression);

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

  var _super2 = _createSuper(Combine);

  function Combine(json) {
    var _this;

    _classCallCheck(this, Combine);

    _this = _super2.call(this, json);
    _this.source = build(json.source);
    _this.separator = build(json.separator);
    return _this;
  }

  _createClass(Combine, [{
    key: "exec",
    value: function exec(ctx) {
      var source = this.source.execute(ctx);
      var separator = this.separator != null ? this.separator.execute(ctx) : '';

      if (source == null) {
        return null;
      } else {
        var filteredArray = source.filter(function (x) {
          return x != null;
        });

        if (filteredArray.length === 0) {
          return null;
        } else {
          return filteredArray.join(separator);
        }
      }
    }
  }]);

  return Combine;
}(Expression);

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

  var _super3 = _createSuper(Split);

  function Split(json) {
    var _this2;

    _classCallCheck(this, Split);

    _this2 = _super3.call(this, json);
    _this2.stringToSplit = build(json.stringToSplit);
    _this2.separator = build(json.separator);
    return _this2;
  }

  _createClass(Split, [{
    key: "exec",
    value: function exec(ctx) {
      var stringToSplit = this.stringToSplit.execute(ctx);
      var separator = this.separator.execute(ctx);

      if (stringToSplit && separator) {
        return stringToSplit.split(separator);
      }

      return stringToSplit ? [stringToSplit] : null;
    }
  }]);

  return Split;
}(Expression);

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

  var _super4 = _createSuper(SplitOnMatches);

  function SplitOnMatches(json) {
    var _this3;

    _classCallCheck(this, SplitOnMatches);

    _this3 = _super4.call(this, json);
    _this3.stringToSplit = build(json.stringToSplit);
    _this3.separatorPattern = build(json.separatorPattern);
    return _this3;
  }

  _createClass(SplitOnMatches, [{
    key: "exec",
    value: function exec(ctx) {
      var stringToSplit = this.stringToSplit.execute(ctx);
      var separatorPattern = this.separatorPattern.execute(ctx);

      if (stringToSplit && separatorPattern) {
        return stringToSplit.split(new RegExp(separatorPattern));
      }

      return stringToSplit ? [stringToSplit] : null;
    }
  }]);

  return SplitOnMatches;
}(Expression); // Length is completely handled by overloaded#Length


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

  var _super5 = _createSuper(Upper);

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

    return _super5.call(this, json);
  }

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

      if (arg != null) {
        return arg.toUpperCase();
      } else {
        return null;
      }
    }
  }]);

  return Upper;
}(Expression);

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

  var _super6 = _createSuper(Lower);

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

    return _super6.call(this, json);
  }

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

      if (arg != null) {
        return arg.toLowerCase();
      } else {
        return null;
      }
    }
  }]);

  return Lower;
}(Expression); // Indexer is completely handled by overloaded#Indexer


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

  var _super7 = _createSuper(PositionOf);

  function PositionOf(json) {
    var _this4;

    _classCallCheck(this, PositionOf);

    _this4 = _super7.call(this, json);
    _this4.pattern = build(json.pattern);
    _this4.string = build(json.string);
    return _this4;
  }

  _createClass(PositionOf, [{
    key: "exec",
    value: function exec(ctx) {
      var pattern = this.pattern.execute(ctx);
      var string = this.string.execute(ctx);

      if (pattern == null || string == null) {
        return null;
      } else {
        return string.indexOf(pattern);
      }
    }
  }]);

  return PositionOf;
}(Expression);

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

  var _super8 = _createSuper(LastPositionOf);

  function LastPositionOf(json) {
    var _this5;

    _classCallCheck(this, LastPositionOf);

    _this5 = _super8.call(this, json);
    _this5.pattern = build(json.pattern);
    _this5.string = build(json.string);
    return _this5;
  }

  _createClass(LastPositionOf, [{
    key: "exec",
    value: function exec(ctx) {
      var pattern = this.pattern.execute(ctx);
      var string = this.string.execute(ctx);

      if (pattern == null || string == null) {
        return null;
      } else {
        return string.lastIndexOf(pattern);
      }
    }
  }]);

  return LastPositionOf;
}(Expression);

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

  var _super9 = _createSuper(Matches);

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

    return _super9.call(this, json);
  }

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

      if (string == null || pattern == null) {
        return null;
      }

      return new RegExp('^' + pattern + '$').test(string);
    }
  }]);

  return Matches;
}(Expression);

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

  var _super10 = _createSuper(Substring);

  function Substring(json) {
    var _this6;

    _classCallCheck(this, Substring);

    _this6 = _super10.call(this, json);
    _this6.stringToSub = build(json.stringToSub);
    _this6.startIndex = build(json.startIndex);
    _this6.length = build(json['length']);
    return _this6;
  }

  _createClass(Substring, [{
    key: "exec",
    value: function exec(ctx) {
      var stringToSub = this.stringToSub.execute(ctx);
      var startIndex = this.startIndex.execute(ctx);
      var length = this.length != null ? this.length.execute(ctx) : null; // According to spec: If stringToSub or startIndex is null, or startIndex is out of range, the result is null.

      if (stringToSub == null || startIndex == null || startIndex < 0 || startIndex >= stringToSub.length) {
        return null;
      } else if (length != null) {
        return stringToSub.substr(startIndex, length);
      } else {
        return stringToSub.substr(startIndex);
      }
    }
  }]);

  return Substring;
}(Expression);

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

  var _super11 = _createSuper(StartsWith);

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

    return _super11.call(this, json);
  }

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

      if (args.some(function (x) {
        return x == null;
      })) {
        return null;
      } else {
        return args[0].slice(0, args[1].length) === args[1];
      }
    }
  }]);

  return StartsWith;
}(Expression);

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

  var _super12 = _createSuper(EndsWith);

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

    return _super12.call(this, json);
  }

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

      if (args.some(function (x) {
        return x == null;
      })) {
        return null;
      } else {
        return args[1] === '' || args[0].slice(-args[1].length) === args[1];
      }
    }
  }]);

  return EndsWith;
}(Expression);

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

  var _super13 = _createSuper(ReplaceMatches);

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

    return _super13.call(this, json);
  }

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

      if (args.some(function (x) {
        return x == null;
      })) {
        return null;
      } else {
        return args[0].replace(new RegExp(args[1], 'g'), args[2]);
      }
    }
  }]);

  return ReplaceMatches;
}(Expression);

module.exports = {
  Combine: Combine,
  Concatenate: Concatenate,
  EndsWith: EndsWith,
  LastPositionOf: LastPositionOf,
  Lower: Lower,
  Matches: Matches,
  PositionOf: PositionOf,
  ReplaceMatches: ReplaceMatches,
  Split: Split,
  SplitOnMatches: SplitOnMatches,
  StartsWith: StartsWith,
  Substring: Substring,
  Upper: Upper
};