raid-fl/lib/actions.js

Raid with fantasy-land compliant structures

"use strict";

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

var _forceArray = _interopRequireDefault(require("force-array"));

var _fantasyLand = _interopRequireDefault(require("fantasy-land"));

var _utils = require("./utils");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const rFANTASY = /^fantasy-land\//;

const alias = c => Object.getOwnPropertyNames(c).filter(n => rFANTASY.test(n)).map(n => [n.replace(rFANTASY, ''), c[n]]);

const aliasType = c => {
  alias(c).forEach(([alias, fn]) => {
    c[alias] = fn;
  });
  alias(c.prototype).forEach(([alias, fn]) => {
    c.prototype[alias] = fn;
  });
  return c;
};

const createAction = name => {
  var action = {
    [name]: class {
      constructor(value) {
        this.__value = value;
        this['@@type'] = name;
      }

      static [_fantasyLand.default.of](value) {
        return new action[name](value);
      }

      static of(value) {
        return new action[name](value);
      }

      static is(type) {
        return type instanceof action[name];
      }

      [_fantasyLand.default.map](fn) {
        return action[name].of(fn(this.join()));
      }

      [_fantasyLand.default.ap](m) {
        return m.chain(fn => this.map(fn));
      }

      [_fantasyLand.default.chain](fn) {
        return fn(this.join());
      }

      [_fantasyLand.default.equals](a) {
        return a.join() === this.join();
      }

      lift(m) {
        return m.map(this.__value);
      }

      join() {
        return this.__value;
      }

      unwrapOrElse(_default) {
        return typeof this.join() === 'undefined' ? _default : this.join();
      }

    }
  };
  return aliasType(action[name]);
};

exports.createAction = createAction;

const createActions = actions => (0, _forceArray.default)(actions).filter(_utils.isString).map(createAction);

exports.createActions = createActions;

const connect = signal => actions => createActions(actions).map(Action => {
  Action.of = value => {
    const action = new Action(value);
    signal.emit(action);
    return action;
  };

  Action[_fantasyLand.default.of] = Action.of;
  return Action;
});

exports.connect = connect;