preact-sigma 6.1.1 → 6.1.3

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { a as SigmaState, c as query, d as Draft, f as Immutable, i as SigmaRef, l as setAutoFreeze, m as Cleanup, n as Sigma, o as SigmaTarget, p as typeSymbol, r as SigmaDefinition, s as castProtected, t as Protected, u as sigma } from "./sigma-c48-qjsH.mjs";
+import { a as SigmaState, c as query, d as Draft, f as Immutable, i as SigmaRef, l as setAutoFreeze, m as Cleanup, n as Sigma, o as SigmaTarget, p as typeSymbol, r as SigmaDefinition, s as castProtected, t as Protected, u as sigma } from "./sigma-Dki3T7re.mjs";
 
 //#region src/defaults.d.ts
 /**

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { a as setAutoFreeze, c as listenersSymbol, i as query, n as SigmaTarget, o as sigma, r as castProtected, t as Sigma } from "./sigma-0X8yJrUR.mjs";
+import { a as setAutoFreeze, c as listenersSymbol, i as query, n as SigmaTarget, o as sigma, r as castProtected, t as Sigma } from "./sigma-Oviv0rzP.mjs";
 import { useEffect, useRef } from "preact/hooks";
 //#region src/defaults.ts
 /**

package/dist/persist.d.mts

@@ -1,4 +1,4 @@
-import { f as Immutable, n as Sigma, t as Protected } from "./sigma-c48-qjsH.mjs";
+import { f as Immutable, n as Sigma, t as Protected } from "./sigma-Dki3T7re.mjs";
 
 //#region src/persist.d.ts
 type MaybePromise<T> = T | Promise<T>;

package/dist/persist.mjs

@@ -1,4 +1,4 @@
-import { o as sigma, s as isPlainObject } from "./sigma-0X8yJrUR.mjs";
+import { o as sigma, s as isPlainObject } from "./sigma-Oviv0rzP.mjs";
 //#region src/persist.ts
 function createIdentityCodec() {
 	return {

package/dist/{sigma-c48-qjsH.d.mts → sigma-Dki3T7re.d.mts}

@@ -88,6 +88,7 @@ type SigmaState<T extends SigmaDefinition> = Sigma<T["state"]> & {
  * Base class for signal-backed state models.
  *
  * `TState` is the source of typing for top-level state keys, subscriptions, signals, and replacement snapshots.
+ * The initial state passed to `super(...)` can use either the mutable `TState` shape or an immutable snapshot.
  * Private class fields stay ordinary instance storage and are not signal-backed, captured,
  * persisted, or used for reactive invalidation by themselves.
  * Merge a same-named interface with the class when direct property reads should be typed on the instance.
@@ -99,7 +100,7 @@ declare abstract class Sigma<TState extends object> {
   };
   [snapshotSymbol]: Record<string, unknown> | undefined;
   protected get [instanceSymbol](): this;
-  constructor(initialState: TState);
+  constructor(initialState: TState | Immutable<TState>);
   /** Optional setup hook that owns side effects and returns cleanup resources. */
   onSetup?(...args: any[]): readonly AnyResource[];
   /** Runs `onSetup(...)` and returns a cleanup that disposes returned resources in reverse order. */
@@ -127,7 +128,7 @@ declare class SigmaTarget<TEvents extends object = {}, TState extends object = {
     events: TEvents;
   };
   protected [listenersSymbol]: SigmaListenerMap;
-  constructor(state?: TState);
+  constructor(state?: TState | Immutable<TState>);
   /**
    * Emits a typed event.
    *
@@ -149,8 +150,8 @@ declare const sigma: Readonly<{
     <TState extends object, TKey extends Extract<keyof TState, string>>(instance: Sigma<TState>, key: TKey, listener: (value: Immutable<TState[TKey]>) => void): Cleanup;
   }; /** Returns the readonly signal backing one top-level state key. */
   getSignal<TState extends object, TKey extends Extract<keyof TState, string>>(instance: Sigma<TState>, key: TKey): ReadonlySignal<Immutable<TState[TKey]>>; /** Captures the current committed top-level state snapshot. */
-  captureState<TState extends object>(instance: Sigma<TState>): Immutable<TState>; /** Publishes a plain-object snapshot as the current committed state. */
-  replaceState<TState extends object>(target: Sigma<TState>, nextState: TState): void;
+  captureState<TState extends object>(instance: Sigma<TState>): Immutable<TState>; /** Publishes a plain-object snapshot, including readonly captured snapshots, as committed state. */
+  replaceState<TState extends object>(target: Sigma<TState>, nextState: TState | Immutable<TState>): void;
 }>;
 /**
  * Marks a class method as a committed-state reactive read with arguments instead of an action.

package/dist/{sigma-0X8yJrUR.mjs → sigma-Oviv0rzP.mjs}

@@ -322,6 +322,7 @@ function defineSignalProperty(instance, key, value) {
 * Base class for signal-backed state models.
 *
 * `TState` is the source of typing for top-level state keys, subscriptions, signals, and replacement snapshots.
+* The initial state passed to `super(...)` can use either the mutable `TState` shape or an immutable snapshot.
 * Private class fields stay ordinary instance storage and are not signal-backed, captured,
 * persisted, or used for reactive invalidation by themselves.
 * Merge a same-named interface with the class when direct property reads should be typed on the instance.
@@ -333,8 +334,9 @@ var Sigma = class {
 	constructor(initialState) {
 		initializeType(this.constructor);
 		if (initialState === emptySentinel) return;
-		for (const key in initialState) {
-			const initialValue = initialState[key];
+		const state = initialState;
+		for (const key in state) {
+			const initialValue = state[key];
 			if (autoFreezeEnabled) freeze(initialValue, true);
 			defineSignalProperty(this, key, initialValue);
 		}
@@ -443,12 +445,13 @@ const sigma = /* @__PURE__ */ Object.freeze({
 		if (activeDraft) throw new Error(`[preact-sigma] replaceState() cannot run while an action has unpublished changes.`);
 		const instance = getActionInstance(target);
 		const baseState = createSnapshot(instance);
-		if (!hasStateChanges(baseState, nextState)) return;
-		const { inversePatches, patches } = hasPatchListeners(instance) ? createReplacementPatches(baseState, nextState) : {
+		const replacement = nextState;
+		if (!hasStateChanges(baseState, replacement)) return;
+		const { inversePatches, patches } = hasPatchListeners(instance) ? createReplacementPatches(baseState, replacement) : {
 			inversePatches: void 0,
 			patches: void 0
 		};
-		publishState(instance, nextState, baseState, patches, inversePatches);
+		publishState(instance, replacement, baseState, patches, inversePatches);
 	}
 });
 /**

package/docs/persist.md

@@ -56,7 +56,7 @@ Use the persist module when those primitives are the right boundary, but you do
 ## Constraints
 
 - Persistence helpers are trusted external model owners. Restore and hydrate helpers may replace committed state even when they receive a protected consumer view.
-- `sigma.replaceState(...)` requires a plain object replacement snapshot. In supported TypeScript usage, pass the class's full `TState` shape.
+- `sigma.replaceState(...)` requires a plain object replacement snapshot. In supported TypeScript usage, pass the class's full `TState` or `Immutable<TState>` shape.
 - Custom partial persistence codecs should reconstruct a full replacement snapshot before restore finishes.
 - Nested sigma-state values are stored only if the chosen codec and payload format support them explicitly.
 - Async restore failures reject through `restore(...)` or the `restored` promise from `hydrate(...)`.

package/package.json

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