@systemfsoftware/xstate-store 0.0.0-bootstrap.0 → 5.0.0-beta.6

package/dist/types-0n0RpfhK.d.ts

@@ -0,0 +1,442 @@
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** A falsy value for `issues` indicates success. */
+    readonly issues?: undefined;
+  }
+  interface Options {
+    /** Explicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard Schema types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Schema. */
+  type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
+  /** Infers the output type of a Standard Schema. */
+  type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
+}
+type EventPayloadMap = Record<string, {} | null | undefined>;
+type ExtractEvents<T extends EventPayloadMap> = Values<{ [K in keyof T & string]: T[K] & {
+  type: K;
+}; }>;
+type StandardSchemaMap = Record<string, StandardSchemaV1<unknown, object>>;
+type InferSchemaOutput<TSchema extends StandardSchemaV1, TFallback> = Compute<StandardSchemaV1.InferOutput<TSchema> extends TFallback ? StandardSchemaV1.InferOutput<TSchema> : never>;
+type InferSchemaPayloadMap<TSchemaMap extends StandardSchemaMap> = { [K in keyof TSchemaMap & string]: NormalizeSchemaPayload<InferSchemaOutput<TSchemaMap[K], EventPayloadMap[string]>>; };
+type NormalizeSchemaPayload<TPayload> = string extends keyof TPayload ? {} : TPayload;
+type StoreSchemas<TContextSchema extends StandardSchemaV1 | undefined = undefined, TEventSchemaMap extends StandardSchemaMap | undefined = undefined, TEmittedSchemaMap extends StandardSchemaMap | undefined = undefined> = {
+  context?: TContextSchema;
+  events?: TEventSchemaMap;
+  emitted?: TEmittedSchemaMap;
+};
+type ResolveStoreContext<TContext extends StoreContext, TContextSchema extends StandardSchemaV1 | undefined> = TContextSchema extends StandardSchemaV1 ? InferSchemaOutput<TContextSchema, StoreContext> : TContext;
+type ResolveStoreEventPayloadMap<TEventPayloadMap extends EventPayloadMap, TEventSchemaMap extends StandardSchemaMap | undefined> = TEventSchemaMap extends StandardSchemaMap ? InferSchemaPayloadMap<TEventSchemaMap> : TEventPayloadMap;
+type ResolveStoreEmittedPayloadMap<TEmittedPayloadMap extends EventPayloadMap, TEmittedSchemaMap extends StandardSchemaMap | undefined> = TEmittedSchemaMap extends StandardSchemaMap ? InferSchemaPayloadMap<TEmittedSchemaMap> : TEmittedPayloadMap;
+type EventPayloadFromEvent<TEvent> = TEvent extends {
+  type: string;
+} ? DistributiveOmit<TEvent, 'type'> : TEvent;
+type EventPayloadMapFromTransitions<TTransitions> = { [K in keyof TTransitions & string]: TTransitions[K] extends ((context: any, event: infer TEvent, ...args: any[]) => unknown) ? EventPayloadFromEvent<TEvent> : {}; };
+type StoreEventPayloadMapFromConfig<TConfig extends AnyStoreConfig> = TConfig extends {
+  schemas: {
+    events: infer TEventSchemaMap;
+  };
+} ? TEventSchemaMap extends StandardSchemaMap ? InferSchemaPayloadMap<TEventSchemaMap> : {} : TConfig extends {
+  on: infer TTransitions;
+} ? EventPayloadMapFromTransitions<TTransitions> : {};
+type EmitterFunction<TEmittedEvent extends EventObject> = (...args: {
+  type: TEmittedEvent['type'];
+} extends TEmittedEvent ? [DistributiveOmit<TEmittedEvent, 'type'>?] : [DistributiveOmit<TEmittedEvent, 'type'>]) => void;
+type TriggerFunction<TEvent extends EventObject> = (...args: {
+  type: TEvent['type'];
+} extends TEvent ? [DistributiveOmit<TEvent, 'type'>?] : [DistributiveOmit<TEvent, 'type'>]) => void;
+type CanFunction<TEvent extends EventObject> = (...args: {
+  type: TEvent['type'];
+} extends TEvent ? [DistributiveOmit<TEvent, 'type'>?] : [DistributiveOmit<TEvent, 'type'>]) => boolean;
+type EventFromPayload<TKey extends string, TPayload> = {
+  type: TKey;
+} & (TPayload extends null | undefined ? {} : TPayload);
+type TriggerObject<TEventPayloadMap extends EventPayloadMap> = { [K in keyof TEventPayloadMap & string]: string extends K ? (...args: any[]) => void : TriggerFunction<EventFromPayload<K, TEventPayloadMap[K]>>; };
+type CanObject<TEventPayloadMap extends EventPayloadMap> = { [K in keyof TEventPayloadMap & string]: string extends K ? (...args: any[]) => boolean : CanFunction<EventFromPayload<K, TEventPayloadMap[K]>>; };
+/**
+ * The object passed to an effect function enqueued via `enq.effect(...)`. It
+ * allows effects to send events back into the store (e.g. after an async
+ * operation resolves) and read the latest store state, which is especially
+ * useful with `createStoreLogic(...)` where there is no store reference to
+ * close over.
+ *
+ * Use `trigger` for event-specific dispatch; `send` accepts the same event
+ * objects as `store.send(...)`. `getSnapshot()` returns the current snapshot at
+ * the time the effect runs, which is the correct way to read fresh context
+ * after an `await` (the `context` argument to the transition is stale by
+ * then).
+ */
+type StoreEffectEnqueue<TContext extends StoreContext = StoreContext, TEventPayloadMap extends EventPayloadMap = {}> = {
+  trigger: TriggerObject<TEventPayloadMap>;
+  send: (event: EventObject) => void;
+  getSnapshot: () => StoreSnapshot<TContext>;
+};
+type EnqueueObject<TContext extends StoreContext, TEmittedEvent extends EventObject, TEventPayloadMap extends EventPayloadMap = {}> = {
+  emit: { [E in TEmittedEvent as E['type']]: EmitterFunction<E>; };
+  trigger: TriggerObject<TEventPayloadMap>;
+  effect: (fn: (enq: StoreEffectEnqueue<TContext, TEventPayloadMap>) => void) => void;
+};
+type StoreEffect<TEmitted extends EventObject> = ((enq?: StoreEffectEnqueue<any, any>) => void) | TEmitted;
+type StoreAssigner<TContext extends StoreContext, TEvent extends EventObject, TEmitted extends EventObject, TEventPayloadMap extends EventPayloadMap = {}> = (context: TContext, event: TEvent, enq: EnqueueObject<TContext, TEmitted, TEventPayloadMap>) => TContext | void;
+type Snapshot<TOutput> = {
+  status: 'active';
+  output: undefined;
+  error: undefined;
+} | {
+  status: 'done';
+  output: TOutput;
+  error: undefined;
+} | {
+  status: 'error';
+  output: undefined;
+  error: unknown;
+} | {
+  status: 'stopped';
+  output: undefined;
+  error: undefined;
+};
+type StoreSnapshot<TContext> = Snapshot<undefined> & {
+  context: TContext;
+};
+/**
+ * An actor-like object that:
+ *
+ * - Has its own state
+ * - Can receive events
+ * - Is observable
+ */
+interface Store<TContext extends StoreContext, TEventPayloadMap extends EventPayloadMap, TEmitted extends EventObject> extends Subscribable<StoreSnapshot<TContext>>, InteropObservable<StoreSnapshot<TContext>>, Readable<StoreSnapshot<TContext>> {
+  /** Standard Schema definitions for this store, if provided. */
+  readonly schemas?: StoreSchemas<any, any, any> | undefined;
+  send: (event: ExtractEvents<TEventPayloadMap>) => void;
+  getSnapshot: () => StoreSnapshot<TContext>;
+  /** Read the current snapshot as a `Readable` value. */
+  get: () => StoreSnapshot<TContext>;
+  getInitialSnapshot: () => StoreSnapshot<TContext>;
+  /**
+   * Subscribes to [inspection events](https://stately.ai/docs/inspection) from
+   * the store.
+   *
+   * Inspectors that call `store.inspect(…)` will immediately receive the
+   * current snapshot as an "\@xstate.transition" inspection event.
+   */
+  inspect: (observer: Observer<StoreInspectionEvent> | ((inspectionEvent: StoreInspectionEvent) => void)) => Subscription;
+  sessionId: string;
+  on: <TType extends TEmitted['type'] | '*'>(type: TType, handler: (emitted: Compute<TEmitted & (TType extends '*' ? unknown : {
+    type: TType;
+  })>) => void) => Subscription;
+  /**
+   * A trigger object that allows you to send events to the store without
+   * manually constructing event objects.
+   *
+   * @example
+   *
+   * ```ts
+   * // Equivalent to:
+   * // store.send({ type: 'increment', by: 1 });
+   * store.trigger.increment({ by: 1 });
+   * ```
+   */
+  trigger: TriggerObject<TEventPayloadMap>;
+  can: CanObject<TEventPayloadMap>;
+  select<TSelected>(selector: Selector<TContext, TSelected>, equalityFn?: (a: TSelected, b: TSelected) => boolean): Selection<TSelected>;
+  /**
+   * Returns the next state and effects for the given state and event, as a
+   * tuple.
+   *
+   * @example
+   *
+   * ```ts
+   * const [nextState, effects] = store.transition(store.getSnapshot(), {
+   *   type: 'increment',
+   *   by: 1
+   * });
+   * ```
+   */
+  transition: StoreTransition<TContext, ExtractEvents<TEventPayloadMap>, TEmitted>;
+  /**
+   * Extends the store with additional functionality via a store extension.
+   *
+   * @example
+   *
+   * ```ts
+   * const store = createStore({
+   *   context: { count: 0 },
+   *   on: { inc: (ctx) => ({ count: ctx.count + 1 }) }
+   * }).with(undoRedo());
+   *
+   * store.trigger.inc();
+   * store.trigger.undo(); // undoes the increment
+   * ```
+   */
+  with<TNewEventPayloadMap extends EventPayloadMap>(extension: StoreExtension<TContext, TEventPayloadMap, TNewEventPayloadMap, TEmitted>): Store<TContext, TEventPayloadMap & TNewEventPayloadMap, TEmitted>;
+}
+type StoreTransition<TContext extends StoreContext, TEvent extends EventObject, TEmitted extends EventObject> = (state: StoreSnapshot<TContext>, event: TEvent) => StoreTransitionResult<StoreSnapshot<TContext>, TEmitted>;
+type StoreTransitionResult<TSnapshot extends StoreSnapshot<any>, TEmitted extends EventObject> = [TSnapshot, StoreEffect<TEmitted>[]] & {
+  _allowed?: boolean;
+};
+type StoreConfig<TContext extends StoreContext, TEventPayloadMap extends EventPayloadMap, TEmittedPayloadMap extends EventPayloadMap = {}, TContextSchema extends StandardSchemaV1 | undefined = undefined, TEventSchemaMap extends StandardSchemaMap | undefined = undefined, TEmittedSchemaMap extends StandardSchemaMap | undefined = undefined> = {
+  context: ResolveStoreContext<TContext, TContextSchema>;
+  schemas?: StoreSchemas<TContextSchema, TEventSchemaMap, TEmittedSchemaMap>;
+  warn?: (message: string) => void;
+  on: TEventSchemaMap extends StandardSchemaMap ? { [K in keyof ResolveStoreEventPayloadMap<TEventPayloadMap, TEventSchemaMap> & string]?: StoreAssigner<ResolveStoreContext<TContext, TContextSchema>, {
+    type: K;
+  } & ResolveStoreEventPayloadMap<TEventPayloadMap, TEventSchemaMap>[K], ExtractEvents<ResolveStoreEmittedPayloadMap<TEmittedPayloadMap, TEmittedSchemaMap>>, ResolveStoreEventPayloadMap<TEventPayloadMap, TEventSchemaMap>>; } : { [K in keyof TEventPayloadMap & string]: StoreAssigner<ResolveStoreContext<TContext, TContextSchema>, {
+    type: K;
+  } & TEventPayloadMap[K], ExtractEvents<ResolveStoreEmittedPayloadMap<TEmittedPayloadMap, TEmittedSchemaMap>>, ResolveStoreEventPayloadMap<TEventPayloadMap, TEventSchemaMap>>; };
+};
+type SpecificStoreConfig<TContext extends StoreContext, TEvent extends EventObject, TEmitted extends EventObject, TContextSchema extends StandardSchemaV1 | undefined = undefined, TEventSchemaMap extends StandardSchemaMap | undefined = undefined, TEmittedSchemaMap extends StandardSchemaMap | undefined = undefined> = {
+  context: ResolveStoreContext<TContext, TContextSchema>;
+  schemas?: StoreSchemas<TContextSchema, TEventSchemaMap, TEmittedSchemaMap>;
+  warn?: (message: string) => void;
+  on: { [E in TEvent as E['type']]?: StoreAssigner<ResolveStoreContext<TContext, TContextSchema>, E, TEmitted, EventPayloadMapFromEvents<TEvent>>; };
+};
+type EventPayloadMapFromEvents<TEvent extends EventObject> = { [E in TEvent as E['type']]: DistributiveOmit<E, 'type'>; };
+type Compute<A> = A extends any ? { [K in keyof A]: A[K]; } : never;
+type AnyStore = Store<any, any, any>;
+type SnapshotFromStore<TStore extends Store<any, any, any>> = TStore extends Store<infer TContext, any, any> ? StoreSnapshot<TContext> : never;
+/**
+ * Extract the type of events from a `Store`.
+ *
+ * @example
+ *
+ * ```ts
+ * const store = createStore(
+ *   { count: 0 },
+ *   {
+ *     inc: (context, event: { by: number }) => ({
+ *       count: context.count + event.by
+ *     }),
+ *     dec: (context, event: { by: number }) => ({
+ *       count: context.count - event.by
+ *     })
+ *   }
+ * );
+ * type StoreEvent = EventFromStore<typeof store>;
+ * //   ^? { type: 'inc', by: number } | { type: 'dec', by: number }
+ * ```
+ *
+ * @example
+ *
+ * Using utility types derived from `EventFromStore` to create individual
+ * type-safe event transition functions for a store:
+ *
+ * ```ts
+ * import {
+ *   createStore,
+ *   type EventFromStore,
+ *   type Store
+ * } from '@systemfsoftware/xstate-store';
+ *
+ * // Extract the event where `Type` matches the event's `type` from the given
+ * // `Store`.
+ * type EventByType<
+ *   TStore extends Store<any, any>,
+ *   Type extends EventFromStore<TStore>['type']
+ * > = Extract<EventFromStore<TStore>, { type: Type }>;
+ *
+ * // Extract a specific store event's "input" type (the event type without the
+ * // `type` property).
+ * type EventInputByType<
+ *   TStore extends Store<any, any>,
+ *   Type extends EventFromStore<TStore>['type']
+ * > = Omit<EventByType<TStore, Type>, 'type'>;
+ *
+ * const store = createStore(
+ *   { count: 0 },
+ *   {
+ *     add: (context, event: { addend: number }) => ({
+ *       count: context.count + event.addend
+ *     }),
+ *     multiply: (context, event: { multiplier: number }) => ({
+ *       count: context.count * event.multiplier
+ *     })
+ *   }
+ * );
+ *
+ * const add = (input: EventInputByType<typeof store, 'add'>) =>
+ *   store.send({ type: 'add', addend: input.addend });
+ *
+ * add({ addend: 1 }); // sends { type: 'add', addend: 1 }
+ *
+ * const multiply = (input: EventInputByType<typeof store, 'multiply'>) =>
+ *   store.send({ type: 'multiply', multiplier: input.multiplier });
+ *
+ * multiply({ multiplier: 2 }); // sends { type: 'multiply', multiplier: 2 }
+ * ```
+ */
+type EventFromStore<TStore extends Store<any, any, any>> = TStore extends Store<infer _TContext, infer TEventPayloadMap, infer _TEmitted> ? ExtractEvents<TEventPayloadMap> : never;
+interface InteropSubscribable<T> {
+  subscribe(observer: Observer<T>): Subscription;
+}
+interface InteropObservable<T> {
+  [Symbol.observable]: () => InteropSubscribable<T>;
+}
+type Observer<T> = {
+  next?: ((value: T) => void) | undefined;
+  error?: ((err: unknown) => void) | undefined;
+  complete?: (() => void) | undefined;
+};
+interface Subscription {
+  unsubscribe(): void;
+}
+interface Subscribable<T> extends InteropSubscribable<T> {
+  subscribe(observer: Observer<T>): Subscription;
+  subscribe(next: (value: T) => void, error?: (error: any) => void, complete?: () => void): Subscription;
+}
+type StoreContext = Record<string, any>;
+/** The full definition of an event, with a string `type`. */
+type EventObject = {
+  /** The type of event that is sent. */
+  type: string;
+};
+type Values<T> = T[keyof T];
+interface StoreBaseInspectionEventProperties {
+  rootId: string;
+  /**
+   * The relevant actorRef for the inspection event.
+   *
+   * For store transition events, this is the `actorRef` of the store.
+   */
+  actorRef: ActorRefLike;
+}
+interface StoreInspectionEvent extends StoreBaseInspectionEventProperties {
+  type: '@xstate.transition';
+  event: AnyEventObject;
+  snapshot: Snapshot<unknown>;
+}
+interface AnyEventObject {
+  type: string;
+  [key: string]: any;
+}
+type StoreInspectedSnapshotEvent = StoreInspectionEvent;
+type StoreInspectedActionEvent = StoreInspectionEvent;
+type StoreInspectedEventEvent = StoreInspectionEvent;
+type StoreInspectedActorEvent = StoreInspectionEvent;
+type ActorRefLike = {
+  sessionId: string;
+  send: (event: any) => void;
+  getSnapshot: () => any;
+};
+type Selector<TContext, TSelected> = (context: TContext) => TSelected;
+type Selection<TSelected> = Readable<TSelected>;
+type StoreSelectorsConfig<TContext extends StoreContext> = Record<string, Selector<TContext, any>>;
+type ResolvedStoreSelectors<TContext extends StoreContext, TSelectors extends StoreSelectorsConfig<TContext>> = { [K in keyof TSelectors]: Selection<ReturnType<TSelectors[K]>>; };
+type StoreWithSelectors<TContext extends StoreContext, TEventPayloadMap extends EventPayloadMap, TEmitted extends EventObject, TSelectors extends StoreSelectorsConfig<TContext>> = Omit<Store<TContext, TEventPayloadMap, TEmitted>, 'with'> & {
+  selectors: ResolvedStoreSelectors<TContext, TSelectors>;
+  with<TNewEventPayloadMap extends EventPayloadMap>(extension: StoreExtension<TContext, TEventPayloadMap, TNewEventPayloadMap, TEmitted>): StoreWithSelectors<TContext, TEventPayloadMap & TNewEventPayloadMap, TEmitted, TSelectors>;
+};
+interface StoreLogicCreator<TContext extends StoreContext, TEventPayloadMap extends EventPayloadMap, TEmitted extends EventObject, TInput, TSelectors extends StoreSelectorsConfig<TContext>> {
+  createStore: undefined extends TInput ? (input?: TInput) => StoreWithSelectors<TContext, TEventPayloadMap, TEmitted, TSelectors> : (input: TInput) => StoreWithSelectors<TContext, TEventPayloadMap, TEmitted, TSelectors>;
+}
+type AnyStoreLogicCreator = StoreLogicCreator<any, any, any, any, any>;
+type StoreFromStoreLogicCreator<TLogic extends AnyStoreLogicCreator> = TLogic extends StoreLogicCreator<infer TContext, infer TEventPayloadMap, infer TEmitted, any, infer TSelectors> ? StoreWithSelectors<TContext, TEventPayloadMap, TEmitted, TSelectors> : never;
+type InputFromStoreLogicCreator<TLogic extends AnyStoreLogicCreator> = TLogic extends StoreLogicCreator<any, any, any, infer TInput, any> ? TInput : never;
+interface Readable<T> extends Subscribable<T> {
+  get: () => T;
+}
+interface BaseAtom<T> extends Subscribable<T>, Readable<T> {}
+interface Atom<T> extends BaseAtom<T> {
+  /** Sets the value of the atom using a function. */
+  set(fn: (prevVal: T) => T): void;
+  /** Sets the value of the atom. */
+  set(value: T): void;
+}
+interface ReducerAtom<TState, TEvent> extends BaseAtom<TState> {
+  send: (event: TEvent) => void;
+}
+interface AtomOptions<T> {
+  compare?: (prev: T, next: T) => boolean;
+}
+interface AtomConfig<TValue, TInput> {
+  createAtom: undefined extends TInput ? (input?: TInput) => Atom<TValue> : (input: TInput) => Atom<TValue>;
+}
+type AnyAtomConfig = AtomConfig<any, any>;
+type ValueFromAtomConfig<TConfig extends AnyAtomConfig> = TConfig extends AtomConfig<infer TValue, any> ? TValue : never;
+type InputFromAtomConfig<TConfig extends AnyAtomConfig> = TConfig extends AtomConfig<any, infer TInput> ? TInput : never;
+type AnyAtom = BaseAtom<any>;
+/**
+ * An atom that is read-only and cannot be set.
+ *
+ * @example
+ *
+ * ```ts
+ * const atom = createAtom(() => 42);
+ * // @ts-expect-error - Cannot set a readonly atom
+ * atom.set(43);
+ * ```
+ */
+interface ReadonlyAtom<T> extends BaseAtom<T> {}
+/** A version of `Omit` that works with distributive types. */
+type DistributiveOmit<T, K extends PropertyKey> = T extends any ? Omit<T, K> : never;
+type StoreLogic<TSnapshot extends StoreSnapshot<any>, TEvent extends EventObject, TEmitted extends EventObject> = {
+  eventTypes?: readonly string[] | undefined;
+  schemas?: StoreSchemas<any, any, any> | undefined;
+  warn?: ((message: string) => void) | undefined;
+  getInitialSnapshot: () => TSnapshot;
+  transition: (snapshot: TSnapshot, event: TEvent) => StoreTransitionResult<TSnapshot, TEmitted>;
+};
+/**
+ * A store extension that transforms store logic, optionally adding new events.
+ *
+ * @example
+ *
+ * ```ts
+ * const store = createStore({
+ *   context: { count: 0 },
+ *   on: { inc: (ctx) => ({ count: ctx.count + 1 }) }
+ * }).with(undoRedo());
+ * ```
+ */
+type StoreExtension<TContext extends StoreContext, TEventPayloadMap extends EventPayloadMap, TNewEventPayloadMap extends EventPayloadMap, TEmitted extends EventObject> = (logic: StoreLogic<StoreSnapshot<TContext>, ExtractEvents<TEventPayloadMap>, TEmitted>) => StoreLogic<StoreSnapshot<TContext>, ExtractEvents<TEventPayloadMap> | ExtractEvents<TNewEventPayloadMap>, TEmitted>;
+type AnyStoreConfig = StoreConfig<any, any, any, any, any, any>;
+type EventFromStoreConfig<TStore extends AnyStoreConfig> = TStore extends StoreConfig<any, infer TEventPayloadMap, any, any, infer TEventSchemaMap, any> ? ExtractEvents<ResolveStoreEventPayloadMap<TEventPayloadMap, TEventSchemaMap>> : never;
+type EmitsFromStoreConfig<TStore extends AnyStoreConfig> = TStore extends StoreConfig<any, any, infer TEmittedPayloadMap, any, any, infer TEmittedSchemaMap> ? ExtractEvents<ResolveStoreEmittedPayloadMap<TEmittedPayloadMap, TEmittedSchemaMap>> : never;
+type ContextFromStoreConfig<TStore extends AnyStoreConfig> = TStore extends StoreConfig<infer TContext, any, any, infer TContextSchema, any, any> ? ResolveStoreContext<TContext, TContextSchema> : never;
+type StoreFromStoreConfig<TConfig extends AnyStoreConfig> = TConfig extends StoreConfig<infer TContext, any, infer TEmittedPayloadMap, infer TContextSchema, any, infer TEmittedSchemaMap> ? Store<ResolveStoreContext<TContext, TContextSchema>, StoreEventPayloadMapFromConfig<TConfig>, ExtractEvents<ResolveStoreEmittedPayloadMap<TEmittedPayloadMap, TEmittedSchemaMap>>> : never;
+export { StoreSchemas as $, ResolveStoreEventPayloadMap as A, StoreContext as B, InputFromStoreLogicCreator as C, ReducerAtom as D, ReadonlyAtom as E, SpecificStoreConfig as F, StoreFromStoreLogicCreator as G, StoreEffectEnqueue as H, StandardSchemaMap as I, StoreInspectedEventEvent as J, StoreInspectedActionEvent as K, Store as L, Selection as M, Selector as N, ResolveStoreContext as O, SnapshotFromStore as P, StoreLogicCreator as Q, StoreAssigner as R, InputFromAtomConfig as S, Readable as T, StoreExtension as U, StoreEffect as V, StoreFromStoreConfig as W, StoreInspectionEvent as X, StoreInspectedSnapshotEvent as Y, StoreLogic as Z, EventObject as _, AnyStoreConfig as a, TriggerObject as at, InferSchemaOutput as b, AtomConfig as c, CanObject as d, StoreSelectorsConfig as et, ContextFromStoreConfig as f, EventFromStoreConfig as g, EventFromStore as h, AnyStore as i, Subscription as it, ResolvedStoreSelectors as j, ResolveStoreEmittedPayloadMap as k, AtomOptions as l, EnqueueObject as m, AnyAtom as n, StoreWithSelectors as nt, AnyStoreLogicCreator as o, ValueFromAtomConfig as ot, EmitsFromStoreConfig as p, StoreInspectedActorEvent as q, AnyAtomConfig as r, Subscribable as rt, Atom as s, StandardSchemaV1 as st, ActorRefLike as t, StoreSnapshot as tt, BaseAtom as u, EventPayloadMap as v, Observer as w, InferSchemaPayloadMap as x, ExtractEvents as y, StoreConfig as z };

