@mathscapes/iterflow 1.0.0-rc1

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core.ts","../src/internal.ts","../src/transforms.ts","../src/terminals.ts","../src/index.ts"],"sourcesContent":["// Error classes\n/**\n * Base error class for all iterflow errors.\n */\nexport class IterflowError extends Error {\n  constructor(msg: string) {\n    super(msg);\n    this.name = 'IterflowError';\n  }\n}\n\n/**\n * Thrown by statistical methods when called on empty sequences.\n */\nexport class EmptySequenceError extends IterflowError {\n  constructor(readonly op: string) {\n    super(`Cannot compute ${op} of empty sequence`);\n    this.name = 'EmptySequenceError';\n  }\n}\n\n// Type definitions\nexport type Predicate<T> = (v: T, i: number) => boolean;\nexport type Mapper<T, U> = (v: T, i: number) => U;\nexport type Reducer<T, U> = (acc: U, v: T, i: number) => U;\nexport type FlatMapper<T, U> = (v: T, i: number) => Iterable<U>;\n\n// Utilities\n/**\n * Type guard to check if a value is iterable.\n */\nexport const isIterable = (v: unknown): v is Iterable<unknown> =>\n  v != null && typeof v === 'object' && Symbol.iterator in v;\n","import { EmptySequenceError } from './core.js';\n\n// Generator factory\nexport function makeTransform<T, U>(\n  src: Iterable<T>,\n  generator: (src: Iterable<T>) => Generator<U>\n): Iterable<U> {\n  return {\n    *[Symbol.iterator]() {\n      yield* generator(src);\n    }\n  };\n}\n\n// Iteration helpers\nexport function assertNonEmpty(count: number, op: string): void {\n  if (count === 0) {\n    throw new EmptySequenceError(op);\n  }\n}\n\nexport function assertHasValue(has: boolean, op: string): void {\n  if (!has) {\n    throw new EmptySequenceError(op);\n  }\n}\n\n// Validation helpers\nexport function validateInteger(n: number, param: string): void {\n  if (!Number.isFinite(n)) {\n    throw new RangeError(`${param} must be finite`);\n  }\n  if (!Number.isInteger(n)) {\n    throw new TypeError(`${param} must be an integer`);\n  }\n}\n\nexport function validateNonNegative(n: number, param: string): void {\n  validateInteger(n, param);\n  if (n < 0) {\n    throw new RangeError(`${param} must be non-negative`);\n  }\n}\n\nexport function validatePositive(n: number, param: string): void {\n  validateInteger(n, param);\n  if (n <= 0) {\n    throw new RangeError(`${param} must be positive`);\n  }\n}\n","import type { Predicate, Mapper, FlatMapper } from './core.js';\nimport { makeTransform, validateNonNegative, validatePositive } from './internal.js';\n\n// Mapping transforms\nexport function map<T, U>(src: Iterable<T>, fn: Mapper<T, U>): Iterable<U> {\n  return makeTransform(src, function* (s) {\n    let i = 0;\n    for (const v of s) yield fn(v, i++);\n  });\n}\n\nexport function flatMap<T, U>(src: Iterable<T>, fn: FlatMapper<T, U>): Iterable<U> {\n  return makeTransform(src, function* (s) {\n    let i = 0;\n    for (const v of s) yield* fn(v, i++);\n  });\n}\n\nexport function enumerate<T>(src: Iterable<T>): Iterable<[number, T]> {\n  return makeTransform(src, function* (s) {\n    let i = 0;\n    for (const v of s) yield [i++, v];\n  });\n}\n\n// Filtering transforms\nexport function filter<T>(src: Iterable<T>, fn: Predicate<T>): Iterable<T> {\n  return makeTransform(src, function* (s) {\n    let i = 0;\n    for (const v of s) if (fn(v, i++)) yield v;\n  });\n}\n\nexport function take<T>(src: Iterable<T>, n: number): Iterable<T> {\n  validateNonNegative(n, 'Count');\n  return makeTransform(src, function* (s) {\n    let remaining = n;\n    for (const v of s) {\n      if (remaining-- <= 0) break;\n      yield v;\n    }\n  });\n}\n\nexport function drop<T>(src: Iterable<T>, n: number): Iterable<T> {\n  validateNonNegative(n, 'Count');\n  return makeTransform(src, function* (s) {\n    let i = 0;\n    for (const v of s) if (i++ >= n) yield v;\n  });\n}\n\nexport function takeWhile<T>(src: Iterable<T>, fn: Predicate<T>): Iterable<T> {\n  return makeTransform(src, function* (s) {\n    let i = 0;\n    for (const v of s) {\n      if (!fn(v, i++)) break;\n      yield v;\n    }\n  });\n}\n\nexport function dropWhile<T>(src: Iterable<T>, fn: Predicate<T>): Iterable<T> {\n  return makeTransform(src, function* (s) {\n    let i = 0, dropping = true;\n    for (const v of s) {\n      if (dropping && !fn(v, i)) dropping = false;\n      if (!dropping) yield v;\n      i++;\n    }\n  });\n}\n\nexport function distinct<T>(src: Iterable<T>): Iterable<T> {\n  return makeTransform(src, function* (s) {\n    const seen = new Set<T>();\n    for (const v of s) {\n      if (!seen.has(v)) { seen.add(v); yield v; }\n    }\n  });\n}\n\n// Windowing transforms\nexport function window<T>(src: Iterable<T>, size: number): Iterable<T[]> {\n  validatePositive(size, 'Window size');\n  return makeTransform(src, function* (s) {\n    const buf: T[] = [];\n    for (const v of s) {\n      buf.push(v);\n      if (buf.length === size) { yield buf.slice(); buf.shift(); }\n    }\n  });\n}\n\nexport function chunk<T>(src: Iterable<T>, size: number): Iterable<T[]> {\n  validatePositive(size, 'Chunk size');\n  return makeTransform(src, function* (s) {\n    let batch: T[] = [];\n    for (const v of s) {\n      batch.push(v);\n      if (batch.length === size) { yield batch; batch = []; }\n    }\n    if (batch.length) yield batch;\n  });\n}\n\n// Combining transforms\nexport function concat<T, U>(src: Iterable<T>, ...others: Iterable<U>[]): Iterable<T | U> {\n  return makeTransform(src, function* (s) {\n    yield* s;\n    for (const o of others) yield* o;\n  });\n}\n","import type { Predicate, Reducer } from './core.js';\nimport { assertNonEmpty, assertHasValue } from './internal.js';\n\n// Collection terminals\nexport function toArray<T>(src: Iterable<T>): T[] {\n  return Array.from(src);\n}\n\nexport function reduce<T, U>(src: Iterable<T>, fn: Reducer<T, U>, init: U): U {\n  let acc = init, i = 0;\n  for (const v of src) acc = fn(acc, v, i++);\n  return acc;\n}\n\nexport function find<T>(src: Iterable<T>, fn: Predicate<T>): T | undefined {\n  let i = 0;\n  for (const v of src) if (fn(v, i++)) return v;\n  return undefined;\n}\n\nexport function forEach<T>(src: Iterable<T>, fn: (v: T, i: number) => void): void {\n  let i = 0;\n  for (const v of src) fn(v, i++);\n}\n\n// Testing terminals\nexport function first<T>(src: Iterable<T>): T | undefined {\n  for (const v of src) return v;\n  return undefined;\n}\n\nexport function last<T>(src: Iterable<T>): T | undefined {\n  if (Array.isArray(src)) return src[src.length - 1];\n  let last: T | undefined;\n  for (const v of src) last = v;\n  return last;\n}\n\nexport function count<T>(src: Iterable<T>): number {\n  if (Array.isArray(src)) return src.length;\n  let n = 0;\n  for (const _ of src) n++;\n  return n;\n}\n\nexport function some<T>(src: Iterable<T>, fn: Predicate<T>): boolean {\n  let i = 0;\n  for (const v of src) if (fn(v, i++)) return true;\n  return false;\n}\n\nexport function every<T>(src: Iterable<T>, fn: Predicate<T>): boolean {\n  let i = 0;\n  for (const v of src) if (!fn(v, i++)) return false;\n  return true;\n}\n\n// Statistical terminals\n/**\n * Calculate the sum of all numbers.\n * @throws {EmptySequenceError} If the sequence is empty.\n */\nexport const sum = (src: Iterable<number>): number => {\n  let total = 0, count = 0;\n  for (const v of src) { total += v; count++; }\n  assertNonEmpty(count, 'sum');\n  return total;\n};\n\n/**\n * Calculate the arithmetic mean.\n * @throws {EmptySequenceError} If the sequence is empty.\n */\nexport const mean = (src: Iterable<number>): number => {\n  let total = 0, count = 0;\n  for (const v of src) { total += v; count++; }\n  assertNonEmpty(count, 'mean');\n  return total / count;\n};\n\n/**\n * Partition array around a pivot for Quickselect.\n * @private\n */\nfunction partition(arr: number[], left: number, right: number): number {\n  const pivot = arr[right]!;\n  let i = left;\n  for (let j = left; j < right; j++) {\n    if (arr[j]! < pivot) {\n      [arr[i], arr[j]] = [arr[j]!, arr[i]!];\n      i++;\n    }\n  }\n  [arr[i], arr[right]] = [arr[right]!, arr[i]!];\n  return i;\n}\n\n/**\n * Find the k-th smallest element using Quickselect (Hoare's selection algorithm).\n * @private\n */\nfunction quickselect(arr: number[], k: number): number {\n  let left = 0;\n  let right = arr.length - 1;\n\n  while (left < right) {\n    const pivotIndex = partition(arr, left, right);\n    if (pivotIndex === k) {\n      return arr[k]!;\n    } else if (pivotIndex > k) {\n      right = pivotIndex - 1;\n    } else {\n      left = pivotIndex + 1;\n    }\n  }\n\n  return arr[left]!;\n}\n\n/**\n * Calculate the median (50th percentile) using Quickselect algorithm.\n * @throws {EmptySequenceError} If the sequence is empty.\n */\nexport const median = (src: Iterable<number>): number => {\n  const arr = Array.from(src);\n  assertNonEmpty(arr.length, 'median');\n\n  const mid = arr.length >> 1;\n  if (arr.length % 2) {\n    // Odd length: return middle element\n    return quickselect(arr, mid);\n  } else {\n    // Even length: return average of two middle elements\n    const upper = quickselect(arr, mid);\n    const lower = quickselect(arr, mid - 1);\n    return (lower + upper) / 2;\n  }\n};\n\n/**\n * Find the minimum value.\n * @throws {EmptySequenceError} If the sequence is empty.\n */\nexport const min = (src: Iterable<number>): number => {\n  let result = Infinity, has = false;\n  for (const v of src) { if (v < result) result = v; has = true; }\n  assertHasValue(has, 'min');\n  return result;\n};\n\n/**\n * Find the maximum value.\n * @throws {EmptySequenceError} If the sequence is empty.\n */\nexport const max = (src: Iterable<number>): number => {\n  let result = -Infinity, has = false;\n  for (const v of src) { if (v > result) result = v; has = true; }\n  assertHasValue(has, 'max');\n  return result;\n};\n\n/**\n * Calculate the population variance using Welford's online algorithm.\n * @throws {EmptySequenceError} If the sequence is empty.\n */\nexport const variance = (src: Iterable<number>): number => {\n  let count = 0;\n  let mean = 0;\n  let M2 = 0;\n\n  for (const x of src) {\n    count++;\n    const delta = x - mean;\n    mean += delta / count;\n    const delta2 = x - mean;\n    M2 += delta * delta2;\n  }\n\n  assertNonEmpty(count, 'variance');\n  return M2 / count;\n};\n","/**\n * iterflow - Lazy iterators with statistics and windowing\n * @packageDocumentation\n */\n\nimport type { Predicate, Mapper, Reducer, FlatMapper } from './core.js';\nimport * as transforms from './transforms.js';\nimport * as terminals from './terminals.js';\n\n// Iterflow class\nexport class Iterflow<T> implements Iterable<T> {\n  constructor(private readonly src: Iterable<T>) {}\n\n  [Symbol.iterator](): Iterator<T> {\n    return this.src[Symbol.iterator]();\n  }\n\n  // Transforms\n  map<U>(fn: Mapper<T, U>): Iterflow<U> {\n    return new Iterflow(transforms.map(this.src, fn));\n  }\n\n  filter(fn: Predicate<T>): Iterflow<T> {\n    return new Iterflow(transforms.filter(this.src, fn));\n  }\n\n  flatMap<U>(fn: FlatMapper<T, U>): Iterflow<U> {\n    return new Iterflow(transforms.flatMap(this.src, fn));\n  }\n\n  take(n: number): Iterflow<T> {\n    return new Iterflow(transforms.take(this.src, n));\n  }\n\n  drop(n: number): Iterflow<T> {\n    return new Iterflow(transforms.drop(this.src, n));\n  }\n\n  takeWhile(fn: Predicate<T>): Iterflow<T> {\n    return new Iterflow(transforms.takeWhile(this.src, fn));\n  }\n\n  dropWhile(fn: Predicate<T>): Iterflow<T> {\n    return new Iterflow(transforms.dropWhile(this.src, fn));\n  }\n\n  distinct(): Iterflow<T> {\n    return new Iterflow(transforms.distinct(this.src));\n  }\n\n  /**\n   * Yield [index, value] pairs.\n   */\n  enumerate(): Iterflow<[number, T]> {\n    return new Iterflow(transforms.enumerate(this.src));\n  }\n\n  /**\n   * Append additional iterables to the sequence.\n   */\n  concat<U>(...others: Iterable<U>[]): Iterflow<T | U> {\n    return new Iterflow(transforms.concat(this.src, ...others));\n  }\n\n  /**\n   * Create sliding windows of the specified size.\n   */\n  window(size: number): Iterflow<T[]> {\n    return new Iterflow(transforms.window(this.src, size));\n  }\n\n  /**\n   * Split the sequence into fixed-size chunks.\n   */\n  chunk(size: number): Iterflow<T[]> {\n    return new Iterflow(transforms.chunk(this.src, size));\n  }\n\n  // Terminals\n  toArray(): T[] {\n    return terminals.toArray(this.src);\n  }\n\n  reduce<U>(fn: Reducer<T, U>, init: U): U {\n    return terminals.reduce(this.src, fn, init);\n  }\n\n  find(fn: Predicate<T>): T | undefined {\n    return terminals.find(this.src, fn);\n  }\n\n  forEach(fn: (v: T, i: number) => void): void {\n    terminals.forEach(this.src, fn);\n  }\n\n  first(): T | undefined {\n    return terminals.first(this.src);\n  }\n\n  last(): T | undefined {\n    return terminals.last(this.src);\n  }\n\n  count(): number {\n    return terminals.count(this.src);\n  }\n\n  some(fn: Predicate<T>): boolean {\n    return terminals.some(this.src, fn);\n  }\n\n  every(fn: Predicate<T>): boolean {\n    return terminals.every(this.src, fn);\n  }\n\n  // Stats (numbers only)\n  /**\n   * Calculate the sum of all numbers.\n   * @throws {EmptySequenceError} If the sequence is empty.\n   */\n  sum(this: Iterflow<number>): number {\n    return terminals.sum(this.src);\n  }\n\n  /**\n   * Calculate the arithmetic mean.\n   * @throws {EmptySequenceError} If the sequence is empty.\n   */\n  mean(this: Iterflow<number>): number {\n    return terminals.mean(this.src);\n  }\n\n  /**\n   * Calculate the median (50th percentile).\n   * @throws {EmptySequenceError} If the sequence is empty.\n   */\n  median(this: Iterflow<number>): number {\n    return terminals.median(this.src);\n  }\n\n  /**\n   * Find the minimum value.\n   * @throws {EmptySequenceError} If the sequence is empty.\n   */\n  min(this: Iterflow<number>): number {\n    return terminals.min(this.src);\n  }\n\n  /**\n   * Find the maximum value.\n   * @throws {EmptySequenceError} If the sequence is empty.\n   */\n  max(this: Iterflow<number>): number {\n    return terminals.max(this.src);\n  }\n\n  /**\n   * Calculate the population variance.\n   * @throws {EmptySequenceError} If the sequence is empty.\n   */\n  variance(this: Iterflow<number>): number {\n    return terminals.variance(this.src);\n  }\n}\n\n// Factory function\nexport function iter<T>(src: Iterable<T>): Iterflow<T> {\n  return new Iterflow(src);\n}\n\n// Re-exports from other modules\nexport { IterflowError, EmptySequenceError, isIterable } from './core.js';\nexport type { Predicate, Mapper, Reducer, FlatMapper } from './core.js';\nexport { sum, mean, median, min, max, variance } from './terminals.js';\n"],"mappings":"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","names":["count","last","count","mean"]}

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "@mathscapes/iterflow",
+  "version": "1.0.0-rc1",
+  "description": "Lazy iterator utilities with built-in statistics and windowing for memory-efficient data processing",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --sourcemap --clean",
+    "test": "node --test --import tsx tests/index.test.ts",
+    "test:coverage": "node --test --experimental-test-coverage --import tsx tests/index.test.ts",
+    "prepublishOnly": "npm run build",
+    "example": "npm run build && npx tsx",
+    "examples": "npx tsx scripts/run-examples.ts"
+  },
+  "keywords": [
+    "iterator",
+    "iterable",
+    "helpers",
+    "utilities",
+    "es2022",
+    "es2025",
+    "typescript",
+    "functional",
+    "statistics",
+    "windowing",
+    "lazy",
+    "stream",
+    "pipeline",
+    "data-processing",
+    "collection",
+    "aggregation",
+    "mean",
+    "median",
+    "variance",
+    "tree-shakeable"
+  ],
+  "author": {
+    "name": "Gaurav Singh",
+    "email": "hi@gvsh.cc",
+    "url": "https://github.com/gv-sh"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mathscapes/iterflow.git"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "bugs": {
+    "url": "https://github.com/mathscapes/iterflow/issues"
+  },
+  "homepage": "https://github.com/mathscapes/iterflow#readme",
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4.14.202",
+    "@types/node": "^20.0.0",
+    "iter-ops": "^3.5.0",
+    "lodash": "^4.17.21",
+    "rxjs": "^7.8.1",
+    "tinybench": "^6.0.0",
+    "tsup": "^8.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.6.0"
+  }
+}