preact-sigma 2.2.0 → 2.2.2

package/README.md

@@ -1,60 +1,168 @@
 # preact-sigma
 
-`preact-sigma` is a typed state-model builder for apps that want Preact's fine-grained reactivity, Immer-backed writes, and explicit lifecycle.
+`preact-sigma` lets you define state once and reuse it as a model.
 
-You define a reusable state type once, then create instances wherever they make sense: inside components, in shared modules, or in plain TypeScript code. Each instance exposes readonly public state, tracked derived reads, imperative actions, and optional setup and event APIs.
+It is built for Preact and TypeScript, and combines:
 
-## Getting Started
+- fine-grained reactive reads
+- Immer-style writes
+- explicit setup and cleanup
+- typed events
+- a constructor you can instantiate anywhere
 
-To add `preact-sigma` to your project:
+Use it when your state has started to feel like more than "some values in a component."
+
+Instead of spreading logic across loose signals, reducers, effects, and cleanup code, you define one model with:
+
+- top-level state
+- derived reads
+- write methods
+- side-effect setup
+- optional events
+
+Then you create instances wherever they make sense: inside a component, in a shared module, or in plain TypeScript.
+
+Under the hood, each top-level state property is backed by its own Preact signal, while writes happen through actions with Immer-backed mutation semantics.
+
+## Why you would use it
+
+`preact-sigma` is a good fit when you want state and behavior to live together.
+
+It is especially useful when you need to:
+
+- keep state, derived values, mutations, and lifecycle in one place
+- create multiple instances of the same state model
+- expose readonly public state while keeping writes explicit
+- get fine-grained reactivity without wiring together a pile of loose signals
+- own timers, subscriptions, listeners, or nested setup with clear cleanup
+
+If a couple of plain signals are enough, use plain signals.  
+`preact-sigma` is for the point where state starts acting like a small system.
+
+## Install
 
 ```bash
 npm install preact-sigma
 ```
 
-If you use AI coding agents, this repo also includes agent-oriented guidance:
+## 30-second example
 
-- [llms.txt](./llms.txt) provides a compact overview of the API and recommended patterns.
-- Companion skills are available via `npx skills add alloc/preact-sigma`.
+```ts
+import { SigmaType } from "preact-sigma";
+
+const Counter = new SigmaType<{ count: number }>()
+  .defaultState({
+    count: 0,
+  })
+  .computed({
+    doubled() {
+      return this.count * 2;
+    },
+  })
+  .actions({
+    increment() {
+      this.count += 1;
+    },
+  });
+
+const counter = new Counter();
+
+counter.increment();
+
+console.log(counter.count); // 1
+console.log(counter.doubled); // 2
+```
+
+That example shows the basic shape:
+
+- state is public and reactive
+- derived values live in `computed(...)`
+- writes happen in `actions(...)`
+- an instance behaves like a small stateful object
+
+## The mental model
+
+A sigma model is made from a few simple pieces.
+
+### `defaultState(...)`
+
+Defines the top-level state for each instance.
+
+Each top-level property becomes a reactive public property on the instance.
+
+Use plain values for simple defaults, or zero-argument functions when each instance needs a fresh object or array.
+
+### `computed(...)`
+
+Use computeds for derived values that take no arguments.
+
+They behave like tracked getters:
+
+```ts
+.completedCount() // no
+todoList.completedCount // yes
+```
+
+### `queries(...)`
+
+Use queries for reactive reads that need arguments.
+
+```ts
+visibleTodos("open");
+```
+
+Queries are for reading, not writing.
+
+### `actions(...)`
 
-## What It Is
+Actions are where state changes happen.
 
-At its core, `preact-sigma` lets you describe a stateful model as a constructor:
+Outside an action, public state is readonly. Inside an action, you write with normal mutation syntax and sigma handles the draft/update flow for you.
 
-- top-level state stays reactive through one signal per state property
-- computed values become tracked getters
-- queries become tracked methods, including queries with arguments
-- actions batch reads and writes through Immer drafts
-- setup handlers own side effects and cleanup
-- typed events let instances notify the outside world without exposing mutable internals
+```ts
+.actions({
+  rename(title: string) {
+    this.title = title;
+  },
+})
+```
+
+### `setup(...)`
 
-The result feels like a small stateful object from application code, while still behaving like signal-driven state from rendering code.
+Setup is where side effects belong.
 
-## What You Can Do With It
+Use it for things like:
 
