@pyreon/rx 0.11.0

package/src/tests/collections.test.ts

@@ -0,0 +1,186 @@
+import { signal } from "@pyreon/reactivity"
+import { describe, expect, it } from "vitest"
+import {
+  chunk,
+  filter,
+  find,
+  flatten,
+  groupBy,
+  keyBy,
+  last,
+  map,
+  mapValues,
+  skip,
+  sortBy,
+  take,
+  uniqBy,
+} 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 },
+]
+
+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("sortBy string key", () => {
+    const sorted = sortBy(users, "name")
+    expect(sorted[0]!.name).toBe("Alice")
+    expect(sorted[3]!.name).toBe("Diana")
+  })
+
+  it("sortBy function", () => {
+    const sorted = sortBy(users, (u) => u.id)
+    expect(sorted[0]!.id).toBe(1)
+  })
+
+  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("uniqBy", () => {
+    const result = uniqBy(users, "role")
+    expect(result).toHaveLength(3) // admin, viewer, editor
+  })
+
+  it("take", () => {
+    expect(take(users, 2)).toHaveLength(2)
+    expect(take(users, 2)[0]!.name).toBe("Alice")
+  })
+
+  it("chunk", () => {
+    const chunks = chunk(users, 2)
+    expect(chunks).toHaveLength(2)
+    expect(chunks[0]).toHaveLength(2)
+  })
+
+  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("skip", () => {
+    const result = skip(users, 2)
+    expect(result).toHaveLength(2)
+    expect(result[0]!.name).toBe("Charlie")
+    expect(result[1]!.name).toBe("Diana")
+  })
+
+  it("last", () => {
+    const result = last(users, 2)
+    expect(result).toHaveLength(2)
+    expect(result[0]!.name).toBe("Charlie")
+    expect(result[1]!.name).toBe("Diana")
+  })
+
+  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", () => {
+    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" })
+  })
+})
+
+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 }])
+    expect(active()).toHaveLength(4)
+  })
+
+  it("map returns computed", () => {
+    const src = signal(users)
+    const names = map(src, (u) => u.name)
+    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("groupBy returns computed", () => {
+    const src = signal(users)
+    const groups = groupBy(src, "role")
+    expect(groups().admin).toHaveLength(2)
+  })
+
+  it("take returns computed", () => {
+    const src = signal(users)
+    const first2 = take(src, 2)
+    expect(first2()).toHaveLength(2)
+
+    src.set([users[0]!])
+    expect(first2()).toHaveLength(1)
+  })
+
+  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
+  })
+
+  it("skip returns computed", () => {
+    const src = signal(users)
+    const skipped = skip(src, 3)
+    expect(skipped()).toHaveLength(1)
+    expect(skipped()[0]!.name).toBe("Diana")
+
+    src.set([...users, { id: 5, name: "Eve", role: "admin", active: true }])
+    expect(skipped()).toHaveLength(2)
+  })
+
+  it("last returns computed", () => {
+    const src = signal(users)
+    const lastTwo = last(src, 2)
+    expect(lastTwo()).toHaveLength(2)
+    expect(lastTwo()[0]!.name).toBe("Charlie")
+
+    src.set([users[0]!])
+    expect(lastTwo()).toHaveLength(1)
+    expect(lastTwo()[0]!.name).toBe("Alice")
+  })
+
+  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 })
+
+    src.set({ x: 10 })
+    expect(doubled()).toEqual({ x: 20 })
+  })
+})

package/src/tests/operators.test.ts

@@ -0,0 +1,153 @@
+import { signal } from "@pyreon/reactivity"
+import { describe, expect, it } from "vitest"
+import { combine, distinct, scan } from "../operators"
+
+describe("distinct", () => {
+  it("skips consecutive duplicate values", () => {
+    const src = signal(1)
+    const d = distinct(src)
+    expect(d()).toBe(1)
+
+    // Same value — should not re-emit
+    src.set(1)
+    expect(d()).toBe(1)
+
+    // Different value — should emit
+    src.set(2)
+    expect(d()).toBe(2)
+
+    // Back to same — should emit (not same as previous)
+    src.set(2)
+    expect(d()).toBe(2)
+
+    // New value
+    src.set(3)
+    expect(d()).toBe(3)
+  })
+
+  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")
+
+    // Same id, different name — should be considered equal, skip
+    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")
+  })
+
+  it("works reactively with signal source", () => {
+    const src = signal("a")
+    const d = distinct(src)
+    expect(d()).toBe("a")
+
+    src.set("b")
+    expect(d()).toBe("b")
+
+    src.set("b")
+    expect(d()).toBe("b")
+
+    src.set("c")
+    expect(d()).toBe("c")
+  })
+})
+
+describe("scan", () => {
+  it("accumulates values over signal changes", () => {
+    const src = signal(0)
+    const total = scan(src, (acc, val) => acc + val, 0)
+
+    // Initial: reducer runs with initial source value
+    expect(total()).toBe(0)
+
+    src.set(1)
+    expect(total()).toBe(1)
+
+    src.set(3)
+    expect(total()).toBe(4)
+
+    src.set(2)
+    expect(total()).toBe(6)
+  })
+
+  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"])
+
+    src.set("hello")
+    expect(log()).toEqual(["start", "hello"])
+
+    src.set("world")
+    expect(log()).toEqual(["start", "hello", "world"])
+  })
+
+  it("is signal-reactive", () => {
+    const src = signal(10)
+    const running = scan(src, (acc, val) => acc + val, 0)
+    expect(running()).toBe(10)
+
+    src.set(5)
+    expect(running()).toBe(15)
+
+    // Different value triggers accumulation again
+    src.set(7)
+    expect(running()).toBe(22)
+  })
+})
+
+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")
+  })
+
+  it("combines 3 signals", () => {
+    const a = signal(1)
+    const b = signal(2)
+    const c = signal(3)
+    const total = combine(a, b, c, (x, y, z) => x + y + z)
+
+    expect(total()).toBe(6)
+  })
+
+  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")
+
+    firstName.set("Jane")
+    expect(fullName()).toBe("Jane Doe")
+
+    lastName.set("Smith")
+    expect(fullName()).toBe("Jane Smith")
+  })
+
+  it("reacts to updates from all 3 sources", () => {
+    const a = signal(1)
+    const b = signal(10)
+    const c = signal(100)
+    const sum = combine(a, b, c, (x, y, z) => x + y + z)
+
+    expect(sum()).toBe(111)
+
+    a.set(2)
+    expect(sum()).toBe(112)
+
+    b.set(20)
+    expect(sum()).toBe(122)
+
+    c.set(200)
+    expect(sum()).toBe(222)
+  })
+})

