@sapphire/iterator-utilities 1.0.3-next.fc35dd86 → 2.0.0-next.1e7d2dec

package/dist/esm/lib/takeWhile.d.mts

@@ -0,0 +1,2 @@
+export { filter as takeWhile } from './filter.mjs';
+import './from.mjs';

package/dist/esm/lib/takeWhile.mjs

@@ -0,0 +1,4 @@
+import '../chunk-PAWJFY3S.mjs';
+export { filter as takeWhile } from './filter.mjs';
+//# sourceMappingURL=takeWhile.mjs.map
+//# sourceMappingURL=takeWhile.mjs.map

package/dist/esm/lib/takeWhile.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"takeWhile.mjs","sourcesContent":[]}

package/dist/iife/index.global.js

@@ -4,6 +4,15 @@ var SapphireIteratorUtilities = (function (exports) {
   var __defProp = Object.defineProperty;
   var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
+  // src/lib/shared/_assertFunction.ts
+  function assertFunction(value) {
+    if (typeof value !== "function") {
+      throw new TypeError(`${value} must be a function`);
+    }
+    return value;
+  }
+  __name(assertFunction, "assertFunction");
+
   // src/lib/from.ts
   function from(value) {
     if (typeof value === "object" && value !== null) {
@@ -42,6 +51,30 @@ var SapphireIteratorUtilities = (function (exports) {
   }
   __name(toIterableIterator, "toIterableIterator");
 
+  // src/lib/every.ts
+  function every(iterable, callbackFn) {
+    callbackFn = assertFunction(callbackFn);
+    let index = 0;
+    for (const value of toIterableIterator(iterable)) {
+      if (!callbackFn(value, index++)) return false;
+    }
+    return true;
+  }
+  __name(every, "every");
+
+  // src/lib/some.ts
+  function some(iterable, callbackFn) {
+    callbackFn = assertFunction(callbackFn);
+    let index = 0;
+    for (const value of toIterableIterator(iterable)) {
+      if (callbackFn(value, index++)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  __name(some, "some");
+
   // src/lib/chain.ts
   function* chain(...iterables) {
     for (const iterable of iterables) {
@@ -133,15 +166,6 @@ var SapphireIteratorUtilities = (function (exports) {
   }
   __name(at, "at");
 
-  // src/lib/shared/_assertFunction.ts
-  function assertFunction(value) {
-    if (typeof value !== "function") {
-      throw new TypeError(`${value} must be a function`);
-    }
-    return value;
-  }
-  __name(assertFunction, "assertFunction");
-
   // src/lib/map.ts
   function* map(iterable, callbackFn) {
     callbackFn = assertFunction(callbackFn);
@@ -200,6 +224,21 @@ var SapphireIteratorUtilities = (function (exports) {
   }
   __name(chunk, "chunk");
 
+  // src/lib/toArray.ts
+  function toArray(iterable) {
+    return [...toIterableIterator(iterable)];
+  }
+  __name(toArray, "toArray");
+
+  // src/lib/collectInto.ts
+  function collectInto(iterable, output) {
+    for (const value of toIterableIterator(iterable)) {
+      output.push(value);
+    }
+    return output;
+  }
+  __name(collectInto, "collectInto");
+
   // src/lib/filter.ts
   function* filter(iterable, callbackFn) {
     callbackFn = assertFunction(callbackFn);
@@ -216,6 +255,69 @@ var SapphireIteratorUtilities = (function (exports) {
   }
   __name(compact, "compact");
 
+  // src/lib/shared/_compare.ts
+  function compareIteratorElements(x, y, comparator) {
+    if (typeof x === "undefined") {
+      if (typeof y === "undefined") return 0;
+      return 1;
+    }
+    if (typeof y === "undefined") {
+      return -1;
+    }
+    return comparator(x, y);
+  }
+  __name(compareIteratorElements, "compareIteratorElements");
+  function orderingIsLess(ordering) {
+    return ordering < 0;
+  }
+  __name(orderingIsLess, "orderingIsLess");
+  function orderingIsEqual(ordering) {
+    return ordering === 0;
+  }
+  __name(orderingIsEqual, "orderingIsEqual");
+  function orderingIsGreater(ordering) {
+    return ordering > 0;
+  }
+  __name(orderingIsGreater, "orderingIsGreater");
+
+  // src/lib/compareBy.ts
+  function compareBy(iterable, other, comparator) {
+    const iterator1 = from(other);
+    for (const x of toIterableIterator(iterable)) {
+      const result1 = iterator1.next();
+      if (result1.done) return 1;
+      const y = result1.value;
+      const comparison = compareIteratorElements(x, y, comparator);
+      if (!orderingIsEqual(comparison)) {
+        return orderingIsLess(comparison) ? -1 : 1;
+      }
+    }
+    return iterator1.next().done ? 0 : -1;
+  }
+  __name(compareBy, "compareBy");
+
+  // src/lib/shared/comparators.ts
+  function swap(cb) {
+    return (x, y) => 0 - cb(x, y);
+  }
+  __name(swap, "swap");
+  function defaultCompare(x, y) {
+    return ascNumber(String(x), String(y));
+  }
+  __name(defaultCompare, "defaultCompare");
+  var descString = swap(defaultCompare);
+  function ascNumber(x, y) {
+    return (x > y) - (x < y);
+  }
+  __name(ascNumber, "ascNumber");
+  var descNumber = swap(ascNumber);
+
+  // src/lib/compare.ts
+  function compare(iterable, other) {
+    return compareBy(iterable, other, defaultCompare);
+  }
+  __name(compare, "compare");
+
   // src/lib/compress.ts
   function* compress(iterable, selectors) {
     const resolvedSelectors = from(selectors);
@@ -285,12 +387,6 @@ var SapphireIteratorUtilities = (function (exports) {
   }
   __name(take, "take");
 
-  // src/lib/toArray.ts
-  function toArray(iterable) {
-    return [...toIterableIterator(iterable)];
-  }
-  __name(toArray, "toArray");
-
   // src/lib/dropLast.ts
   function dropLast(iterable, count2) {
     count2 = assertNotNegative(toIntegerOrInfinityOrThrow(count2), count2);
@@ -321,16 +417,23 @@ var SapphireIteratorUtilities = (function (exports) {
   }
   __name(enumerate, "enumerate");
 
-  // src/lib/every.ts
-  function every(iterable, callbackFn) {
+  // src/lib/equalBy.ts
+  function equalBy(iterable, other, callbackFn) {
     callbackFn = assertFunction(callbackFn);
-    let index = 0;
-    for (const value of toIterableIterator(iterable)) {
-      if (!callbackFn(value, index++)) return false;
+    const iterator1 = from(other);
+    for (const value0 of toIterableIterator(iterable)) {
+      const result1 = iterator1.next();
+      if (result1.done || !callbackFn(value0, result1.value)) return false;
     }
-    return true;
+    return iterator1.next().done === true;
   }
-  __name(every, "every");
+  __name(equalBy, "equalBy");
+
+  // src/lib/equal.ts
+  function equal(iterable, other) {
+    return equalBy(iterable, other, (a, b) => a === b);
+  }
+  __name(equal, "equal");
 
   // src/lib/find.ts
   function find(iterable, callbackFn) {
@@ -380,6 +483,37 @@ var SapphireIteratorUtilities = (function (exports) {
   }
   __name(forEach, "forEach");
 
+  // src/lib/fuse.ts
+  function fuse(iterable) {
+    let ended = false;
+    const iterator = toIterableIterator(iterable);
+    return makeIterableIterator(() => {
+      if (ended) {
+        return { done: true, value: void 0 };
+      }
+      const result = iterator.next();
+      if (result.done) {
+        ended = true;
+      }
+      return result;
+    });
+  }
+  __name(fuse, "fuse");
+
+  // src/lib/greaterOrEqualThan.ts
+  function greaterOrEqualThan(iterable, other) {
+    const result = compare(iterable, other);
+    return !orderingIsLess(result);
+  }
+  __name(greaterOrEqualThan, "greaterOrEqualThan");
+
+  // src/lib/greaterThan.ts
+  function greaterThan(iterable, other) {
+    const result = compare(iterable, other);
+    return orderingIsGreater(result);
+  }
+  __name(greaterThan, "greaterThan");
+
   // src/lib/indexOf.ts
   function indexOf(iterable, value) {
     let index = 0;
@@ -393,6 +527,21 @@ var SapphireIteratorUtilities = (function (exports) {
   }
   __name(indexOf, "indexOf");
 
+  // src/lib/inspect.ts
+  function inspect(iterable, callbackFn) {
+    callbackFn = assertFunction(callbackFn);
+    let index = 0;
+    const iterator = from(iterable);
+    return makeIterableIterator(() => {
+      const result = iterator.next();
+      if (!result.done) {
+        callbackFn(result.value, index++);
+      }
+      return result;
+    });
+  }
+  __name(inspect, "inspect");
+
   // src/lib/intersect.ts
   function intersect(first2, second) {
     const set = new Set(toIterableIterator(second));
@@ -400,12 +549,78 @@ var SapphireIteratorUtilities = (function (exports) {
   }
   __name(intersect, "intersect");
 
+  // src/lib/intersperse.ts
+  function intersperse(iterable, separator) {
+    let started = false;
+    let nextItem;
+    let nextItemTaken = false;
+    const iterator = from(iterable);
+    return makeIterableIterator(() => {
+      if (started) {
+        if (nextItemTaken) {
+          nextItemTaken = false;
+          return { done: false, value: nextItem };
+        }
+        const result = iterator.next();
+        if (result.done) {
+          return { done: true, value: void 0 };
+        }
+        nextItem = result.value;
+        nextItemTaken = true;
+        return { done: false, value: separator };
+      }
+      started = true;
+      return iterator.next();
+    });
+  }
+  __name(intersperse, "intersperse");
+
   // src/lib/isEmpty.ts
   function isEmpty(iterable) {
     return from(iterable).next().done ?? false;
   }
   __name(isEmpty, "isEmpty");
 
+  // src/lib/isSortedBy.ts
+  function isSortedBy(iterable, comparator) {
+    comparator = assertFunction(comparator);
+    const iterator = toIterableIterator(iterable);
+    const result = iterator.next();
+    if (result.done) return true;
+    let previous = result.value;
+    for (const current of iterator) {
+      const comparison = compareIteratorElements(previous, current, comparator);
+      if (orderingIsGreater(comparison)) return false;
+      previous = current;
+    }
+    return true;
+  }
+  __name(isSortedBy, "isSortedBy");
+
+  // src/lib/isSorted.ts
+  function isSorted(iterable) {
+    return isSortedBy(iterable, defaultCompare);
+  }
+  __name(isSorted, "isSorted");
+
+  // src/lib/isSortedByKey.ts
+  function isSortedByKey(iterable, callbackFn, comparator = defaultCompare) {
+    callbackFn = assertFunction(callbackFn);
+    const iterator = toIterableIterator(iterable);
+    const result = iterator.next();
+    if (result.done) return true;
+    let previousKey = callbackFn(result.value, 0);
+    let index = 1;
+    for (const current of iterator) {
+      const currentKey = callbackFn(current, index++);
+      const comparison = compareIteratorElements(previousKey, currentKey, comparator);
+      if (orderingIsGreater(comparison)) return false;
+      previousKey = currentKey;
+    }
+    return true;
+  }
+  __name(isSortedByKey, "isSortedByKey");
+
   // src/lib/last.ts
   function last(iterable) {
     let last2;
@@ -416,26 +631,114 @@ var SapphireIteratorUtilities = (function (exports) {
   }
   __name(last, "last");
 
+  // src/lib/lessOrEqualThan.ts
+  function lessOrEqualThan(iterable, other) {
+    const result = compare(iterable, other);
+    return !orderingIsGreater(result);
+  }
+  __name(lessOrEqualThan, "lessOrEqualThan");
+
+  // src/lib/lessThan.ts
+  function lessThan(iterable, other) {
+    const result = compare(iterable, other);
+    return orderingIsLess(result);
+  }
+  __name(lessThan, "lessThan");
+
+  // src/lib/maxBy.ts
+  function maxBy(iterable, comparator) {
+    comparator = assertFunction(comparator);
+    const iterator = toIterableIterator(iterable);
+    const first2 = iterator.next();
+    if (first2.done) return null;
+    let maximum = first2.value;
+    for (const value of iterator) {
+      const comparison = compareIteratorElements(value, maximum, comparator);
+      if (!orderingIsLess(comparison)) {
+        maximum = value;
+      }
+    }
+    return maximum;
+  }
+  __name(maxBy, "maxBy");
+
   // src/lib/max.ts
   function max(iterable) {
-    let max2 = null;
-    for (const value of map(iterable, toNumberOrThrow)) {
-      if (max2 === null || value > max2) max2 = value;
-    }
-    return max2;
+    return maxBy(iterable, defaultCompare);
   }
   __name(max, "max");
 
+  // src/lib/maxByKey.ts
+  function maxByKey(iterable, callbackFn, comparator = defaultCompare) {
+    callbackFn = assertFunction(callbackFn);
+    const iterator = toIterableIterator(iterable);
+    const first2 = iterator.next();
+    if (first2.done) return null;
+    let maximum = first2.value;
+    let maximumKey = callbackFn(maximum, 0);
+    let index = 1;
+    for (const value of iterator) {
+      const key = callbackFn(value, index++);
+      const comparison = compareIteratorElements(maximumKey, key, comparator);
+      if (!orderingIsGreater(comparison)) {
+        maximum = value;
+        maximumKey = key;
+      }
+    }
+    return maximum;
+  }
+  __name(maxByKey, "maxByKey");
+
+  // src/lib/minBy.ts
+  function minBy(iterable, comparator) {
+    comparator = assertFunction(comparator);
+    const iterator = toIterableIterator(iterable);
+    const first2 = iterator.next();
+    if (first2.done) return null;
+    let minimum = first2.value;
+    for (const value of iterator) {
+      const comparison = compareIteratorElements(value, minimum, comparator);
+      if (!orderingIsGreater(comparison)) {
+        minimum = value;
+      }
+    }
+    return minimum;
+  }
+  __name(minBy, "minBy");
+
   // src/lib/min.ts
   function min(iterable) {
-    let min2 = null;
-    for (const value of map(iterable, toNumberOrThrow)) {
-      if (min2 === null || value < min2) min2 = value;
-    }
-    return min2;
+    return minBy(iterable, defaultCompare);
   }
   __name(min, "min");
 
+  // src/lib/minByKey.ts
+  function minByKey(iterable, callbackFn, comparator = defaultCompare) {
+    callbackFn = assertFunction(callbackFn);
+    const iterator = toIterableIterator(iterable);
+    const first2 = iterator.next();
+    if (first2.done) return null;
+    let minimum = first2.value;
+    let minimumKey = callbackFn(minimum, 0);
+    let index = 1;
+    for (const value of iterator) {
+      const key = callbackFn(value, index++);
+      const comparison = compareIteratorElements(minimumKey, key, comparator);
+      if (!orderingIsLess(comparison)) {
+        minimum = value;
+        minimumKey = key;
+      }
+    }
+    return minimum;
+  }
+  __name(minByKey, "minByKey");
+
+  // src/lib/notEqual.ts
+  function notEqual(iterable, other) {
+    return !equal(iterable, other);
+  }
+  __name(notEqual, "notEqual");
+
   // src/lib/partition.ts
   function partition(iterable, predicate) {
     predicate = assertFunction(predicate);
@@ -558,10 +861,7 @@ var SapphireIteratorUtilities = (function (exports) {
 
   // src/lib/reverse.ts
   function* reverse(iterable) {
-    const items = [];
-    for (const item of toIterableIterator(iterable)) {
-      items.push(item);
-    }
+    const items = toArray(iterable);
     for (let i = items.length - 1; i >= 0; i--) {
       yield items[i];
     }
@@ -614,19 +914,6 @@ var SapphireIteratorUtilities = (function (exports) {
   }
   __name(slice, "slice");
 
-  // src/lib/some.ts
-  function some(iterable, callbackFn) {
-    callbackFn = assertFunction(callbackFn);
-    let index = 0;
-    for (const value of toIterableIterator(iterable)) {
-      if (callbackFn(value, index++)) {
-        return true;
-      }
-    }
-    return false;
-  }
-  __name(some, "some");
-
   // src/lib/sorted.ts
   function sorted(iterable, compareFn) {
     return toArray(iterable).sort(compareFn).values();
@@ -642,6 +929,24 @@ var SapphireIteratorUtilities = (function (exports) {
   }
   __name(starMap, "starMap");
 
+  // src/lib/stepBy.ts
+  function stepBy(iterable, step) {
+    step = assertPositive(toIntegerOrInfinityOrThrow(step), step);
+    const iterator = from(iterable);
+    return makeIterableIterator(() => {
+      const result = iterator.next();
+      if (result.done) {
+        return { done: true, value: void 0 };
+      }
+      for (let i = 0; i < step - 1; i++) {
+        const result2 = iterator.next();
+        if (result2.done) break;
+      }
+      return { done: false, value: result.value };
+    });
+  }
+  __name(stepBy, "stepBy");
+
   // src/lib/sum.ts
   function sum(iterable) {
     let sum2 = 0;
@@ -740,23 +1045,38 @@ var SapphireIteratorUtilities = (function (exports) {
   }
   __name(zip, "zip");
 
+  exports.all = every;
+  exports.any = some;
   exports.append = append;
+  exports.ascNumber = ascNumber;
+  exports.ascString = defaultCompare;
   exports.at = at;
   exports.average = average;
   exports.chain = chain;
   exports.chunk = chunk;
+  exports.collect = toArray;
+  exports.collectInto = collectInto;
   exports.compact = compact;
+  exports.compare = compare;
+  exports.compareBy = compareBy;
   exports.compress = compress;
   exports.concat = append;
   exports.contains = contains;
   exports.count = count;
   exports.cycle = cycle;
+  exports.defaultCompare = defaultCompare;
+  exports.descNumber = descNumber;
+  exports.descString = descString;
   exports.difference = difference;
   exports.drop = drop;
   exports.dropLast = dropLast;
   exports.dropWhile = dropWhile;
   exports.empty = empty;
   exports.enumerate = enumerate;
+  exports.eq = equal;
+  exports.eqBy = equalBy;
+  exports.equal = equal;
+  exports.equalBy = equalBy;
   exports.every = every;
   exports.except = difference;
   exports.filter = filter;
@@ -767,13 +1087,34 @@ var SapphireIteratorUtilities = (function (exports) {
   exports.flatMap = flatMap;
   exports.forEach = forEach;
   exports.from = from;
+  exports.fuse = fuse;
+  exports.ge = greaterOrEqualThan;
+  exports.greaterOrEqualThan = greaterOrEqualThan;
+  exports.greaterThan = greaterThan;
+  exports.gt = greaterThan;
   exports.indexOf = indexOf;
+  exports.inspect = inspect;
   exports.intersect = intersect;
+  exports.intersperse = intersperse;
   exports.isEmpty = isEmpty;
+  exports.isSorted = isSorted;
+  exports.isSortedBy = isSortedBy;
+  exports.isSortedByKey = isSortedByKey;
   exports.last = last;
+  exports.le = lessOrEqualThan;
+  exports.lessOrEqualThan = lessOrEqualThan;
+  exports.lessThan = lessThan;
+  exports.lt = lessThan;
   exports.map = map;
   exports.max = max;
+  exports.maxBy = maxBy;
+  exports.maxByKey = maxByKey;
   exports.min = min;
+  exports.minBy = minBy;
+  exports.minByKey = minByKey;
+  exports.ne = notEqual;
+  exports.notEqual = notEqual;
+  exports.nth = at;
   exports.omit = difference;
   exports.partition = partition;
   exports.peekable = peekable;
@@ -791,6 +1132,7 @@ var SapphireIteratorUtilities = (function (exports) {
   exports.some = some;
   exports.sorted = sorted;
   exports.starMap = starMap;
+  exports.stepBy = stepBy;
   exports.sum = sum;
   exports.take = take;
   exports.takeLast = takeLast;