@pyreon/rx 0.11.4 → 0.11.6

package/README.md

@@ -13,21 +13,21 @@ bun add @pyreon/rx
 ## Usage
 
 ```ts
-import { rx } from "@pyreon/rx"
-import { signal } from "@pyreon/reactivity"
+import { rx } from '@pyreon/rx'
+import { signal } from '@pyreon/reactivity'
 
 const users = signal<User[]>([])
 
-const active = rx.filter(users, u => u.active)    // Computed<User[]>
-const sorted = rx.sortBy(active, "name")           // Computed<User[]>
-const top10 = rx.take(sorted, 10)                  // Computed<User[]>
+const active = rx.filter(users, (u) => u.active) // Computed<User[]>
+const sorted = rx.sortBy(active, 'name') // Computed<User[]>
+const top10 = rx.take(sorted, 10) // Computed<User[]>
 
 // Pipe chains
 const result = rx.pipe(
   users,
-  items => items.filter(u => u.active),
-  items => items.sort((a, b) => a.name.localeCompare(b.name)),
-  items => items.slice(0, 10),
+  (items) => items.filter((u) => u.active),
+  (items) => items.sort((a, b) => a.name.localeCompare(b.name)),
+  (items) => items.slice(0, 10),
 )
 ```
 

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["reactive"],"sources":["../src/types.ts","../src/aggregation.ts","../src/collections.ts","../src/operators.ts","../src/pipe.ts","../src/search.ts","../src/timing.ts","../src/index.ts"],"sourcesContent":["import type { computed, signal } from \"@pyreon/reactivity\"\n\n/** A readable signal — any callable that returns a value and tracks subscribers. */\nexport type ReadableSignal<T> = (() => T) & { peek?: () => T }\n\n/** Result of a signal-aware transform — Computed when input is signal, plain when not. */\nexport type ReactiveResult<TInput, TOutput> =\n  TInput extends ReadableSignal<any> ? ReturnType<typeof computed<TOutput>> : TOutput\n\n/** Key extractor — string key name or function. */\nexport type KeyOf<T> = keyof T | ((item: T) => string | number)\n\n/** Resolve a key extractor to a function. */\nexport function resolveKey<T>(key: KeyOf<T>): (item: T) => string | number {\n  return typeof key === \"function\" ? key : (item: T) => String(item[key])\n}\n\n/** Check if a value is a signal (callable function with .set or .peek). */\nexport function isSignal<T>(value: unknown): value is ReadableSignal<T> {\n  return typeof value === \"function\"\n}\n","import { computed } from \"@pyreon/reactivity\"\nimport type { KeyOf, ReadableSignal } from \"./types\"\nimport { isSignal, resolveKey } from \"./types\"\n\nfunction reactive<TIn, TOut>(source: TIn, fn: (val: any) => TOut): any {\n  if (isSignal(source)) return computed(() => fn((source as ReadableSignal<any>)()))\n  return fn(source)\n}\n\n/** Count items in collection. */\nexport function count<T>(source: ReadableSignal<T[]>): ReturnType<typeof computed<number>>\nexport function count<T>(source: T[]): number\nexport function count<T>(source: ReadableSignal<T[]> | T[]): any {\n  return reactive(source, (arr: T[]) => arr.length)\n}\n\n/** Sum numeric values. Optionally by key. */\nexport function sum<T>(\n  source: ReadableSignal<T[]>,\n  key?: KeyOf<T>,\n): ReturnType<typeof computed<number>>\nexport function sum<T>(source: T[], key?: KeyOf<T>): number\nexport function sum<T>(source: ReadableSignal<T[]> | T[], key?: KeyOf<T>): any {\n  const getVal = key ? resolveKey(key) : (item: T) => item as unknown as number\n  return reactive(source, (arr: T[]) => arr.reduce((acc, item) => acc + Number(getVal(item)), 0))\n}\n\n/** Find minimum item. Optionally by key. */\nexport function min<T>(\n  source: ReadableSignal<T[]>,\n  key?: KeyOf<T>,\n): ReturnType<typeof computed<T | undefined>>\nexport function min<T>(source: T[], key?: KeyOf<T>): T | undefined\nexport function min<T>(source: ReadableSignal<T[]> | T[], key?: KeyOf<T>): any {\n  const getVal = key ? resolveKey(key) : (item: T) => item as unknown as number\n  return reactive(source, (arr: T[]) => {\n    if (arr.length === 0) return undefined\n    let result = arr[0] as T\n    let minVal = Number(getVal(result))\n    for (let i = 1; i < arr.length; i++) {\n      const val = Number(getVal(arr[i] as T))\n      if (val < minVal) {\n        minVal = val\n        result = arr[i] as T\n      }\n    }\n    return result\n  })\n}\n\n/** Find maximum item. Optionally by key. */\nexport function max<T>(\n  source: ReadableSignal<T[]>,\n  key?: KeyOf<T>,\n): ReturnType<typeof computed<T | undefined>>\nexport function max<T>(source: T[], key?: KeyOf<T>): T | undefined\nexport function max<T>(source: ReadableSignal<T[]> | T[], key?: KeyOf<T>): any {\n  const getVal = key ? resolveKey(key) : (item: T) => item as unknown as number\n  return reactive(source, (arr: T[]) => {\n    if (arr.length === 0) return undefined\n    let result = arr[0] as T\n    let maxVal = Number(getVal(result))\n    for (let i = 1; i < arr.length; i++) {\n      const val = Number(getVal(arr[i] as T))\n      if (val > maxVal) {\n        maxVal = val\n        result = arr[i] as T\n      }\n    }\n    return result\n  })\n}\n\n/** Average of numeric values. Optionally by key. */\nexport function average<T>(\n  source: ReadableSignal<T[]>,\n  key?: KeyOf<T>,\n): ReturnType<typeof computed<number>>\nexport function average<T>(source: T[], key?: KeyOf<T>): number\nexport function average<T>(source: ReadableSignal<T[]> | T[], key?: KeyOf<T>): any {\n  const getVal = key ? resolveKey(key) : (item: T) => item as unknown as number\n  return reactive(source, (arr: T[]) => {\n    if (arr.length === 0) return 0\n    return arr.reduce((acc, item) => acc + Number(getVal(item)), 0) / arr.length\n  })\n}\n","import { computed } from \"@pyreon/reactivity\"\nimport type { KeyOf, ReadableSignal } from \"./types\"\nimport { isSignal, resolveKey } from \"./types\"\n\n// ─── Helpers ────────────────────────────────────────────────────────────────\n\nfunction reactive<TIn, TOut>(\n  source: TIn,\n  fn: (val: any) => TOut,\n): TIn extends ReadableSignal<any> ? ReturnType<typeof computed<TOut>> : TOut {\n  if (isSignal(source)) {\n    return computed(() => fn((source as ReadableSignal<any>)())) as any\n  }\n  return fn(source) as any\n}\n\n// ─── Collection transforms ──────────────────────────────────────────────────\n\n/** Filter items by predicate. Signal in → Computed out. */\nexport function filter<T>(\n  source: ReadableSignal<T[]>,\n  predicate: (item: T, index: number) => boolean,\n): ReturnType<typeof computed<T[]>>\nexport function filter<T>(source: T[], predicate: (item: T, index: number) => boolean): T[]\nexport function filter<T>(\n  source: ReadableSignal<T[]> | T[],\n  predicate: (item: T, index: number) => boolean,\n): any {\n  return reactive(source, (arr: T[]) => arr.filter(predicate))\n}\n\n/** Map items to a new type. */\nexport function map<T, U>(\n  source: ReadableSignal<T[]>,\n  fn: (item: T, index: number) => U,\n): ReturnType<typeof computed<U[]>>\nexport function map<T, U>(source: T[], fn: (item: T, index: number) => U): U[]\nexport function map<T, U>(\n  source: ReadableSignal<T[]> | T[],\n  fn: (item: T, index: number) => U,\n): any {\n  return reactive(source, (arr: T[]) => arr.map(fn))\n}\n\n/** Sort items by key or comparator. */\nexport function sortBy<T>(\n  source: ReadableSignal<T[]>,\n  key: KeyOf<T>,\n): ReturnType<typeof computed<T[]>>\nexport function sortBy<T>(source: T[], key: KeyOf<T>): T[]\nexport function sortBy<T>(source: ReadableSignal<T[]> | T[], key: KeyOf<T>): any {\n  const getKey = resolveKey(key)\n  return reactive(source, (arr: T[]) =>\n    [...arr].sort((a, b) => {\n      const ka = getKey(a)\n      const kb = getKey(b)\n      return ka < kb ? -1 : ka > kb ? 1 : 0\n    }),\n  )\n}\n\n/** Group items by key. Returns Record<string, T[]>. */\nexport function groupBy<T>(\n  source: ReadableSignal<T[]>,\n  key: KeyOf<T>,\n): ReturnType<typeof computed<Record<string, T[]>>>\nexport function groupBy<T>(source: T[], key: KeyOf<T>): Record<string, T[]>\nexport function groupBy<T>(source: ReadableSignal<T[]> | T[], key: KeyOf<T>): any {\n  const getKey = resolveKey(key)\n  return reactive(source, (arr: T[]) => {\n    const result: Record<string, T[]> = {}\n    for (const item of arr) {\n      const k = String(getKey(item))\n      let group = result[k]\n      if (!group) {\n        group = []\n        result[k] = group\n      }\n      group.push(item)\n    }\n    return result\n  })\n}\n\n/** Index items by key. Returns Record<string, T> (last wins on collision). */\nexport function keyBy<T>(\n  source: ReadableSignal<T[]>,\n  key: KeyOf<T>,\n): ReturnType<typeof computed<Record<string, T>>>\nexport function keyBy<T>(source: T[], key: KeyOf<T>): Record<string, T>\nexport function keyBy<T>(source: ReadableSignal<T[]> | T[], key: KeyOf<T>): any {\n  const getKey = resolveKey(key)\n  return reactive(source, (arr: T[]) => {\n    const result: Record<string, T> = {}\n    for (const item of arr) result[String(getKey(item))] = item\n    return result\n  })\n}\n\n/** Deduplicate items by key. */\nexport function uniqBy<T>(\n  source: ReadableSignal<T[]>,\n  key: KeyOf<T>,\n): ReturnType<typeof computed<T[]>>\nexport function uniqBy<T>(source: T[], key: KeyOf<T>): T[]\nexport function uniqBy<T>(source: ReadableSignal<T[]> | T[], key: KeyOf<T>): any {\n  const getKey = resolveKey(key)\n  return reactive(source, (arr: T[]) => {\n    const seen = new Set<string | number>()\n    return arr.filter((item) => {\n      const k = getKey(item)\n      if (seen.has(k)) return false\n      seen.add(k)\n      return true\n    })\n  })\n}\n\n/** Take the first n items. */\nexport function take<T>(source: ReadableSignal<T[]>, n: number): ReturnType<typeof computed<T[]>>\nexport function take<T>(source: T[], n: number): T[]\nexport function take<T>(source: ReadableSignal<T[]> | T[], n: number): any {\n  return reactive(source, (arr: T[]) => arr.slice(0, n))\n}\n\n/** Split into chunks of given size. */\nexport function chunk<T>(\n  source: ReadableSignal<T[]>,\n  size: number,\n): ReturnType<typeof computed<T[][]>>\nexport function chunk<T>(source: T[], size: number): T[][]\nexport function chunk<T>(source: ReadableSignal<T[]> | T[], size: number): any {\n  return reactive(source, (arr: T[]) => {\n    const result: T[][] = []\n    for (let i = 0; i < arr.length; i += size) result.push(arr.slice(i, i + size))\n    return result\n  })\n}\n\n/** Flatten one level of nesting. */\nexport function flatten<T>(source: ReadableSignal<T[][]>): ReturnType<typeof computed<T[]>>\nexport function flatten<T>(source: T[][]): T[]\nexport function flatten<T>(source: ReadableSignal<T[][]> | T[][]): any {\n  return reactive(source, (arr: T[][]) => arr.flat())\n}\n\n/** Find the first item matching a predicate. */\nexport function find<T>(\n  source: ReadableSignal<T[]>,\n  predicate: (item: T) => boolean,\n): ReturnType<typeof computed<T | undefined>>\nexport function find<T>(source: T[], predicate: (item: T) => boolean): T | undefined\nexport function find<T>(source: ReadableSignal<T[]> | T[], predicate: (item: T) => boolean): any {\n  return reactive(source, (arr: T[]) => arr.find(predicate))\n}\n\n/** Skip the first n items. */\nexport function skip<T>(source: ReadableSignal<T[]>, n: number): ReturnType<typeof computed<T[]>>\nexport function skip<T>(source: T[], n: number): T[]\nexport function skip<T>(source: ReadableSignal<T[]> | T[], n: number): any {\n  return reactive(source, (arr: T[]) => arr.slice(n))\n}\n\n/** Take the last n items. */\nexport function last<T>(source: ReadableSignal<T[]>, n: number): ReturnType<typeof computed<T[]>>\nexport function last<T>(source: T[], n: number): T[]\nexport function last<T>(source: ReadableSignal<T[]> | T[], n: number): any {\n  return reactive(source, (arr: T[]) => arr.slice(-n))\n}\n\n/** Map over values of a Record. Useful after groupBy. */\nexport function mapValues<T, U>(\n  source: ReadableSignal<Record<string, T>>,\n  fn: (value: T, key: string) => U,\n): ReturnType<typeof computed<Record<string, U>>>\nexport function mapValues<T, U>(\n  source: Record<string, T>,\n  fn: (value: T, key: string) => U,\n): Record<string, U>\nexport function mapValues<T, U>(\n  source: ReadableSignal<Record<string, T>> | Record<string, T>,\n  fn: (value: T, key: string) => U,\n): any {\n  return reactive(source, (obj: Record<string, T>) => {\n    const result: Record<string, U> = {}\n    for (const key of Object.keys(obj)) result[key] = fn(obj[key] as T, key)\n    return result\n  })\n}\n","import { computed, effect, signal } from \"@pyreon/reactivity\"\nimport type { ReadableSignal } from \"./types\"\n\n/**\n * Distinct — skip consecutive duplicate values from a signal.\n * Uses `Object.is` by default, or a custom equality function.\n */\nexport function distinct<T>(\n  source: ReadableSignal<T>,\n  equals: (a: T, b: T) => boolean = Object.is,\n): ReadableSignal<T> {\n  const result = signal(source())\n\n  effect(() => {\n    const val = source()\n    if (!equals(val, result.peek())) {\n      result.set(val)\n    }\n  })\n\n  return result\n}\n\n/**\n * Scan — running accumulator over signal changes.\n * Like Array.reduce but emits the accumulated value on each source change.\n *\n * @example\n * ```ts\n * const clicks = signal(0)\n * const total = rx.scan(clicks, (acc, val) => acc + val, 0)\n * // clicks: 1 → total: 1\n * // clicks: 3 → total: 4\n * // clicks: 2 → total: 6\n * ```\n */\nexport function scan<T, U>(\n  source: ReadableSignal<T>,\n  reducer: (acc: U, value: T) => U,\n  initial: U,\n): ReadableSignal<U> {\n  const result = signal(initial)\n\n  effect(() => {\n    const val = source()\n    result.set(reducer(result.peek(), val))\n  })\n\n  return result\n}\n\n/**\n * Combine multiple signals into a single computed value.\n *\n * @example\n * ```ts\n * const fullName = rx.combine(firstName, lastName, (f, l) => `${f} ${l}`)\n * ```\n */\nexport function combine<A, B, R>(\n  a: ReadableSignal<A>,\n  b: ReadableSignal<B>,\n  fn: (a: A, b: B) => R,\n): ReturnType<typeof computed<R>>\nexport function combine<A, B, C, R>(\n  a: ReadableSignal<A>,\n  b: ReadableSignal<B>,\n  c: ReadableSignal<C>,\n  fn: (a: A, b: B, c: C) => R,\n): ReturnType<typeof computed<R>>\nexport function combine(...args: any[]): any {\n  const fn = args[args.length - 1] as (...vals: any[]) => any\n  const sources = args.slice(0, -1) as ReadableSignal<any>[]\n  return computed(() => fn(...sources.map((s) => s())))\n}\n","import { computed } from \"@pyreon/reactivity\"\nimport type { ReadableSignal } from \"./types\"\nimport { isSignal } from \"./types\"\n\n/**\n * Pipe a signal through a chain of transform functions.\n * Each transform receives the resolved value (not the signal) and returns a new value.\n * The entire chain is wrapped in a single `computed()`.\n *\n * @example\n * ```ts\n * const topRisks = rx.pipe(\n *   findings,\n *   (items) => items.filter(f => f.severity === \"critical\"),\n *   (items) => items.sort((a, b) => b.score - a.score),\n *   (items) => items.slice(0, 10),\n * )\n * // topRisks() → reactive, type-safe\n * ```\n */\nexport function pipe<A, B>(\n  source: ReadableSignal<A>,\n  f1: (a: A) => B,\n): ReturnType<typeof computed<B>>\nexport function pipe<A, B, C>(\n  source: ReadableSignal<A>,\n  f1: (a: A) => B,\n  f2: (b: B) => C,\n): ReturnType<typeof computed<C>>\nexport function pipe<A, B, C, D>(\n  source: ReadableSignal<A>,\n  f1: (a: A) => B,\n  f2: (b: B) => C,\n  f3: (c: C) => D,\n): ReturnType<typeof computed<D>>\nexport function pipe<A, B, C, D, E>(\n  source: ReadableSignal<A>,\n  f1: (a: A) => B,\n  f2: (b: B) => C,\n  f3: (c: C) => D,\n  f4: (d: D) => E,\n): ReturnType<typeof computed<E>>\nexport function pipe<A, B, C, D, E, F>(\n  source: ReadableSignal<A>,\n  f1: (a: A) => B,\n  f2: (b: B) => C,\n  f3: (c: C) => D,\n  f4: (d: D) => E,\n  f5: (e: E) => F,\n): ReturnType<typeof computed<F>>\n// Plain value overloads\nexport function pipe<A, B>(source: A, f1: (a: A) => B): B\nexport function pipe<A, B, C>(source: A, f1: (a: A) => B, f2: (b: B) => C): C\nexport function pipe<A, B, C, D>(source: A, f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D): D\nexport function pipe<A, B, C, D, E>(\n  source: A,\n  f1: (a: A) => B,\n  f2: (b: B) => C,\n  f3: (c: C) => D,\n  f4: (d: D) => E,\n): E\nexport function pipe<A, B, C, D, E, F>(\n  source: A,\n  f1: (a: A) => B,\n  f2: (b: B) => C,\n  f3: (c: C) => D,\n  f4: (d: D) => E,\n  f5: (e: E) => F,\n): F\nexport function pipe(source: any, ...fns: Array<(v: any) => any>): any {\n  if (isSignal(source)) {\n    return computed(() => {\n      let val = (source as ReadableSignal<any>)()\n      for (const fn of fns) val = fn(val)\n      return val\n    })\n  }\n  let val = source\n  for (const fn of fns) val = fn(val)\n  return val\n}\n","import { computed } from \"@pyreon/reactivity\"\nimport type { ReadableSignal } from \"./types\"\nimport { isSignal } from \"./types\"\n\n/**\n * Search items by substring matching across specified keys.\n * Case-insensitive. Signal-aware — reactive when either source or query is a signal.\n *\n * @example\n * ```ts\n * const results = rx.search(users, searchQuery, [\"name\", \"email\"])\n * ```\n */\nexport function search<T>(\n  source: ReadableSignal<T[]> | T[],\n  query: ReadableSignal<string> | string,\n  keys: (keyof T)[],\n): any {\n  const isReactive = isSignal(source) || isSignal(query)\n\n  const doSearch = (): T[] => {\n    const arr = isSignal(source) ? (source as ReadableSignal<T[]>)() : source\n    const q = (isSignal(query) ? (query as ReadableSignal<string>)() : query).toLowerCase().trim()\n    if (!q) return arr\n    return arr.filter((item) =>\n      keys.some((key) => {\n        const val = item[key]\n        return typeof val === \"string\" && val.toLowerCase().includes(q)\n      }),\n    )\n  }\n\n  return isReactive ? computed(doSearch) : doSearch()\n}\n","import { effect, signal } from \"@pyreon/reactivity\"\nimport type { ReadableSignal } from \"./types\"\n\n/**\n * Debounce a signal — emits the latest value after `ms` of silence.\n * Returns a new signal that updates only after the source stops changing.\n *\n * Works both inside and outside component context.\n * The returned signal has a `.dispose()` method to stop tracking.\n */\nexport function debounce<T>(\n  source: ReadableSignal<T>,\n  ms: number,\n): ReadableSignal<T> & { dispose: () => void } {\n  const debounced = signal(source())\n  let timer: ReturnType<typeof setTimeout> | undefined\n\n  const fx = effect(() => {\n    const val = source()\n    if (timer) clearTimeout(timer)\n    timer = setTimeout(() => debounced.set(val), ms)\n  })\n\n  const dispose = () => {\n    if (timer) clearTimeout(timer)\n    fx.dispose()\n  }\n\n  return Object.assign(debounced as ReadableSignal<T>, { dispose })\n}\n\n/**\n * Throttle a signal — emits at most once every `ms` milliseconds.\n * Immediately emits on first change, then waits for the interval.\n *\n * Works both inside and outside component context.\n * The returned signal has a `.dispose()` method to stop tracking.\n */\nexport function throttle<T>(\n  source: ReadableSignal<T>,\n  ms: number,\n): ReadableSignal<T> & { dispose: () => void } {\n  const throttled = signal(source())\n  let lastEmit = 0\n  let timer: ReturnType<typeof setTimeout> | undefined\n\n  const fx = effect(() => {\n    const val = source()\n    const now = Date.now()\n    const elapsed = now - lastEmit\n\n    if (elapsed >= ms) {\n      throttled.set(val)\n      lastEmit = now\n    } else {\n      if (timer) clearTimeout(timer)\n      timer = setTimeout(() => {\n        throttled.set(val)\n        lastEmit = Date.now()\n      }, ms - elapsed)\n    }\n  })\n\n  const dispose = () => {\n    if (timer) clearTimeout(timer)\n    fx.dispose()\n  }\n\n  return Object.assign(throttled as ReadableSignal<T>, { dispose })\n}\n","import { average, count, max, min, sum } from \"./aggregation\"\nimport {\n  chunk,\n  filter,\n  find,\n  flatten,\n  groupBy,\n  keyBy,\n  last,\n  map,\n  mapValues,\n  skip,\n  sortBy,\n  take,\n  uniqBy,\n} from \"./collections\"\nimport { combine, distinct, scan } from \"./operators\"\nimport { pipe } from \"./pipe\"\nimport { search } from \"./search\"\nimport { debounce, throttle } from \"./timing\"\n\nexport type { KeyOf, ReadableSignal } from \"./types\"\n\n/**\n * Signal-aware reactive transforms.\n *\n * Every function is overloaded:\n * - `Signal<T[]>` input → returns `Computed<R>` (reactive)\n * - `T[]` input → returns `R` (static)\n *\n * @example\n * ```ts\n * import { rx } from \"@pyreon/rx\"\n *\n * const users = signal<User[]>([])\n * const active = rx.filter(users, u => u.active)      // Computed<User[]>\n * const sorted = rx.sortBy(active, \"name\")             // Computed<User[]>\n * const top10 = rx.take(sorted, 10)                    // Computed<User[]>\n *\n * // Or pipe:\n * const result = rx.pipe(users,\n *   items => items.filter(u => u.active),\n *   items => items.sort((a, b) => a.name.localeCompare(b.name)),\n *   items => items.slice(0, 10),\n * )\n * ```\n */\nexport const rx = {\n  // Collections\n  filter,\n  map,\n  sortBy,\n  groupBy,\n  keyBy,\n  uniqBy,\n  take,\n  skip,\n  last,\n  chunk,\n  flatten,\n  find,\n  mapValues,\n\n  // Aggregation\n  count,\n  sum,\n  min,\n  max,\n  average,\n\n  // Operators\n  distinct,\n  scan,\n  combine,\n\n  // Timing\n  debounce,\n  throttle,\n\n  // Search\n  search,\n\n  // Pipe\n  pipe,\n} as const\n\n// Also export individual functions for tree-shaking\nexport {\n  average,\n  chunk,\n  combine,\n  count,\n  debounce,\n  distinct,\n  filter,\n  find,\n  flatten,\n  groupBy,\n  keyBy,\n  last,\n  map,\n  mapValues,\n  max,\n  min,\n  pipe,\n  scan,\n  search,\n  skip,\n  sortBy,\n  sum,\n  take,\n  throttle,\n  uniqBy,\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":["reactive"],"sources":["../src/types.ts","../src/aggregation.ts","../src/collections.ts","../src/operators.ts","../src/pipe.ts","../src/search.ts","../src/timing.ts","../src/index.ts"],"sourcesContent":["import type { computed, signal } from '@pyreon/reactivity'\n\n/** A readable signal — any callable that returns a value and tracks subscribers. */\nexport type ReadableSignal<T> = (() => T) & { peek?: () => T }\n\n/** Result of a signal-aware transform — Computed when input is signal, plain when not. */\nexport type ReactiveResult<TInput, TOutput> =\n  TInput extends ReadableSignal<any> ? ReturnType<typeof computed<TOutput>> : TOutput\n\n/** Key extractor — string key name or function. */\nexport type KeyOf<T> = keyof T | ((item: T) => string | number)\n\n/** Resolve a key extractor to a function. */\nexport function resolveKey<T>(key: KeyOf<T>): (item: T) => string | number {\n  return typeof key === 'function' ? key : (item: T) => String(item[key])\n}\n\n/** Check if a value is a signal (callable function with .set or .peek). */\nexport function isSignal<T>(value: unknown): value is ReadableSignal<T> {\n  return typeof value === 'function'\n}\n","import { computed } from '@pyreon/reactivity'\nimport type { KeyOf, ReadableSignal } from './types'\nimport { isSignal, resolveKey } from './types'\n\nfunction reactive<TIn, TOut>(source: TIn, fn: (val: any) => TOut): any {\n  if (isSignal(source)) return computed(() => fn((source as ReadableSignal<any>)()))\n  return fn(source)\n}\n\n/** Count items in collection. */\nexport function count<T>(source: ReadableSignal<T[]>): ReturnType<typeof computed<number>>\nexport function count<T>(source: T[]): number\nexport function count<T>(source: ReadableSignal<T[]> | T[]): any {\n  return reactive(source, (arr: T[]) => arr.length)\n}\n\n/** Sum numeric values. Optionally by key. */\nexport function sum<T>(\n  source: ReadableSignal<T[]>,\n  key?: KeyOf<T>,\n): ReturnType<typeof computed<number>>\nexport function sum<T>(source: T[], key?: KeyOf<T>): number\nexport function sum<T>(source: ReadableSignal<T[]> | T[], key?: KeyOf<T>): any {\n  const getVal = key ? resolveKey(key) : (item: T) => item as unknown as number\n  return reactive(source, (arr: T[]) => arr.reduce((acc, item) => acc + Number(getVal(item)), 0))\n}\n\n/** Find minimum item. Optionally by key. */\nexport function min<T>(\n  source: ReadableSignal<T[]>,\n  key?: KeyOf<T>,\n): ReturnType<typeof computed<T | undefined>>\nexport function min<T>(source: T[], key?: KeyOf<T>): T | undefined\nexport function min<T>(source: ReadableSignal<T[]> | T[], key?: KeyOf<T>): any {\n  const getVal = key ? resolveKey(key) : (item: T) => item as unknown as number\n  return reactive(source, (arr: T[]) => {\n    if (arr.length === 0) return undefined\n    let result = arr[0] as T\n    let minVal = Number(getVal(result))\n    for (let i = 1; i < arr.length; i++) {\n      const val = Number(getVal(arr[i] as T))\n      if (val < minVal) {\n        minVal = val\n        result = arr[i] as T\n      }\n    }\n    return result\n  })\n}\n\n/** Find maximum item. Optionally by key. */\nexport function max<T>(\n  source: ReadableSignal<T[]>,\n  key?: KeyOf<T>,\n): ReturnType<typeof computed<T | undefined>>\nexport function max<T>(source: T[], key?: KeyOf<T>): T | undefined\nexport function max<T>(source: ReadableSignal<T[]> | T[], key?: KeyOf<T>): any {\n  const getVal = key ? resolveKey(key) : (item: T) => item as unknown as number\n  return reactive(source, (arr: T[]) => {\n    if (arr.length === 0) return undefined\n    let result = arr[0] as T\n    let maxVal = Number(getVal(result))\n    for (let i = 1; i < arr.length; i++) {\n      const val = Number(getVal(arr[i] as T))\n      if (val > maxVal) {\n        maxVal = val\n        result = arr[i] as T\n      }\n    }\n    return result\n  })\n}\n\n/** Average of numeric values. Optionally by key. */\nexport function average<T>(\n  source: ReadableSignal<T[]>,\n  key?: KeyOf<T>,\n): ReturnType<typeof computed<number>>\nexport function average<T>(source: T[], key?: KeyOf<T>): number\nexport function average<T>(source: ReadableSignal<T[]> | T[], key?: KeyOf<T>): any {\n  const getVal = key ? resolveKey(key) : (item: T) => item as unknown as number\n  return reactive(source, (arr: T[]) => {\n    if (arr.length === 0) return 0\n    return arr.reduce((acc, item) => acc + Number(getVal(item)), 0) / arr.length\n  })\n}\n","import { computed } from '@pyreon/reactivity'\nimport type { KeyOf, ReadableSignal } from './types'\nimport { isSignal, resolveKey } from './types'\n\n// ─── Helpers ────────────────────────────────────────────────────────────────\n\nfunction reactive<TIn, TOut>(\n  source: TIn,\n  fn: (val: any) => TOut,\n): TIn extends ReadableSignal<any> ? ReturnType<typeof computed<TOut>> : TOut {\n  if (isSignal(source)) {\n    return computed(() => fn((source as ReadableSignal<any>)())) as any\n  }\n  return fn(source) as any\n}\n\n// ─── Collection transforms ──────────────────────────────────────────────────\n\n/** Filter items by predicate. Signal in → Computed out. */\nexport function filter<T>(\n  source: ReadableSignal<T[]>,\n  predicate: (item: T, index: number) => boolean,\n): ReturnType<typeof computed<T[]>>\nexport function filter<T>(source: T[], predicate: (item: T, index: number) => boolean): T[]\nexport function filter<T>(\n  source: ReadableSignal<T[]> | T[],\n  predicate: (item: T, index: number) => boolean,\n): any {\n  return reactive(source, (arr: T[]) => arr.filter(predicate))\n}\n\n/** Map items to a new type. */\nexport function map<T, U>(\n  source: ReadableSignal<T[]>,\n  fn: (item: T, index: number) => U,\n): ReturnType<typeof computed<U[]>>\nexport function map<T, U>(source: T[], fn: (item: T, index: number) => U): U[]\nexport function map<T, U>(\n  source: ReadableSignal<T[]> | T[],\n  fn: (item: T, index: number) => U,\n): any {\n  return reactive(source, (arr: T[]) => arr.map(fn))\n}\n\n/** Sort items by key or comparator. */\nexport function sortBy<T>(\n  source: ReadableSignal<T[]>,\n  key: KeyOf<T>,\n): ReturnType<typeof computed<T[]>>\nexport function sortBy<T>(source: T[], key: KeyOf<T>): T[]\nexport function sortBy<T>(source: ReadableSignal<T[]> | T[], key: KeyOf<T>): any {\n  const getKey = resolveKey(key)\n  return reactive(source, (arr: T[]) =>\n    [...arr].sort((a, b) => {\n      const ka = getKey(a)\n      const kb = getKey(b)\n      return ka < kb ? -1 : ka > kb ? 1 : 0\n    }),\n  )\n}\n\n/** Group items by key. Returns Record<string, T[]>. */\nexport function groupBy<T>(\n  source: ReadableSignal<T[]>,\n  key: KeyOf<T>,\n): ReturnType<typeof computed<Record<string, T[]>>>\nexport function groupBy<T>(source: T[], key: KeyOf<T>): Record<string, T[]>\nexport function groupBy<T>(source: ReadableSignal<T[]> | T[], key: KeyOf<T>): any {\n  const getKey = resolveKey(key)\n  return reactive(source, (arr: T[]) => {\n    const result: Record<string, T[]> = {}\n    for (const item of arr) {\n      const k = String(getKey(item))\n      let group = result[k]\n      if (!group) {\n        group = []\n        result[k] = group\n      }\n      group.push(item)\n    }\n    return result\n  })\n}\n\n/** Index items by key. Returns Record<string, T> (last wins on collision). */\nexport function keyBy<T>(\n  source: ReadableSignal<T[]>,\n  key: KeyOf<T>,\n): ReturnType<typeof computed<Record<string, T>>>\nexport function keyBy<T>(source: T[], key: KeyOf<T>): Record<string, T>\nexport function keyBy<T>(source: ReadableSignal<T[]> | T[], key: KeyOf<T>): any {\n  const getKey = resolveKey(key)\n  return reactive(source, (arr: T[]) => {\n    const result: Record<string, T> = {}\n    for (const item of arr) result[String(getKey(item))] = item\n    return result\n  })\n}\n\n/** Deduplicate items by key. */\nexport function uniqBy<T>(\n  source: ReadableSignal<T[]>,\n  key: KeyOf<T>,\n): ReturnType<typeof computed<T[]>>\nexport function uniqBy<T>(source: T[], key: KeyOf<T>): T[]\nexport function uniqBy<T>(source: ReadableSignal<T[]> | T[], key: KeyOf<T>): any {\n  const getKey = resolveKey(key)\n  return reactive(source, (arr: T[]) => {\n    const seen = new Set<string | number>()\n    return arr.filter((item) => {\n      const k = getKey(item)\n      if (seen.has(k)) return false\n      seen.add(k)\n      return true\n    })\n  })\n}\n\n/** Take the first n items. */\nexport function take<T>(source: ReadableSignal<T[]>, n: number): ReturnType<typeof computed<T[]>>\nexport function take<T>(source: T[], n: number): T[]\nexport function take<T>(source: ReadableSignal<T[]> | T[], n: number): any {\n  return reactive(source, (arr: T[]) => arr.slice(0, n))\n}\n\n/** Split into chunks of given size. */\nexport function chunk<T>(\n  source: ReadableSignal<T[]>,\n  size: number,\n): ReturnType<typeof computed<T[][]>>\nexport function chunk<T>(source: T[], size: number): T[][]\nexport function chunk<T>(source: ReadableSignal<T[]> | T[], size: number): any {\n  return reactive(source, (arr: T[]) => {\n    const result: T[][] = []\n    for (let i = 0; i < arr.length; i += size) result.push(arr.slice(i, i + size))\n    return result\n  })\n}\n\n/** Flatten one level of nesting. */\nexport function flatten<T>(source: ReadableSignal<T[][]>): ReturnType<typeof computed<T[]>>\nexport function flatten<T>(source: T[][]): T[]\nexport function flatten<T>(source: ReadableSignal<T[][]> | T[][]): any {\n  return reactive(source, (arr: T[][]) => arr.flat())\n}\n\n/** Find the first item matching a predicate. */\nexport function find<T>(\n  source: ReadableSignal<T[]>,\n  predicate: (item: T) => boolean,\n): ReturnType<typeof computed<T | undefined>>\nexport function find<T>(source: T[], predicate: (item: T) => boolean): T | undefined\nexport function find<T>(source: ReadableSignal<T[]> | T[], predicate: (item: T) => boolean): any {\n  return reactive(source, (arr: T[]) => arr.find(predicate))\n}\n\n/** Skip the first n items. */\nexport function skip<T>(source: ReadableSignal<T[]>, n: number): ReturnType<typeof computed<T[]>>\nexport function skip<T>(source: T[], n: number): T[]\nexport function skip<T>(source: ReadableSignal<T[]> | T[], n: number): any {\n  return reactive(source, (arr: T[]) => arr.slice(n))\n}\n\n/** Take the last n items. */\nexport function last<T>(source: ReadableSignal<T[]>, n: number): ReturnType<typeof computed<T[]>>\nexport function last<T>(source: T[], n: number): T[]\nexport function last<T>(source: ReadableSignal<T[]> | T[], n: number): any {\n  return reactive(source, (arr: T[]) => arr.slice(-n))\n}\n\n/** Map over values of a Record. Useful after groupBy. */\nexport function mapValues<T, U>(\n  source: ReadableSignal<Record<string, T>>,\n  fn: (value: T, key: string) => U,\n): ReturnType<typeof computed<Record<string, U>>>\nexport function mapValues<T, U>(\n  source: Record<string, T>,\n  fn: (value: T, key: string) => U,\n): Record<string, U>\nexport function mapValues<T, U>(\n  source: ReadableSignal<Record<string, T>> | Record<string, T>,\n  fn: (value: T, key: string) => U,\n): any {\n  return reactive(source, (obj: Record<string, T>) => {\n    const result: Record<string, U> = {}\n    for (const key of Object.keys(obj)) result[key] = fn(obj[key] as T, key)\n    return result\n  })\n}\n","import { computed, effect, signal } from '@pyreon/reactivity'\nimport type { ReadableSignal } from './types'\n\n/**\n * Distinct — skip consecutive duplicate values from a signal.\n * Uses `Object.is` by default, or a custom equality function.\n */\nexport function distinct<T>(\n  source: ReadableSignal<T>,\n  equals: (a: T, b: T) => boolean = Object.is,\n): ReadableSignal<T> {\n  const result = signal(source())\n\n  effect(() => {\n    const val = source()\n    if (!equals(val, result.peek())) {\n      result.set(val)\n    }\n  })\n\n  return result\n}\n\n/**\n * Scan — running accumulator over signal changes.\n * Like Array.reduce but emits the accumulated value on each source change.\n *\n * @example\n * ```ts\n * const clicks = signal(0)\n * const total = rx.scan(clicks, (acc, val) => acc + val, 0)\n * // clicks: 1 → total: 1\n * // clicks: 3 → total: 4\n * // clicks: 2 → total: 6\n * ```\n */\nexport function scan<T, U>(\n  source: ReadableSignal<T>,\n  reducer: (acc: U, value: T) => U,\n  initial: U,\n): ReadableSignal<U> {\n  const result = signal(initial)\n\n  effect(() => {\n    const val = source()\n    result.set(reducer(result.peek(), val))\n  })\n\n  return result\n}\n\n/**\n * Combine multiple signals into a single computed value.\n *\n * @example\n * ```ts\n * const fullName = rx.combine(firstName, lastName, (f, l) => `${f} ${l}`)\n * ```\n */\nexport function combine<A, B, R>(\n  a: ReadableSignal<A>,\n  b: ReadableSignal<B>,\n  fn: (a: A, b: B) => R,\n): ReturnType<typeof computed<R>>\nexport function combine<A, B, C, R>(\n  a: ReadableSignal<A>,\n  b: ReadableSignal<B>,\n  c: ReadableSignal<C>,\n  fn: (a: A, b: B, c: C) => R,\n): ReturnType<typeof computed<R>>\nexport function combine(...args: any[]): any {\n  const fn = args[args.length - 1] as (...vals: any[]) => any\n  const sources = args.slice(0, -1) as ReadableSignal<any>[]\n  return computed(() => fn(...sources.map((s) => s())))\n}\n","import { computed } from '@pyreon/reactivity'\nimport type { ReadableSignal } from './types'\nimport { isSignal } from './types'\n\n/**\n * Pipe a signal through a chain of transform functions.\n * Each transform receives the resolved value (not the signal) and returns a new value.\n * The entire chain is wrapped in a single `computed()`.\n *\n * @example\n * ```ts\n * const topRisks = rx.pipe(\n *   findings,\n *   (items) => items.filter(f => f.severity === \"critical\"),\n *   (items) => items.sort((a, b) => b.score - a.score),\n *   (items) => items.slice(0, 10),\n * )\n * // topRisks() → reactive, type-safe\n * ```\n */\nexport function pipe<A, B>(\n  source: ReadableSignal<A>,\n  f1: (a: A) => B,\n): ReturnType<typeof computed<B>>\nexport function pipe<A, B, C>(\n  source: ReadableSignal<A>,\n  f1: (a: A) => B,\n  f2: (b: B) => C,\n): ReturnType<typeof computed<C>>\nexport function pipe<A, B, C, D>(\n  source: ReadableSignal<A>,\n  f1: (a: A) => B,\n  f2: (b: B) => C,\n  f3: (c: C) => D,\n): ReturnType<typeof computed<D>>\nexport function pipe<A, B, C, D, E>(\n  source: ReadableSignal<A>,\n  f1: (a: A) => B,\n  f2: (b: B) => C,\n  f3: (c: C) => D,\n  f4: (d: D) => E,\n): ReturnType<typeof computed<E>>\nexport function pipe<A, B, C, D, E, F>(\n  source: ReadableSignal<A>,\n  f1: (a: A) => B,\n  f2: (b: B) => C,\n  f3: (c: C) => D,\n  f4: (d: D) => E,\n  f5: (e: E) => F,\n): ReturnType<typeof computed<F>>\n// Plain value overloads\nexport function pipe<A, B>(source: A, f1: (a: A) => B): B\nexport function pipe<A, B, C>(source: A, f1: (a: A) => B, f2: (b: B) => C): C\nexport function pipe<A, B, C, D>(source: A, f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D): D\nexport function pipe<A, B, C, D, E>(\n  source: A,\n  f1: (a: A) => B,\n  f2: (b: B) => C,\n  f3: (c: C) => D,\n  f4: (d: D) => E,\n): E\nexport function pipe<A, B, C, D, E, F>(\n  source: A,\n  f1: (a: A) => B,\n  f2: (b: B) => C,\n  f3: (c: C) => D,\n  f4: (d: D) => E,\n  f5: (e: E) => F,\n): F\nexport function pipe(source: any, ...fns: Array<(v: any) => any>): any {\n  if (isSignal(source)) {\n    return computed(() => {\n      let val = (source as ReadableSignal<any>)()\n      for (const fn of fns) val = fn(val)\n      return val\n    })\n  }\n  let val = source\n  for (const fn of fns) val = fn(val)\n  return val\n}\n","import { computed } from '@pyreon/reactivity'\nimport type { ReadableSignal } from './types'\nimport { isSignal } from './types'\n\n/**\n * Search items by substring matching across specified keys.\n * Case-insensitive. Signal-aware — reactive when either source or query is a signal.\n *\n * @example\n * ```ts\n * const results = rx.search(users, searchQuery, [\"name\", \"email\"])\n * ```\n */\nexport function search<T>(\n  source: ReadableSignal<T[]> | T[],\n  query: ReadableSignal<string> | string,\n  keys: (keyof T)[],\n): any {\n  const isReactive = isSignal(source) || isSignal(query)\n\n  const doSearch = (): T[] => {\n    const arr = isSignal(source) ? (source as ReadableSignal<T[]>)() : source\n    const q = (isSignal(query) ? (query as ReadableSignal<string>)() : query).toLowerCase().trim()\n    if (!q) return arr\n    return arr.filter((item) =>\n      keys.some((key) => {\n        const val = item[key]\n        return typeof val === 'string' && val.toLowerCase().includes(q)\n      }),\n    )\n  }\n\n  return isReactive ? computed(doSearch) : doSearch()\n}\n","import { effect, signal } from '@pyreon/reactivity'\nimport type { ReadableSignal } from './types'\n\n/**\n * Debounce a signal — emits the latest value after `ms` of silence.\n * Returns a new signal that updates only after the source stops changing.\n *\n * Works both inside and outside component context.\n * The returned signal has a `.dispose()` method to stop tracking.\n */\nexport function debounce<T>(\n  source: ReadableSignal<T>,\n  ms: number,\n): ReadableSignal<T> & { dispose: () => void } {\n  const debounced = signal(source())\n  let timer: ReturnType<typeof setTimeout> | undefined\n\n  const fx = effect(() => {\n    const val = source()\n    if (timer) clearTimeout(timer)\n    timer = setTimeout(() => debounced.set(val), ms)\n  })\n\n  const dispose = () => {\n    if (timer) clearTimeout(timer)\n    fx.dispose()\n  }\n\n  return Object.assign(debounced as ReadableSignal<T>, { dispose })\n}\n\n/**\n * Throttle a signal — emits at most once every `ms` milliseconds.\n * Immediately emits on first change, then waits for the interval.\n *\n * Works both inside and outside component context.\n * The returned signal has a `.dispose()` method to stop tracking.\n */\nexport function throttle<T>(\n  source: ReadableSignal<T>,\n  ms: number,\n): ReadableSignal<T> & { dispose: () => void } {\n  const throttled = signal(source())\n  let lastEmit = 0\n  let timer: ReturnType<typeof setTimeout> | undefined\n\n  const fx = effect(() => {\n    const val = source()\n    const now = Date.now()\n    const elapsed = now - lastEmit\n\n    if (elapsed >= ms) {\n      throttled.set(val)\n      lastEmit = now\n    } else {\n      if (timer) clearTimeout(timer)\n      timer = setTimeout(() => {\n        throttled.set(val)\n        lastEmit = Date.now()\n      }, ms - elapsed)\n    }\n  })\n\n  const dispose = () => {\n    if (timer) clearTimeout(timer)\n    fx.dispose()\n  }\n\n  return Object.assign(throttled as ReadableSignal<T>, { dispose })\n}\n","import { average, count, max, min, sum } from './aggregation'\nimport {\n  chunk,\n  filter,\n  find,\n  flatten,\n  groupBy,\n  keyBy,\n  last,\n  map,\n  mapValues,\n  skip,\n  sortBy,\n  take,\n  uniqBy,\n} from './collections'\nimport { combine, distinct, scan } from './operators'\nimport { pipe } from './pipe'\nimport { search } from './search'\nimport { debounce, throttle } from './timing'\n\nexport type { KeyOf, ReadableSignal } from './types'\n\n/**\n * Signal-aware reactive transforms.\n *\n * Every function is overloaded:\n * - `Signal<T[]>` input → returns `Computed<R>` (reactive)\n * - `T[]` input → returns `R` (static)\n *\n * @example\n * ```ts\n * import { rx } from \"@pyreon/rx\"\n *\n * const users = signal<User[]>([])\n * const active = rx.filter(users, u => u.active)      // Computed<User[]>\n * const sorted = rx.sortBy(active, \"name\")             // Computed<User[]>\n * const top10 = rx.take(sorted, 10)                    // Computed<User[]>\n *\n * // Or pipe:\n * const result = rx.pipe(users,\n *   items => items.filter(u => u.active),\n *   items => items.sort((a, b) => a.name.localeCompare(b.name)),\n *   items => items.slice(0, 10),\n * )\n * ```\n */\nexport const rx = {\n  // Collections\n  filter,\n  map,\n  sortBy,\n  groupBy,\n  keyBy,\n  uniqBy,\n  take,\n  skip,\n  last,\n  chunk,\n  flatten,\n  find,\n  mapValues,\n\n  // Aggregation\n  count,\n  sum,\n  min,\n  max,\n  average,\n\n  // Operators\n  distinct,\n  scan,\n  combine,\n\n  // Timing\n  debounce,\n  throttle,\n\n  // Search\n  search,\n\n  // Pipe\n  pipe,\n} as const\n\n// Also export individual functions for tree-shaking\nexport {\n  average,\n  chunk,\n  combine,\n  count,\n  debounce,\n  distinct,\n  filter,\n  find,\n  flatten,\n  groupBy,\n  keyBy,\n  last,\n  map,\n  mapValues,\n  max,\n  min,\n  pipe,\n  scan,\n  search,\n  skip,\n  sortBy,\n  sum,\n  take,\n  throttle,\n  uniqBy,\n}\n"],"mappings":"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"}

