[@xstate/store] v3

.changeset/five-walls-approve.md

@@ -0,0 +1,27 @@
+---
+'@xstate/store': major
+---
+
+The `createStore` function now only accepts a single configuration object argument. This is a breaking change that simplifies the API and aligns with the configuration pattern used throughout XState.
+
+```ts
+// Before
+// createStore(
+//   {
+//     count: 0
+//   },
+//   {
+//     increment: (context) => ({ count: context.count + 1 })
+//   }
+// );
+
+// After
+createStore({
+  context: {
+    count: 0
+  },
+  on: {
+    increment: (context) => ({ count: context.count + 1 })
+  }
+});
+```

.changeset/great-candles-rule.md

@@ -0,0 +1,24 @@
+---
+'@xstate/store': major
+---
+
+You can now enqueue effects in state transitions.
+
+```ts
+const store = createStore({
+  context: {
+    count: 0
+  },
+  on: {
+    incrementDelayed: (context, event, enq) => {
+      enq.effect(async () => {
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        store.send({ type: 'increment' });
+      });
+
+      return context;
+    },
+    increment: (context) => ({ count: context.count + 1 })
+  }
+});
+```

.changeset/quick-bears-swim.md

@@ -0,0 +1,24 @@
+---
+'@xstate/store': minor
+---
+
+Added `store.trigger` API for sending events with a fluent interface:
+
+```ts
+const store = createStore({
+  context: { count: 0 },
+  on: {
+    increment: (ctx, event: { by: number }) => ({
+      count: ctx.count + event.by
+    })
+  }
+});
+
+// Instead of manually constructing event objects:
+store.send({ type: 'increment', by: 5 });
+
+// You can now use the fluent trigger API:
+store.trigger.increment({ by: 5 });
+```
+
+The `trigger` API provides full type safety for event names and payloads, making it easier and safer to send events to the store.

.changeset/spotty-moose-joke.md

@@ -0,0 +1,28 @@
+---
+'@xstate/store': major
+---
+
+The `createStoreWithProducer(…)` function now only accepts two arguments: a `producer` and a config (`{ context, on }`) object.
+
+```ts
+// Before
+// createStoreWithProducer(
+//   producer,
+//   {
+//     count: 0
+//   },
+//   {
+//     increment: (context) => ({ count: context.count + 1 })
+//   }
+// );
+
+// After
+createStoreWithProducer(producer, {
+  context: {
+    count: 0
+  },
+  on: {
+    increment: (context) => ({ count: context.count + 1 })
+  }
+});
+```

.changeset/thick-paws-invite.md

@@ -0,0 +1,19 @@
+---
+'@xstate/store': major
+---
+
+Only complete assigner functions that replace the `context` fully are supported. This is a breaking change that simplifies the API and provides more type safety.
+
+```diff
+const store = createStore({
+  context: {
+    items: [],
+    count: 0
+  },
+  on: {
+-   increment: { count: (context) => context.count + 1 }
+-   increment: (context) => ({ count: context.count + 1 })
++   increment: (context) => ({ ...context, count: context.count + 1 })
+  }
+})
+```

.changeset/wise-bikes-leave.md

@@ -0,0 +1,21 @@
+---
+'@xstate/store': major
+---
+
+Emitted event types are now specified in functions on the `emits` property of the store definition:
+
+```ts
+const store = createStore({
+  // …
+  emits: {
+    increased: (payload: { upBy: number }) => {}
+  },
+  on: {
+    inc: (ctx, ev: { by: number }, enq) => {
+      enq.emit.increased({ upBy: ev.by });
+
+      // …
+    }
+  }
+});
+```

packages/xstate-store/src/fromStore.ts

@@ -7,8 +7,7 @@ import {
   StoreSnapshot,
   EventObject,
   ExtractEventsFromPayloadMap,
-  StoreAssigner,
-  StorePropertyAssigner
+  StoreAssigner
 } from './types';
 
 type StoreLogic<
@@ -61,29 +60,26 @@ export function fromStore<
   TContext extends StoreContext,
   TEventPayloadMap extends EventPayloadMap,
   TInput,
-  TTypes extends { emitted?: EventObject }
->(
-  config: {
-    context: ((input: TInput) => TContext) | TContext;
-    on: {
-      [K in keyof TEventPayloadMap & string]:
-        | StoreAssigner<
-            NoInfer<TContext>,
-            { type: K } & TEventPayloadMap[K],
-            Cast<TTypes['emitted'], EventObject>
-          >
-        | StorePropertyAssigner<
-            NoInfer<TContext>,
-            { type: K } & TEventPayloadMap[K],
-            Cast<TTypes['emitted'], EventObject>
-          >;
-    };
-  } & { types?: TTypes }
-): StoreLogic<
+  TEmitted extends EventPayloadMap
+>(config: {
+  context: ((input: TInput) => TContext) | TContext;
+  on: {
+    [K in keyof TEventPayloadMap & string]: StoreAssigner<
+      NoInfer<TContext>,
+      { type: K } & TEventPayloadMap[K],
+      ExtractEventsFromPayloadMap<TEmitted>
+    >;
+  };
+  emits?: {
+    [K in keyof TEmitted & string]: (
+      payload: { type: K } & TEmitted[K]
+    ) => void;
+  };
+}): StoreLogic<
   TContext,
   ExtractEventsFromPayloadMap<TEventPayloadMap>,
   TInput,
-  TTypes['emitted'] extends EventObject ? TTypes['emitted'] : EventObject
+  ExtractEventsFromPayloadMap<TEmitted>
 >;
 export function fromStore<
   TContext extends StoreContext,
@@ -97,17 +93,11 @@ export function fromStore<
     | ({
         context: ((input: TInput) => TContext) | TContext;
         on: {
-          [K in keyof TEventPayloadMap & string]:
-            | StoreAssigner<
-                NoInfer<TContext>,
-                { type: K } & TEventPayloadMap[K],
-                Cast<TTypes['emitted'], EventObject>
-              >
-            | StorePropertyAssigner<
-                NoInfer<TContext>,
-                { type: K } & TEventPayloadMap[K],
-                Cast<TTypes['emitted'], EventObject>
-              >;
+          [K in keyof TEventPayloadMap & string]: StoreAssigner<
+            NoInfer<TContext>,
+            { type: K } & TEventPayloadMap[K],
+            Cast<TTypes['emitted'], EventObject>
+          >;
         };
       } & { types?: TTypes }),
   transitions?: TransitionsFromEventPayloadMap<
@@ -142,9 +132,15 @@ export function fromStore<
   const transition = createStoreTransition(transitionsObj);
   return {
     transition: (snapshot, event, actorScope) => {
-      const [nextSnapshot, emittedEvents] = transition(snapshot, event);
+      const [nextSnapshot, effects] = transition(snapshot, event);
 
-      emittedEvents.forEach(actorScope.emit);
+      for (const effect of effects) {
+        if (typeof effect === 'function') {
+          effect();
+        } else {
+          actorScope.emit(effect);
+        }
+      }
 
       return nextSnapshot;
     },