@coriolis/parametered-projection/cjs/index.js

Parametered projections for coriolis

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

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;
}

function ownKeys(object, enumerableOnly) {
  var keys = Object.keys(object);

  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object);
    if (enumerableOnly) symbols = symbols.filter(function (sym) {
      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
    });
    keys.push.apply(keys, symbols);
  }

  return keys;
}

function _objectSpread2(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = arguments[i] != null ? arguments[i] : {};

    if (i % 2) {
      ownKeys(Object(source), true).forEach(function (key) {
        _defineProperty(target, key, source[key]);
      });
    } else if (Object.getOwnPropertyDescriptors) {
      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
    } else {
      ownKeys(Object(source)).forEach(function (key) {
        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
      });
    }
  }

  return target;
}

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

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

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

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

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

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 _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 _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 _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.");
}

var createSubsetGetter = function createSubsetGetter(index, getNotYetIndexed) {
  return function (indexed, key, rest) {
    var _subset;

    var subset = indexed.subset;

    if (!subset) {
      subset = createIndex(function () {
        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }

        return getNotYetIndexed.apply(void 0, [key].concat(args));
      });
      index.set(key, _objectSpread2(_objectSpread2({}, indexed), {}, {
        subset: subset
      }));
    }

    return (_subset = subset).get.apply(_subset, _toConsumableArray(rest));
  };
};

var createValueGetter = function createValueGetter(index, getNotYetIndexed) {
  var getSubset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : createSubsetGetter(index, getNotYetIndexed);
  return function (key) {
    var indexed = index.get(key) || {};

    for (var _len2 = arguments.length, rest = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
      rest[_key2 - 1] = arguments[_key2];
    }

    if (rest.length) {
      return getSubset(indexed, key, rest);
    }

    if (indexed.loading) {
      throw new Error('Cycle index referencing is not possible');
    }

    if ('value' in indexed) {
      return indexed.value;
    }

    indexed.loading = true;
    var value = getNotYetIndexed(key);
    index.set(key, _objectSpread2(_objectSpread2({}, indexed), {}, {
      value: value,
      loading: false
    }));
    return value;
  };
};

var createIndex = function createIndex(getNotYetIndexed) {
  var index = new Map();
  var get = createValueGetter(index, getNotYetIndexed);

  var list = function list() {
    return _toConsumableArray(index).reduce(function (list, _ref) {
      var _ref2 = _slicedToArray(_ref, 2),
          key = _ref2[0],
          _ref2$ = _ref2[1],
          subset = _ref2$.subset,
          value = _ref2$.value;

      return [].concat(_toConsumableArray(list), _toConsumableArray(value ? [[key, value]] : []), _toConsumableArray(subset ? subset.list().map(function (_ref3) {
        var _ref4 = _slicedToArray(_ref3, 2),
            subkey = _ref4[0],
            value = _ref4[1];

        return [[].concat(key, subkey), value];
      }) : []));
    }, []);
  };

  var flush = function flush(key) {
    for (var _len3 = arguments.length, rest = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
      rest[_key3 - 1] = arguments[_key3];
    }

    if (rest.length) {
      var indexed = index.get(key);

      if (indexed && indexed.subset) {
        var _indexed$subset;

        (_indexed$subset = indexed.subset).flush.apply(_indexed$subset, rest);
      }

      return;
    }

    index = new Map(_toConsumableArray(index).filter(function (_ref5) {
      var _ref6 = _slicedToArray(_ref5, 1),
          itemKey = _ref6[0];

      return itemKey !== key;
    }));
  };

  return {
    get: get,
    list: list,
    flush: flush
  };
};

var identity = function identity(arg) {
  return arg;
}; // projection wrapper that allow an projection to be parametered and still have shared cached results


var parameteredProjection = function parameteredProjection(projection) {
  return createIndex(function () {
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    return function (projectionAPI) {
      var count = 0;

      var useParam = function useParam() {
        var idx = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : count++;
        return projectionAPI.useValue(args[idx]);
      };

      var useParameteredEvent = function useParameteredEvent() {
        var from = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
        var to = arguments.length > 1 ? arguments[1] : undefined;
        return projectionAPI.useEvent.apply(projectionAPI, _toConsumableArray(args.slice(from, to)));
      };

      var useParameteredProjection = function useParameteredProjection() {
        var from = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
        var projectionGetter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : identity;
        return [].concat(projectionGetter.apply(void 0, _toConsumableArray(args.slice(from)))).forEach(projectionAPI.useProjection);
      };

      var setParameteredName = function setParameteredName(nameBuilder) {
        var from = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
        var to = arguments.length > 2 ? arguments[2] : undefined;
        return projectionAPI.setName(nameBuilder.apply(void 0, _toConsumableArray(args.slice(from, to))));
      };

      return projection(_objectSpread2({
        useParam: useParam,
        useParameteredEvent: useParameteredEvent,
        useParameteredProjection: useParameteredProjection,
        setParameteredName: setParameteredName
      }, projectionAPI));
    };
  }).get;
};

var toString = function toString(obj) {
  return obj && obj.toString();
};

var quoted = function quoted(value) {
  return "\"".concat(value, "\"");
};

var listNames = function listNames(list) {
  return list.map(toString).map(quoted).join(', ');
};

var lastPayloadOfType = parameteredProjection(function (_ref) {
  var useParameteredEvent = _ref.useParameteredEvent,
      setParameteredName = _ref.setParameteredName;
  return setParameteredName(function () {
    for (var _len = arguments.length, eventBuilders = new Array(_len), _key = 0; _key < _len; _key++) {
      eventBuilders[_key] = arguments[_key];
    }

    return "Last payload of type ".concat(listNames(eventBuilders));
  }), useParameteredEvent(), function (_ref2) {
    var payload = _ref2.payload;
    return payload;
  };
});

exports.lastPayloadOfType = lastPayloadOfType;
exports.parameteredProjection = parameteredProjection;
//# sourceMappingURL=index.js.map