@xstate/store - npm Package Compare versions

Comparing version 2.3.0 to 2.4.0

dist/declarations/src/fromStore.d.ts

@@ -1,3 +0,5 @@
-import { createStore } from "./store.js";
-import { EventPayloadMap, StoreContext, StoreSnapshot, Snapshot } from "./types.js";
+import { ActorLogic, Cast } from 'xstate';
+import { TransitionsFromEventPayloadMap } from "./store.js";
+import { EventPayloadMap, StoreContext, StoreSnapshot, EventObject, ExtractEventsFromPayloadMap, StoreAssigner, StorePropertyAssigner } from "./types.js";
+type StoreLogic<TContext extends StoreContext, TEvent extends EventObject, TInput, TEmitted extends EventObject> = ActorLogic<StoreSnapshot<TContext>, TEvent, TInput, any, TEmitted>;
 /**
@@ -13,13 +15,28 @@ * An actor logic creator which creates store [actor
  */
-export declare function fromStore<TContext extends StoreContext, TEventPayloadMap extends EventPayloadMap, TInput>(initialContext: ((input: TInput) => TContext) | TContext, transitions: Parameters<typeof createStore<TContext, TEventPayloadMap>>[1]): {
-    transition: (snapshot: StoreSnapshot<TContext>, event: import("./types.js").ExtractEventsFromPayloadMap<TEventPayloadMap>) => StoreSnapshot<TContext>;
-    start: () => void;
-    getInitialSnapshot: (_: any, input: TInput) => {
-        status: "active";
-        context: TContext;
-        output: undefined;
-        error: undefined;
+export declare function fromStore<TContext extends StoreContext, TEventPayloadMap extends EventPayloadMap, TInput>(initialContext: ((input: TInput) => TContext) | TContext, transitions: TransitionsFromEventPayloadMap<TEventPayloadMap, NoInfer<TContext>, EventObject>): StoreLogic<TContext, ExtractEventsFromPayloadMap<TEventPayloadMap>, TInput, EventObject>;
+/**
+ * An actor logic creator which creates store [actor
+ * logic](https://stately.ai/docs/actors#actor-logic) for use with XState.
+ *
+ * @param config An object containing the store configuration
+ * @param config.context The initial context for the store, either a function
+ *   that returns context based on input, or the context itself
+ * @param config.on An object defining the transitions for different event types
+ * @param config.types Optional object to define custom event types
+ * @returns An actor logic creator function that creates store actor logic
+ */
+export declare 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>>;
     };
-    getPersistedSnapshot: (s: StoreSnapshot<TContext>) => StoreSnapshot<TContext>;
-    restoreSnapshot: (s: Snapshot<unknown>) => StoreSnapshot<TContext>;
-};
+} & {
+    types?: TTypes;
+}): StoreLogic<TContext, ExtractEventsFromPayloadMap<TEventPayloadMap>, TInput, TTypes['emitted'] extends EventObject ? TTypes['emitted'] : EventObject>;
+export {};

dist/declarations/src/react.d.ts

@@ -1,2 +0,2 @@
-import { Store, SnapshotFromStore } from "./types.js";
+import { SnapshotFromStore, AnyStore } from "./types.js";
 /**
@@ -23,2 +23,2 @@ * A React hook that subscribes to the `store` and selects a value from the
  */
-export declare function useSelector<TStore extends Store<any, any>, T>(store: TStore, selector: (snapshot: SnapshotFromStore<TStore>) => T, compare?: (a: T | undefined, b: T) => boolean): T;
+export declare function useSelector<TStore extends AnyStore, T>(store: TStore, selector: (snapshot: SnapshotFromStore<TStore>) => T, compare?: (a: T | undefined, b: T) => boolean): T;

dist/declarations/src/solid.d.ts

@@ -1,2 +0,2 @@
-import type { Store, SnapshotFromStore } from "./types.js";
+import type { SnapshotFromStore, AnyStore } from "./types.js";
 /**
@@ -32,2 +32,2 @@ * Creates a selector which subscribes to the store and selects a value from the
  */
