preact-sigma 3.1.0 → 4.0.0

package/README.md

@@ -7,7 +7,7 @@
 ## Installation
 
 ```bash
-npm install preact-sigma
+npm install preact-sigma @preact/signals immer preact
 ```
 
 ## Quick Example

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import { ReadonlySignal, action, batch, computed, effect, untracked } from "@preact/signals";
-import { Immutable, Patch, freeze, immerable } from "immer";
+import { ReadonlySignal } from "@preact/signals";
+import { Patch } from "immer";
 
 //#region src/internal/symbols.d.ts
 declare const signalPrefix = "#";
@@ -83,7 +83,7 @@ type Draft<T> = T extends PrimitiveType ? T : T extends AtomicObject ? T : HasSi
  *
  * Use this instead of `immer.Immutable`
  */
-type Immutable$1<T> = T extends PrimitiveType ? T : T extends AtomicObject ? T : HasSigmaRefBrand<T> extends true ? T : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<Immutable$1<K>, Immutable$1<V>> : T extends ReadonlySet<infer V> ? ReadonlySet<Immutable$1<V>> : T extends WeakReferences ? T : T extends object ? { readonly [K in keyof T]: Immutable$1<T[K]> } : T;
+type Immutable<T> = T extends PrimitiveType ? T : T extends AtomicObject ? T : HasSigmaRefBrand<T> extends true ? T : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<Immutable<K>, Immutable<V>> : T extends ReadonlySet<infer V> ? ReadonlySet<Immutable<V>> : T extends WeakReferences ? T : T extends object ? { readonly [K in keyof T]: Immutable<T[K]> } : T;
 //#endregion
 //#region src/internal/types.d.ts
 type Def = typeof sigmaTypeBrand;
@@ -110,13 +110,13 @@ type AnyState = Record<string, unknown>;
 type AnyDefaultState<TState extends object> = { [K in keyof TState]?: DefaultStateValue<TState[K]> };
 /** A cleanup resource supported by `.setup(...)`, including function, `dispose()`, and `Symbol.dispose` cleanup. */
 type AnyResource = Cleanup | Disposable | DisposableLike | AbortController;
-type ComputedValues<TComputeds> = { readonly [K in keyof TComputeds]: TComputeds[K] extends AnyFunction ? Immutable$1<ReturnType<TComputeds[K]>> : never };
+type ComputedValues<TComputeds> = { readonly [K in keyof TComputeds]: TComputeds[K] extends AnyFunction ? Immutable<ReturnType<TComputeds[K]>> : never };
 type QueryMethods<TQueries> = { [K in keyof TQueries]: TQueries[K] extends AnyFunction ? (...args: Parameters<TQueries[K]>) => ReturnType<TQueries[K]> : never };
 type ActionMethods<TActions> = { [K in keyof TActions]: TActions[K] extends AnyFunction ? (...args: Parameters<TActions[K]>) => ReturnType<TActions[K]> : never };
 type MergeObjects<TLeft, TRight, TConstraint extends object = object> = TRight extends TConstraint ? TLeft extends TConstraint ? Simplify<Omit<TLeft, keyof TRight> & TRight> : TRight : TLeft extends TConstraint ? TLeft : {};
 type Simplify<T> = {} & { [K in keyof T]: T[K] };
