@rlabs-inc/signals 0.2.0 → 1.0.0

package/README.md

@@ -1,18 +1,20 @@
 # @rlabs-inc/signals
 
-**Ultra-lightweight fine-grained reactivity for TypeScript**
+**Production-grade fine-grained reactivity for TypeScript.**
 
-A standalone reactive primitives library inspired by Svelte 5 runes, Solid.js, and Vue reactivity. Zero dependencies. ~800 lines of pure TypeScript.
+A complete standalone mirror of Svelte 5's reactivity system. No compiler needed, no DOM, works anywhere - Bun, Node, Deno, or browser.
 
 ## Features
 
-- **Fine-grained reactivity** - Only effects that read a signal re-run when it changes
-- **Deep reactivity** - Objects and arrays are automatically deeply reactive
-- **Lazy deriveds** - Computed values only recompute when read
-- **Batching** - Group updates to prevent multiple re-runs
-- **Reactive collections** - ReactiveMap, ReactiveSet, and reactiveArray
-- **Zero dependencies** - Pure TypeScript, works everywhere
-- **Tiny** - ~5KB minified
+- **True Fine-Grained Reactivity** - Changes to deeply nested properties only trigger effects that read that exact path
+- **Per-Property Tracking** - Proxy-based deep reactivity with lazy signal creation per property
+- **Three-State Dirty Tracking** - Efficient CLEAN/MAYBE_DIRTY/DIRTY propagation
+- **Automatic Cleanup** - Effects clean up when disposed, no memory leaks
+- **Batching** - Group updates to prevent redundant effect runs
+- **Self-Referencing Effects** - Effects can write to their own dependencies
+- **Infinite Loop Protection** - Throws after 1000 iterations to catch bugs
+- **Reactive Collections** - ReactiveMap, ReactiveSet, ReactiveDate
+- **TypeScript Native** - Full type safety with generics
 
 ## Installation
 
@@ -25,88 +27,84 @@ npm install @rlabs-inc/signals
 ## Quick Start
 
 ```typescript
-import { signal, effect, derived } from '@rlabs-inc/signals'
+import { signal, derived, effect, flushSync } from '@rlabs-inc/signals'
 
-// Simple signal
+// Create a signal
 const count = signal(0)
 
-// Effect runs when dependencies change
+// Create a derived value
+const doubled = derived(() => count.value * 2)
+
+// Create an effect
 effect(() => {
-  console.log('Count:', count.value)
+  console.log(`Count: ${count.value}, Doubled: ${doubled.value}`)
 })
-// Logs: "Count: 0"
 
-count.value = 1
-// Logs: "Count: 1"
+// Flush to run effects synchronously
+flushSync()  // Logs: "Count: 0, Doubled: 0"
 
-// Derived values
-const doubled = derived(() => count.value * 2)
-console.log(doubled.value) // 2
+// Update the signal
+count.value = 5
+flushSync()  // Logs: "Count: 5, Doubled: 10"
+```
 
-// Deep reactivity - signal() is deeply reactive for objects/arrays!
-const user = signal({
-  name: 'John',
-  address: {
-    city: 'NYC'
-  }
-})
+## API Reference
 
-effect(() => {
-  console.log('City:', user.value.address.city)
-})
-// Logs: "City: NYC"
+### Signals
 
-user.value.address.city = 'LA'
-// Logs: "City: LA" - mutations at any depth trigger effects!
+#### `signal<T>(initialValue: T, options?): WritableSignal<T>`
 
-// Even deeply nested arrays work
-const data = signal({ items: [[1, 2], [3, 4]] })
-data.value.items[0][1] = 99  // Triggers effects!
+Create a reactive value with `.value` getter/setter.
+
+```typescript
+const name = signal('John')
+console.log(name.value)  // 'John'
+name.value = 'Jane'      // Triggers effects
 ```
 
-## API Reference
+**Options:**
+- `equals?: (a: T, b: T) => boolean` - Custom equality function
 
-### signal(initial, options?)
+#### `state<T extends object>(initialValue: T): T`
 