-export declare function useSelector<TStore extends Store<any, any>, T>(store: TStore, selector: (snapshot: SnapshotFromStore<TStore>) => T, compare?: (a: T | undefined, b: T) => boolean): () => T;
+export declare function useSelector<TStore extends AnyStore, T>(store: TStore, selector: (snapshot: SnapshotFromStore<TStore>) => T, compare?: (a: T | undefined, b: T) => boolean): () => T;

dist/declarations/src/store.d.ts

@@ -1,2 +0,10 @@
-import { EventPayloadMap, Store, ExtractEventsFromPayloadMap, StoreSnapshot, StoreAssigner, StorePropertyAssigner, StoreContext } from "./types.js";
+import { EventObject } from 'xstate';
+import { Cast, EventPayloadMap, ExtractEventsFromPayloadMap, Store, StoreAssigner, StoreContext, StorePropertyAssigner, StoreSnapshot } from "./types.js";
+export type TransitionsFromEventPayloadMap<TEventPayloadMap extends EventPayloadMap, TContext extends StoreContext, TEmitted extends EventObject> = {
+    [K in keyof TEventPayloadMap & string]: StoreAssigner<TContext, {
+        type: K;
+    } & TEventPayloadMap[K], TEmitted> | StorePropertyAssigner<TContext, {
+        type: K;
+    } & TEventPayloadMap[K], TEmitted>;
+};
 /**
@@ -10,2 +18,45 @@ * Creates a **store** that has its own internal state and can be sent events
  * const store = createStore({
+ *   types: {
+ *     // ...
+ *   },
+ *   context: { count: 0 },
+ *   on: {
+ *     inc: (context, event: { by: number }) => {
+ *       return {
+ *         count: context.count + event.by
+ *       };
+ *     }
+ *   }
+ * });
+ *
+ * store.subscribe((snapshot) => {
+ *   console.log(snapshot);
+ * });
+ *
+ * store.send({ type: 'inc', by: 5 });
+ * // Logs { context: { count: 5 }, status: 'active', ... }
+ * ```
+ */
+export declare function createStore<TContext extends StoreContext, TEventPayloadMap extends EventPayloadMap, TTypes extends {
+    emitted?: EventObject;
+}>({ context, on, types }: {
+    context: 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;
+}): Store<TContext, ExtractEventsFromPayloadMap<TEventPayloadMap>, Cast<TTypes['emitted'], EventObject>>;
+/**
+ * Creates a **store** that has its own internal state and can be sent events
+ * that update its internal state based on transitions.
+ *
+ * @example
+ *
+ * ```ts
+ * const store = createStore(
  *   // Initial context
@@ -15,11 +66,9 @@ *   { count: 0 },
  *   {
- *     on: {
- *       inc: (context, event: { by: number }) => {
- *         return {
- *           count: context.count + event.by
- *         }
- *       }
+ *     inc: (context, event: { by: number }) => {
+ *       return {
+ *         count: context.count + event.by
+ *       };
  *     }
  *   }
- * });
+ * );
  *
@@ -34,9 +83,3 @@ * store.subscribe((snapshot) => {
  */
-export declare function createStore<TContext extends StoreContext, TEventPayloadMap extends EventPayloadMap>(initialContext: TContext, transitions: {
-    [K in keyof TEventPayloadMap & string]: StoreAssigner<NoInfer<TContext>, {
-        type: K;
-    } & TEventPayloadMap[K]> | StorePropertyAssigner<NoInfer<TContext>, {
-        type: K;
-    } & TEventPayloadMap[K]>;
-}): Store<TContext, ExtractEventsFromPayloadMap<TEventPayloadMap>>;
+export declare function createStore<TContext extends StoreContext, TEventPayloadMap extends EventPayloadMap>(initialContext: TContext, transitions: TransitionsFromEventPayloadMap<TEventPayloadMap, TContext, EventObject>): Store<TContext, ExtractEventsFromPayloadMap<TEventPayloadMap>, EventObject>;
 /**
@@ -72,7 +115,7 @@ * Creates a `Store` with a provided producer (such as Immer's `producer(…)` A
  */