-type ComputedContext<T extends AnySigmaType, TOverrides extends Partial<SigmaDefinition> = {}> = Simplify<Immutable$1<MergeObjects<T[Def]["state"], TOverrides["state"]>> & ComputedValues<MergeObjects<T[Def]["computeds"], TOverrides["computeds"]>>>;
-type ReadonlyContext<T extends AnySigmaType, TOverrides extends Partial<SigmaDefinition> = {}> = Simplify<Immutable$1<MergeObjects<T[Def]["state"], TOverrides["state"]>> & ComputedValues<MergeObjects<T[Def]["computeds"], TOverrides["computeds"]>> & QueryMethods<MergeObjects<T[Def]["queries"], TOverrides["queries"]>>>;
+type ComputedContext<T extends AnySigmaType, TOverrides extends Partial<SigmaDefinition> = {}> = Simplify<Immutable<MergeObjects<T[Def]["state"], TOverrides["state"]>> & ComputedValues<MergeObjects<T[Def]["computeds"], TOverrides["computeds"]>>>;
+type ReadonlyContext<T extends AnySigmaType, TOverrides extends Partial<SigmaDefinition> = {}> = Simplify<Immutable<MergeObjects<T[Def]["state"], TOverrides["state"]>> & ComputedValues<MergeObjects<T[Def]["computeds"], TOverrides["computeds"]>> & QueryMethods<MergeObjects<T[Def]["queries"], TOverrides["queries"]>>>;
 type Emit<T extends AnySigmaType, TOverrides extends Partial<SigmaDefinition> = {}> = MergeObjects<T[Def]["events"], TOverrides["events"], AnyEvents> extends infer TEvents ? [TEvents] extends [AnyEvents] ? <TEvent extends string & keyof TEvents>(name: TEvent, ...[detail]: EventParameters<TEvents[TEvent]>) => void : never : never;
 type ActionContext<T extends AnySigmaType, TOverrides extends Partial<SigmaDefinition> = {}> = Simplify<Draft<MergeObjects<T[Def]["state"], TOverrides["state"]>> & ComputedValues<MergeObjects<T[Def]["computeds"], TOverrides["computeds"]>> & QueryMethods<MergeObjects<T[Def]["queries"], TOverrides["queries"]>> & ActionMethods<MergeObjects<T[Def]["actions"], TOverrides["actions"]>> & {
   /** Publishes the current action draft immediately so later boundaries use committed state. */commit(): void; /** Emits a typed event from the current action. */
@@ -150,8 +150,8 @@ type SigmaObserveOptions = {
 };
 /** The change object delivered to `.observe(...)` listeners. */
 type SigmaObserveChange<TState extends AnyState, TWithPatches extends boolean = false> = {
-  readonly newState: Immutable$1<TState>;
-  readonly oldState: Immutable$1<TState>;
+  readonly newState: Immutable<TState>;
+  readonly oldState: Immutable<TState>;
 } & (TWithPatches extends true ? {
   readonly inversePatches: readonly Patch[];
   readonly patches: readonly Patch[];
@@ -175,7 +175,7 @@ type EventMethods<TEvents extends AnyEvents | undefined> = [undefined] extends [
 type SetupMethods<TSetupArgs extends any[] | undefined> = [TSetupArgs] extends [undefined] ? never : {
   /** Runs every registered setup handler and returns one cleanup function for the active setup. */setup(...args: Extract<TSetupArgs, any[]>): Cleanup;
 };
-type MapSigmaDefinition<T extends SigmaDefinition> = keyof T extends infer K ? K extends "state" ? Immutable$1<T[K]> & SignalAccessors<Immutable$1<T[K]>> : K extends "computeds" ? ComputedValues<T[K]> & SignalAccessors<ComputedValues<T[K]>> : K extends "queries" ? QueryMethods<T[K]> : K extends "actions" ? ActionMethods<T[K]> : K extends "events" ? EventMethods<T[K]> : K extends "setupArgs" ? SetupMethods<T[K]> : never : never;
+type MapSigmaDefinition<T extends SigmaDefinition> = keyof T extends infer K ? K extends "state" ? Immutable<T[K]> & SignalAccessors<Immutable<T[K]>> : K extends "computeds" ? ComputedValues<T[K]> & SignalAccessors<ComputedValues<T[K]>> : K extends "queries" ? QueryMethods<T[K]> : K extends "actions" ? ActionMethods<T[K]> : K extends "events" ? EventMethods<T[K]> : K extends "setupArgs" ? SetupMethods<T[K]> : never : never;
 type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
 /** The public instance shape produced by a configured sigma type, including signal access inferred from the definition. */
 type SigmaState<T extends SigmaDefinition = SigmaDefinition> = AnySigmaState & Simplify<UnionToIntersection<MapSigmaDefinition<T>>>;
@@ -203,7 +203,7 @@ declare function setAutoFreeze(autoFreeze: boolean): void;
  * referenced values. Its type is inferred from the instance's sigma-state
  * definition.
  */
-declare function snapshot<T extends AnySigmaState>(publicInstance: T): T extends SigmaState<infer TDefinition> ? Immutable$1<TDefinition["state"]> : never;
+declare function snapshot<T extends AnySigmaState>(publicInstance: T): T extends SigmaState<infer TDefinition> ? Immutable<TDefinition["state"]> : never;
 /**
  * Replaces an instance's committed public state from a snapshot object.
  *
@@ -212,7 +212,7 @@ declare function snapshot<T extends AnySigmaState>(publicInstance: T): T extends
  * notifies observers when the committed state changes. Its type is inferred
  * from the instance's sigma-state definition.
  */
-declare function replaceState<T extends AnySigmaState>(publicInstance: T, nextState: T extends SigmaState<infer TDefinition> ? Immutable$1<TDefinition["state"]> : never): void;
+declare function replaceState<T extends AnySigmaState>(publicInstance: T, nextState: T extends SigmaState<infer TDefinition> ? Immutable<TDefinition["state"]> : never): void;
 //#endregion
 //#region src/framework.d.ts
 /** Checks whether a value is an instance created by a configured sigma type. */
@@ -342,4 +342,4 @@ declare function useSigma<T extends AnySigmaState>(create: () => T, setupArgs?:
  */
 declare function useListener<TTarget extends EventTarget | AnySigmaState, TEvent extends InferEventType<TTarget>>(target: TTarget | null, name: TEvent, listener: InferListener<TTarget, TEvent>): void;
 //#endregion
-export { type AnyDefaultState, type AnyEvents, type AnyResource, type AnySigmaState, type AnySigmaStateWithEvents, type AnyState, EventParameters, type Immutable, InferEventType, InferListener, type InferSetupArgs, type SigmaObserveChange, type SigmaObserveOptions, type SigmaRef, type SigmaState, SigmaTarget, SigmaType, action, batch, computed, effect, freeze, immerable, isSigmaState, listen, query, replaceState, reservedKeys, setAutoFreeze, sigmaEventsBrand, sigmaRefBrand, sigmaStateBrand, sigmaTypeBrand, signalPrefix, snapshot, untracked, useListener, useSigma };
+export { type AnyDefaultState, type AnyEvents, type AnyResource, type AnySigmaState, type AnySigmaStateWithEvents, type AnyState, EventParameters, InferEventType, InferListener, type InferSetupArgs, type SigmaObserveChange, type SigmaObserveOptions, type SigmaRef, type SigmaState, SigmaTarget, SigmaType, isSigmaState, listen, query, replaceState, reservedKeys, setAutoFreeze, sigmaEventsBrand, sigmaRefBrand, sigmaStateBrand, sigmaTypeBrand, signalPrefix, snapshot, useListener, useSigma };

package/dist/index.mjs

@@ -1,6 +1,5 @@
-import { action, batch, batch as batch$1, computed, computed as computed$1, effect, signal, untracked, untracked as untracked$1 } from "@preact/signals";
+import { batch, computed, signal, untracked } from "@preact/signals";
 import * as immer from "immer";
-import { freeze, immerable } from "immer";
 import { useEffect, useRef, useState } from "preact/hooks";
 //#region src/internal/context.ts
 const disabledContextOptions = {
@@ -232,7 +231,7 @@ function initializeSigmaInstance(publicInstance, type, initialState) {
 			enumerable: true
 		});
 	}
-	for (const key in type._computeFunctions) Object.defineProperty(publicInstance, "#" + key, { value: computed$1(() => type._computeFunctions[key].call(getContext(instance, "computedReadonly"))) });
+	for (const key in type._computeFunctions) Object.defineProperty(publicInstance, "#" + key, { value: computed(() => type._computeFunctions[key].call(getContext(instance, "computedReadonly"))) });
 	registerSigmaInternals(publicInstance, instance);
 }
 function buildQueryMethod(queryFunction) {
@@ -240,7 +239,7 @@ function buildQueryMethod(queryFunction) {
 		const instance = getSigmaInternals(this);
 		const owner = getContextOwner(this);
 		if (owner) return queryFunction.apply(getContext(owner, "queryDraftAware"), args);
-		return computed$1(() => queryFunction.apply(getContext(instance, "queryCommitted"), args)).value;
+		return computed(() => queryFunction.apply(getContext(instance, "queryCommitted"), args)).value;
 	};
 }
 function buildActionMethod(actionName, actionFn) {
@@ -311,7 +310,7 @@ function runActionInvocation(context, actionName, actionFn, args) {
 	const isAdHocAction = actionName === "act()";
 	const actionIsAsync = isAsyncFunction(actionFn);
 	if (actionIsAsync && isAdHocAction) throw new Error("[preact-sigma] act() callbacks must stay synchronous");
-	return untracked$1(() => {
+	return untracked(() => {
 		let owner;
 		const callerOwner = getContextOwner(context);
 		if (callerOwner && callerOwner.instance === instance && !actionIsAsync) owner = callerOwner;
@@ -432,7 +431,7 @@ function isPromiseLike(value) {
 	return value != null && typeof value.then === "function";
 }
 function publishState(instance, finalized) {
-	batch$1(() => {
+	batch(() => {
 		for (const key of instance.stateKeys) {
 			const nextValue = finalized.newState[key];
 			if (isAutoFreeze()) immer.freeze(nextValue, true);
@@ -548,7 +547,7 @@ function isSigmaState(value) {
 * that do not need to live on the sigma-state instance.
 */
 function query(fn) {
-	return ((...args) => computed$1(() => fn(...args)).value);
+	return ((...args) => computed(() => fn(...args)).value);
 }
 /**
 * Builds sigma-state constructors by accumulating default state, computeds,
@@ -738,4 +737,4 @@ function useListener(target, name, listener) {
 	}, [target, name]);
 }
 //#endregion
-export { SigmaTarget, SigmaType, action, batch, computed, effect, freeze, immerable, isSigmaState, listen, query, replaceState, setAutoFreeze, snapshot, untracked, useListener, useSigma };
+export { SigmaTarget, SigmaType, isSigmaState, listen, query, replaceState, setAutoFreeze, snapshot, useListener, useSigma };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "preact-sigma",
-  "version": "3.1.0",
+  "version": "4.0.0",
   "keywords": [],
   "license": "MIT",
   "author": "Alec Larson",
@@ -20,11 +20,6 @@
       "import": "./dist/index.mjs"
     }
   },
-  "dependencies": {
-    "@preact/signals": "^2.8.2",
-    "immer": "^11.1.4",
-    "preact": "11.0.0-beta.1"
-  },
   "devDependencies": {
     "@preact/preset-vite": "^2.10.5",
     "@types/node": "^25.5.0",
@@ -38,6 +33,11 @@
     "vite": "^8.0.2",
     "vitest": "^4.1.1"
   },
+  "peerDependencies": {
+    "@preact/signals": ">=2",
+    "immer": ">=11",
+    "preact": ">=10"
+  },
   "scripts": {
     "build": "tsdown",
     "test": "vitest run",