entrust/entrust.umd.js

delegatee-last structure for curried functions

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
  typeof define === 'function' && define.amd ? define(['exports'], factory) :
  (factory((global.entrust = {})));
}(this, (function (exports) { 'use strict';

  var PLACEHOLDER = "🍛";
  var bindInternal3 = function bindInternal3 (func, thisContext) {
    return function (a, b, c) {
      return func.call(thisContext, a, b, c);
    };
  };
  var some$1 = function fastSome (subject, fn, thisContext) {
    var length = subject.length,
        iterator = thisContext !== undefined ? bindInternal3(fn, thisContext) : fn,
        i;
    for (i = 0; i < length; i++) {
      if (iterator(subject[i], i, subject)) {
        return true;
      }
    }
    return false;
  };
  var curry = function (fn) {
    var test = function (x) { return x === PLACEHOLDER; };
    return function curried() {
      var arguments$1 = arguments;
      var argLength = arguments.length;
      var args = new Array(argLength);
      for (var i = 0; i < argLength; ++i) {
        args[i] = arguments$1[i];
      }
      var countNonPlaceholders = function (toCount) {
        var count = toCount.length;
        while (!test(toCount[count])) {
          count--;
        }
        return count
      };
      var length = (
        some$1(args, test) ?
          countNonPlaceholders(args) :
          args.length
      );
      function saucy() {
        var arguments$1 = arguments;
        var arg2Length = arguments.length;
        var args2 = new Array(arg2Length);
        for (var j = 0; j < arg2Length; ++j) {
          args2[j] = arguments$1[j];
        }
        return curried.apply(this, args.map(
          function (y) { return (
            test(y) && args2[0] ?
              args2.shift() :
              y
          ); }
        ).concat(args2))
      }
      return (
        length >= fn.length ?
          fn.apply(this, args) :
          saucy
      )
    }
  };
  var innerpipe = function (args) { return function (x) {
    var first = args[0];
    var rest = args.slice(1);
    var current = first(x);
    for (var a = 0; a < rest.length; a++) {
      current = rest[a](current);
    }
    return current
  }; };
  function pipe() {
    var arguments$1 = arguments;
    var argLength = arguments.length;
    var args = new Array(argLength);
    for (var i = 0; i < argLength; ++i) {
      args[i] = arguments$1[i];
    }
    return innerpipe(args)
  }
  var prop = curry(function (property, o) { return o && property && o[property]; });
  var _keys = Object.keys;
  var keys = _keys;
  var propLength = prop("length");
  var objectLength = pipe(keys, propLength);
  var delegatee = curry(function (method, arg, x) { return (x[method](arg)); });
  var filter = delegatee("filter");

  var entrust0 = function (fn, x) { return x[fn](); };
  var e0 = curry(entrust0);

  var entrust1 = function (fn, a, x) { return x[fn](a); };
  var e1 = curry(entrust1);

  var entrust2 = function (fn, a, b, x) { return x[fn](a, b); };
  var e2 = curry(entrust2);

  var entrust3 = function (fn, a, b, c, x) { return x[fn](a, b, c); };
  var e3 = curry(entrust3);

  var entrust4 = function (fn, a, b, c, d, x) { return x[fn](a, b, c, d); };
  var e4 = curry(entrust4);

  var entrust5 = function (fn, a, b, c, d, e, x) { return x[fn](a, b, c, d, e); };
  var e5 = curry(entrust5);

  var entrust6 = function (fn, a, b, c, d, e, f, x) { return x[fn](a, b, c, d, e, f); };
  var e6 = curry(entrust6);

  var entrust7 = function (fn, a, b, c, d, e, f, g, x) { return x[fn](a, b, c, d, e, f, g); };
  var e7 = curry(entrust7);

  var entrust8 = function (fn, a, b, c, d, e, f, g, h, x) { return x[fn](a, b, c, d, e, f, g, h); };
  var e8 = curry(entrust8);

  var entrust9 = function (fn, a, b, c, d, e, f, g, h, i, x) { return x[fn](a, b, c, d, e, f, g, h, i); };
  var e9 = curry(entrust9);

  var entrust10 = function (fn, a, b, c, d, e, f, g, h, i, j, x) { return x[fn](
    a, b, c, d, e, f, g, h, i, j
  ); };
  var e10 = curry(entrust10);

  var entrustN = function (n, method, args, delegatee) {
    var entrustees = [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10];
    var params = [method ].concat( args, [delegatee]);
    return entrustees[n].apply(null, params)
  };
  var eN = curry(entrustN);
  function entrustD(n, m, a, d) {
    if (n !== a.length) {
      throw new Error((m + " expects total args (" + (a.length) + ") to equal the given arity (" + n + ")"))
    }
    return entrustN(n, m, a, d)
  }
  var eD = curry(
    entrustD
  );

  var custom = function (curry) {
    var raw = {
      e0: entrust0,
      e1: entrust1,
      e2: entrust2,
      e3: entrust3,
      e4: entrust4,
      e5: entrust5,
      e6: entrust6,
      e7: entrust7,
      e8: entrust8,
      e9: entrust9,
      e10: entrust10,
      eD: entrustD,
      eN: entrustN
    };
    return Object.keys(raw).map(function (k) {
      var obj;
      return (( obj = {}, obj[k] = curry(raw[k]), obj ));
    }).reduce(function (x, y) { return Object.assign({}, x, y); }, {})
  };

  exports.e0 = e0;
  exports.e1 = e1;
  exports.e2 = e2;
  exports.e3 = e3;
  exports.e4 = e4;
  exports.e5 = e5;
  exports.e6 = e6;
  exports.e7 = e7;
  exports.e8 = e8;
  exports.e9 = e9;
  exports.e10 = e10;
  exports.eN = eN;
  exports.eD = eD;
  exports.custom = custom;

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

})));