package/src/tests/pipe.test.ts

@@ -0,0 +1,51 @@
+import { signal } from "@pyreon/reactivity"
+import { describe, expect, it } from "vitest"
+import { pipe } from "../pipe"
+
+describe("pipe — plain values", () => {
+  it("chains transforms", () => {
+    const result = pipe(
+      [3, 1, 4, 1, 5, 9],
+      (arr) => arr.filter((n) => n > 2),
+      (arr) => arr.sort((a, b) => a - b),
+      (arr) => arr.slice(0, 3),
+    )
+    expect(result).toEqual([3, 4, 5])
+  })
+
+  it("single transform", () => {
+    expect(pipe([1, 2, 3], (arr) => arr.length)).toBe(3)
+  })
+})
+
+describe("pipe — signal values", () => {
+  it("returns computed that tracks source", () => {
+    const src = signal([3, 1, 4, 1, 5, 9])
+    const result = pipe(
+      src,
+      (arr) => arr.filter((n) => n > 2),
+      (arr) => arr.sort((a, b) => a - b),
+    )
+    expect(result()).toEqual([3, 4, 5, 9])
+
+    src.set([10, 1])
+    expect(result()).toEqual([10])
+  })
+
+  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 },
+    ])
+
+    const topNames = pipe(
+      users,
+      (items) => items.sort((a, b) => b.score - a.score),
+      (items) => items.slice(0, 2),
+      (items) => items.map((u) => u.name),
+    )
+    expect(topNames()).toEqual(["B", "A"])
+  })
+})

package/src/tests/timing.test.ts

@@ -0,0 +1,55 @@
+import { signal } from "@pyreon/reactivity"
+import { afterEach, describe, expect, it, vi } from "vitest"
+import { debounce, throttle } from "../timing"
+
+describe("debounce", () => {
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it("dispose() stops tracking source changes", () => {
+    vi.useFakeTimers()
+    const src = signal(0)
+    const debounced = debounce(src, 100)
+    expect(debounced()).toBe(0)
+
+    // Change source and advance past debounce window
+    src.set(1)
+    vi.advanceTimersByTime(100)
+    expect(debounced()).toBe(1)
+
+    // Dispose — further changes should not propagate
+    debounced.dispose()
+
+    src.set(2)
+    vi.advanceTimersByTime(200)
+    expect(debounced()).toBe(1) // still 1, not 2
+  })
+})
+
+describe("throttle", () => {
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it("dispose() stops tracking source changes", () => {
+    vi.useFakeTimers()
+    const src = signal(0)
+    const throttled = throttle(src, 100)
+    expect(throttled()).toBe(0)
+
+    // Advance time so the next change passes the throttle window
+    vi.advanceTimersByTime(100)
+
+    src.set(1)
+    expect(throttled()).toBe(1)
+
+    // Dispose — further changes should not propagate
+    throttled.dispose()
+
+    vi.advanceTimersByTime(200)
+    src.set(2)
+    vi.advanceTimersByTime(200)
+    expect(throttled()).toBe(1) // still 1, not 2
+  })
+})

package/src/timing.ts

@@ -0,0 +1,70 @@
+import { effect, signal } from "@pyreon/reactivity"
+import type { ReadableSignal } from "./types"
+
+/**
+ * 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.
+ */
+export function debounce<T>(
+  source: ReadableSignal<T>,
+  ms: number,
+): ReadableSignal<T> & { dispose: () => void } {
+  const debounced = signal(source())
+  let timer: ReturnType<typeof setTimeout> | undefined
+
+  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 as ReadableSignal<T>, { 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.
+ */
+export function throttle<T>(
+  source: ReadableSignal<T>,
+  ms: number,
+): ReadableSignal<T> & { dispose: () => void } {
+  const throttled = signal(source())
+  let lastEmit = 0
+  let timer: ReturnType<typeof setTimeout> | undefined
+
+  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 as ReadableSignal<T>, { dispose })
+}

package/src/types.ts

@@ -0,0 +1,21 @@
+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 }
+
+/** Result of a signal-aware transform — Computed when input is signal, plain when not. */
+export type ReactiveResult<TInput, TOutput> =
+  TInput extends ReadableSignal<any> ? ReturnType<typeof computed<TOutput>> : TOutput
+
+/** Key extractor — string key name or function. */
+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])
+}
+
+/** 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"
+}