Function fromStore

packages/xstate-store/src/fromStore.ts:255–311

(config: {
  context: ((input: unknown) => StoreContext) | StoreContext;
  schemas?: StoreSchemas<any, any, any>;
  on: TransitionsFromEventPayloadMap<any, any, any>;
})

  FromStoreEmittedEvents<TEmittedPayloadMap, TEmittedSchemaMap>
>;
export function fromStore(config: {
  context: ((input: unknown) => StoreContext) | StoreContext;
  schemas?: StoreSchemas<any, any, any>;
  on: TransitionsFromEventPayloadMap<any, any, any>;
}): StoreLogic<any, any, any, any> {
  const initialContext = config.context;
  const transition = createStoreTransition(config.on);

  return {
    transition: (snapshot, event, actorScope) => {
      const [nextSnapshot, effects] = transition(snapshot, event);

      // The actor only commits `nextSnapshot` after this function returns, so
      // synchronous effects must read it directly; effects that run later
      // (after an `await`) read the latest committed snapshot from the actor.
      // This matches `createStore`, where `currentSnapshot` is updated before
      // effects run.
      let committed = false;
      const effectEnqueue = {
        send: (event: EventObject) => actorScope.self.send(event),
        trigger: new Proxy({} as any, {
          get: (_, eventType: string) => {
            return (payload: any) =>
              actorScope.self.send({ type: eventType, ...payload });
          }
        }),
        getSnapshot: () =>
          committed ? actorScope.self.getSnapshot() : nextSnapshot
      };

      for (const effect of effects) {
        if (typeof effect === 'function') {
          effect(effectEnqueue);
        } else {
          actorScope.emit(effect);
        }
      }

      committed = true;

      return nextSnapshot;
    },
    getInitialSnapshot: (_, input: unknown) => {
      return {
        status: 'active',
        context:
          typeof initialContext === 'function'
            ? initialContext(input)
            : initialContext,
        output: undefined,
        error: undefined
      };
    },
    getPersistedSnapshot: (s: Snapshot<unknown>) => s,
    restoreSnapshot: (s: Snapshot<unknown>) => s as StoreSnapshot<any>
  };
}