xstate 6.0.0-alpha.39 → 6.0.0-alpha.40

package/dist/declarations/src/machineVersions.d.ts

@@ -1,4 +1,6 @@
-import type { AnyMachineSchemas } from "./types.v6.js";
+import type { StandardSchemaV1 } from "./schema.types.js";
+import type { MachineEventSchema, MachineSnapshotSchema, MachineVersionDescriptor } from "./machineVersion.types.js";
+export type { MachineEventSchema, MachineSnapshotSchema, MachineVersionDescriptor, PersistedMachineSnapshot } from "./machineVersion.types.js";
 import type { AnyStateMachine, ContextFrom, EventFrom, PersistedSnapshotFor, Snapshot } from "./types.js";
 export type PersistedMachineIdentity<TMachine extends AnyStateMachine = AnyStateMachine> = {
     id: TMachine['id'];
@@ -6,8 +8,10 @@ export type PersistedMachineIdentity<TMachine extends AnyStateMachine = AnyState
 };
 type VersionedStateMachine = AnyStateMachine & {
     version: string;
-    schemas?: AnyMachineSchemas;
+    snapshotSchema: MachineSnapshotSchema;
+    eventSchema: MachineEventSchema;
 };
+type VersionEntry = MachineVersionDescriptor;
 export type PersistedSnapshotFrom<TMachine extends AnyStateMachine> = Snapshot<unknown> & PersistedSnapshotFor<TMachine> & {
     context: ContextFrom<TMachine>;
     machine: PersistedMachineIdentity<TMachine>;
@@ -17,54 +21,80 @@ export type PersistedSnapshotDataFrom<TMachine extends AnyStateMachine> = Snapsh
     context: ContextFrom<TMachine>;
     [key: string]: unknown;
 };