-Create a reactive signal that holds a value. **For objects and arrays, signals are deeply reactive** - mutations at any depth trigger effects.
+Create a deeply reactive object. No `.value` needed - access properties directly.
 
 ```typescript
-// Primitives
-const count = signal(0)
-console.log(count.value) // 0
-count.value = 5
-console.log(count.value) // 5
+const user = state({ name: 'John', address: { city: 'NYC' } })
+user.name = 'Jane'           // Reactive
+user.address.city = 'LA'     // Also reactive, deeply
+```
 
-// Objects - deeply reactive!
-const user = signal({ name: 'John', address: { city: 'NYC' } })
-user.value.address.city = 'LA'  // Triggers effects!
+### Derived Values
 
-// Arrays - deeply reactive!
-const matrix = signal([[1, 2], [3, 4]])
-matrix.value[0][1] = 99  // Triggers effects!
-matrix.value.push([5, 6])  // Triggers effects!
+#### `derived<T>(fn: () => T): DerivedSignal<T>`
 
-// Arbitrarily deep nesting works
-const complex = signal({
-  level1: [{ level2: [[{ level3: 'value' }]] }]
-})
-complex.value.level1[0].level2[0][0].level3 = 'mutated'  // Triggers!
+Create a computed value that automatically updates when dependencies change.
 
-// With custom equality (for full replacement comparison)
-const obj = signal({ x: 1 }, {
-  equals: (a, b) => a.x === b.x
-})
+```typescript
+const firstName = signal('John')
+const lastName = signal('Doe')
+
+const fullName = derived(() => `${firstName.value} ${lastName.value}`)
+console.log(fullName.value)  // 'John Doe'
 ```
 
-### effect(fn)
+Deriveds are:
+- **Lazy** - Only computed when read
+- **Cached** - Value is memoized until dependencies change
+- **Pure** - Cannot write to signals inside (throws error)
+
+### Effects
 
-Create a reactive effect that re-runs when dependencies change.
+#### `effect(fn: () => void | CleanupFn): DisposeFn`
+
+Create a side effect that re-runs when dependencies change.
 
 ```typescript
-const name = signal('John')
+const count = signal(0)
 
 const dispose = effect(() => {
-  console.log('Hello,', name.value)
+  console.log('Count is:', count.value)
 
   // Optional cleanup function
   return () => {
@@ -114,224 +112,266 @@ const dispose = effect(() => {
   }
 })
 
-name.value = 'Jane' // Effect re-runs
-
-dispose() // Stop the effect
+// Stop the effect
+dispose()
 ```
 
-### derived(fn, options?)
+#### `effect.root(fn: () => T): DisposeFn`
 
-Create a computed/derived value that updates automatically.
+Create an effect scope that can contain nested effects.
 
 ```typescript
-const count = signal(5)
-const doubled = derived(() => count.value * 2)
-
-console.log(doubled.value) // 10
-
-count.value = 10
-console.log(doubled.value) // 20
+const dispose = effect.root(() => {
+  effect(() => { /* ... */ })
+  effect(() => { /* ... */ })
+})
 
-// Alias: derived.by() (Svelte compatibility)
-const tripled = derived.by(() => count.value * 3)
+// Disposes all nested effects
+dispose()
 ```
 
-### state(initial)
+#### `effect.pre(fn: () => void): DisposeFn`
 
-Convenience function for deeply reactive objects **without `.value`**. Use when you want direct property access instead of going through `.value`.
+Create an effect that runs synchronously (like `$effect.pre` in Svelte).
 
 ```typescript
-// state() - direct access, no .value needed
-const app = state({
-  user: {
-    name: 'John',
-    preferences: {
-      theme: 'dark'
-    }
-  },
-  items: [1, 2, 3]
+effect.pre(() => {
+  // Runs immediately, no flushSync needed
 })
-
-effect(() => {
-  console.log(app.user.preferences.theme)  // No .value!
-})
-
-app.user.preferences.theme = 'light' // Triggers effect
-app.items.push(4) // Arrays are reactive too
-
-// Equivalent using signal():
-const app2 = signal({ ... })
-app2.value.user.preferences.theme = 'light'  // Same, but with .value
 ```
 