-`preact-sigma` is useful when you want state logic to live in one reusable unit instead of being split across loose signals, reducers, and effect cleanup code.
+- timers
+- event listeners
+- subscriptions
+- nested model setup
+- storage sync
 
-With it, you can:
+Setup is explicit. A new instance does not automatically run setup. When setup does run, it returns one cleanup function that tears down everything that instance owns.
 
-- model domain state as reusable constructors instead of one-off store objects
-- read public state directly while keeping writes inside typed action methods
-- derive reactive values with computed getters and parameterized queries
-- publish state changes from synchronous or async actions
-- observe committed state changes and optional Immer patches
-- snapshot committed top-level state and replace committed state for undo-like flows
-- manage timers, listeners, nested state setup, and teardown through explicit cleanup
-- use the same model inside Preact components with `useSigma(...)` and `useListener(...)`
+### Events
 
-## Why This Shape Exists
+Use events when the model needs to notify the outside world without exposing mutable internals.
+
+Emit inside actions or setup:
+
+```ts
+this.emit("saved", { count: 3 });
+```
 
-This package exists to keep stateful logic cohesive without giving up signal-level reactivity.
+Listen from the outside:
 
-It is a good fit when plain signals start to sprawl across modules, but heavier store abstractions feel too opaque or too tied to component structure. `preact-sigma` keeps the "model object" ergonomics of a class-like API, while preserving readonly public reads, explicit write boundaries, and explicit ownership of side effects.
+```ts
+const stop = instance.on("saved", ({ count }) => {
+  console.log(count);
+});
+```
 
-## Big Picture Example
+## A more realistic example
 
 ```ts
-import { computed, SigmaType } from "preact-sigma";
+import { SigmaType } from "preact-sigma";
 
 type Todo = {
   id: string;
@@ -65,20 +173,18 @@ type Todo = {
 const TodoList = new SigmaType<
   { draft: string; todos: Todo[]; saving: boolean },
   { saved: { count: number } }
->("TodoList")
+>()
   .defaultState({
     draft: "",
     todos: [],
     saving: false,
   })
   .computed({
-    // Computeds are tracked getters with no arguments.
     remainingCount() {
       return this.todos.filter((todo) => !todo.done).length;
     },
   })
   .queries({
-    // Queries stay reactive at the call site and can accept arguments.
     visibleTodos(filter: "all" | "open" | "done") {
       return this.todos.filter((todo) => {
         if (filter === "open") return !todo.done;
@@ -88,7 +194,6 @@ const TodoList = new SigmaType<
     },
   })
   .actions({
-    // Public state is readonly, so writes live in actions.
     setDraft(draft: string) {
       this.draft = draft;
     },
@@ -100,6 +205,7 @@ const TodoList = new SigmaType<
         title: this.draft,
         done: false,
       });
+
       this.draft = "";
     },
     toggleTodo(id: string) {
@@ -108,7 +214,7 @@ const TodoList = new SigmaType<
     },
     async save() {
       this.saving = true;
-      this.commit(); // Publish the loading state before awaiting.
+      this.commit(); // publish "saving" before awaiting
 
       await fetch("/api/todos", {
         method: "POST",
@@ -116,12 +222,11 @@ const TodoList = new SigmaType<
       });
 
       this.saving = false;
-      this.commit(); // Publish post-await writes explicitly.
+      this.commit(); // publish before emitting
       this.emit("saved", { count: this.todos.length });
     },
   })
   .setup(function (storageKey: string) {
-    // Setup is explicit and returns cleanup resources.
     const interval = window.setInterval(() => {
       localStorage.setItem(storageKey, JSON.stringify(this.todos));
     }, 1000);
@@ -130,44 +235,93 @@ const TodoList = new SigmaType<
   });
 
 const todoList = new TodoList();
-
-// setup(...) returns one cleanup function for everything this instance owns.
 const cleanup = todoList.setup("todos-demo");
 
-// Queries are reactive where they are read.
-const firstOpenTitle = computed(() => {
-  return todoList.visibleTodos("open")[0]?.title ?? "Nothing open";
-});
-
-// Events are typed and unsubscribe cleanly.
 const stop = todoList.on("saved", ({ count }) => {
   console.log(`Saved ${count} todos`);
 });
 
-todoList.setDraft("Write the README");
+todoList.setDraft("Rewrite the README");
 todoList.addTodo();
-await todoList.save();
 
 console.log(todoList.remainingCount);
-console.log(firstOpenTitle.value);
+console.log(todoList.visibleTodos("open"));
+
+await todoList.save();
 
 stop();
 cleanup();
 ```
 