package/package.json

@@ -1,19 +1,16 @@
 {
   "name": "@pyreon/rx",
-  "version": "0.11.4",
+  "version": "0.11.6",
   "description": "Signal-aware reactive transforms — filter, map, sort, group, pipe for Pyreon signals",
+  "bugs": {
+    "url": "https://github.com/pyreon/pyreon/issues"
+  },
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/pyreon/pyreon.git",
     "directory": "packages/fundamentals/rx"
   },
-  "bugs": {
-    "url": "https://github.com/pyreon/pyreon/issues"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
   "files": [
     "lib",
     "src",
@@ -29,17 +26,20 @@
       "types": "./lib/types/index.d.ts"
     }
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "build": "vl_rolldown_build",
     "dev": "vl_rolldown_build-watch",
     "test": "vitest run",
     "typecheck": "tsc --noEmit",
-    "lint": "biome check ."
-  },
-  "peerDependencies": {
-    "@pyreon/reactivity": "^0.11.4"
+    "lint": "oxlint ."
   },
   "devDependencies": {
-    "@pyreon/typescript": "^0.11.4"
+    "@pyreon/typescript": "^0.11.6"
+  },
+  "peerDependencies": {
+    "@pyreon/reactivity": "^0.11.6"
   }
 }

package/src/aggregation.ts

