@nerdalytics/beacon 1.0.0

package/LICENSE

@@ -0,0 +1,8 @@
+The MIT License (MIT)
+Copyright © 2025 Denny Trebbin (nerdalytics)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,187 @@
+# Beacon
+
+A lightweight reactive signal library for Node.js backends. Enables reactive state management with automatic dependency tracking and efficient updates for server-side applications.
+
+## Table of Contents
+
+- [Features](#features)
+- [Installation](#installation)
+- [Usage](#usage)
+- [API](#api)
+  - [state](#statetinitialvalue-t-signalt)
+  - [derived](#derivedfn--t-signalt)
+  - [effect](#effectfn--void--void)
+  - [batch](#batchfn--t-t)
+- [Development](#development)
+  - [Node.js LTS Compatibility](#nodejs-lts-compatibility)
+- [Key Differences vs TC39 Proposal](#key-differences-between-my-library-and-the-tc39-proposal)
+- [Implementation Details](#implementation-details)
+- [FAQ](#faq)
+- [License](#license)
+
+## Features
+
+- 🔄 **Reactive signals** - Create reactive values that automatically track dependencies
+- 🧮 **Computed values** - Derive values from other signals with automatic updates
+- 🔍 **Fine-grained reactivity** - Dependencies are tracked precisely at the signal level
+- 🏎️ **Efficient updates** - Only recompute values when dependencies change
+- 📦 **Batched updates** - Group multiple updates for performance
+- 🧹 **Automatic cleanup** - Effects and computations automatically clean up dependencies
+- 🔁 **Cycle handling** - Safely manages cyclic dependencies without crashing
+- 🛠️ **TypeScript-first** - Full TypeScript support with generics
+- 🪶 **Lightweight** - Zero dependencies, < 200 LOC
+- ✅ **Node.js compatibility** - Works with Node.js LTS v20+ and v22+
+
+## Installation
+
+```bash
+npm install @nerdalytics/beacon
+```
+
+## Usage
+
+```typescript
+import { state, derived, effect, batch } from "@nerdalytics/beacon";
+
+// Create reactive state
+const count = state(0);
+const doubled = derived(() => count() * 2);
+
+// Read values
+console.log(count()); // => 0
+console.log(doubled()); // => 0
+
+// Setup an effect that automatically runs when dependencies change
+// effect() returns a cleanup function that removes all subscriptions when called
+const unsubscribe = effect(() => {
+  console.log(`Count is ${count()}, doubled is ${doubled()}`);
+});
+// => "Count is 0, doubled is 0" (effect runs immediately when created)
+
+// Update values - effect automatically runs after each change
+count.set(5);
+// => "Count is 5, doubled is 10"
+
+// Update with a function
+count.update((n) => n + 1);
+// => "Count is 6, doubled is 12"
+
+// Batch updates (only triggers effects once at the end)
+batch(() => {
+  count.set(10);
+  count.set(20);
+});
+// => "Count is 20, doubled is 40" (only once)
+
+// Unsubscribe the effect to stop it from running on future updates
+// and clean up all its internal subscriptions
+unsubscribe();
+```
+
+## API
+
+### `state<T>(initialValue: T): Signal<T>`
+
+Creates a new reactive signal with the given initial value.
+
+### `derived<T>(fn: () => T): Signal<T>`
+
+Creates a derived signal that updates when its dependencies change.
+
+### `effect(fn: () => void): () => void`
+
+Creates an effect that runs the given function immediately and whenever its dependencies change. Returns an unsubscribe function that stops the effect and cleans up all subscriptions when called.
+
+### `batch<T>(fn: () => T): T`
+
+Batches multiple updates to only trigger effects once at the end.
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Run all tests
+npm test
+
+# Run all tests with coverage
+npm run test:coverage
+
+# Run specific test suites
+# Core functionality
+npm run test:unit:state
+npm run test:unit:derived
+npm run test:unit:effect
+npm run test:unit:batch
+
+# Advanced patterns
+npm run test:unit:cleanup    # Tests for effect cleanup behavior
+npm run test:unit:cyclic     # Tests for cyclic dependency handling
+
+# Format code
+npm run format
+
+# Build for Node.js LTS compatibility (v20+)
+npm run build:lts
+```
+
+### Node.js LTS Compatibility
+
+Beacon supports the two most recent Node.js LTS versions (currently v20 and v22). When the package is published to npm, it includes transpiled code compatible with these LTS versions.
+
+## Key Differences Between My Library and the [TC39 Proposal][1]
+
+| Aspect | @nerdalytics/beacon | TC39 Proposal |
+|--------|---------------------|---------------|
+| **API Style** | Functional approach (`state()`, `derived()`) | Class-based design (`Signal.State`, `Signal.Computed`) |
+| **Reading/Writing Pattern** | Function call for reading (`count()`), methods for writing (`count.set(5)`) | Method-based access (`get()`/`set()`) |
+| **Framework Support** | High-level abstractions like `effect()` and `batch()` | Lower-level primitives (`Signal.subtle.Watcher`) that frameworks build upon |
+| **Advanced Features** | Focused on core reactivity | Includes introspection capabilities, watched/unwatched callbacks, and Signal.subtle namespace |
+| **Scope and Purpose** | Practical Node.js use cases with minimal API surface | Standardization with robust interoperability between frameworks |
+
+## Implementation Details
+
+Beacon is designed with a focus on simplicity, performance, and robust handling of complex dependency scenarios.
+
+### Key Implementation Concepts
+
+- **Fine-grained reactivity**: Dependencies are tracked automatically at the signal level
+- **Efficient updates**: Changes only propagate to affected parts of the dependency graph
+- **Cyclical dependency handling**: Robust handling of circular references without crashing
+- **Memory management**: Automatic cleanup of subscriptions when effects are disposed
+
+For an in-depth explanation of Beacon's internal architecture, advanced features, and best practices for handling complex scenarios like cyclical dependencies, see the [TECHNICAL_DETAILS.md][2] document.
+
+## FAQ
+
+<details>
+
+<summary>Why "Beacon" Instead of "Signal"?</summary>
+I chose "Beacon" because it clearly represents how the library broadcasts notifications when state changes—just like a lighthouse guides ships. While my library draws inspiration from Preact Signals, Angular Signals, and aspects of Svelte, I wanted to create something lighter and specifically designed for Node.js backends. Using "Beacon" instead of "Signal" helps avoid confusion with the TC39 proposal and similar libraries while still accurately describing the core functionality.
+
+</details>
+
+<details>
+
+<summary>How does Beacon handle infinite update cycles?</summary>
+Beacon uses a queue-based update system that won't crash even with cyclical dependencies. If signals form a cycle where values constantly change (A updates B updates A...), the system will continue processing these updates without stack overflows. However, this could potentially affect performance if updates never stabilize. See the [TECHNICAL_DETAILS.md][4] document for best practices on handling cyclical dependencies.
+
+</details>
+
+<details>
+
+<summary>How performant is Beacon?</summary>
+Beacon is designed with performance in mind for server-side Node.js environments. It achieves millions of operations per second for core operations like reading and writing signals.
+
+</details>
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE][3] file for details.
+
+<!-- Links collection -->
+
+[1]: https://github.com/tc39/proposal-signals
+[2]: ./TECHNICAL_DETAILS.md
+[3]: ./LICENSE

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+type Unsubscribe = () => void;
+export interface Signal<T> {
+    (): T;
+    set(value: T): void;
+    update(fn: (currentValue: T) => T): void;
+}
+/**
+ * Creates a new reactive state with the provided initial value
+ */
+export declare const state: <T>(initialValue: T) => Signal<T>;
+/**
+ * Creates an effect that runs when its dependencies change
+ */
+export declare const effect: (fn: () => void) => Unsubscribe;
+/**
+ * Creates a derived signal that computes its value from other signals
+ */
+export declare const derived: <T>(fn: () => T) => Signal<T>;
+/**
+ * Batches multiple updates to run effects only once at the end
+ */
+export declare const batch: <T>(fn: () => T) => T;
+export {};

package/dist/index.js

@@ -0,0 +1,129 @@
+// Global state for tracking
+let currentEffect = null;
+let batchDepth = 0;
+const pendingEffects = new Set();
+const subscriberDependencies = new WeakMap();
+// Use a flag to prevent multiple updates from running the effects
+let updateInProgress = false;
+/**
+ * Creates a new reactive state with the provided initial value
+ */
+export const state = (initialValue) => {
+    let value = initialValue;
+    const subscribers = new Set();
+    const read = () => {
+        if (currentEffect) {
+            subscribers.add(currentEffect);
+            let dependencies = subscriberDependencies.get(currentEffect);
+            if (!dependencies) {
+                dependencies = new Set();
+                subscriberDependencies.set(currentEffect, dependencies);
+            }
+            dependencies.add(subscribers);
+        }
+        return value;
+    };
+    const write = (newValue) => {
+        if (Object.is(value, newValue)) {
+            return; // No change
+        }
+        value = newValue;
+        if (subscribers.size === 0) {
+            return;
+        }
+        // Add subscribers to pendingEffects - always use loop for better performance
+        for (const sub of subscribers) {
+            pendingEffects.add(sub);
+        }
+        if (batchDepth === 0 && !updateInProgress) {
+            processEffects();
+        }
+    };
+    const update = (fn) => {
+        write(fn(value));
+    };
+    return Object.assign(read, { set: write, update });
+};
+/**
+ * Process all pending effects, ensuring full propagation through the dependency chain
+ */
+const processEffects = () => {
+    if (pendingEffects.size === 0 || updateInProgress) {
+        return;
+    }
+    updateInProgress = true;
+    while (pendingEffects.size > 0) {
+        const currentEffects = [...pendingEffects];
+        pendingEffects.clear();
+        for (const effect of currentEffects) {
+            effect();
+        }
+    }
+    updateInProgress = false;
+};
+/**
+ * Helper to clean up effect subscriptions
+ */
+const cleanupEffect = (effect) => {
+    const deps = subscriberDependencies.get(effect);
+    if (deps) {
+        for (const subscribers of deps) {
+            subscribers.delete(effect);
+        }
+        deps.clear();
+    }
+};
+/**
+ * Creates an effect that runs when its dependencies change
+ */
+export const effect = (fn) => {
+    const runEffect = () => {
+        cleanupEffect(runEffect);
+        const prevEffect = currentEffect;
+        currentEffect = runEffect;
+        try {
+            fn();
+        }
+        finally {
+            currentEffect = prevEffect;
+        }
+    };
+    runEffect();
+    return () => {
+        cleanupEffect(runEffect);
+    };
+};
+/**
+ * Creates a derived signal that computes its value from other signals
+ */
+export const derived = (fn) => {
+    // Initialize signal with the computed value
+    const signal = state(fn());
+    // Only run fn() again when dependencies change
+    effect(() => {
+        signal.set(fn());
+    });
+    return signal;
+};
+/**
+ * Batches multiple updates to run effects only once at the end
+ */
+export const batch = (fn) => {
+    batchDepth++;
+    try {
+        return fn();
+    }
+    catch (error) {
+        if (batchDepth === 1) {
+            pendingEffects.clear();
+        }
+        throw error;
+    }
+    finally {
+        batchDepth--;
+        if (batchDepth === 0 && pendingEffects.size > 0) {
+            processEffects();
+        }
+    }
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

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

package/package.json

@@ -0,0 +1,58 @@
+{
+	"name": "@nerdalytics/beacon",
+	"version": "1.0.0",
+	"description": "A lightweight reactive signal library for Node.js backends. Enables reactive state management with automatic dependency tracking and efficient updates for server-side applications.",
+	"type": "module",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"files": [
+		"dist/",
+		"src/",
+		"LICENSE"
+	],
+	"scripts": {
+		"test": "node --test --experimental-config-file=node.config.json \"test/**/*.test.ts\"",
+		"test:coverage": "node --test --experimental-config-file=node.config.json --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=lcov.info \"test/**/*.test.ts\"",
+		"test:unit": "node --test --experimental-config-file=node.config.json --test-name-pattern=\"/^(State|Derived|Effect|Batch|Cleanup|Cyclic Dependencies)$/\"",
+		"test:unit:state": "node --test --experimental-config-file=node.config.json --test-name-pattern=\"/^State$/\"",
+		"test:unit:derived": "node --test --experimental-config-file=node.config.json --test-name-pattern=\"/^Derived$/\"",
+		"test:unit:effect": "node --test --experimental-config-file=node.config.json --test-name-pattern=\"/^Effect$/\"",
+		"test:unit:batch": "node --test --experimental-config-file=node.config.json --test-name-pattern=\"/^Batch$/\"",
+		"test:unit:cleanup": "node --test --experimental-config-file=node.config.json --test-name-pattern=\"/^Cleanup$/\"",
+		"test:unit:cyclic": "node --test --experimental-config-file=node.config.json --test-name-pattern=\"/^Cyclic Dependencies$/\"",
+		"test:integration": "node --test --experimental-config-file=node.config.json --test-name-pattern=\"/^Deep Dependency Chains$/\"",
+		"test:perf": "node --test --experimental-config-file=node.config.json --test-name-pattern=\"/^Performance$/\"",
+		"test:perf:update-docs": "node scripts/update-performance-docs.ts",
+		"format": "biome format --write .",
+		"prebuild": "rm -rf dist/",
+		"build": "npm run build:lts",
+		"build:lts": "tsc -p tsconfig.build.json",
+		"prepublishOnly": "npm run build"
+	},
+	"keywords": [
+		"reactive",
+		"signals",
+		"state-management",
+		"nodejs",
+		"typescript",
+		"reactive-programming",
+		"dependency-tracking",
+		"esm",
+		"observable",
+		"backend",
+		"server-side",
+		"computed-values",
+		"effects",
+		"batching"
+	],
+	"author": "Denny Trebbin",
+	"license": "MIT",
+	"devDependencies": {
+		"@biomejs/biome": "1.9.4",
+		"@types/node": "22.13.16",
+		"typescript": "5.8.2"
+	},
+	"engines": {
+		"node": ">=20.0.0"
+	}
+}

package/src/index.ts

@@ -0,0 +1,175 @@
+// Types
+type Subscriber = () => void
+
+type Unsubscribe = () => void
+
+export interface Signal<T> {
+	(): T // get value
+	set(value: T): void // set value directly
+	update(fn: (currentValue: T) => T): void // update value with a function
+}
+
+// Global state for tracking
+let currentEffect: Subscriber | null = null
+
+let batchDepth = 0
+
+const pendingEffects = new Set<Subscriber>()
+
+const subscriberDependencies = new WeakMap<Subscriber, Set<Set<Subscriber>>>()
+
+// Use a flag to prevent multiple updates from running the effects
+let updateInProgress = false
+
+/**
+ * Creates a new reactive state with the provided initial value
+ */
+export const state = <T>(initialValue: T): Signal<T> => {
+	let value = initialValue
+
+	const subscribers = new Set<Subscriber>()
+
+	const read = (): T => {
+		if (currentEffect) {
+			subscribers.add(currentEffect)
+
+			let dependencies = subscriberDependencies.get(currentEffect)
+
+			if (!dependencies) {
+				dependencies = new Set()
+
+				subscriberDependencies.set(currentEffect, dependencies)
+			}
+
+			dependencies.add(subscribers)
+		}
+
+		return value
+	}
+
+	const write = (newValue: T): void => {
+		if (Object.is(value, newValue)) {
+			return // No change
+		}
+		value = newValue
+
+		if (subscribers.size === 0) {
+			return
+		}
+
+		// Add subscribers to pendingEffects - always use loop for better performance
+		for (const sub of subscribers) {
+			pendingEffects.add(sub)
+		}
+
+		if (batchDepth === 0 && !updateInProgress) {
+			processEffects()
+		}
+	}
+
+	const update = (fn: (currentValue: T) => T): void => {
+		write(fn(value))
+	}
+
+	return Object.assign(read, { set: write, update })
+}
+
+/**
+ * Process all pending effects, ensuring full propagation through the dependency chain
+ */
+const processEffects = (): void => {
+	if (pendingEffects.size === 0 || updateInProgress) {
+		return
+	}
+
+	updateInProgress = true
+
+	while (pendingEffects.size > 0) {
+		const currentEffects = [...pendingEffects]
+		pendingEffects.clear()
+
+		for (const effect of currentEffects) {
+			effect()
+		}
+	}
+
+	updateInProgress = false
+}
+
+/**
+ * Helper to clean up effect subscriptions
+ */
+const cleanupEffect = (effect: Subscriber): void => {
+	const deps = subscriberDependencies.get(effect)
+
+	if (deps) {
+		for (const subscribers of deps) {
+			subscribers.delete(effect)
+		}
+
+		deps.clear()
+	}
+}
+
+/**
+ * Creates an effect that runs when its dependencies change
+ */
+export const effect = (fn: () => void): Unsubscribe => {
+	const runEffect = (): void => {
+		cleanupEffect(runEffect)
+
+		const prevEffect = currentEffect
+
+		currentEffect = runEffect
+
+		try {
+			fn()
+		} finally {
+			currentEffect = prevEffect
+		}
+	}
+
+	runEffect()
+
+	return (): void => {
+		cleanupEffect(runEffect)
+	}
+}
+
+/**
+ * Creates a derived signal that computes its value from other signals
+ */
+export const derived = <T>(fn: () => T): Signal<T> => {
+	// Initialize signal with the computed value
+	const signal = state<T>(fn())
+
+	// Only run fn() again when dependencies change
+	effect((): void => {
+		signal.set(fn())
+	})
+
+	return signal
+}
+
+/**
+ * Batches multiple updates to run effects only once at the end
+ */
+export const batch = <T>(fn: () => T): T => {
+	batchDepth++
+
+	try {
+		return fn()
+	} catch (error) {
+		if (batchDepth === 1) {
+			pendingEffects.clear()
+		}
+
+		throw error
+	} finally {
+		batchDepth--
+
+		if (batchDepth === 0 && pendingEffects.size > 0) {
+			processEffects()
+		}
+	}
+}