iterflow 0.2.2

package/dist/fn/index.cjs

@@ -0,0 +1,904 @@
+'use strict';
+
+// src/errors.ts
+var iterflowError = class extends Error {
+  operation;
+  context;
+  constructor(message, operation, context) {
+    super(message);
+    this.name = "iterflowError";
+    this.operation = operation;
+    this.context = context;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  /**
+   * Returns a detailed error message with context
+   */
+  toDetailedString() {
+    let msg = `${this.name}: ${this.message}`;
+    if (this.operation) {
+      msg += `
+  Operation: ${this.operation}`;
+    }
+    if (this.context && Object.keys(this.context).length > 0) {
+      msg += "\n  Context:";
+      for (const [key, value] of Object.entries(this.context)) {
+        msg += `
+    ${key}: ${JSON.stringify(value)}`;
+      }
+    }
+    if (this.stack) {
+      msg += `
+  Stack: ${this.stack.split("\n").slice(1).join("\n")}`;
+    }
+    return msg;
+  }
+};
+var ValidationError = class extends iterflowError {
+  constructor(message, operation, context) {
+    super(message, operation, context);
+    this.name = "ValidationError";
+  }
+};
+
+// src/validation.ts
+function validatePositiveInteger(value, paramName, operation) {
+  if (!Number.isInteger(value)) {
+    throw new ValidationError(
+      `${paramName} must be an integer, got ${value}`,
+      operation,
+      { paramName, value }
+    );
+  }
+  if (value < 1) {
+    throw new ValidationError(
+      `${paramName} must be at least 1, got ${value}`,
+      operation,
+      { paramName, value }
+    );
+  }
+}
+function validateRange(value, min2, max2, paramName, operation) {
+  if (value < min2 || value > max2) {
+    throw new ValidationError(
+      `${paramName} must be between ${min2} and ${max2}, got ${value}`,
+      operation,
+      { paramName, value, min: min2, max: max2 }
+    );
+  }
+}
+function validateNonZero(value, paramName, operation) {
+  if (value === 0) {
+    throw new ValidationError(`${paramName} cannot be zero`, operation, {
+      paramName,
+      value
+    });
+  }
+}
+
+// src/fn/composition.ts
+function pipe(...fns) {
+  return (input) => fns.reduce((acc, fn) => fn(acc), input);
+}
+function compose(...fns) {
+  return (input) => fns.reduceRight((acc, fn) => fn(acc), input);
+}
+function createOperation(name, generator) {
+  if (generator.length === 1) {
+    return (iterable) => {
+      const result = generator(iterable);
+      Object.defineProperty(result, "name", { value: name });
+      return result;
+    };
+  }
+  return (...configs) => {
+    return (iterable) => {
+      const result = generator(iterable, ...configs);
+      Object.defineProperty(result, "name", { value: name });
+      return result;
+    };
+  };
+}
+function mapTransducer(fn) {
+  return (reducer) => {
+    return (accumulator, value) => {
+      return reducer(accumulator, fn(value));
+    };
+  };
+}
+function filterTransducer(predicate) {
+  return (reducer) => {
+    return (accumulator, value) => {
+      return predicate(value) ? reducer(accumulator, value) : accumulator;
+    };
+  };
+}
+function takeTransducer(n) {
+  return (reducer) => {
+    let taken = 0;
+    return (accumulator, value) => {
+      if (taken < n) {
+        taken++;
+        const result = reducer(accumulator, value);
+        if (taken === n) {
+          return reduced(result);
+        }
+        return result;
+      }
+      return accumulator;
+    };
+  };
+}
+function composeTransducers(...transducers) {
+  return (reducer) => {
+    return transducers.reduceRight((acc, xf) => xf(acc), reducer);
+  };
+}
+var REDUCED = Symbol("@@transducer/reduced");
+function reduced(value) {
+  return {
+    [REDUCED]: true,
+    value
+  };
+}
+function isReduced(value) {
+  return value != null && value[REDUCED] === true;
+}
+function transduce(transducer, reducer, initial, iterable) {
+  const xform = transducer(reducer);
+  let accumulator = initial;
+  for (const value of iterable) {
+    accumulator = xform(accumulator, value);
+    if (isReduced(accumulator)) {
+      return accumulator.value;
+    }
+  }
+  return accumulator;
+}
+function transducerToIterator(transducer) {
+  return function* (iterable) {
+    const results = [];
+    const reducer = (acc, value) => {
+      acc.push(value);
+      return acc;
+    };
+    const xform = transducer(reducer);
+    for (const value of iterable) {
+      const before = results.length;
+      const result = xform(results, value);
+      if (isReduced(result)) {
+        for (let i = before; i < result.value.length; i++) {
+          yield result.value[i];
+        }
+        return;
+      }
+      for (let i = before; i < results.length; i++) {
+        yield results[i];
+      }
+    }
+  };
+}
+
+// src/fn/index.ts
+function sum(iterable) {
+  let total = 0;
+  for (const value of iterable) {
+    total += value;
+  }
+  return total;
+}
+function mean(iterable) {
+  let total = 0;
+  let count2 = 0;
+  for (const value of iterable) {
+    total += value;
+    count2++;
+  }
+  return count2 === 0 ? void 0 : total / count2;
+}
+function min(iterable) {
+  let minimum = void 0;
+  for (const value of iterable) {
+    if (minimum === void 0 || value < minimum) {
+      minimum = value;
+    }
+  }
+  return minimum;
+}
+function max(iterable) {
+  let maximum = void 0;
+  for (const value of iterable) {
+    if (maximum === void 0 || value > maximum) {
+      maximum = value;
+    }
+  }
+  return maximum;
+}
+function count(iterable) {
+  let count2 = 0;
+  for (const _ of iterable) {
+    count2++;
+  }
+  return count2;
+}
+function median(iterable) {
+  const values = Array.from(iterable);
+  if (values.length === 0) return void 0;
+  values.sort((a, b) => a - b);
+  const mid = Math.floor(values.length / 2);
+  if (values.length % 2 === 0) {
+    return (values[mid - 1] + values[mid]) / 2;
+  } else {
+    return values[mid];
+  }
+}
+function variance(iterable) {
+  const values = Array.from(iterable);
+  if (values.length === 0) return void 0;
+  const mean2 = values.reduce((sum2, val) => sum2 + val, 0) / values.length;
+  let sumSquaredDiffs = 0;
+  for (let i = 0; i < values.length; i++) {
+    const diff = values[i] - mean2;
+    sumSquaredDiffs += diff * diff;
+  }
+  return sumSquaredDiffs / values.length;
+}
+function stdDev(iterable) {
+  const varianceValue = variance(iterable);
+  return varianceValue === void 0 ? void 0 : Math.sqrt(varianceValue);
+}
+function percentile(iterable, p) {
+  validateRange(p, 0, 100, "percentile", "percentile");
+  const values = Array.from(iterable);
+  if (values.length === 0) return void 0;
+  values.sort((a, b) => a - b);
+  if (p === 0) return values[0];
+  if (p === 100) return values[values.length - 1];
+  const index = p / 100 * (values.length - 1);
+  const lower = Math.floor(index);
+  const upper = Math.ceil(index);
+  if (lower === upper) {
+    return values[lower];
+  }
+  const weight = index - lower;
+  return values[lower] * (1 - weight) + values[upper] * weight;
+}
+function mode(iterable) {
+  const values = Array.from(iterable);
+  if (values.length === 0) return void 0;
+  const frequency = /* @__PURE__ */ new Map();
+  let maxFreq = 0;
+  for (const value of values) {
+    const count2 = (frequency.get(value) || 0) + 1;
+    frequency.set(value, count2);
+    maxFreq = Math.max(maxFreq, count2);
+  }
+  const modes = [];
+  for (const [value, freq] of frequency) {
+    if (freq === maxFreq) {
+      modes.push(value);
+    }
+  }
+  return modes.sort((a, b) => a - b);
+}
+function quartiles(iterable) {
+  const values = Array.from(iterable);
+  if (values.length === 0) return void 0;
+  values.sort((a, b) => a - b);
+  const calculatePercentile = (p) => {
+    if (p === 0) return values[0];
+    if (p === 100) return values[values.length - 1];
+    const index = p / 100 * (values.length - 1);
+    const lower = Math.floor(index);
+    const upper = Math.ceil(index);
+    if (lower === upper) {
+      return values[lower];
+    }
+    const weight = index - lower;
+    return values[lower] * (1 - weight) + values[upper] * weight;
+  };
+  return {
+    Q1: calculatePercentile(25),
+    Q2: calculatePercentile(50),
+    Q3: calculatePercentile(75)
+  };
+}
+function span(iterable) {
+  let minimum = void 0;
+  let maximum = void 0;
+  for (const value of iterable) {
+    if (minimum === void 0 || value < minimum) {
+      minimum = value;
+    }
+    if (maximum === void 0 || value > maximum) {
+      maximum = value;
+    }
+  }
+  return minimum === void 0 || maximum === void 0 ? void 0 : maximum - minimum;
+}
+function product(iterable) {
+  let result = 1;
+  for (const value of iterable) {
+    result *= value;
+  }
+  return result;
+}
+function covariance(iter1, iter2) {
+  const values1 = Array.from(iter1);
+  const values2 = Array.from(iter2);
+  if (values1.length === 0 || values2.length === 0 || values1.length !== values2.length) {
+    return void 0;
+  }
+  const mean1 = values1.reduce((sum2, val) => sum2 + val, 0) / values1.length;
+  const mean2 = values2.reduce((sum2, val) => sum2 + val, 0) / values2.length;
+  let covariance2 = 0;
+  for (let i = 0; i < values1.length; i++) {
+    covariance2 += (values1[i] - mean1) * (values2[i] - mean2);
+  }
+  return covariance2 / values1.length;
+}
+function correlation(iter1, iter2) {
+  const values1 = Array.from(iter1);
+  const values2 = Array.from(iter2);
+  if (values1.length === 0 || values2.length === 0 || values1.length !== values2.length) {
+    return void 0;
+  }
+  const mean1 = values1.reduce((sum2, val) => sum2 + val, 0) / values1.length;
+  const mean2 = values2.reduce((sum2, val) => sum2 + val, 0) / values2.length;
+  let covariance2 = 0;
+  let variance1 = 0;
+  let variance2 = 0;
+  for (let i = 0; i < values1.length; i++) {
+    const diff1 = values1[i] - mean1;
+    const diff2 = values2[i] - mean2;
+    covariance2 += diff1 * diff2;
+    variance1 += diff1 * diff1;
+    variance2 += diff2 * diff2;
+  }
+  const stdDev1 = Math.sqrt(variance1 / values1.length);
+  const stdDev2 = Math.sqrt(variance2 / values2.length);
+  if (stdDev1 === 0 || stdDev2 === 0) {
+    return void 0;
+  }
+  return covariance2 / (values1.length * stdDev1 * stdDev2);
+}
+function map(fn) {
+  return function* (iterable) {
+    for (const value of iterable) {
+      yield fn(value);
+    }
+  };
+}
+function filter(predicate) {
+  return function* (iterable) {
+    for (const value of iterable) {
+      if (predicate(value)) {
+        yield value;
+      }
+    }
+  };
+}
+function take(limit) {
+  return function* (iterable) {
+    let count2 = 0;
+    for (const value of iterable) {
+      if (count2 >= limit) break;
+      yield value;
+      count2++;
+    }
+  };
+}
+function drop(count2) {
+  return function* (iterable) {
+    let dropped = 0;
+    for (const value of iterable) {
+      if (dropped < count2) {
+        dropped++;
+        continue;
+      }
+      yield value;
+    }
+  };
+}
+function flatMap(fn) {
+  return function* (iterable) {
+    for (const value of iterable) {
+      yield* fn(value);
+    }
+  };
+}
+function concat() {
+  return function* (...iterables) {
+    for (const iterable of iterables) {
+      yield* iterable;
+    }
+  };
+}
+function intersperse(separator) {
+  return function* (iterable) {
+    let isFirst = true;
+    for (const value of iterable) {
+      if (!isFirst) {
+        yield separator;
+      }
+      yield value;
+      isFirst = false;
+    }
+  };
+}
+function scan(fn, initial) {
+  return function* (iterable) {
+    let accumulator = initial;
+    yield accumulator;
+    for (const value of iterable) {
+      accumulator = fn(accumulator, value);
+      yield accumulator;
+    }
+  };
+}
+function enumerate() {
+  return function* (iterable) {
+    let index = 0;
+    for (const value of iterable) {
+      yield [index, value];
+      index++;
+    }
+  };
+}
+function reverse() {
+  return function* (iterable) {
+    const buffer = Array.from(iterable);
+    for (let i = buffer.length - 1; i >= 0; i--) {
+      yield buffer[i];
+    }
+  };
+}
+function sort(iterable) {
+  return (function* () {
+    const buffer = Array.from(iterable);
+    buffer.sort((a, b) => {
+      if (typeof a === "number" && typeof b === "number") {
+        return a - b;
+      }
+      return String(a).localeCompare(String(b));
+    });
+    yield* buffer;
+  })();
+}
+function sortBy(compareFn) {
+  return function* (iterable) {
+    const buffer = Array.from(iterable);
+    buffer.sort(compareFn);
+    yield* buffer;
+  };
+}
+function window(size) {
+  validatePositiveInteger(size, "size", "window");
+  return function* (iterable) {
+    const buffer = new Array(size);
+    let count2 = 0;
+    let index = 0;
+    for (const value of iterable) {
+      buffer[index] = value;
+      count2++;
+      index = (index + 1) % size;
+      if (count2 >= size) {
+        const window2 = new Array(size);
+        for (let i = 0; i < size; i++) {
+          window2[i] = buffer[(index + i) % size];
+        }
+        yield window2;
+      }
+    }
+  };
+}
+function chunk(size) {
+  validatePositiveInteger(size, "size", "chunk");
+  return function* (iterable) {
+    let buffer = new Array(size);
+    let bufferIndex = 0;
+    for (const value of iterable) {
+      buffer[bufferIndex++] = value;
+      if (bufferIndex === size) {
+        yield buffer;
+        buffer = new Array(size);
+        bufferIndex = 0;
+      }
+    }
+    if (bufferIndex > 0) {
+      yield buffer.slice(0, bufferIndex);
+    }
+  };
+}
+function pairwise(iterable) {
+  return (function* () {
+    const windowIter = window(2)(iterable);
+    for (const arr of { [Symbol.iterator]: () => windowIter }) {
+      yield [arr[0], arr[1]];
+    }
+  })();
+}
+function partition(predicate) {
+  return function(iterable) {
+    const truthy = [];
+    const falsy = [];
+    for (const value of iterable) {
+      if (predicate(value)) {
+        truthy.push(value);
+      } else {
+        falsy.push(value);
+      }
+    }
+    return [truthy, falsy];
+  };
+}
+function groupBy(keyFn) {
+  return function(iterable) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const value of iterable) {
+      const key = keyFn(value);
+      if (!groups.has(key)) {
+        groups.set(key, []);
+      }
+      groups.get(key).push(value);
+    }
+    return groups;
+  };
+}
+function distinct(iterable) {
+  return (function* () {
+    const seen = /* @__PURE__ */ new Set();
+    for (const value of iterable) {
+      if (!seen.has(value)) {
+        seen.add(value);
+        yield value;
+      }
+    }
+  })();
+}
+function distinctBy(keyFn) {
+  return function* (iterable) {
+    const seenKeys = /* @__PURE__ */ new Set();
+    for (const value of iterable) {
+      const key = keyFn(value);
+      if (!seenKeys.has(key)) {
+        seenKeys.add(key);
+        yield value;
+      }
+    }
+  };
+}
+function tap(fn) {
+  return function* (iterable) {
+    for (const value of iterable) {
+      fn(value);
+      yield value;
+    }
+  };
+}
+function takeWhile(predicate) {
+  return function* (iterable) {
+    for (const value of iterable) {
+      if (!predicate(value)) break;
+      yield value;
+    }
+  };
+}
+function dropWhile(predicate) {
+  return function* (iterable) {
+    let dropping = true;
+    for (const value of iterable) {
+      if (dropping && predicate(value)) {
+        continue;
+      }
+      dropping = false;
+      yield value;
+    }
+  };
+}
+function toArray(iterable) {
+  return Array.from(iterable);
+}
+function reduce(fn, initial) {
+  return function(iterable) {
+    let accumulator = initial;
+    for (const value of iterable) {
+      accumulator = fn(accumulator, value);
+    }
+    return accumulator;
+  };
+}
+function find(predicate) {
+  return function(iterable) {
+    for (const value of iterable) {
+      if (predicate(value)) {
+        return value;
+      }
+    }
+    return void 0;
+  };
+}
+function findIndex(predicate) {
+  return function(iterable) {
+    let index = 0;
+    for (const value of iterable) {
+      if (predicate(value)) {
+        return index;
+      }
+      index++;
+    }
+    return -1;
+  };
+}
+function some(predicate) {
+  return function(iterable) {
+    for (const value of iterable) {
+      if (predicate(value)) {
+        return true;
+      }
+    }
+    return false;
+  };
+}
+function every(predicate) {
+  return function(iterable) {
+    for (const value of iterable) {
+      if (!predicate(value)) {
+        return false;
+      }
+    }
+    return true;
+  };
+}
+function first(iterable, defaultValue) {
+  const iterator = iterable[Symbol.iterator]();
+  const result = iterator.next();
+  return result.done ? defaultValue : result.value;
+}
+function last(iterable, defaultValue) {
+  let lastValue = defaultValue;
+  let hasValue = false;
+  for (const value of iterable) {
+    lastValue = value;
+    hasValue = true;
+  }
+  return hasValue ? lastValue : defaultValue;
+}
+function nth(index) {
+  return function(iterable) {
+    if (index < 0) {
+      return void 0;
+    }
+    let currentIndex = 0;
+    for (const value of iterable) {
+      if (currentIndex === index) {
+        return value;
+      }
+      currentIndex++;
+    }
+    return void 0;
+  };
+}
+function isEmpty(iterable) {
+  const iterator = iterable[Symbol.iterator]();
+  const result = iterator.next();
+  return result.done === true;
+}
+function includes(searchValue) {
+  return function(iterable) {
+    for (const value of iterable) {
+      if (value === searchValue) {
+        return true;
+      }
+    }
+    return false;
+  };
+}
+function zip(iter1, iter2) {
+  return (function* () {
+    const it1 = iter1[Symbol.iterator]();
+    const it2 = iter2[Symbol.iterator]();
+    while (true) {
+      const result1 = it1.next();
+      const result2 = it2.next();
+      if (result1.done || result2.done) {
+        break;
+      }
+      yield [result1.value, result2.value];
+    }
+  })();
+}
+function zipWith(iter1, iter2, fn) {
+  return (function* () {
+    const zipIter = zip(iter1, iter2);
+    for (const [a, b] of { [Symbol.iterator]: () => zipIter }) {
+      yield fn(a, b);
+    }
+  })();
+}
+function range(startOrStop, stop, step = 1) {
+  const actualStart = stop === void 0 ? 0 : startOrStop;
+  const actualStop = stop === void 0 ? startOrStop : stop;
+  return (function* () {
+    validateNonZero(step, "step", "range");
+    if (step > 0) {
+      for (let i = actualStart; i < actualStop; i += step) {
+        yield i;
+      }
+    } else {
+      for (let i = actualStart; i > actualStop; i += step) {
+        yield i;
+      }
+    }
+  })();
+}
+function repeat(value, times) {
+  return (function* () {
+    if (times === void 0) {
+      while (true) {
+        yield value;
+      }
+    } else {
+      for (let i = 0; i < times; i++) {
+        yield value;
+      }
+    }
+  })();
+}
+function interleave(...iterables) {
+  return (function* () {
+    if (iterables.length === 0) return;
+    const iterators = iterables.map((it) => it[Symbol.iterator]());
+    const active = new Set(iterators);
+    while (active.size > 0) {
+      for (const iterator of iterators) {
+        if (!active.has(iterator)) continue;
+        const result = iterator.next();
+        if (result.done) {
+          active.delete(iterator);
+        } else {
+          yield result.value;
+        }
+      }
+    }
+  })();
+}
+function merge(...args) {
+  let compareFn;
+  let iterables;
+  if (typeof args[0] === "function") {
+    compareFn = args[0];
+    iterables = args.slice(1);
+  } else {
+    compareFn = (a, b) => {
+      if (a < b) return -1;
+      if (a > b) return 1;
+      return 0;
+    };
+    iterables = args;
+  }
+  return (function* () {
+    if (iterables.length === 0) return;
+    const heap = [];
+    for (let i = 0; i < iterables.length; i++) {
+      const iterator = iterables[i][Symbol.iterator]();
+      const result = iterator.next();
+      if (!result.done) {
+        heap.push({ value: result.value, iterator, index: i });
+      }
+    }
+    const bubbleDown = (index) => {
+      const length = heap.length;
+      while (true) {
+        let smallest = index;
+        const leftChild = 2 * index + 1;
+        const rightChild = 2 * index + 2;
+        if (leftChild < length && compareFn(heap[leftChild].value, heap[smallest].value) < 0) {
+          smallest = leftChild;
+        }
+        if (rightChild < length && compareFn(heap[rightChild].value, heap[smallest].value) < 0) {
+          smallest = rightChild;
+        }
+        if (smallest === index) break;
+        [heap[index], heap[smallest]] = [heap[smallest], heap[index]];
+        index = smallest;
+      }
+    };
+    for (let i = Math.floor(heap.length / 2) - 1; i >= 0; i--) {
+      bubbleDown(i);
+    }
+    while (heap.length > 0) {
+      const { value, iterator } = heap[0];
+      yield value;
+      const result = iterator.next();
+      if (result.done) {
+        heap[0] = heap[heap.length - 1];
+        heap.pop();
+        if (heap.length > 0) {
+          bubbleDown(0);
+        }
+      } else {
+        heap[0].value = result.value;
+        bubbleDown(0);
+      }
+    }
+  })();
+}
+function chain(...iterables) {
+  return (function* () {
+    for (const iterable of iterables) {
+      yield* iterable;
+    }
+  })();
+}
+
+exports.chain = chain;
+exports.chunk = chunk;
+exports.compose = compose;
+exports.composeTransducers = composeTransducers;
+exports.concat = concat;
+exports.correlation = correlation;
+exports.count = count;
+exports.covariance = covariance;
+exports.createOperation = createOperation;
+exports.distinct = distinct;
+exports.distinctBy = distinctBy;
+exports.drop = drop;
+exports.dropWhile = dropWhile;
+exports.enumerate = enumerate;
+exports.every = every;
+exports.filter = filter;
+exports.filterTransducer = filterTransducer;
+exports.find = find;
+exports.findIndex = findIndex;
+exports.first = first;
+exports.flatMap = flatMap;
+exports.groupBy = groupBy;
+exports.includes = includes;
+exports.interleave = interleave;
+exports.intersperse = intersperse;
+exports.isEmpty = isEmpty;
+exports.isReduced = isReduced;
+exports.last = last;
+exports.map = map;
+exports.mapTransducer = mapTransducer;
+exports.max = max;
+exports.mean = mean;
+exports.median = median;
+exports.merge = merge;
+exports.min = min;
+exports.mode = mode;
+exports.nth = nth;
+exports.pairwise = pairwise;
+exports.partition = partition;
+exports.percentile = percentile;
+exports.pipe = pipe;
+exports.product = product;
+exports.quartiles = quartiles;
+exports.range = range;
+exports.reduce = reduce;
+exports.reduced = reduced;
+exports.repeat = repeat;
+exports.reverse = reverse;
+exports.scan = scan;
+exports.some = some;
+exports.sort = sort;
+exports.sortBy = sortBy;
+exports.span = span;
+exports.stdDev = stdDev;
+exports.sum = sum;
+exports.take = take;
+exports.takeTransducer = takeTransducer;
+exports.takeWhile = takeWhile;
+exports.tap = tap;
+exports.toArray = toArray;
+exports.transduce = transduce;
+exports.transducerToIterator = transducerToIterator;
+exports.variance = variance;
+exports.window = window;
+exports.zip = zip;
+exports.zipWith = zipWith;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map