-**When to use which:**
-- `signal()` - Unified API, always use `.value` (recommended)
-- `state()` - When you want direct property access without `.value`
+### Batching & Scheduling
 
-### batch(fn)
+#### `batch(fn: () => T): T`
 
-Batch multiple updates into a single reaction cycle.
+Batch multiple signal updates into a single effect run.
 
 ```typescript
 const a = signal(1)
 const b = signal(2)
 
-effect(() => {
-  console.log('Sum:', a.value + b.value)
-})
-// Logs: "Sum: 3"
+effect(() => console.log(a.value + b.value))
 
 batch(() => {
   a.value = 10
   b.value = 20
 })
-// Logs: "Sum: 30" (only once, not twice)
+// Effect runs once with final values, not twice
 ```
 
-### untrack(fn)
+#### `flushSync<T>(fn?: () => T): T | undefined`
 
-Read signals without creating dependencies.
+Synchronously flush all pending effects.
 
 ```typescript
-const a = signal(1)
-const b = signal(2)
+count.value = 5
+flushSync()  // Effects run NOW, not on next microtask
+```
+
+#### `tick(): Promise<void>`
+
+Wait for the next update cycle.
+
+```typescript
+count.value = 5
+await tick()  // Effects have run
+```
 
+### Utilities
+
+#### `untrack<T>(fn: () => T): T`
+
+Read signals without creating dependencies.
+
+```typescript
 effect(() => {
-  console.log('a:', a.value) // Creates dependency
-  untrack(() => {
-    console.log('b:', b.value) // Does NOT create dependency
-  })
+  const a = count.value           // Creates dependency
+  const b = untrack(() => other.value)  // No dependency
 })
-
-b.value = 100 // Effect does NOT re-run
-a.value = 100 // Effect re-runs
 ```
 
-### watch(source, callback, options?)
+#### `peek<T>(signal: Source<T>): T`
 
-Watch a signal and call callback when it changes.
+Read a signal's value without tracking (low-level).
+
+### Deep Reactivity
+
+#### `proxy<T extends object>(value: T): T`
+
+Create a deeply reactive proxy (used internally by `state()`).
 
 ```typescript
-const count = signal(0)
+const obj = proxy({ a: { b: { c: 1 } } })
+obj.a.b.c = 2  // Only triggers effects reading a.b.c
+```
 
-const dispose = watch(
-  () => count.value,
-  (newValue, oldValue) => {
-    console.log(`Changed from ${oldValue} to ${newValue}`)
-  }
-)
+#### `toRaw<T>(value: T): T`
 
-count.value = 1 // Logs: "Changed from 0 to 1"
+Get the original object from a proxy.
 
-// With immediate option
-watch(
-  () => count.value,
-  (value) => console.log('Value:', value),
-  { immediate: true }
-)
-// Logs immediately: "Value: 1"
+```typescript
+const raw = toRaw(user)  // Original non-reactive object
 ```
 
-### ReactiveMap
+#### `isReactive(value: unknown): boolean`
+
+Check if a value is a reactive proxy.
 
-A reactive Map that triggers updates on modifications.
+### Reactive Collections
+
+#### `ReactiveMap<K, V>`
+
+A Map with per-key reactivity.
 
 ```typescript
-const map = new ReactiveMap<string, number>()
+const users = new ReactiveMap<string, User>()
 
 effect(() => {
-  console.log('Value:', map.get('key'))
+  console.log(users.get('john'))  // Only re-runs when 'john' changes
 })
 
-map.set('key', 42) // Triggers effect
+users.set('jane', { name: 'Jane' })  // Doesn't trigger above effect
 ```
 
-### ReactiveSet
+#### `ReactiveSet<T>`
 