-In Preact, the same constructor can be used with `useSigma(() => new TodoList(), ["todos-demo"])` so the component owns one instance and `setup(...)` cleanup runs automatically. Use `useListener(...)` when you want component-scoped event subscriptions with automatic teardown.
+## The one rule to remember about actions
+
+For normal synchronous actions, mutate state and return. You usually do **not** need `this.commit()`.
+
+Use `this.commit()` when you have unpublished changes and the action is about to cross a boundary like:
+
+- `await`
+- `emit(...)`
+- another action boundary that should not keep using the current draft
+
+In practice, that means:
+
+- sync action with no boundary: mutate and return
+- async action before `await`: `commit()` if you want those changes published first
+- action before `emit(...)`: `commit()` if there are pending changes
+
+That rule is the main thing to learn beyond the basic API.
+
+## In Preact
+
+`preact-sigma` works outside components, but it also has a nice component story.
+
+Use `useSigma(...)` when the component should own one instance:
+
+```ts
+import { useSigma } from "preact-sigma";
+
+const todoList = useSigma(() => new TodoList(), ["todos-demo"]);
+```
+
+If the model defines setup handlers, `useSigma(...)` runs setup for that component-owned instance and cleans it up automatically when setup params change or the component unmounts.
 
-Cleanup resources can be returned as functions, `AbortController`, objects with `dispose()`, or objects with `Symbol.dispose`.
+Use `useListener(...)` for component-scoped event subscriptions:
 
-Inside setup, `this` exposes the public instance plus `emit(...)` and `act(fn)`. Use `this.act(function () { ... })` when setup needs one synchronous anonymous action with normal draft, `commit()`, and `emit(...)` semantics, whether that work happens immediately in the setup body or later from a setup-owned callback, but should not become a public action method.
+```ts
+import { useListener } from "preact-sigma";
 
-## Best Practices
+useListener(todoList, "saved", ({ count }) => {
+  console.log(`Saved ${count} todos`);
+});
+```
 
-- Let `new SigmaType<TState, TEvents>()` and the builder inputs drive inference. Avoid forcing extra type arguments onto builder methods.
-- Keep top-level state properties meaningful. Each top-level property gets its own signal, so shape state around the reads you want to track.
-- Use `computed(...)` for argument-free derived state, and use queries for reactive reads that need parameters.
-- Put writes in actions. A draft boundary is any point where sigma cannot keep reusing the current draft. `emit()`, `await`, and any action call other than a same-instance sync nested action call are draft boundaries, so call `this.commit()` before those boundaries when pending writes should become public. Setup can use `this.act(function () { ... })` to run one synchronous anonymous action for initialization work or setup-owned callbacks without adding a public action method.
-- Use `snapshot(instance)` and `replaceState(instance, snapshot)` for committed-state replay. They work on top-level state keys and stay outside action semantics.
-- Use `SigmaRef<T>` when a value should stay by reference in sigma's `Draft` and `Immutable` types. A normal assignment to a `SigmaRef<T>`-typed value only changes typing and does not change Immer's runtime drafting or freezing behavior.
-- Use `immerable` on custom classes only when they should participate in Immer drafting. `setAutoFreeze(false)` disables sigma's runtime deep-freezing when you need published state to stay unfrozen.
-- Use `setup(...)` for owned side effects, and always return cleanup resources for anything the instance starts.
+## What you get out of the box
+
+Beyond the core model API, `preact-sigma` also includes:
+
+- `observe(...)` for reacting to committed state changes
+- optional Immer patch delivery in observers
+- `snapshot(...)` and `replaceState(...)` for restore/undo-like flows
+- `get(key)` when you need direct signal access for a state key or computed
+
+## Why this shape exists
+
+`preact-sigma` exists for the space between two extremes:
+
+- **too small for a big store abstraction**
+- **too stateful for a handful of loose signals**
+
+It keeps the ergonomics of working with a model object, while preserving:
+
+- readonly public reads
+- explicit write boundaries
+- fine-grained reactivity
+- explicit ownership of side effects
+
+That makes it useful for app state that has real behavior, not just values.
+
+## More docs
+
+- [`llms.txt`](./llms.txt) contains the exhaustive API and behavior reference.
+- Companion skills are available via `npx skills add alloc/preact-sigma`.
+- The `preact-sigma` skill packages procedural guidance and agent-oriented workflow for the library.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "preact-sigma",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "keywords": [],
   "license": "MIT",
   "author": "Alec Larson",