preact-sigma 6.1.2 → 6.1.4

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-CfLLgWDX.mjs";
+import { a as SigmaRef, c as castProtected, d as sigma, f as Draft, h as Cleanup, i as SigmaDefinition, l as query, m as typeSymbol, n as ReadableSigma, o as SigmaState, p as Immutable, r as Sigma, s as SigmaTarget, t as Protected, u as setAutoFreeze } from "./sigma-BfaJUPWw.mjs";
 
 //#region src/defaults.d.ts
 /**
@@ -58,4 +58,4 @@ type UseSigmaArgs<T extends Sigma<any>> = T extends {
  */
 declare function useSigma<T extends Sigma<any>>(...args: UseSigmaArgs<T>): Protected<T>;
 //#endregion
-export { type Draft, type Immutable, InferEventType, InferListener, Listenable, Protected, Sigma, SigmaDefinition, SigmaListenable, SigmaRef, SigmaState, SigmaTarget, UseSigmaArgs, UseSigmaOptions, castProtected, listen, mergeDefaults, query, setAutoFreeze, sigma, useListener, useSigma };
+export { type Draft, type Immutable, InferEventType, InferListener, Listenable, Protected, ReadableSigma, Sigma, SigmaDefinition, SigmaListenable, SigmaRef, SigmaState, SigmaTarget, UseSigmaArgs, UseSigmaOptions, castProtected, listen, mergeDefaults, query, setAutoFreeze, sigma, useListener, useSigma };

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-yp6KR1lk.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-DEKK3bHd.mjs";
 import { useEffect, useRef } from "preact/hooks";
 //#region src/defaults.ts
 /**

package/dist/persist.d.mts

@@ -1,13 +1,7 @@
-import { f as Immutable, n as Sigma, t as Protected } from "./sigma-CfLLgWDX.mjs";
+import { n as ReadableSigma, p as Immutable, r as Sigma } from "./sigma-BfaJUPWw.mjs";
 
 //#region src/persist.d.ts
 type MaybePromise<T> = T | Promise<T>;
-/**
- * Sigma instance or protected consumer view accepted by persistence helpers.
- *
- * Restore and hydrate helpers may replace committed state through this trusted owner boundary.
- */
-type PersistInstance<TState extends object> = Sigma<TState> | Protected<Sigma<TState>>;
 /** Decode-time context passed to persistence codecs. */
 interface PersistDecodeContext<TState extends object> {
   /** Storage key used to read the record being decoded. */
@@ -114,19 +108,19 @@ interface SyncHydrationHandle extends PersistenceHandle {
   readonly restored: RestoreResult;
 }
 /** Restores committed state from a persisted record through an async store. */
-declare function restore<TState extends object, TKey extends keyof TState>(instance: PersistInstance<TState>, options: PickPersistOptions<TState, TKey>): Promise<RestoreResult>;
-declare function restore<TState extends object, TStored = Immutable<TState>>(instance: PersistInstance<TState>, options: PersistOptions<TState, TStored>): Promise<RestoreResult>;
+declare function restore<TState extends object, TKey extends keyof TState>(instance: ReadableSigma<TState>, options: PickPersistOptions<TState, TKey>): Promise<RestoreResult>;
+declare function restore<TState extends object, TStored = Immutable<TState>>(instance: ReadableSigma<TState>, options: PersistOptions<TState, TStored>): Promise<RestoreResult>;
 /** Restores committed state from a persisted record through a sync store. */
-declare function restoreSync<TState extends object, TKey extends keyof TState>(instance: PersistInstance<TState>, options: SyncPickPersistOptions<TState, TKey>): RestoreResult;
-declare function restoreSync<TState extends object, TStored = Immutable<TState>>(instance: PersistInstance<TState>, options: SyncPersistOptions<TState, TStored>): RestoreResult;
+declare function restoreSync<TState extends object, TKey extends keyof TState>(instance: ReadableSigma<TState>, options: SyncPickPersistOptions<TState, TKey>): RestoreResult;
+declare function restoreSync<TState extends object, TStored = Immutable<TState>>(instance: ReadableSigma<TState>, options: SyncPersistOptions<TState, TStored>): RestoreResult;
 /** Persists future committed state changes for one sigma instance. */
-declare function persist<TState extends object, TKey extends keyof TState>(instance: PersistInstance<TState>, options: PickPersistOptions<TState, TKey>): PersistenceHandle;
-declare function persist<TState extends object, TStored = Immutable<TState>>(instance: PersistInstance<TState>, options: PersistOptions<TState, TStored>): PersistenceHandle;
+declare function persist<TState extends object, TKey extends keyof TState>(instance: ReadableSigma<TState>, options: PickPersistOptions<TState, TKey>): PersistenceHandle;
+declare function persist<TState extends object, TStored = Immutable<TState>>(instance: ReadableSigma<TState>, options: PersistOptions<TState, TStored>): PersistenceHandle;
 /** Restores state, then begins persisting future committed changes. */
-declare function hydrate<TState extends object, TKey extends keyof TState>(instance: PersistInstance<TState>, options: PickPersistOptions<TState, TKey>): HydrationHandle;
-declare function hydrate<TState extends object, TStored = Immutable<TState>>(instance: PersistInstance<TState>, options: PersistOptions<TState, TStored>): HydrationHandle;
+declare function hydrate<TState extends object, TKey extends keyof TState>(instance: ReadableSigma<TState>, options: PickPersistOptions<TState, TKey>): HydrationHandle;
+declare function hydrate<TState extends object, TStored = Immutable<TState>>(instance: ReadableSigma<TState>, options: PersistOptions<TState, TStored>): HydrationHandle;
 /** Restores state synchronously, then begins persisting future committed changes. */
-declare function hydrateSync<TState extends object, TKey extends keyof TState>(instance: PersistInstance<TState>, options: SyncPickPersistOptions<TState, TKey>): SyncHydrationHandle;
-declare function hydrateSync<TState extends object, TStored = Immutable<TState>>(instance: PersistInstance<TState>, options: SyncPersistOptions<TState, TStored>): SyncHydrationHandle;
+declare function hydrateSync<TState extends object, TKey extends keyof TState>(instance: ReadableSigma<TState>, options: SyncPickPersistOptions<TState, TKey>): SyncHydrationHandle;
+declare function hydrateSync<TState extends object, TStored = Immutable<TState>>(instance: ReadableSigma<TState>, options: SyncPersistOptions<TState, TStored>): SyncHydrationHandle;
 //#endregion
 export { HydrationHandle, PersistCodec, PersistDecodeContext, PersistErrorContext, PersistOptions, PersistRecord, PersistSchedule, PersistStore, PersistenceHandle, PickPersistOptions, RestoreResult, SyncHydrationHandle, SyncPersistOptions, SyncPersistStore, SyncPickPersistOptions, hydrate, hydrateSync, persist, restore, restoreSync };

package/dist/persist.mjs

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

package/dist/{sigma-CfLLgWDX.d.mts → sigma-BfaJUPWw.d.mts}

@@ -75,6 +75,7 @@ declare function setAutoFreeze(autoFreeze: boolean): void;
 type SigmaRef<T extends object = {}> = T & {
   [refSymbol]?: true;
 };
+type ReadableSigma<TState extends object> = Sigma<TState> | Protected<Sigma<TState>>;
 /** Definition shape used by helper types that need both state and event maps. */
 type SigmaDefinition = {
   state: object;
@@ -88,6 +89,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 +101,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 +129,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,7 +151,7 @@ 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, including readonly captured snapshots, as committed state. */
+  captureState<TState extends object>(instance: ReadableSigma<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;
 }>;
 /**
@@ -170,4 +172,4 @@ type Protected<T extends Sigma<any>> = BrandProtected<T extends {
   };
 } ? { readonly [K in keyof T as K extends ProtectedKey ? never : K]: K extends typeof typeSymbol ? T[K] : K extends keyof TState ? Immutable<T[K]> : T[K] extends AnyFunction ? (...params: Parameters<T[K]>) => Immutable<ReturnType<T[K]>> : Immutable<T[K]> } : never>;
 //#endregion
-export { SigmaState as a, query as c, Draft as d, Immutable as f, SigmaRef as i, setAutoFreeze as l, Cleanup as m, Sigma as n, SigmaTarget as o, typeSymbol as p, SigmaDefinition as r, castProtected as s, Protected as t, sigma as u };
+export { SigmaRef as a, castProtected as c, sigma as d, Draft as f, Cleanup as h, SigmaDefinition as i, query as l, typeSymbol as m, ReadableSigma as n, SigmaState as o, Immutable as p, Sigma as r, SigmaTarget as s, Protected as t, setAutoFreeze as u };

package/dist/{sigma-yp6KR1lk.mjs → sigma-DEKK3bHd.mjs}

@@ -114,9 +114,11 @@ function getStateSignal(instance, key) {
 	return instance[key + signalSuffix];
 }
 function createSnapshot(instance) {
-	if (instance[snapshotSymbol]) return instance[snapshotSymbol];
+	const source = instance;
+	if (source[snapshotSymbol]) return source[snapshotSymbol];
 	const state = {};
-	for (const key in instance) if (isStateKey(instance, key)) state[key] = getStateSignal(instance, key).value;
+	for (const key in source) if (isStateKey(source, key)) state[key] = getStateSignal(source, key).value;
+	source[snapshotSymbol] = state;
 	return state;
 }
 function createDraft(instance) {
@@ -322,6 +324,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 +336,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);
 		}

package/package.json

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