@@ -1,6 +1,6 @@
-import { computed } from "@pyreon/reactivity"
-import type { KeyOf, ReadableSignal } from "./types"
-import { isSignal, resolveKey } from "./types"
+import { computed } from '@pyreon/reactivity'
+import type { KeyOf, ReadableSignal } from './types'
+import { isSignal, resolveKey } from './types'
 
 function reactive<TIn, TOut>(source: TIn, fn: (val: any) => TOut): any {
   if (isSignal(source)) return computed(() => fn((source as ReadableSignal<any>)()))

package/src/collections.ts

@@ -1,6 +1,6 @@
-import { computed } from "@pyreon/reactivity"
-import type { KeyOf, ReadableSignal } from "./types"
-import { isSignal, resolveKey } from "./types"
+import { computed } from '@pyreon/reactivity'
+import type { KeyOf, ReadableSignal } from './types'
+import { isSignal, resolveKey } from './types'
 
 // ─── Helpers ────────────────────────────────────────────────────────────────
 

package/src/index.ts

@@ -1,4 +1,4 @@
-import { average, count, max, min, sum } from "./aggregation"
+import { average, count, max, min, sum } from './aggregation'
 import {
   chunk,
   filter,
@@ -13,13 +13,13 @@ import {
   sortBy,
   take,
   uniqBy,
-} from "./collections"
-import { combine, distinct, scan } from "./operators"
-import { pipe } from "./pipe"
-import { search } from "./search"
-import { debounce, throttle } from "./timing"
+} from './collections'
+import { combine, distinct, scan } from './operators'
+import { pipe } from './pipe'
+import { search } from './search'
+import { debounce, throttle } from './timing'
 
-export type { KeyOf, ReadableSignal } from "./types"
+export type { KeyOf, ReadableSignal } from './types'
 
 /**
  * Signal-aware reactive transforms.

package/src/operators.ts

@@ -1,5 +1,5 @@
-import { computed, effect, signal } from "@pyreon/reactivity"
-import type { ReadableSignal } from "./types"
+import { computed, effect, signal } from '@pyreon/reactivity'
+import type { ReadableSignal } from './types'
 
 /**
  * Distinct — skip consecutive duplicate values from a signal.

package/src/pipe.ts

@@ -1,6 +1,6 @@
-import { computed } from "@pyreon/reactivity"
-import type { ReadableSignal } from "./types"
-import { isSignal } from "./types"
+import { computed } from '@pyreon/reactivity'
+import type { ReadableSignal } from './types'
+import { isSignal } from './types'
 
 /**
  * Pipe a signal through a chain of transform functions.

package/src/search.ts

@@ -1,6 +1,6 @@
-import { computed } from "@pyreon/reactivity"
-import type { ReadableSignal } from "./types"
-import { isSignal } from "./types"
+import { computed } from '@pyreon/reactivity'
+import type { ReadableSignal } from './types'
+import { isSignal } from './types'
 
 /**
  * Search items by substring matching across specified keys.
@@ -25,7 +25,7 @@ export function search<T>(
     return arr.filter((item) =>
       keys.some((key) => {
         const val = item[key]
-        return typeof val === "string" && val.toLowerCase().includes(q)
+        return typeof val === 'string' && val.toLowerCase().includes(q)
       }),
     )
   }

package/src/tests/aggregation.test.ts

@@ -1,53 +1,53 @@
-import { signal } from "@pyreon/reactivity"
-import { describe, expect, it } from "vitest"
-import { average, count, max, min, sum } from "../aggregation"
+import { signal } from '@pyreon/reactivity'
+import { describe, expect, it } from 'vitest'
+import { average, count, max, min, sum } from '../aggregation'
 
-describe("aggregation — plain values", () => {
-  it("count", () => {
+describe('aggregation — plain values', () => {
+  it('count', () => {
     expect(count([1, 2, 3])).toBe(3)
     expect(count([])).toBe(0)
   })
 
-  it("sum", () => {
+  it('sum', () => {
     expect(sum([1, 2, 3])).toBe(6)
   })
 
-  it("sum with key", () => {
+  it('sum with key', () => {
     const items = [{ v: 10 }, { v: 20 }, { v: 30 }]
-    expect(sum(items, "v")).toBe(60)
+    expect(sum(items, 'v')).toBe(60)
   })
 
-  it("min", () => {
+  it('min', () => {
     const items = [{ v: 3 }, { v: 1 }, { v: 2 }]
-    expect(min(items, "v")?.v).toBe(1)
+    expect(min(items, 'v')?.v).toBe(1)
   })
 
-  it("max", () => {
+  it('max', () => {
     const items = [{ v: 3 }, { v: 1 }, { v: 2 }]
-    expect(max(items, "v")?.v).toBe(3)
+    expect(max(items, 'v')?.v).toBe(3)
   })
 
-  it("min/max empty array", () => {
+  it('min/max empty array', () => {
     expect(min([])).toBeUndefined()
     expect(max([])).toBeUndefined()
   })
 
-  it("average", () => {
+  it('average', () => {
     expect(average([2, 4, 6])).toBe(4)
   })
 
-  it("average with key", () => {
+  it('average with key', () => {
     const items = [{ v: 10 }, { v: 20 }, { v: 30 }]
-    expect(average(items, "v")).toBe(20)
+    expect(average(items, 'v')).toBe(20)
   })
 
-  it("average empty array returns 0", () => {
+  it('average empty array returns 0', () => {
     expect(average([])).toBe(0)
   })
 })
 
-describe("aggregation — signal values", () => {
-  it("count returns computed", () => {
+describe('aggregation — signal values', () => {
+  it('count returns computed', () => {
     const src = signal([1, 2, 3])
     const c = count(src)
     expect(c()).toBe(3)
@@ -55,7 +55,7 @@ describe("aggregation — signal values", () => {
     expect(c()).toBe(1)
   })
 
-  it("sum returns computed", () => {
+  it('sum returns computed', () => {
     const src = signal([1, 2, 3])
     const s = sum(src)
     expect(s()).toBe(6)
@@ -63,7 +63,7 @@ describe("aggregation — signal values", () => {
     expect(s()).toBe(30)
   })
 
-  it("average returns computed", () => {
+  it('average returns computed', () => {
     const src = signal([2, 4, 6])
     const avg = average(src)
     expect(avg()).toBe(4)
@@ -72,9 +72,9 @@ describe("aggregation — signal values", () => {
     expect(avg()).toBe(15)
   })
 
-  it("average with key returns computed", () => {
+  it('average with key returns computed', () => {
     const src = signal([{ v: 10 }, { v: 20 }, { v: 30 }])
-    const avg = average(src, "v")
+    const avg = average(src, 'v')
     expect(avg()).toBe(20)
 
     src.set([{ v: 100 }])

package/src/tests/collections.test.ts

@@ -1,5 +1,5 @@
-import { signal } from "@pyreon/reactivity"
-import { describe, expect, it } from "vitest"
+import { signal } from '@pyreon/reactivity'
+import { describe, expect, it } from 'vitest'
 import {
   chunk,
   filter,
@@ -14,131 +14,131 @@ import {
   sortBy,
   take,
   uniqBy,
-} from "../collections"
+} from '../collections'
 
 type User = { id: number; name: string; role: string; active: boolean }
 const users: User[] = [
-  { id: 1, name: "Alice", role: "admin", active: true },
-  { id: 2, name: "Bob", role: "viewer", active: false },
-  { id: 3, name: "Charlie", role: "admin", active: true },
-  { id: 4, name: "Diana", role: "editor", active: true },
+  { id: 1, name: 'Alice', role: 'admin', active: true },
+  { id: 2, name: 'Bob', role: 'viewer', active: false },
+  { id: 3, name: 'Charlie', role: 'admin', active: true },
+  { id: 4, name: 'Diana', role: 'editor', active: true },
 ]
 
-describe("collections — plain values", () => {
-  it("filter", () => {
+describe('collections — plain values', () => {
+  it('filter', () => {
     expect(filter(users, (u) => u.active)).toHaveLength(3)
   })
 
-  it("map", () => {
-    expect(map(users, (u) => u.name)).toEqual(["Alice", "Bob", "Charlie", "Diana"])
+  it('map', () => {
+    expect(map(users, (u) => u.name)).toEqual(['Alice', 'Bob', 'Charlie', 'Diana'])
   })
 
-  it("sortBy string key", () => {
-    const sorted = sortBy(users, "name")
-    expect(sorted[0]!.name).toBe("Alice")
-    expect(sorted[3]!.name).toBe("Diana")
+  it('sortBy string key', () => {
+    const sorted = sortBy(users, 'name')
+    expect(sorted[0]!.name).toBe('Alice')
+    expect(sorted[3]!.name).toBe('Diana')
   })
 
-  it("sortBy function", () => {
+  it('sortBy function', () => {
     const sorted = sortBy(users, (u) => u.id)
     expect(sorted[0]!.id).toBe(1)
   })
 
-  it("groupBy", () => {
-    const groups = groupBy(users, "role")
+  it('groupBy', () => {
+    const groups = groupBy(users, 'role')
     expect(groups.admin).toHaveLength(2)
     expect(groups.viewer).toHaveLength(1)
   })
 
-  it("keyBy", () => {
-    const indexed = keyBy(users, "id")
-    expect(indexed["1"]!.name).toBe("Alice")
-    expect(indexed["3"]!.name).toBe("Charlie")
+  it('keyBy', () => {
+    const indexed = keyBy(users, 'id')
+    expect(indexed['1']!.name).toBe('Alice')
+    expect(indexed['3']!.name).toBe('Charlie')
   })
 
-  it("uniqBy", () => {
-    const result = uniqBy(users, "role")
+  it('uniqBy', () => {
+    const result = uniqBy(users, 'role')
     expect(result).toHaveLength(3) // admin, viewer, editor
   })
 
-  it("take", () => {
+  it('take', () => {
     expect(take(users, 2)).toHaveLength(2)
-    expect(take(users, 2)[0]!.name).toBe("Alice")
+    expect(take(users, 2)[0]!.name).toBe('Alice')
   })
 
-  it("chunk", () => {
+  it('chunk', () => {
     const chunks = chunk(users, 2)
     expect(chunks).toHaveLength(2)
     expect(chunks[0]).toHaveLength(2)
   })
 
-  it("flatten", () => {
+  it('flatten', () => {
     const nested = [[1, 2], [3, 4], [5]]
     expect(flatten(nested)).toEqual([1, 2, 3, 4, 5])
   })
 
-  it("find", () => {
-    expect(find(users, (u) => u.name === "Bob")?.id).toBe(2)
-    expect(find(users, (u) => u.name === "Nobody")).toBeUndefined()
+  it('find', () => {
+    expect(find(users, (u) => u.name === 'Bob')?.id).toBe(2)
+    expect(find(users, (u) => u.name === 'Nobody')).toBeUndefined()
   })
 
-  it("skip", () => {
+  it('skip', () => {
     const result = skip(users, 2)
     expect(result).toHaveLength(2)
-    expect(result[0]!.name).toBe("Charlie")
-    expect(result[1]!.name).toBe("Diana")
+    expect(result[0]!.name).toBe('Charlie')
+    expect(result[1]!.name).toBe('Diana')
   })
 
-  it("last", () => {
+  it('last', () => {
     const result = last(users, 2)
     expect(result).toHaveLength(2)
-    expect(result[0]!.name).toBe("Charlie")
-    expect(result[1]!.name).toBe("Diana")
+    expect(result[0]!.name).toBe('Charlie')
+    expect(result[1]!.name).toBe('Diana')
   })
 
-  it("mapValues", () => {
+  it('mapValues', () => {
     const record: Record<string, number> = { a: 1, b: 2, c: 3 }
     const result = mapValues(record, (v) => v * 10)
     expect(result).toEqual({ a: 10, b: 20, c: 30 })
   })
 
-  it("mapValues with key argument", () => {
+  it('mapValues with key argument', () => {
     const record: Record<string, number> = { x: 1, y: 2 }
     const result = mapValues(record, (v, k) => `${k}=${v}`)
-    expect(result).toEqual({ x: "x=1", y: "y=2" })
+    expect(result).toEqual({ x: 'x=1', y: 'y=2' })
   })
 })
 
-describe("collections — signal values (reactive)", () => {
-  it("filter returns computed that tracks signal", () => {
+describe('collections — signal values (reactive)', () => {
+  it('filter returns computed that tracks signal', () => {
     const src = signal(users)
     const active = filter(src, (u) => u.active)
     expect(active()).toHaveLength(3)
 
     // Mutate source
-    src.set([...users, { id: 5, name: "Eve", role: "admin", active: true }])
+    src.set([...users, { id: 5, name: 'Eve', role: 'admin', active: true }])
     expect(active()).toHaveLength(4)
   })
 
-  it("map returns computed", () => {
+  it('map returns computed', () => {
     const src = signal(users)
     const names = map(src, (u) => u.name)
-    expect(names()).toEqual(["Alice", "Bob", "Charlie", "Diana"])
+    expect(names()).toEqual(['Alice', 'Bob', 'Charlie', 'Diana'])
   })
 
-  it("sortBy returns computed", () => {
-    const src = signal([{ n: "B" }, { n: "A" }, { n: "C" }])
-    const sorted = sortBy(src, "n")
-    expect(sorted()[0]!.n).toBe("A")
+  it('sortBy returns computed', () => {
+    const src = signal([{ n: 'B' }, { n: 'A' }, { n: 'C' }])
+    const sorted = sortBy(src, 'n')
+    expect(sorted()[0]!.n).toBe('A')
   })
 
-  it("groupBy returns computed", () => {
+  it('groupBy returns computed', () => {
     const src = signal(users)
-    const groups = groupBy(src, "role")
+    const groups = groupBy(src, 'role')
     expect(groups().admin).toHaveLength(2)
   })
 
-  it("take returns computed", () => {
+  it('take returns computed', () => {
     const src = signal(users)
     const first2 = take(src, 2)
     expect(first2()).toHaveLength(2)
@@ -147,35 +147,35 @@ describe("collections — signal values (reactive)", () => {
     expect(first2()).toHaveLength(1)
   })
 
-  it("does not mutate original array", () => {
-    const original = [{ n: "B" }, { n: "A" }]
+  it('does not mutate original array', () => {
+    const original = [{ n: 'B' }, { n: 'A' }]
     const src = signal(original)
-    sortBy(src, "n")()
-    expect(original[0]!.n).toBe("B") // original untouched
+    sortBy(src, 'n')()
+    expect(original[0]!.n).toBe('B') // original untouched
   })
 
-  it("skip returns computed", () => {
+  it('skip returns computed', () => {
     const src = signal(users)
     const skipped = skip(src, 3)
     expect(skipped()).toHaveLength(1)
-    expect(skipped()[0]!.name).toBe("Diana")
+    expect(skipped()[0]!.name).toBe('Diana')
 
-    src.set([...users, { id: 5, name: "Eve", role: "admin", active: true }])
+    src.set([...users, { id: 5, name: 'Eve', role: 'admin', active: true }])
     expect(skipped()).toHaveLength(2)
   })
 
-  it("last returns computed", () => {
+  it('last returns computed', () => {
     const src = signal(users)
     const lastTwo = last(src, 2)
     expect(lastTwo()).toHaveLength(2)
-    expect(lastTwo()[0]!.name).toBe("Charlie")
+    expect(lastTwo()[0]!.name).toBe('Charlie')
 
     src.set([users[0]!])
     expect(lastTwo()).toHaveLength(1)
-    expect(lastTwo()[0]!.name).toBe("Alice")
+    expect(lastTwo()[0]!.name).toBe('Alice')
   })
 
-  it("mapValues returns computed", () => {
+  it('mapValues returns computed', () => {
     const src = signal<Record<string, number>>({ a: 1, b: 2 })
     const doubled = mapValues(src, (v) => v * 2)
     expect(doubled()).toEqual({ a: 2, b: 4 })
@@ -184,25 +184,25 @@ describe("collections — signal values (reactive)", () => {
     expect(doubled()).toEqual({ x: 20 })
   })
 
-  it("mapValues with signal tracks key argument reactively", () => {
+  it('mapValues with signal tracks key argument reactively', () => {
     const src = signal<Record<string, number[]>>({
       admin: [1, 2, 3],
       viewer: [4, 5],
     })
     const counts = mapValues(src, (arr, key) => ({ role: key, count: arr.length }))
     expect(counts()).toEqual({
-      admin: { role: "admin", count: 3 },
-      viewer: { role: "viewer", count: 2 },
+      admin: { role: 'admin', count: 3 },
+      viewer: { role: 'viewer', count: 2 },
     })
 
     src.set({ admin: [1], editor: [2, 3, 4, 5] })
     expect(counts()).toEqual({
-      admin: { role: "admin", count: 1 },
-      editor: { role: "editor", count: 4 },
+      admin: { role: 'admin', count: 1 },
+      editor: { role: 'editor', count: 4 },
     })
   })
 
-  it("mapValues with signal handles empty record", () => {
+  it('mapValues with signal handles empty record', () => {
     const src = signal<Record<string, number>>({})
     const doubled = mapValues(src, (v) => v * 2)
     expect(doubled()).toEqual({})

package/src/tests/operators.test.ts

@@ -1,9 +1,9 @@
-import { signal } from "@pyreon/reactivity"
-import { describe, expect, it } from "vitest"
-import { combine, distinct, scan } from "../operators"
+import { signal } from '@pyreon/reactivity'
+import { describe, expect, it } from 'vitest'
+import { combine, distinct, scan } from '../operators'
 
-describe("distinct", () => {
-  it("skips consecutive duplicate values", () => {
+describe('distinct', () => {
+  it('skips consecutive duplicate values', () => {
     const src = signal(1)
     const d = distinct(src)
     expect(d()).toBe(1)
@@ -25,38 +25,38 @@ describe("distinct", () => {
     expect(d()).toBe(3)
   })
 
-  it("supports custom equality function", () => {
-    const src = signal({ id: 1, name: "Alice" })
+  it('supports custom equality function', () => {
+    const src = signal({ id: 1, name: 'Alice' })
     const d = distinct(src, (a, b) => a.id === b.id)
-    expect(d().name).toBe("Alice")
+    expect(d().name).toBe('Alice')
 
     // Same id, different name — should be considered equal, skip
-    src.set({ id: 1, name: "Updated Alice" })
-    expect(d().name).toBe("Alice")
+    src.set({ id: 1, name: 'Updated Alice' })
+    expect(d().name).toBe('Alice')
 
     // Different id — should emit
-    src.set({ id: 2, name: "Bob" })
-    expect(d().name).toBe("Bob")
+    src.set({ id: 2, name: 'Bob' })
+    expect(d().name).toBe('Bob')
   })
 
-  it("works reactively with signal source", () => {
-    const src = signal("a")
+  it('works reactively with signal source', () => {
+    const src = signal('a')
     const d = distinct(src)
-    expect(d()).toBe("a")
+    expect(d()).toBe('a')
 
-    src.set("b")
-    expect(d()).toBe("b")
+    src.set('b')
+    expect(d()).toBe('b')
 
-    src.set("b")
-    expect(d()).toBe("b")
+    src.set('b')
+    expect(d()).toBe('b')
 
-    src.set("c")
-    expect(d()).toBe("c")
+    src.set('c')
+    expect(d()).toBe('c')
   })
 })
 
-describe("scan", () => {
-  it("accumulates values over signal changes", () => {
+describe('scan', () => {
+  it('accumulates values over signal changes', () => {
     const src = signal(0)
     const total = scan(src, (acc, val) => acc + val, 0)
 
@@ -73,21 +73,21 @@ describe("scan", () => {
     expect(total()).toBe(6)
   })
 
-  it("works with non-numeric accumulation", () => {
-    const src = signal("start")
+  it('works with non-numeric accumulation', () => {
+    const src = signal('start')
     const log = scan(src, (acc, val) => [...acc, val], [] as string[])
 
     // Effect runs immediately with initial value
-    expect(log()).toEqual(["start"])
+    expect(log()).toEqual(['start'])
 
-    src.set("hello")
-    expect(log()).toEqual(["start", "hello"])
+    src.set('hello')
+    expect(log()).toEqual(['start', 'hello'])
 
-    src.set("world")
-    expect(log()).toEqual(["start", "hello", "world"])
+    src.set('world')
+    expect(log()).toEqual(['start', 'hello', 'world'])
   })
 
-  it("is signal-reactive", () => {
+  it('is signal-reactive', () => {
     const src = signal(10)
     const running = scan(src, (acc, val) => acc + val, 0)
     expect(running()).toBe(10)
@@ -101,16 +101,16 @@ describe("scan", () => {
   })
 })
 
-describe("combine", () => {
-  it("combines 2 signals", () => {
-    const firstName = signal("John")
-    const lastName = signal("Doe")
+describe('combine', () => {
+  it('combines 2 signals', () => {
+    const firstName = signal('John')
+    const lastName = signal('Doe')
     const fullName = combine(firstName, lastName, (f, l) => `${f} ${l}`)
 
-    expect(fullName()).toBe("John Doe")
+    expect(fullName()).toBe('John Doe')
   })
 
-  it("combines 3 signals", () => {
+  it('combines 3 signals', () => {
     const a = signal(1)
     const b = signal(2)
     const c = signal(3)
@@ -119,21 +119,21 @@ describe("combine", () => {
     expect(total()).toBe(6)
   })
 
-  it("reacts to updates from any source", () => {
-    const firstName = signal("John")
-    const lastName = signal("Doe")
+  it('reacts to updates from any source', () => {
+    const firstName = signal('John')
+    const lastName = signal('Doe')
     const fullName = combine(firstName, lastName, (f, l) => `${f} ${l}`)
 
-    expect(fullName()).toBe("John Doe")
+    expect(fullName()).toBe('John Doe')
 
-    firstName.set("Jane")
-    expect(fullName()).toBe("Jane Doe")
+    firstName.set('Jane')
+    expect(fullName()).toBe('Jane Doe')
 
-    lastName.set("Smith")
-    expect(fullName()).toBe("Jane Smith")
+    lastName.set('Smith')
+    expect(fullName()).toBe('Jane Smith')
   })
 
-  it("reacts to updates from all 3 sources", () => {
+  it('reacts to updates from all 3 sources', () => {
     const a = signal(1)
     const b = signal(10)
     const c = signal(100)

package/src/tests/pipe.test.ts

@@ -1,9 +1,9 @@
-import { signal } from "@pyreon/reactivity"
-import { describe, expect, it } from "vitest"
-import { pipe } from "../pipe"
+import { signal } from '@pyreon/reactivity'
+import { describe, expect, it } from 'vitest'
+import { pipe } from '../pipe'
 
-describe("pipe — plain values", () => {
-  it("chains transforms", () => {
+describe('pipe — plain values', () => {
+  it('chains transforms', () => {
     const result = pipe(
       [3, 1, 4, 1, 5, 9],
       (arr) => arr.filter((n) => n > 2),
@@ -13,13 +13,13 @@ describe("pipe — plain values", () => {
     expect(result).toEqual([3, 4, 5])
   })
 
-  it("single transform", () => {
+  it('single transform', () => {
     expect(pipe([1, 2, 3], (arr) => arr.length)).toBe(3)
   })
 })
 
-describe("pipe — signal values", () => {
-  it("returns computed that tracks source", () => {
+describe('pipe — signal values', () => {
+  it('returns computed that tracks source', () => {
     const src = signal([3, 1, 4, 1, 5, 9])
     const result = pipe(
       src,
@@ -32,12 +32,12 @@ describe("pipe — signal values", () => {
     expect(result()).toEqual([10])
   })
 
-  it("supports type narrowing across steps", () => {
+  it('supports type narrowing across steps', () => {
     type User = { name: string; score: number }
     const users = signal<User[]>([
-      { name: "A", score: 5 },
-      { name: "B", score: 10 },
-      { name: "C", score: 3 },
+      { name: 'A', score: 5 },
+      { name: 'B', score: 10 },
+      { name: 'C', score: 3 },
     ])
 
     const topNames = pipe(
@@ -46,10 +46,10 @@ describe("pipe — signal values", () => {
       (items) => items.slice(0, 2),
       (items) => items.map((u) => u.name),
     )
-    expect(topNames()).toEqual(["B", "A"])
+    expect(topNames()).toEqual(['B', 'A'])
   })
 
-  it("supports 4 transforms", () => {
+  it('supports 4 transforms', () => {
     const src = signal([10, 5, 20, 3, 15, 8])
     const result = pipe(
       src,
@@ -67,7 +67,7 @@ describe("pipe — signal values", () => {
     expect(result()).toBe(150)
   })
 
-  it("supports 5 transforms", () => {
+  it('supports 5 transforms', () => {
     const src = signal([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
     const result = pipe(
       src,
@@ -77,17 +77,17 @@ describe("pipe — signal values", () => {
       (arr) => arr.reduce((sum, n) => sum + n, 0), // 180
       (n) => `Total: ${n}`,
     )
-    expect(result()).toBe("Total: 180")
+    expect(result()).toBe('Total: 180')
   })
 
-  it("4+ transforms with plain values (non-signal)", () => {
+  it('4+ transforms with plain values (non-signal)', () => {
     const result = pipe(
       [5, 3, 8, 1, 9, 2],
       (arr) => arr.filter((n) => n > 3),
       (arr) => arr.sort((a, b) => b - a),
       (arr) => arr.slice(0, 2),
-      (arr) => arr.join("-"),
+      (arr) => arr.join('-'),
     )
-    expect(result).toBe("9-8")
+    expect(result).toBe('9-8')
   })
 })

package/src/tests/search.test.ts

@@ -1,109 +1,109 @@
-import { signal } from "@pyreon/reactivity"
-import { describe, expect, it } from "vitest"
-import { search } from "../search"
+import { signal } from '@pyreon/reactivity'
+import { describe, expect, it } from 'vitest'
+import { search } from '../search'
 
 type User = { id: number; name: string; email: string }
 
 const users: User[] = [
-  { id: 1, name: "Alice", email: "alice@example.com" },
-  { id: 2, name: "Bob", email: "bob@test.com" },
-  { id: 3, name: "Charlie", email: "charlie@example.com" },
-  { id: 4, name: "Diana", email: "diana@test.com" },
+  { id: 1, name: 'Alice', email: 'alice@example.com' },
+  { id: 2, name: 'Bob', email: 'bob@test.com' },
+  { id: 3, name: 'Charlie', email: 'charlie@example.com' },
+  { id: 4, name: 'Diana', email: 'diana@test.com' },
 ]
 
-describe("search — plain values", () => {
-  it("returns all items when query is empty", () => {
-    const result = search(users, "", ["name"])
+describe('search — plain values', () => {
+  it('returns all items when query is empty', () => {
+    const result = search(users, '', ['name'])
     expect(result).toHaveLength(4)
   })
 
-  it("filters by single key", () => {
-    const result = search(users, "alice", ["name"])
+  it('filters by single key', () => {
+    const result = search(users, 'alice', ['name'])
     expect(result).toHaveLength(1)
-    expect(result[0]!.name).toBe("Alice")
+    expect(result[0]!.name).toBe('Alice')
   })
 
-  it("filters across multiple keys", () => {
-    const result = search(users, "example", ["name", "email"])
+  it('filters across multiple keys', () => {
+    const result = search(users, 'example', ['name', 'email'])
     expect(result).toHaveLength(2)
-    expect(result.map((u: (typeof users)[number]) => u.name)).toEqual(["Alice", "Charlie"])
+    expect(result.map((u: (typeof users)[number]) => u.name)).toEqual(['Alice', 'Charlie'])
   })
 
-  it("is case-insensitive", () => {
-    const result = search(users, "BOB", ["name"])
+  it('is case-insensitive', () => {
+    const result = search(users, 'BOB', ['name'])
     expect(result).toHaveLength(1)
-    expect(result[0]!.name).toBe("Bob")
+    expect(result[0]!.name).toBe('Bob')
   })
 
-  it("trims whitespace from query", () => {
-    const result = search(users, "  alice  ", ["name"])
+  it('trims whitespace from query', () => {
+    const result = search(users, '  alice  ', ['name'])
     expect(result).toHaveLength(1)
   })
 
-  it("returns empty array when no matches", () => {
-    const result = search(users, "zzz", ["name", "email"])
+  it('returns empty array when no matches', () => {
+    const result = search(users, 'zzz', ['name', 'email'])
     expect(result).toHaveLength(0)
   })
 
-  it("only matches string values (skips non-string fields)", () => {
+  it('only matches string values (skips non-string fields)', () => {
     // id is a number — should not be matched
-    const result = search(users, "1", ["id" as keyof User, "name"])
+    const result = search(users, '1', ['id' as keyof User, 'name'])
     expect(result).toHaveLength(0)
   })
 })
 
-describe("search — signal source (reactive)", () => {
-  it("returns computed when source is a signal", () => {
+describe('search — signal source (reactive)', () => {
+  it('returns computed when source is a signal', () => {
     const src = signal(users)
-    const result = search(src, "alice", ["name"])
-    expect(typeof result).toBe("function")
+    const result = search(src, 'alice', ['name'])
+    expect(typeof result).toBe('function')
     expect(result()).toHaveLength(1)
   })
 
-  it("reacts to source changes", () => {
+  it('reacts to source changes', () => {
     const src = signal(users)
-    const result = search(src, "test", ["email"])
+    const result = search(src, 'test', ['email'])
     expect(result()).toHaveLength(2) // bob + diana
 
-    src.set([...users, { id: 5, name: "Eve", email: "eve@test.com" }])
+    src.set([...users, { id: 5, name: 'Eve', email: 'eve@test.com' }])
     expect(result()).toHaveLength(3)
   })
 
-  it("returns computed when query is a signal", () => {
-    const query = signal("")
-    const result = search(users, query, ["name"])
+  it('returns computed when query is a signal', () => {
+    const query = signal('')
+    const result = search(users, query, ['name'])
 
-    expect(typeof result).toBe("function")
+    expect(typeof result).toBe('function')
     expect(result()).toHaveLength(4) // empty query returns all
 
-    query.set("ali")
+    query.set('ali')
     expect(result()).toHaveLength(1)
 
-    query.set("a") // Alice, Charlie, Diana
+    query.set('a') // Alice, Charlie, Diana
     expect(result()).toHaveLength(3)
   })
 
-  it("reacts to both source and query signal changes", () => {
+  it('reacts to both source and query signal changes', () => {
     const src = signal(users)
-    const query = signal("")
-    const result = search(src, query, ["name"])
+    const query = signal('')
+    const result = search(src, query, ['name'])
 
     expect(result()).toHaveLength(4)
 
-    query.set("bob")
+    query.set('bob')
     expect(result()).toHaveLength(1)
 
     // Remove Bob from source
-    src.set(users.filter((u) => u.name !== "Bob"))
+    src.set(users.filter((u) => u.name !== 'Bob'))
     expect(result()).toHaveLength(0)
 
-    query.set("")
+    query.set('')
     expect(result()).toHaveLength(3) // all remaining users
   })
 
-  it("returns empty when signal query matches nothing", () => {
-    const query = signal("nonexistent")
-    const result = search(users, query, ["name", "email"])
+  it('returns empty when signal query matches nothing', () => {
+    const query = signal('nonexistent')
+    const result = search(users, query, ['name', 'email'])
     expect(result()).toHaveLength(0)
   })
 })

package/src/tests/timing.test.ts

@@ -1,13 +1,13 @@
-import { signal } from "@pyreon/reactivity"
-import { afterEach, describe, expect, it, vi } from "vitest"
-import { debounce, throttle } from "../timing"
+import { signal } from '@pyreon/reactivity'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { debounce, throttle } from '../timing'
 
-describe("debounce", () => {
+describe('debounce', () => {
   afterEach(() => {
     vi.useRealTimers()
   })
 
-  it("dispose() stops tracking source changes", () => {
+  it('dispose() stops tracking source changes', () => {
     vi.useFakeTimers()
     const src = signal(0)
     const debounced = debounce(src, 100)
@@ -26,14 +26,14 @@ describe("debounce", () => {
     expect(debounced()).toBe(1) // still 1, not 2
   })
 
-  it("dispose() clears pending timer so debounced value stays frozen", () => {
+  it('dispose() clears pending timer so debounced value stays frozen', () => {
     vi.useFakeTimers()
-    const src = signal("a")
+    const src = signal('a')
     const debounced = debounce(src, 200)
-    expect(debounced()).toBe("a")
+    expect(debounced()).toBe('a')
 
     // Start a debounce cycle
-    src.set("b")
+    src.set('b')
     vi.advanceTimersByTime(50) // not yet debounced
 
     // Dispose mid-cycle — pending timer should be cleared
@@ -42,10 +42,10 @@ describe("debounce", () => {
     // Advance well past the debounce window
     vi.advanceTimersByTime(500)
     // Value should remain "a" — the pending "b" was cancelled
-    expect(debounced()).toBe("a")
+    expect(debounced()).toBe('a')
   })
 
-  it("debounces rapid updates to only emit the latest", () => {
+  it('debounces rapid updates to only emit the latest', () => {
     vi.useFakeTimers()
     const src = signal(0)
     const debounced = debounce(src, 100)
@@ -62,7 +62,7 @@ describe("debounce", () => {
     expect(debounced()).toBe(3)
   })
 
-  it("multiple dispose calls do not throw", () => {
+  it('multiple dispose calls do not throw', () => {
     vi.useFakeTimers()
     const src = signal(0)
     const debounced = debounce(src, 100)
@@ -72,12 +72,12 @@ describe("debounce", () => {
   })
 })
 
-describe("throttle", () => {
+describe('throttle', () => {
   afterEach(() => {
     vi.useRealTimers()
   })
 
-  it("dispose() stops tracking source changes", () => {
+  it('dispose() stops tracking source changes', () => {
     vi.useFakeTimers()
     const src = signal(0)
     const throttled = throttle(src, 100)
@@ -98,7 +98,7 @@ describe("throttle", () => {
     expect(throttled()).toBe(1) // still 1, not 2
   })
 
-  it("dispose() clears pending trailing timer", () => {
+  it('dispose() clears pending trailing timer', () => {
     vi.useFakeTimers()
     const src = signal(0)
     const throttled = throttle(src, 200)
@@ -120,7 +120,7 @@ describe("throttle", () => {
     expect(throttled()).toBe(1) // trailing update never fires
   })
 
-  it("emits immediately on first change after window", () => {
+  it('emits immediately on first change after window', () => {
     vi.useFakeTimers()
     const src = signal(0)
     const throttled = throttle(src, 100)
@@ -133,7 +133,7 @@ describe("throttle", () => {
     expect(throttled()).toBe(42)
   })
 
-  it("trailing timer fires the latest value after throttle window", () => {
+  it('trailing timer fires the latest value after throttle window', () => {
     vi.useFakeTimers()
     const src = signal(0)
     const throttled = throttle(src, 100)
@@ -152,7 +152,7 @@ describe("throttle", () => {
     expect(throttled()).toBe(3) // latest value
   })
 
-  it("multiple dispose calls do not throw", () => {
+  it('multiple dispose calls do not throw', () => {
     vi.useFakeTimers()
     const src = signal(0)
     const throttled = throttle(src, 100)

package/src/timing.ts

@@ -1,5 +1,5 @@
-import { effect, signal } from "@pyreon/reactivity"
-import type { ReadableSignal } from "./types"
+import { effect, signal } from '@pyreon/reactivity'
+import type { ReadableSignal } from './types'
 
 /**
  * Debounce a signal — emits the latest value after `ms` of silence.

package/src/types.ts

@@ -1,4 +1,4 @@
-import type { computed, signal } from "@pyreon/reactivity"
+import type { computed, signal } from '@pyreon/reactivity'
 
 /** A readable signal — any callable that returns a value and tracks subscribers. */
 export type ReadableSignal<T> = (() => T) & { peek?: () => T }
@@ -12,10 +12,10 @@ export type KeyOf<T> = keyof T | ((item: T) => string | number)
 
 /** Resolve a key extractor to a function. */
 export function resolveKey<T>(key: KeyOf<T>): (item: T) => string | number {
-  return typeof key === "function" ? key : (item: T) => String(item[key])
+  return typeof key === 'function' ? key : (item: T) => String(item[key])
 }
 
 /** Check if a value is a signal (callable function with .set or .peek). */
 export function isSignal<T>(value: unknown): value is ReadableSignal<T> {
-  return typeof value === "function"
+  return typeof value === 'function'
 }