-A reactive Set that triggers updates on modifications.
+A Set with per-item reactivity.
 
 ```typescript
-const set = new ReactiveSet<string>()
+const tags = new ReactiveSet<string>()
 
 effect(() => {
-  console.log('Has item:', set.has('item'))
+  console.log(tags.has('important'))  // Only re-runs when 'important' changes
 })
-
-set.add('item') // Triggers effect
 ```
 
-### reactiveArray(initial?)
+#### `ReactiveDate`
 
-Create a reactive array with fine-grained reactivity.
+A Date with reactive getters/setters.
 
 ```typescript
-const items = reactiveArray([1, 2, 3])
+const date = new ReactiveDate()
 
 effect(() => {
-  console.log('First:', items[0])
-  console.log('Length:', items.length)
+  console.log(date.getHours())  // Re-runs when time changes
 })
 
-items[0] = 10    // Triggers effect
-items.push(4)    // Triggers effect
+date.setHours(12)  // Triggers effect
 ```
 
-### Utilities
+## Advanced Usage
+
+### Self-Referencing Effects
+
+Effects can write to signals they depend on:
 
 ```typescript
-// Create read-only view
 const count = signal(0)
-const ro = readonly(count)
-// ro.value = 5  // TypeScript error
 
-// Read without tracking (alias for untrack)
-const value = peek(() => count.value)
+effect(() => {
+  if (count.value < 10) {
+    count.value++  // Will re-run until count reaches 10
+  }
+})
+```
 
-// Check if value is reactive
-isReactive(someObject)
+**Note:** Unguarded self-references throw after 1000 iterations.
 
-// Get raw object from reactive proxy
-const raw = toRaw(reactiveObject)
+### Custom Equality
 
