Split everything out into separate modules.

Added promise functions:
pdelay
pdefer
pall
ptry
pmap
prace
preduce

Author: Jocelyn Badgley (Twipped)

rollup.config.js

@@ -11,7 +11,7 @@ const bannerConfig = {
 export default [
 
   {
-    input: 'src/utils.js',
+    input: 'src/index.js',
     output: {
       file: 'dist/utils.cjs.js',
       format: 'cjs',
@@ -24,7 +24,7 @@ export default [
   },
 
   {
-    input: 'src/utils.js',
+    input: 'src/index.js',
     output: {
       file: 'dist/utils.esm.js',
       format: 'esm',
@@ -35,7 +35,7 @@ export default [
     ],
   },
   {
-    input: 'src/utils.js',
+    input: 'src/index.js',
     output: {
       file: 'dist/utils.esm.min.js',
       format: 'esm',
@@ -57,7 +57,7 @@ export default [
   },
 
   {
-    input: 'src/utils.js',
+    input: 'src/index.js',
     output: {
       file: 'dist/utils.browser.js',
       format: 'umd',

src/any.js

@@ -0,0 +1,43 @@
+
+import { truthy } from './isType';
+import { flatten } from './collections';
+
+export function all (...args) {
+  let input;
+  if (args.length > 1) {
+    input = args;
+  } else {
+    input = flatten(args[0], 1);
+  }
+
+  let result = input.shift();
+  for (const value of input) {
+    if (!truthy(result)) {
+      return false;
+    }
+    result = value;
+  }
+
+  return result;
+}
+
+export function any (...args) {
+  let input;
+  if (args.length > 1) {
+    input = args;
+  } else {
+    input = flatten(args[0], 1);
+  }
+
+  for (const value of input) {
+    if (truthy(value)) {
+      return value;
+    }
+  }
+
+  return input[input.length - 1];
+}
+
+export function none (...args) {
+  return !any(...args);
+}

src/anyBy.js

@@ -0,0 +1,79 @@
+
+import {
+  isFunction,
+  isArray,
+  isSet,
+  isMap,
+  isObject,
+} from './isType';
+import { iteratee } from './functions';
+import { entries } from './iterators';
+
+export function allBy (collection, predicate = null) {
+  if (!collection) return false;
+  if (predicate === null) {
+    predicate = (v) => v;
+  } else if (!isFunction(predicate)) {
+    predicate = iteratee(predicate);
+  }
+
+  const it = entries(collection);
+
+  let i = 0;
+  for (const [ k, v ] of it) {
+    if (!predicate(v, k, i++)) return false;
+  }
+
+  return true;
+}
+
+
+export function anyBy (collection, predicate = null) {
+  if (!collection) return false;
+  if (predicate === null) {
+    predicate = (v) => v;
+  } else if (!isFunction(iteratee)) {
+    predicate = iteratee(predicate);
+  }
+
+  if (isArray(collection)) {
+    let i = 0;
+    for (const value of collection) {
+      if (predicate(value, i, i++)) return true;
+    }
+    return false;
+  }
+
+  if (isSet(collection)) {
+    let i = 0;
+    for (const item of collection) {
+      if (predicate(item, i, i++)) return true;
+    }
+    return false;
+  }
+
+  // received a Map
+  if (isMap(collection)) {
+    let i = 0;
+    for (const [ key, value ] of collection.entries()) {
+      if (predicate(value, key, i++)) return true;
+    }
+    return false;
+  }
+
+  // received an object hash
+  if (isObject(collection)) {
+    let i = 0;
+    for (const [ key, value ] of Object.entries(collection)) {
+      if (predicate(value, key, i++)) return true;
+    }
+    return false;
+  }
+
+  return !!collection;
+}
+
+
+export function noneBy (collection, predicate = null) {
+  return !anyBy(collection, predicate);
+}

src/anyOf.js

@@ -0,0 +1,30 @@
+
+import { uc } from './text';
+import { isFunction } from './isType';
+import { anyBy, allBy } from './anyBy';
+import { isEqualTo } from './equality';
+
+export function anyOf (...args) {
+  args = args.flat(Infinity).map(uc);
+  if (!anyBy(args, isFunction)) {
+    // arguments do not contain a function, so we can optimize
+    if (args.length === 1) return (tok) => uc(tok) === args[0];
+    return (tok) => args.includes(uc(tok));
+  }
+
+  args = args.map((a) => isFunction(a) && a || isEqualTo(a));
+  if (args.length === 1) return (tok) => args[0](tok);
+  return (tok) => anyBy(args, (check) => check(tok));
+}
+
+export function allOf (...args) {
+  args = args.flat(Infinity).map((a) => isFunction(a) && a || isEqualTo(a));
+  if (args.length === 1) return (tok) => args[0](tok);
+  return (tok) => allBy(args, (check) => check(tok));
+}
+
+export function noneOf (...args) {
+  args = args.flat(Infinity).map((a) => isFunction(a) && a || isEqualTo(a));
+  if (args.length === 1) return (tok) => args[0](tok);
+  return (tok) => !anyBy(args, (check) => check(tok));
+}

src/assert.js

@@ -0,0 +1,17 @@
+
+import {
+  isArray,
+  isObject,
+  isNumber,
+  isString,
+} from './isType';
+
+export function assert (ok, message) {
+  if (!ok) throw new TypeError(message);
+}
+
+assert.isArray       = (ok, message) => assert(isArray(ok), message);
+assert.isObject      = (ok, message) => assert(isObject(ok), message);
+assert.isPlainObject = (ok, message) => assert(isObject(ok, true), message);
+assert.isString      = (ok, message) => assert(isString(ok), message);
+assert.isNumber      = (ok, message) => assert(isNumber(ok), message);