-export type ParsedPersistedSnapshot<TMachines extends readonly AnyStateMachine[]> = {
-    [K in keyof TMachines]: TMachines[K] extends AnyStateMachine ? {
-        machine: TMachines[K];
-        snapshot: PersistedSnapshotFrom<TMachines[K]>;
+export type ParsedPersistedSnapshot<TEntries extends readonly VersionEntry[]> = {
+    [K in keyof TEntries]: TEntries[K] extends VersionEntry ? TEntries[K] extends VersionedStateMachine ? {
+        source: TEntries[K];
+        machine: TEntries[K];
+        snapshot: PersistedSnapshotFromEntry<TEntries[K]>;
+    } : {
+        source: TEntries[K];
+        snapshot: PersistedSnapshotFromEntry<TEntries[K]>;
     } : never;
 }[number];
-export type MachineVersionsOptions<TMachines extends readonly AnyStateMachine[]> = {
-    unversioned?: NonNullable<TMachines[number]['version']>;
+export type MachineVersionsOptions<TEntries extends readonly VersionEntry[]> = {
+    unversioned?: SnapshotSourceVersion<TEntries>;
 };
 type MaybePromise<T> = T | PromiseLike<T>;
-type MachineVersion<TMachines extends readonly VersionedStateMachine[]> = TMachines[number]['version'];
-type MachineForVersion<TMachines extends readonly VersionedStateMachine[], TVersion extends string> = {
-    [K in keyof TMachines]: TMachines[K] extends VersionedStateMachine ? TMachines[K]['version'] extends TVersion ? TMachines[K] : never : never;
+type MachineVersion<TEntries extends readonly VersionEntry[]> = Extract<TEntries[number], VersionedStateMachine>['version'];
+type SnapshotSourceVersion<TEntries extends readonly VersionEntry[]> = {
+    [K in keyof TEntries]: TEntries[K] extends VersionedStateMachine | {
+        snapshotSchema: MachineSnapshotSchema;
+    } ? TEntries[K]['version'] : never;
 }[number];
+type EventSourceVersion<TEntries extends readonly VersionEntry[]> = {
+    [K in keyof TEntries]: TEntries[K] extends VersionedStateMachine | {
+        eventSchema: MachineEventSchema;
+    } ? TEntries[K]['version'] : never;
+}[number];
+type MachineForVersion<TEntries extends readonly VersionEntry[], TVersion extends string> = {
+    [K in keyof TEntries]: TEntries[K] extends VersionedStateMachine ? TEntries[K]['version'] extends TVersion ? TEntries[K] : never : never;
+}[number];
+type SnapshotEntryForVersion<TEntries extends readonly VersionEntry[], TVersion extends string> = {
+    [K in keyof TEntries]: TEntries[K] extends VersionedStateMachine | {
+        snapshotSchema: MachineSnapshotSchema;
+    } ? TEntries[K]['version'] extends TVersion ? TEntries[K] : never : never;
+}[number];
+type EventEntryForVersion<TEntries extends readonly VersionEntry[], TVersion extends string> = {
+    [K in keyof TEntries]: TEntries[K] extends VersionedStateMachine | {
+        eventSchema: MachineEventSchema;
+    } ? TEntries[K]['version'] extends TVersion ? TEntries[K] : never : never;
+}[number];
+type PersistedSnapshotFromEntry<TEntry extends VersionEntry> = TEntry extends {
+    snapshotSchema: infer TSchema extends MachineSnapshotSchema;
+} ? StandardSchemaV1.InferOutput<TSchema> : TEntry extends VersionedStateMachine ? PersistedSnapshotFrom<TEntry> : never;
+type EventFromEntry<TEntry extends VersionEntry> = TEntry extends {
+    eventSchema: infer TSchema extends MachineEventSchema;
+} ? StandardSchemaV1.InferOutput<TSchema> : TEntry extends VersionedStateMachine ? EventFrom<TEntry> : never;
 export type PersistedSnapshotSource = {
     id?: string;
     version?: string;
 };
-export type SnapshotMigrationHandlers<TMachines extends readonly VersionedStateMachine[], TTarget extends VersionedStateMachine> = {
-    [TVersion in Exclude<MachineVersion<TMachines>, TTarget['version']>]?: (snapshot: PersistedSnapshotFrom<MachineForVersion<TMachines, TVersion>>) => MaybePromise<PersistedSnapshotDataFrom<TTarget>>;
+export type SnapshotMigrationHandlers<TEntries extends readonly VersionEntry[], TTarget extends VersionedStateMachine> = {
+    [TVersion in Exclude<SnapshotSourceVersion<TEntries>, TTarget['version']>]?: (snapshot: PersistedSnapshotFromEntry<SnapshotEntryForVersion<TEntries, TVersion>>) => MaybePromise<PersistedSnapshotDataFrom<TTarget>>;
 } & {
     '*'?: (snapshot: unknown, source: PersistedSnapshotSource) => MaybePromise<PersistedSnapshotDataFrom<TTarget>>;
 };
-export type MigrateSnapshotOptions<TMachines extends readonly VersionedStateMachine[], TTargetVersion extends MachineVersion<TMachines>> = {
+export type MigrateSnapshotOptions<TEntries extends readonly VersionEntry[], TTargetVersion extends MachineVersion<TEntries>> = {
     to: TTargetVersion;
-    migrations: SnapshotMigrationHandlers<TMachines, MachineForVersion<TMachines, TTargetVersion>>;
+    migrations: SnapshotMigrationHandlers<TEntries, MachineForVersion<TEntries, TTargetVersion>>;
 };
 export type EventHistorySource = {
     id?: string;
     version?: string;
 };
-export type EventAdapterHandlers<TMachines extends readonly VersionedStateMachine[], TTarget extends VersionedStateMachine> = {
-    [TVersion in Exclude<MachineVersion<TMachines>, TTarget['version']>]?: (events: readonly EventFrom<MachineForVersion<TMachines, TVersion>>[]) => MaybePromise<readonly EventFrom<TTarget>[]>;
+export type EventAdapterHandlers<TEntries extends readonly VersionEntry[], TTarget extends VersionedStateMachine> = {
+    [TVersion in Exclude<EventSourceVersion<TEntries>, TTarget['version']>]?: (events: readonly EventFromEntry<EventEntryForVersion<TEntries, TVersion>>[]) => MaybePromise<readonly EventFrom<TTarget>[]>;
 } & {
     '*'?: (events: readonly unknown[], source: EventHistorySource) => MaybePromise<readonly EventFrom<TTarget>[]>;
 };
-export type AdaptEventsOptions<TMachines extends readonly VersionedStateMachine[], TTargetVersion extends MachineVersion<TMachines>> = {
+export type AdaptEventsOptions<TEntries extends readonly VersionEntry[], TTargetVersion extends MachineVersion<TEntries>> = {
     from: EventHistorySource;
     to: TTargetVersion;
-    adapters: EventAdapterHandlers<TMachines, MachineForVersion<TMachines, TTargetVersion>>;
+    adapters: EventAdapterHandlers<TEntries, MachineForVersion<TEntries, TTargetVersion>>;
 };
-/** Creates migration and adaptation utilities backed by retained versions of one machine. */
-export declare function machineVersions<const TMachines extends readonly [
-    VersionedStateMachine,
-    ...VersionedStateMachine[]
-]>(machines: TMachines, options?: MachineVersionsOptions<TMachines>): {
-    parseSnapshot: (raw: unknown) => Promise<ParsedPersistedSnapshot<TMachines>>;
-    adaptEvents<TTargetVersion extends MachineVersion<TMachines>>(events: readonly unknown[], adaptationOptions: AdaptEventsOptions<TMachines, TTargetVersion>): Promise<EventFrom<MachineForVersion<TMachines, TTargetVersion>>[]>;
-    migrateSnapshot<TTargetVersion extends MachineVersion<TMachines>>(raw: unknown, migrationOptions: MigrateSnapshotOptions<TMachines, TTargetVersion>): Promise<PersistedSnapshotFrom<MachineForVersion<TMachines, TTargetVersion>>>;
+/** Creates migration and adaptation utilities for versions of one machine. */
+export declare function machineVersions<const TEntries extends readonly [VersionEntry, ...VersionEntry[]]>(entries: TEntries, options?: MachineVersionsOptions<TEntries>): {
+    parseSnapshot: (raw: unknown) => Promise<ParsedPersistedSnapshot<TEntries>>;
+    adaptEvents<TTargetVersion extends MachineVersion<TEntries>>(events: readonly unknown[], adaptationOptions: AdaptEventsOptions<TEntries, TTargetVersion>): Promise<EventFrom<MachineForVersion<TEntries, TTargetVersion>>[]>;
+    migrateSnapshot<TTargetVersion extends MachineVersion<TEntries>>(raw: unknown, migrationOptions: MigrateSnapshotOptions<TEntries, TTargetVersion>): Promise<PersistedSnapshotFrom<MachineForVersion<TEntries, TTargetVersion>>>;
 };
-export {};

package/dist/declarations/src/types.d.ts

@@ -349,6 +349,8 @@ export interface AnyStateMachine extends AnyActorLogic {
     config: any;
     version?: string;
     schemas?: import("./types.v6.js").AnyMachineSchemas;
+    snapshotSchema: import("./machineVersion.types.js").MachineSnapshotSchema;
+    eventSchema: import("./machineVersion.types.js").MachineEventSchema;
     provide(sources: any): AnyStateMachine;
     resolveState(config: any): any;
     getTransitionData(snapshot: any, event: any, actorScope: AnyActorScope, selectionResults?: Map<AnyTransitionDefinition, unknown>): AnyTransitionDefinition[];
@@ -532,15 +534,29 @@ export interface TimerEvent extends EventObject {
 declare const persistedSnapshotLogic: unique symbol;
 type PersistedSnapshotLogicIdentity<TLogic> = TLogic extends {
     readonly id: infer TId extends string;
-    readonly version: infer TVersion extends string;
 } ? {
     readonly id: TId;
-    readonly version: TVersion;
+    readonly version: TLogic extends {
+        readonly version: infer TVersion extends string;
+    } ? TVersion : string;
 } : never;
 /** A persisted snapshot tied to a versioned actor logic identity. */
 export type PersistedSnapshotFor<TLogic> = {
     readonly [persistedSnapshotLogic]: PersistedSnapshotLogicIdentity<TLogic>;
 };
+/**
+ * A persisted snapshot restorable into the given actor logic: any snapshot
+ * created by logic with the same machine `id` is accepted, regardless of
+ * version (version mismatches are handled at runtime, e.g. by `migrate`).
+ */
+export type RestorablePersistedSnapshotFor<TLogic> = {
+    readonly [persistedSnapshotLogic]: TLogic extends {
+        readonly id: infer TId extends string;
+    } ? {
+        readonly id: TId;
+        readonly version: string;
+    } : never;
+};
 export interface ActorOptions<TLogic extends AnyActorLogic> {
     /**
      * The clock that is responsible for setting and clearing timeouts, such as
@@ -589,7 +605,7 @@ export interface ActorOptions<TLogic extends AnyActorLogic> {
      * Can be generated with {@link Actor.getPersistedSnapshot}.
      * @see https://stately.ai/docs/persistence
      */
-    snapshot?: Snapshot<unknown> & Partial<PersistedSnapshotFor<DoNotInfer<TLogic>>>;
+    snapshot?: Snapshot<unknown> & Partial<RestorablePersistedSnapshotFor<DoNotInfer<TLogic>>>;
     /** @deprecated Use `snapshot` instead. */
     state?: Snapshot<unknown>;
     /** The source actor logic. */