-// Create effect scope
-const scope = effectScope()
-scope.run(() => {
-  effect(() => { /* ... */ })
-  effect(() => { /* ... */ })
+```typescript
+import { signal, shallowEquals } from '@rlabs-inc/signals'
+
+const obj = signal({ a: 1 }, { equals: shallowEquals })
+obj.value = { a: 1 }  // Won't trigger - shallowly equal
+```
+
+Built-in equality functions:
+- `equals` - Default, uses `Object.is`
+- `safeEquals` - Handles NaN correctly
+- `shallowEquals` - Shallow object comparison
+- `neverEquals` - Always triggers (always false)
+- `alwaysEquals` - Never triggers (always true)
+
+### Low-Level API
+
+For advanced use cases, you can access internal primitives:
+
+```typescript
+import { source, get, set } from '@rlabs-inc/signals'
+
+// Create a raw source (no .value wrapper)
+const src = source(0)
+
+// Read with tracking
+const value = get(src)
+
+// Write with notification
+set(src, 10)
+```
+
+## Error Handling
+
+### "Cannot write to signals inside a derived"
+
+Deriveds must be pure computations:
+
+```typescript
+// BAD - will throw
+const bad = derived(() => {
+  otherSignal.value = 10  // Throws!
+  return count.value
+})
+
+// GOOD - use effects for side effects
+effect(() => {
+  if (count.value > 0) {
+    otherSignal.value = count.value * 2
+  }
+})
+```
+
+### "Maximum update depth exceeded"
+
+Your effect is infinitely re-triggering itself:
+
+```typescript
+// BAD - infinite loop
+effect(() => {
+  count.value = count.value + 1  // Always triggers itself
+})
+
+// GOOD - add a guard
+effect(() => {
+  if (count.value < 100) {
+    count.value++
+  }
 })
-scope.stop() // Disposes all effects
 ```
 
+## Performance
+
+This library is designed for performance:
+
+- **Lazy evaluation** - Deriveds only compute when read
+- **Version-based deduplication** - No duplicate dependency tracking
+- **Linked list effect tree** - O(1) effect insertion/removal
+- **Microtask batching** - Updates coalesce automatically
+- **Per-property signals** - Fine-grained updates at any depth
+
 ## Comparison with Svelte 5
 
-| Svelte 5 | @rlabs-inc/signals |
-|----------|-------------------|
-| `$state(value)` | `signal(value)` - deeply reactive for objects/arrays |
-| `$state(obj)` direct access | `state(obj)` - no `.value` needed |
-| `$derived(expr)` | `derived(() => expr)` |
-| `$derived.by(fn)` | `derived.by(fn)` or `derived(fn)` |
-| `$effect(fn)` | `effect(fn)` |
-| `SvelteMap` | `ReactiveMap` |
-| `SvelteSet` | `ReactiveSet` |
-
-**Key differences:**
-- No compiler needed - works with plain TypeScript
-- Use `.value` to read/write signals (like Vue/Solid)
-- No Happy DOM or browser environment required
-- `signal()` is deeply reactive out of the box - arrays of arrays of objects just work
-
-## Why?
-
-We built this because:
-1. We love Svelte 5's reactivity model
-2. We wanted to use it outside Svelte components
-3. We didn't want the overhead of Happy DOM for server-side usage
-4. We needed a lightweight solution for libraries like [FatherStateDB](https://github.com/rlabs-inc/fatherstatedb)
+| Feature | Svelte 5 | @rlabs-inc/signals |
+|---------|----------|-------------------|
+| Compiler required | Yes | No |
+| DOM integration | Yes | No |
+| Fine-grained reactivity | Yes | Yes |
+| Deep proxy reactivity | Yes | Yes |
+| Batching | Yes | Yes |
+| Effect cleanup | Yes | Yes |
+| TypeScript | Yes | Yes |
+| Runs in Node/Bun | Needs adapter | Native |
 
 ## License
 
 MIT
-
----
-
-Built with ❤️ by RLabs Inc.

package/dist/collections/date.d.ts

@@ -0,0 +1,67 @@
+/**
+ * A reactive Date
+ *
+ * All getters are reactive - they track changes to the underlying time.
+ * All setters trigger updates.
+ *
+ * @example
+ * ```ts
+ * const date = new ReactiveDate()
+ *
+ * effect(() => {
+ *   console.log('Hours:', date.getHours())
+ * })
+ *
+ * date.setHours(12) // Triggers effect
+ * ```
+ */
+export declare class ReactiveDate extends Date {
+    #private;
+    constructor();
+    constructor(value: number | string | Date);
+    constructor(year: number, monthIndex: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number);
+    getTime(): number;
+    getFullYear(): number;
+    getMonth(): number;
+    getDate(): number;
+    getDay(): number;
+    getHours(): number;
+    getMinutes(): number;
+    getSeconds(): number;
+    getMilliseconds(): number;
+    getUTCFullYear(): number;
+    getUTCMonth(): number;
+    getUTCDate(): number;
+    getUTCDay(): number;
+    getUTCHours(): number;
+    getUTCMinutes(): number;
+    getUTCSeconds(): number;
+    getUTCMilliseconds(): number;
+    getTimezoneOffset(): number;
+    setTime(time: number): number;
+    setFullYear(year: number, month?: number, date?: number): number;
+    setMonth(month: number, date?: number): number;
+    setDate(date: number): number;
+    setHours(hours: number, min?: number, sec?: number, ms?: number): number;
+    setMinutes(min: number, sec?: number, ms?: number): number;
+    setSeconds(sec: number, ms?: number): number;
+    setMilliseconds(ms: number): number;
+    setUTCFullYear(year: number, month?: number, date?: number): number;
+    setUTCMonth(month: number, date?: number): number;
+    setUTCDate(date: number): number;
+    setUTCHours(hours: number, min?: number, sec?: number, ms?: number): number;
+    setUTCMinutes(min: number, sec?: number, ms?: number): number;
+    setUTCSeconds(sec: number, ms?: number): number;
+    setUTCMilliseconds(ms: number): number;
+    toString(): string;
+    toDateString(): string;
+    toTimeString(): string;
+    toISOString(): string;
+    toUTCString(): string;
+    toLocaleString(locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
+    toLocaleDateString(locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
+    toLocaleTimeString(locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
+    toJSON(): string;
+    valueOf(): number;
+}
+//# sourceMappingURL=date.d.ts.map

package/dist/collections/date.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../../src/collections/date.ts"],"names":[],"mappings":"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"}