@pyreon/rx 0.11.0

package/lib/index.js

@@ -0,0 +1,343 @@
+import { computed, effect, signal } from "@pyreon/reactivity";
+
+//#region src/types.ts
+/** Resolve a key extractor to a function. */
+function resolveKey(key) {
+	return typeof key === "function" ? key : (item) => String(item[key]);
+}
+/** Check if a value is a signal (callable function with .set or .peek). */
+function isSignal(value) {
+	return typeof value === "function";
+}
+
+//#endregion
+//#region src/aggregation.ts
+function reactive$1(source, fn) {
+	if (isSignal(source)) return computed(() => fn(source()));
+	return fn(source);
+}
+function count(source) {
+	return reactive$1(source, (arr) => arr.length);
+}
+function sum(source, key) {
+	const getVal = key ? resolveKey(key) : (item) => item;
+	return reactive$1(source, (arr) => arr.reduce((acc, item) => acc + Number(getVal(item)), 0));
+}
+function min(source, key) {
+	const getVal = key ? resolveKey(key) : (item) => item;
+	return reactive$1(source, (arr) => {
+		if (arr.length === 0) return void 0;
+		let result = arr[0];
+		let minVal = Number(getVal(result));
+		for (let i = 1; i < arr.length; i++) {
+			const val = Number(getVal(arr[i]));
+			if (val < minVal) {
+				minVal = val;
+				result = arr[i];
+			}
+		}
+		return result;
+	});
+}
+function max(source, key) {
+	const getVal = key ? resolveKey(key) : (item) => item;
+	return reactive$1(source, (arr) => {
+		if (arr.length === 0) return void 0;
+		let result = arr[0];
+		let maxVal = Number(getVal(result));
+		for (let i = 1; i < arr.length; i++) {
+			const val = Number(getVal(arr[i]));
+			if (val > maxVal) {
+				maxVal = val;
+				result = arr[i];
+			}
+		}
+		return result;
+	});
+}
+function average(source, key) {
+	const getVal = key ? resolveKey(key) : (item) => item;
+	return reactive$1(source, (arr) => {
+		if (arr.length === 0) return 0;
+		return arr.reduce((acc, item) => acc + Number(getVal(item)), 0) / arr.length;
+	});
+}
+
+//#endregion
+//#region src/collections.ts
+function reactive(source, fn) {
+	if (isSignal(source)) return computed(() => fn(source()));
+	return fn(source);
+}
+function filter(source, predicate) {
+	return reactive(source, (arr) => arr.filter(predicate));
+}
+function map(source, fn) {
+	return reactive(source, (arr) => arr.map(fn));
+}
+function sortBy(source, key) {
+	const getKey = resolveKey(key);
+	return reactive(source, (arr) => [...arr].sort((a, b) => {
+		const ka = getKey(a);
+		const kb = getKey(b);
+		return ka < kb ? -1 : ka > kb ? 1 : 0;
+	}));
+}
+function groupBy(source, key) {
+	const getKey = resolveKey(key);
+	return reactive(source, (arr) => {
+		const result = {};
+		for (const item of arr) {
+			const k = String(getKey(item));
+			let group = result[k];
+			if (!group) {
+				group = [];
+				result[k] = group;
+			}
+			group.push(item);
+		}
+		return result;
+	});
+}
+function keyBy(source, key) {
+	const getKey = resolveKey(key);
+	return reactive(source, (arr) => {
+		const result = {};
+		for (const item of arr) result[String(getKey(item))] = item;
+		return result;
+	});
+}
+function uniqBy(source, key) {
+	const getKey = resolveKey(key);
+	return reactive(source, (arr) => {
+		const seen = /* @__PURE__ */ new Set();
+		return arr.filter((item) => {
+			const k = getKey(item);
+			if (seen.has(k)) return false;
+			seen.add(k);
+			return true;
+		});
+	});
+}
+function take(source, n) {
+	return reactive(source, (arr) => arr.slice(0, n));
+}
+function chunk(source, size) {
+	return reactive(source, (arr) => {
+		const result = [];
+		for (let i = 0; i < arr.length; i += size) result.push(arr.slice(i, i + size));
+		return result;
+	});
+}
+function flatten(source) {
+	return reactive(source, (arr) => arr.flat());
+}
+function find(source, predicate) {
+	return reactive(source, (arr) => arr.find(predicate));
+}
+function skip(source, n) {
+	return reactive(source, (arr) => arr.slice(n));
+}
+function last(source, n) {
+	return reactive(source, (arr) => arr.slice(-n));
+}
+function mapValues(source, fn) {
+	return reactive(source, (obj) => {
+		const result = {};
+		for (const key of Object.keys(obj)) result[key] = fn(obj[key], key);
+		return result;
+	});
+}
+
+//#endregion
+//#region src/operators.ts
+/**
+* Distinct — skip consecutive duplicate values from a signal.
+* Uses `Object.is` by default, or a custom equality function.
+*/
+function distinct(source, equals = Object.is) {
+	const result = signal(source());
+	effect(() => {
+		const val = source();
+		if (!equals(val, result.peek())) result.set(val);
+	});
+	return result;
+}
+/**
+* Scan — running accumulator over signal changes.
+* Like Array.reduce but emits the accumulated value on each source change.
+*
+* @example
+* ```ts
+* const clicks = signal(0)
+* const total = rx.scan(clicks, (acc, val) => acc + val, 0)
+* // clicks: 1 → total: 1
+* // clicks: 3 → total: 4
+* // clicks: 2 → total: 6
+* ```
+*/
+function scan(source, reducer, initial) {
+	const result = signal(initial);
+	effect(() => {
+		const val = source();
+		result.set(reducer(result.peek(), val));
+	});
+	return result;
+}
+function combine(...args) {
+	const fn = args[args.length - 1];
+	const sources = args.slice(0, -1);
+	return computed(() => fn(...sources.map((s) => s())));
+}
+
+//#endregion
+//#region src/pipe.ts
+function pipe(source, ...fns) {
+	if (isSignal(source)) return computed(() => {
+		let val = source();
+		for (const fn of fns) val = fn(val);
+		return val;
+	});
+	let val = source;
+	for (const fn of fns) val = fn(val);
+	return val;
+}
+
+//#endregion
+//#region src/search.ts
+/**
+* Search items by substring matching across specified keys.
+* Case-insensitive. Signal-aware — reactive when either source or query is a signal.
+*
+* @example
+* ```ts
+* const results = rx.search(users, searchQuery, ["name", "email"])
+* ```
+*/
+function search(source, query, keys) {
+	const isReactive = isSignal(source) || isSignal(query);
+	const doSearch = () => {
+		const arr = isSignal(source) ? source() : source;
+		const q = (isSignal(query) ? query() : query).toLowerCase().trim();
+		if (!q) return arr;
+		return arr.filter((item) => keys.some((key) => {
+			const val = item[key];
+			return typeof val === "string" && val.toLowerCase().includes(q);
+		}));
+	};
+	return isReactive ? computed(doSearch) : doSearch();
+}
+
+//#endregion
+//#region src/timing.ts
+/**
+* Debounce a signal — emits the latest value after `ms` of silence.
+* Returns a new signal that updates only after the source stops changing.
+*
+* Works both inside and outside component context.
+* The returned signal has a `.dispose()` method to stop tracking.
+*/
+function debounce(source, ms) {
+	const debounced = signal(source());
+	let timer;
+	const fx = effect(() => {
+		const val = source();
+		if (timer) clearTimeout(timer);
+		timer = setTimeout(() => debounced.set(val), ms);
+	});
+	const dispose = () => {
+		if (timer) clearTimeout(timer);
+		fx.dispose();
+	};
+	return Object.assign(debounced, { dispose });
+}
+/**
+* Throttle a signal — emits at most once every `ms` milliseconds.
+* Immediately emits on first change, then waits for the interval.
+*
+* Works both inside and outside component context.
+* The returned signal has a `.dispose()` method to stop tracking.
+*/
+function throttle(source, ms) {
+	const throttled = signal(source());
+	let lastEmit = 0;
+	let timer;
+	const fx = effect(() => {
+		const val = source();
+		const now = Date.now();
+		const elapsed = now - lastEmit;
+		if (elapsed >= ms) {
+			throttled.set(val);
+			lastEmit = now;
+		} else {
+			if (timer) clearTimeout(timer);
+			timer = setTimeout(() => {
+				throttled.set(val);
+				lastEmit = Date.now();
+			}, ms - elapsed);
+		}
+	});
+	const dispose = () => {
+		if (timer) clearTimeout(timer);
+		fx.dispose();
+	};
+	return Object.assign(throttled, { dispose });
+}
+
+//#endregion
+//#region src/index.ts
+/**
+* Signal-aware reactive transforms.
+*
+* Every function is overloaded:
+* - `Signal<T[]>` input → returns `Computed<R>` (reactive)
+* - `T[]` input → returns `R` (static)
+*
+* @example
+* ```ts
+* import { rx } from "@pyreon/rx"
+*
+* 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[]>
+*
+* // Or pipe:
+* 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),
+* )
+* ```
+*/
+const rx = {
+	filter,
+	map,
+	sortBy,
+	groupBy,
+	keyBy,
+	uniqBy,
+	take,
+	skip,
+	last,
+	chunk,
+	flatten,
+	find,
+	mapValues,
+	count,
+	sum,
+	min,
+	max,
+	average,
+	distinct,
+	scan,
+	combine,
+	debounce,
+	throttle,
+	search,
+	pipe
+};
+
+//#endregion
+export { average, chunk, combine, count, debounce, distinct, filter, find, flatten, groupBy, keyBy, last, map, mapValues, max, min, pipe, rx, scan, search, skip, sortBy, sum, take, throttle, uniqBy };
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +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(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/lib/types/index.d.ts

@@ -0,0 +1,214 @@
+import { computed } from "@pyreon/reactivity";
+
+//#region src/types.d.ts
+/** A readable signal — any callable that returns a value and tracks subscribers. */
+type ReadableSignal<T> = (() => T) & {
+  peek?: () => T;
+};
+/** Key extractor — string key name or function. */
+type KeyOf<T> = keyof T | ((item: T) => string | number);
+//#endregion
+//#region src/aggregation.d.ts
+/** Count items in collection. */
+declare function count<T>(source: ReadableSignal<T[]>): ReturnType<typeof computed<number>>;
+declare function count<T>(source: T[]): number;
+/** Sum numeric values. Optionally by key. */
+declare function sum<T>(source: ReadableSignal<T[]>, key?: KeyOf<T>): ReturnType<typeof computed<number>>;
+declare function sum<T>(source: T[], key?: KeyOf<T>): number;
+/** Find minimum item. Optionally by key. */
+declare function min<T>(source: ReadableSignal<T[]>, key?: KeyOf<T>): ReturnType<typeof computed<T | undefined>>;
+declare function min<T>(source: T[], key?: KeyOf<T>): T | undefined;
+/** Find maximum item. Optionally by key. */
+declare function max<T>(source: ReadableSignal<T[]>, key?: KeyOf<T>): ReturnType<typeof computed<T | undefined>>;
+declare function max<T>(source: T[], key?: KeyOf<T>): T | undefined;
+/** Average of numeric values. Optionally by key. */
+declare function average<T>(source: ReadableSignal<T[]>, key?: KeyOf<T>): ReturnType<typeof computed<number>>;
+declare function average<T>(source: T[], key?: KeyOf<T>): number;
+//#endregion
+//#region src/collections.d.ts
+/** Filter items by predicate. Signal in → Computed out. */
+declare function filter<T>(source: ReadableSignal<T[]>, predicate: (item: T, index: number) => boolean): ReturnType<typeof computed<T[]>>;
+declare function filter<T>(source: T[], predicate: (item: T, index: number) => boolean): T[];
+/** Map items to a new type. */
+declare function map<T, U>(source: ReadableSignal<T[]>, fn: (item: T, index: number) => U): ReturnType<typeof computed<U[]>>;
+declare function map<T, U>(source: T[], fn: (item: T, index: number) => U): U[];
+/** Sort items by key or comparator. */
+declare function sortBy<T>(source: ReadableSignal<T[]>, key: KeyOf<T>): ReturnType<typeof computed<T[]>>;
+declare function sortBy<T>(source: T[], key: KeyOf<T>): T[];
+/** Group items by key. Returns Record<string, T[]>. */
+declare function groupBy<T>(source: ReadableSignal<T[]>, key: KeyOf<T>): ReturnType<typeof computed<Record<string, T[]>>>;
+declare function groupBy<T>(source: T[], key: KeyOf<T>): Record<string, T[]>;
+/** Index items by key. Returns Record<string, T> (last wins on collision). */
+declare function keyBy<T>(source: ReadableSignal<T[]>, key: KeyOf<T>): ReturnType<typeof computed<Record<string, T>>>;
+declare function keyBy<T>(source: T[], key: KeyOf<T>): Record<string, T>;
+/** Deduplicate items by key. */
+declare function uniqBy<T>(source: ReadableSignal<T[]>, key: KeyOf<T>): ReturnType<typeof computed<T[]>>;
+declare function uniqBy<T>(source: T[], key: KeyOf<T>): T[];
+/** Take the first n items. */
+declare function take<T>(source: ReadableSignal<T[]>, n: number): ReturnType<typeof computed<T[]>>;
+declare function take<T>(source: T[], n: number): T[];
+/** Split into chunks of given size. */
+declare function chunk<T>(source: ReadableSignal<T[]>, size: number): ReturnType<typeof computed<T[][]>>;
+declare function chunk<T>(source: T[], size: number): T[][];
+/** Flatten one level of nesting. */
+declare function flatten<T>(source: ReadableSignal<T[][]>): ReturnType<typeof computed<T[]>>;
+declare function flatten<T>(source: T[][]): T[];
+/** Find the first item matching a predicate. */
+declare function find<T>(source: ReadableSignal<T[]>, predicate: (item: T) => boolean): ReturnType<typeof computed<T | undefined>>;
+declare function find<T>(source: T[], predicate: (item: T) => boolean): T | undefined;
+/** Skip the first n items. */
+declare function skip<T>(source: ReadableSignal<T[]>, n: number): ReturnType<typeof computed<T[]>>;
+declare function skip<T>(source: T[], n: number): T[];
+/** Take the last n items. */
+declare function last<T>(source: ReadableSignal<T[]>, n: number): ReturnType<typeof computed<T[]>>;
+declare function last<T>(source: T[], n: number): T[];
+/** Map over values of a Record. Useful after groupBy. */
+declare function mapValues<T, U>(source: ReadableSignal<Record<string, T>>, fn: (value: T, key: string) => U): ReturnType<typeof computed<Record<string, U>>>;
+declare function mapValues<T, U>(source: Record<string, T>, fn: (value: T, key: string) => U): Record<string, U>;
+//#endregion
+//#region src/operators.d.ts
+/**
+ * Distinct — skip consecutive duplicate values from a signal.
+ * Uses `Object.is` by default, or a custom equality function.
+ */
+declare function distinct<T>(source: ReadableSignal<T>, equals?: (a: T, b: T) => boolean): ReadableSignal<T>;
+/**
+ * Scan — running accumulator over signal changes.
+ * Like Array.reduce but emits the accumulated value on each source change.
+ *
+ * @example
+ * ```ts
+ * const clicks = signal(0)
+ * const total = rx.scan(clicks, (acc, val) => acc + val, 0)
+ * // clicks: 1 → total: 1
+ * // clicks: 3 → total: 4
+ * // clicks: 2 → total: 6
+ * ```
+ */
+declare function scan<T, U>(source: ReadableSignal<T>, reducer: (acc: U, value: T) => U, initial: U): ReadableSignal<U>;
+/**
+ * Combine multiple signals into a single computed value.
+ *
+ * @example
+ * ```ts
+ * const fullName = rx.combine(firstName, lastName, (f, l) => `${f} ${l}`)
+ * ```
+ */
+declare function combine<A, B, R>(a: ReadableSignal<A>, b: ReadableSignal<B>, fn: (a: A, b: B) => R): ReturnType<typeof computed<R>>;
+declare function combine<A, B, C, R>(a: ReadableSignal<A>, b: ReadableSignal<B>, c: ReadableSignal<C>, fn: (a: A, b: B, c: C) => R): ReturnType<typeof computed<R>>;
+//#endregion
+//#region src/pipe.d.ts
+/**
+ * Pipe a signal through a chain of transform functions.
+ * Each transform receives the resolved value (not the signal) and returns a new value.
+ * The entire chain is wrapped in a single `computed()`.
+ *
+ * @example
+ * ```ts
+ * const topRisks = rx.pipe(
+ *   findings,
+ *   (items) => items.filter(f => f.severity === "critical"),
+ *   (items) => items.sort((a, b) => b.score - a.score),
+ *   (items) => items.slice(0, 10),
+ * )
+ * // topRisks() → reactive, type-safe
+ * ```
+ */
+declare function pipe<A, B>(source: ReadableSignal<A>, f1: (a: A) => B): ReturnType<typeof computed<B>>;
+declare function pipe<A, B, C>(source: ReadableSignal<A>, f1: (a: A) => B, f2: (b: B) => C): ReturnType<typeof computed<C>>;
+declare function pipe<A, B, C, D>(source: ReadableSignal<A>, f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D): ReturnType<typeof computed<D>>;
+declare function pipe<A, B, C, D, E>(source: ReadableSignal<A>, f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E): ReturnType<typeof computed<E>>;
+declare function pipe<A, B, C, D, E, F>(source: ReadableSignal<A>, f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E, f5: (e: E) => F): ReturnType<typeof computed<F>>;
+declare function pipe<A, B>(source: A, f1: (a: A) => B): B;
+declare function pipe<A, B, C>(source: A, f1: (a: A) => B, f2: (b: B) => C): C;
+declare function pipe<A, B, C, D>(source: A, f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D): D;
+//#endregion
+//#region src/search.d.ts
+/**
+ * Search items by substring matching across specified keys.
+ * Case-insensitive. Signal-aware — reactive when either source or query is a signal.
+ *
+ * @example
+ * ```ts
+ * const results = rx.search(users, searchQuery, ["name", "email"])
+ * ```
+ */
+declare function search<T>(source: ReadableSignal<T[]> | T[], query: ReadableSignal<string> | string, keys: (keyof T)[]): any;
+//#endregion
+//#region src/timing.d.ts
+/**
+ * Debounce a signal — emits the latest value after `ms` of silence.
+ * Returns a new signal that updates only after the source stops changing.
+ *
+ * Works both inside and outside component context.
+ * The returned signal has a `.dispose()` method to stop tracking.
+ */
+declare function debounce<T>(source: ReadableSignal<T>, ms: number): ReadableSignal<T> & {
+  dispose: () => void;
+};
+/**
+ * Throttle a signal — emits at most once every `ms` milliseconds.
+ * Immediately emits on first change, then waits for the interval.
+ *
+ * Works both inside and outside component context.
+ * The returned signal has a `.dispose()` method to stop tracking.
+ */
+declare function throttle<T>(source: ReadableSignal<T>, ms: number): ReadableSignal<T> & {
+  dispose: () => void;
+};
+//#endregion
+//#region src/index.d.ts
+/**
+ * Signal-aware reactive transforms.
+ *
+ * Every function is overloaded:
+ * - `Signal<T[]>` input → returns `Computed<R>` (reactive)
+ * - `T[]` input → returns `R` (static)
+ *
+ * @example
+ * ```ts
+ * import { rx } from "@pyreon/rx"
+ *
+ * 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[]>
+ *
+ * // Or pipe:
+ * 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),
+ * )
+ * ```
+ */
+declare const rx: {
+  readonly filter: typeof filter;
+  readonly map: typeof map;
+  readonly sortBy: typeof sortBy;
+  readonly groupBy: typeof groupBy;
+  readonly keyBy: typeof keyBy;
+  readonly uniqBy: typeof uniqBy;
+  readonly take: typeof take;
+  readonly skip: typeof skip;
+  readonly last: typeof last;
+  readonly chunk: typeof chunk;
+  readonly flatten: typeof flatten;
+  readonly find: typeof find;
+  readonly mapValues: typeof mapValues;
+  readonly count: typeof count;
+  readonly sum: typeof sum;
+  readonly min: typeof min;
+  readonly max: typeof max;
+  readonly average: typeof average;
+  readonly distinct: typeof distinct;
+  readonly scan: typeof scan;
+  readonly combine: typeof combine;
+  readonly debounce: typeof debounce;
+  readonly throttle: typeof throttle;
+  readonly search: typeof search;
+  readonly pipe: typeof pipe;
+};
+//#endregion
+export { type KeyOf, type ReadableSignal, average, chunk, combine, count, debounce, distinct, filter, find, flatten, groupBy, keyBy, last, map, mapValues, max, min, pipe, rx, scan, search, skip, sortBy, sum, take, throttle, uniqBy };
+//# sourceMappingURL=index2.d.ts.map

package/lib/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index2.d.ts","names":[],"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"],"mappings":"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"}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@pyreon/rx",
+  "version": "0.11.0",
+  "description": "Signal-aware reactive transforms — filter, map, sort, group, pipe for Pyreon signals",
+  "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",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "import": "./lib/index.js",
+      "types": "./lib/types/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "vl_rolldown_build",
+    "dev": "vl_rolldown_build-watch",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check ."
+  },
+  "peerDependencies": {
+    "@pyreon/reactivity": "^0.11.0"
+  },
+  "devDependencies": {
+    "@pyreon/typescript": "^0.11.0"
+  }
+}