-export declare function createStoreWithProducer<TContext extends StoreContext, TEventPayloadMap extends EventPayloadMap>(producer: NoInfer<(context: TContext, recipe: (context: TContext) => void) => TContext>, initialContext: TContext, transitions: {
+export declare function createStoreWithProducer<TContext extends StoreContext, TEventPayloadMap extends EventPayloadMap, TEmitted extends EventObject = EventObject>(producer: NoInfer<(context: TContext, recipe: (context: TContext) => void) => TContext>, initialContext: TContext, transitions: {
     [K in keyof TEventPayloadMap & string]: (context: NoInfer<TContext>, event: {
         type: K;
     } & TEventPayloadMap[K]) => void;
-}): Store<TContext, ExtractEventsFromPayloadMap<TEventPayloadMap>>;
+}): Store<TContext, ExtractEventsFromPayloadMap<TEventPayloadMap>, TEmitted>;
 declare global {
@@ -91,9 +134,8 @@ interface SymbolConstructor {
  */
-export declare function createStoreTransition<TContext extends StoreContext, TEventPayloadMap extends EventPayloadMap>(transitions: {
-    [K in keyof TEventPayloadMap & string]: StoreAssigner<NoInfer<TContext>, {
+export declare function createStoreTransition<TContext extends StoreContext, TEventPayloadMap extends EventPayloadMap, TEmitted extends EventObject>(transitions: {
+    [K in keyof TEventPayloadMap & string]: StoreAssigner<TContext, {
         type: K;
-    } & TEventPayloadMap[K]> | StorePropertyAssigner<NoInfer<TContext>, {
+    } & TEventPayloadMap[K], TEmitted> | StorePropertyAssigner<TContext, {
         type: K;
-    } & TEventPayloadMap[K]>;
-}, updater?: (context: NoInfer<TContext>, recipe: (context: NoInfer<TContext>) => NoInfer<TContext>) => NoInfer<TContext>): (snapshot: StoreSnapshot<TContext>, event: ExtractEventsFromPayloadMap<TEventPayloadMap>) => StoreSnapshot<TContext>;
-export declare function uniqueId(): string;
+    } & TEventPayloadMap[K], TEmitted>;
+}, updater?: (context: TContext, recipe: (context: TContext) => TContext) => TContext): (snapshot: StoreSnapshot<TContext>, event: ExtractEventsFromPayloadMap<TEventPayloadMap>) => [StoreSnapshot<TContext>, TEmitted[]];

dist/declarations/src/types.d.ts

@@ -8,7 +8,13 @@ export type EventPayloadMap = Record<string, {} | null | undefined>;
 export type Recipe<T, TReturn> = (state: T) => TReturn;
-export type StoreAssigner<TContext extends StoreContext, TEvent extends EventObject> = (context: TContext, event: TEvent) => Partial<TContext>;
-export type StoreCompleteAssigner<TContext, TEvent extends EventObject> = (ctx: TContext, ev: TEvent) => TContext;
-export type StorePartialAssigner<TContext, TEvent extends EventObject, K extends keyof TContext> = (ctx: TContext, ev: TEvent) => Partial<TContext>[K];
-export type StorePropertyAssigner<TContext, TEvent extends EventObject> = {
-    [K in keyof TContext]?: TContext[K] | StorePartialAssigner<TContext, TEvent, K>;
+export type StoreAssigner<TContext extends StoreContext, TEvent extends EventObject, TEmitted extends EventObject> = (context: TContext, event: TEvent, enq: {
+    emit: (ev: TEmitted) => void;
+}) => Partial<TContext>;
+export type StoreCompleteAssigner<TContext, TEvent extends EventObject, TEmitted extends EventObject> = (ctx: TContext, ev: TEvent, enq: {
+    emit: (ev: TEmitted) => void;
+}) => TContext;
+export type StorePartialAssigner<TContext, TEvent extends EventObject, K extends keyof TContext, TEmitted extends EventObject> = (ctx: TContext, ev: TEvent, enq: {
+    emit: (ev: TEmitted) => void;
+}) => Partial<TContext>[K];
+export type StorePropertyAssigner<TContext, TEvent extends EventObject, TEmitted extends EventObject> = {
+    [K in keyof TContext]?: TContext[K] | StorePartialAssigner<TContext, TEvent, K, TEmitted>;
 };
@@ -42,4 +48,4 @@ export type Snapshot<TOutput> = {
  */
-export interface Store<TContext, Ev extends EventObject> extends Subscribable<StoreSnapshot<TContext>>, InteropObservable<StoreSnapshot<TContext>> {
-    send: (event: Ev) => void;
+export interface Store<TContext, TEvent extends EventObject, TEmitted extends EventObject> extends Subscribable<StoreSnapshot<TContext>>, InteropObservable<StoreSnapshot<TContext>> {
+    send: (event: TEvent) => void;
     getSnapshot: () => StoreSnapshot<TContext>;
@@ -56,4 +62,11 @@ getInitialSnapshot: () => StoreSnapshot<TContext>;
     sessionId: string;
+    on: <TEmittedType extends TEmitted['type']>(eventType: TEmittedType, emittedEventHandler: (ev: Compute<TEmitted & {
+        type: TEmittedType;
+    }>) => void) => Subscription;
 }
-export type SnapshotFromStore<TStore extends Store<any, any>> = TStore extends Store<infer TContext, any> ? StoreSnapshot<TContext> : never;
+export type AnyStore = Store<any, any, any>;
+export type Compute<A extends any> = {
+    [K in keyof A]: A[K];
+} & unknown;
+export type SnapshotFromStore<TStore extends Store<any, any, any>> = TStore extends Store<infer TContext, any, any> ? StoreSnapshot<TContext> : never;
 /**
@@ -129,3 +142,3 @@ * Extract the type of events from a `Store`.
  */
-export type EventFromStore<TStore extends Store<any, any>> = TStore extends Store<infer _TContext, infer TEvent> ? TEvent : never;
+export type EventFromStore<TStore extends Store<any, any, any>> = TStore extends Store<infer _TContext, infer TEvent, infer _TEmitted> ? TEvent : never;
 export interface InteropSubscribable<T> {
@@ -203,2 +216,4 @@ subscribe(observer: Observer<T>): Subscription;
 };
+export type Prop<T, K> = K extends keyof T ? T[K] : never;
+export type Cast<A, B> = A extends B ? A : B;
 export {};

dist/xstate-store.cjs.d.ts

 export * from "./declarations/src/index";
-//# sourceMappingURL=xstate-store.cjs.d.ts.map
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoieHN0YXRlLXN0b3JlLmNqcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi9kZWNsYXJhdGlvbnMvc3JjL2luZGV4LmQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEifQ==

dist/xstate-store.cjs.js

@@ -21,2 +21,3 @@ 'use strict';
   let observers;
+  let listeners;
   const initialSnapshot = {
@@ -29,5 +30,16 @@ context: initialContext,
   let currentSnapshot = initialSnapshot;
+  const emit = ev => {
+    if (!listeners) {
+      return;
+    }
+    const type = ev.type;
+    const typeListeners = listeners.get(type);
+    if (typeListeners) {
+      typeListeners.forEach(listener => listener(ev));
+    }
+  };
   const transition = createStoreTransition(transitions, updater);
   function receive(event) {
-    currentSnapshot = transition(currentSnapshot, event);
+    let emitted;
+    [currentSnapshot, emitted] = transition(currentSnapshot, event);
     inspectionObservers.get(store)?.forEach(observer => {
@@ -43,4 +55,22 @@ observer.next?.({
     observers?.forEach(o => o.next?.(currentSnapshot));
+    emitted.forEach(emit);
   }
   const store = {
+    on(emittedEventType, handler) {
+      if (!listeners) {
+        listeners = new Map();
+      }
+      let eventListeners = listeners.get(emittedEventType);
+      if (!eventListeners) {
+        eventListeners = new Set();
+        listeners.set(emittedEventType, eventListeners);
+      }
+      const wrappedHandler = handler.bind(undefined);
+      eventListeners.add(wrappedHandler);
+      return {
+        unsubscribe() {
+          eventListeners.delete(wrappedHandler);
+        }
+      };
+    },
     sessionId: uniqueId(),
@@ -114,2 +144,32 @@ send(event) {
  * const store = createStore({
+ *   types: {
+ *     // ...
+ *   },
+ *   context: { count: 0 },
+ *   on: {
+ *     inc: (context, event: { by: number }) => {
+ *       return {
+ *         count: context.count + event.by
+ *       };
+ *     }
+ *   }
+ * });
+ *
+ * store.subscribe((snapshot) => {
+ *   console.log(snapshot);
+ * });
+ *
+ * store.send({ type: 'inc', by: 5 });
+ * // Logs { context: { count: 5 }, status: 'active', ... }
+ * ```
+ */
+
+/**
+ * Creates a **store** that has its own internal state and can be sent events
+ * that update its internal state based on transitions.
+ *
+ * @example
+ *
+ * ```ts
+ * const store = createStore(
  *   // Initial context
@@ -119,11 +179,9 @@ *   { count: 0 },
  *   {
- *     on: {
- *       inc: (context, event: { by: number }) => {
- *         return {
- *           count: context.count + event.by
- *         }
- *       }
+ *     inc: (context, event: { by: number }) => {
+ *       return {
+ *         count: context.count + event.by
+ *       };
  *     }
  *   }
- * });
+ * );
  *
@@ -138,4 +196,8 @@ * store.subscribe((snapshot) => {
  */
-function createStore(initialContext, transitions) {
-  return createStoreCore(initialContext, transitions);
+
+function createStore(initialContextOrObject, transitions) {
+  if (transitions === undefined) {
+    return createStoreCore(initialContextOrObject.context, initialContextOrObject.on);
+  }
+  return createStoreCore(initialContextOrObject, transitions);
 }
@@ -188,8 +250,15 @@
     const assigner = transitions?.[event.type];
+    const emitted = [];
+    const enqueue = {
+      emit: ev => {
+        emitted.push(ev);
+      }
+    };
     if (!assigner) {
-      return snapshot;
+      return [snapshot, emitted];
     }
     if (typeof assigner === 'function') {
-      currentContext = updater ? updater(currentContext, draftContext => assigner?.(draftContext, event)) : setter(currentContext, draftContext => Object.assign({}, currentContext, assigner?.(draftContext, event // TODO: help me
-      )));
+      currentContext = updater ? updater(currentContext, draftContext => assigner?.(draftContext, event, enqueue)) : setter(currentContext, draftContext => Object.assign({}, currentContext, assigner?.(draftContext, event,
+      // TODO: help me
+      enqueue)));
     } else {
@@ -199,10 +268,10 @@ const partialUpdate = {};
         const propAssignment = assigner[key];
-        partialUpdate[key] = typeof propAssignment === 'function' ? propAssignment(currentContext, event) : propAssignment;
+        partialUpdate[key] = typeof propAssignment === 'function' ? propAssignment(currentContext, event, enqueue) : propAssignment;
       }
       currentContext = Object.assign({}, currentContext, partialUpdate);
     }
-    return {
+    return [{
       ...snapshot,
       context: currentContext
-    };
+    }, emitted];
   };
@@ -226,7 +295,32 @@ }
  */
-function fromStore(initialContext, transitions) {
-  const transition = createStoreTransition(transitions);
+
+/**
+ * An actor logic creator which creates store [actor
+ * logic](https://stately.ai/docs/actors#actor-logic) for use with XState.
+ *
+ * @param config An object containing the store configuration
+ * @param config.context The initial context for the store, either a function
+ *   that returns context based on input, or the context itself
+ * @param config.on An object defining the transitions for different event types
+ * @param config.types Optional object to define custom event types
+ * @returns An actor logic creator function that creates store actor logic
+ */
+
+function fromStore(initialContextOrObj, transitions) {
+  let initialContext;
+  let transitionsObj;
+  if (typeof initialContextOrObj === 'object' && 'context' in initialContextOrObj) {
+    initialContext = initialContextOrObj.context;
+    transitionsObj = initialContextOrObj.on;
+  } else {
+    initialContext = initialContextOrObj;
+    transitionsObj = transitions;
+  }
+  const transition = createStoreTransition(transitionsObj);
   return {
-    transition,
-    start: () => {},
+    transition: (snapshot, event, actorScope) => {
+      const [nextSnapshot, emittedEvents] = transition(snapshot, event);
+      emittedEvents.forEach(actorScope.emit);
+      return nextSnapshot;
+    },
     getInitialSnapshot: (_, input) => {
@@ -233,0 +327,0 @@ return {

dist/xstate-store.esm.js

@@ -17,2 +17,3 @@ const symbolObservable = (() => typeof Symbol === 'function' && Symbol.observable || '@@observable')();
   let observers;
+  let listeners;
   const initialSnapshot = {
@@ -25,5 +26,16 @@ context: initialContext,
   let currentSnapshot = initialSnapshot;
+  const emit = ev => {
+    if (!listeners) {
+      return;
+    }
+    const type = ev.type;
+    const typeListeners = listeners.get(type);
+    if (typeListeners) {
+      typeListeners.forEach(listener => listener(ev));
+    }
+  };
   const transition = createStoreTransition(transitions, updater);
   function receive(event) {
-    currentSnapshot = transition(currentSnapshot, event);
+    let emitted;
+    [currentSnapshot, emitted] = transition(currentSnapshot, event);
     inspectionObservers.get(store)?.forEach(observer => {
@@ -39,4 +51,22 @@ observer.next?.({
     observers?.forEach(o => o.next?.(currentSnapshot));
+    emitted.forEach(emit);
   }
   const store = {
+    on(emittedEventType, handler) {
+      if (!listeners) {
+        listeners = new Map();
+      }
+      let eventListeners = listeners.get(emittedEventType);
+      if (!eventListeners) {
+        eventListeners = new Set();
+        listeners.set(emittedEventType, eventListeners);
+      }
+      const wrappedHandler = handler.bind(undefined);
+      eventListeners.add(wrappedHandler);
+      return {
+        unsubscribe() {
+          eventListeners.delete(wrappedHandler);
+        }
+      };
+    },
     sessionId: uniqueId(),
@@ -110,2 +140,32 @@ send(event) {
  * const store = createStore({
+ *   types: {
+ *     // ...
+ *   },
+ *   context: { count: 0 },
+ *   on: {
+ *     inc: (context, event: { by: number }) => {
+ *       return {
+ *         count: context.count + event.by
+ *       };
+ *     }
+ *   }
+ * });
+ *
+ * store.subscribe((snapshot) => {
+ *   console.log(snapshot);
+ * });
+ *
+ * store.send({ type: 'inc', by: 5 });
+ * // Logs { context: { count: 5 }, status: 'active', ... }
+ * ```
+ */
+
+/**
+ * Creates a **store** that has its own internal state and can be sent events
+ * that update its internal state based on transitions.
+ *
+ * @example
+ *
+ * ```ts
+ * const store = createStore(
  *   // Initial context
@@ -115,11 +175,9 @@ *   { count: 0 },
  *   {
- *     on: {
- *       inc: (context, event: { by: number }) => {
- *         return {
- *           count: context.count + event.by
- *         }
- *       }
+ *     inc: (context, event: { by: number }) => {
+ *       return {
+ *         count: context.count + event.by
+ *       };
  *     }
  *   }
- * });
+ * );
  *
@@ -134,4 +192,8 @@ * store.subscribe((snapshot) => {
  */
-function createStore(initialContext, transitions) {
-  return createStoreCore(initialContext, transitions);
+
+function createStore(initialContextOrObject, transitions) {
+  if (transitions === undefined) {
+    return createStoreCore(initialContextOrObject.context, initialContextOrObject.on);
+  }
+  return createStoreCore(initialContextOrObject, transitions);
 }
@@ -184,8 +246,15 @@
     const assigner = transitions?.[event.type];
+    const emitted = [];
+    const enqueue = {
+      emit: ev => {
+        emitted.push(ev);
+      }
+    };
     if (!assigner) {
-      return snapshot;
+      return [snapshot, emitted];
     }
     if (typeof assigner === 'function') {
-      currentContext = updater ? updater(currentContext, draftContext => assigner?.(draftContext, event)) : setter(currentContext, draftContext => Object.assign({}, currentContext, assigner?.(draftContext, event // TODO: help me
-      )));
+      currentContext = updater ? updater(currentContext, draftContext => assigner?.(draftContext, event, enqueue)) : setter(currentContext, draftContext => Object.assign({}, currentContext, assigner?.(draftContext, event,
+      // TODO: help me
+      enqueue)));
     } else {
@@ -195,10 +264,10 @@ const partialUpdate = {};
         const propAssignment = assigner[key];
-        partialUpdate[key] = typeof propAssignment === 'function' ? propAssignment(currentContext, event) : propAssignment;
+        partialUpdate[key] = typeof propAssignment === 'function' ? propAssignment(currentContext, event, enqueue) : propAssignment;
       }
       currentContext = Object.assign({}, currentContext, partialUpdate);
     }
-    return {
+    return [{
       ...snapshot,
       context: currentContext
-    };
+    }, emitted];
   };
@@ -222,7 +291,32 @@ }
  */
-function fromStore(initialContext, transitions) {
-  const transition = createStoreTransition(transitions);
+
+/**
+ * An actor logic creator which creates store [actor
+ * logic](https://stately.ai/docs/actors#actor-logic) for use with XState.
+ *
+ * @param config An object containing the store configuration
+ * @param config.context The initial context for the store, either a function
+ *   that returns context based on input, or the context itself
+ * @param config.on An object defining the transitions for different event types
+ * @param config.types Optional object to define custom event types
+ * @returns An actor logic creator function that creates store actor logic
+ */
+
+function fromStore(initialContextOrObj, transitions) {
+  let initialContext;
+  let transitionsObj;
+  if (typeof initialContextOrObj === 'object' && 'context' in initialContextOrObj) {
+    initialContext = initialContextOrObj.context;
+    transitionsObj = initialContextOrObj.on;
+  } else {
+    initialContext = initialContextOrObj;
+    transitionsObj = transitions;
+  }
+  const transition = createStoreTransition(transitionsObj);
   return {
-    transition,
-    start: () => {},
+    transition: (snapshot, event, actorScope) => {
+      const [nextSnapshot, emittedEvents] = transition(snapshot, event);
+      emittedEvents.forEach(actorScope.emit);
+      return nextSnapshot;
+    },
     getInitialSnapshot: (_, input) => {
@@ -229,0 +323,0 @@ return {

package.json

 {
   "name": "@xstate/store",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "Simple stores",
@@ -60,4 +60,3 @@ "keywords": [
     "@types/react": "^18.3.3",
-    "@xstate/react": "^4.1.1",
-    "@xstate/vue": "^3.1.2",
+    "@types/react-dom": "^18.3.0",
     "immer": "^10.0.2",
@@ -68,3 +67,5 @@ "react": "^18.0.0",
     "solid-testing-library": "^0.3.0",
-    "xstate": "^5.18.0"
+    "@xstate/react": "^4.1.2",
+    "@xstate/vue": "^3.1.3",
+    "xstate": "^5.18.1"
   },
@@ -91,2 +92,2 @@ "peerDependencies": {
   }
-}
+}

react/dist/xstate-store-react.cjs.d.ts

 export * from "../../dist/declarations/src/react";
-//# sourceMappingURL=xstate-store-react.cjs.d.ts.map
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoieHN0YXRlLXN0b3JlLXJlYWN0LmNqcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vZGlzdC9kZWNsYXJhdGlvbnMvc3JjL3JlYWN0LmQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEifQ==

solid/dist/xstate-store-solid.cjs.d.ts

 export * from "../../dist/declarations/src/solid";
-//# sourceMappingURL=xstate-store-solid.cjs.d.ts.map
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoieHN0YXRlLXN0b3JlLXNvbGlkLmNqcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vZGlzdC9kZWNsYXJhdGlvbnMvc3JjL3NvbGlkLmQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEifQ==

No alert changes

Improved metrics

Total package byte prevSize

53025

increased by21.5%

Lines of code

1307

increased by24.71%

Worsened metrics

Dev dependency count

11

increased by10%

Number of package files

26

decreased by-18.75%

No dependency changes