package/dist/undo.d.ts

@@ -0,0 +1,77 @@
+import { B as StoreContext, U as StoreExtension, _ as EventObject, m as EnqueueObject, tt as StoreSnapshot, v as EventPayloadMap, y as ExtractEvents } from "./types-0n0RpfhK.js";
+interface UndoRedoEventOptions<TContext extends StoreContext, TEvent extends EventObject> {
+  /** A function that returns the transaction ID of an event. */
+  getTransactionId?: (event: TEvent, snapshot: StoreSnapshot<TContext>) => string | null | undefined;
+  /**
+   * A function that returns whether an event should be skipped during
+   * undo/redo. Skipped events are not stored in history and are not replayed
+   * during undo/redo.
+   */
+  skipEvent?: (event: TEvent, snapshot: StoreSnapshot<TContext>) => boolean;
+}
+interface UndoRedoSnapshotOptions<TContext extends StoreContext, TEvent extends EventObject, TEmitted extends EventObject, TEventPayloadMap extends EventPayloadMap> {
+  /** A function that returns the transaction ID of an event. */
+  getTransactionId?: (event: TEvent, snapshot: StoreSnapshot<TContext>) => string | null | undefined;
+  /**
+   * A function that returns whether a snapshot should be skipped during
+   * undo/redo. Skipped events don't save snapshots to history.
+   */
+  skipEvent?: (event: TEvent, snapshot: StoreSnapshot<TContext>) => boolean;
+  /** Maximum number of snapshots to keep in history. Defaults to Infinity. */
+  historyLimit?: number;
+  /**
+   * A function to compare snapshots for equality. When true, the new snapshot
+   * will not be added to history. Useful for avoiding duplicate snapshots.
+   */
+  compare?: (pastSnapshot: StoreSnapshot<TContext>, currentSnapshot: StoreSnapshot<TContext>) => boolean;
+  /** Customizes the context restored by snapshot-based undo/redo. */
+  restore?: (args: {
+    current: TContext;
+    next: TContext;
+    direction: 'undo' | 'redo';
+  }, enqueue: EnqueueObject<TContext, TEmitted, TEventPayloadMap>) => TContext;
+}
+type UndoRedoStrategyOptions<TContext extends StoreContext, TEvent extends EventObject, TEmitted extends EventObject, TEventPayloadMap extends EventPayloadMap> = ({
+  strategy?: 'event';
+} & UndoRedoEventOptions<TContext, TEvent>) | ({
+  strategy: 'snapshot';
+} & UndoRedoSnapshotOptions<TContext, TEvent, TEmitted, TEventPayloadMap>);
+/**
+ * Creates store logic with undo/redo functionality.
+ *
+ * Supports two strategies:
+ *
+ * - 'event' (default): Maintains event history and replays events
+ * - 'snapshot': Maintains snapshot history for faster undo/redo
+ *
+ * @example
+ *
+ * ```ts
+ * const store = createStore({
+ *   context: { count: 0 },
+ *   on: {
+ *     inc: (ctx) => ({ count: ctx.count + 1 })
+ *   }
+ * }).with(undoRedo());
+ *
+ * store.trigger.inc();
+ * store.trigger.undo(); // count = 0
+ * ```
+ *
+ * @example
+ *
+ * ```ts
+ * // Snapshot strategy
+ * const store = createStore({
+ *   context: { count: 0 },
+ *   on: { inc: (ctx) => ({ count: ctx.count + 1 }) }
+ * }).with(undoRedo({ strategy: 'snapshot', historyLimit: 10 }));
+ * ```
+ *
+ * @returns Store extension with additional `undo` and `redo` event handlers
+ */
+export declare function undoRedo<TContext extends StoreContext, TEventPayloadMap extends EventPayloadMap, TEmitted extends EventObject>(options?: UndoRedoStrategyOptions<TContext, ExtractEvents<TEventPayloadMap>, TEmitted, TEventPayloadMap>): StoreExtension<TContext, TEventPayloadMap, {
+  undo: null;
+  redo: null;
+}, TEmitted>;
+export {};