xstate 5.0.0-beta.12 → 5.0.0-beta.13

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

@@ -1,4 +1,4 @@
-import { MachineConfig, EventObject, AnyEventObject, MachineContext, ActorMap, InternalMachineImplementations, ParameterizedObject } from './types.ts';
-import { TypegenConstraint, TypegenDisabled, ResolveTypegenMeta } from './typegenTypes.ts';
-import { StateMachine } from './StateMachine.ts';
+import { MachineConfig, EventObject, AnyEventObject, MachineContext, ActorMap, InternalMachineImplementations, ParameterizedObject } from "./types.js";
+import { TypegenConstraint, TypegenDisabled, ResolveTypegenMeta } from "./typegenTypes.js";
+import { StateMachine } from "./StateMachine.js";
 export declare function createMachine<TContext extends MachineContext, TEvent extends EventObject = AnyEventObject, TActorMap extends ActorMap = ActorMap, TTypesMeta extends TypegenConstraint = TypegenDisabled>(config: MachineConfig<TContext, TEvent, ParameterizedObject, TActorMap, TTypesMeta>, implementations?: InternalMachineImplementations<TContext, TEvent, ResolveTypegenMeta<TTypesMeta, TEvent, ParameterizedObject, TActorMap>>): StateMachine<TContext, TEvent, ParameterizedObject, TActorMap, ResolveTypegenMeta<TTypesMeta, TEvent, ParameterizedObject, TActorMap>>;

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

@@ -1,4 +1,4 @@
-import { Clock } from './interpreter.ts';
+import { Clock } from "./interpreter.js";
 export interface SimulatedClock extends Clock {
     start(speed: number): void;
     increment(ms: number): void;

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

@@ -1,6 +1,6 @@
-import type { StateNode } from './StateNode.ts';
-import { TypegenDisabled, TypegenEnabled } from './typegenTypes.ts';
-import type { ActorRef, AnyState, AnyStateMachine, BaseActionObject, EventObject, HistoryValue, MachineContext, PersistedMachineState, Prop, StateConfig, StateValue, TransitionDefinition } from './types.ts';
+import type { StateNode } from "./StateNode.js";
+import { TypegenDisabled, TypegenEnabled } from "./typegenTypes.js";
+import type { ActorRef, AnyState, AnyStateMachine, BaseActionObject, EventObject, HistoryValue, MachineContext, PersistedMachineState, Prop, StateConfig, StateValue, TransitionDefinition } from "./types.js";
 export declare function isStateConfig<TContext extends MachineContext, TEvent extends EventObject>(state: any): state is StateConfig<TContext, TEvent>;
 /**
  * @deprecated Use `isStateConfig(object)` or `state instanceof State` instead.

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

@@ -1,7 +1,7 @@
-import { State } from './State.ts';
-import { StateNode } from './StateNode.ts';
-import type { AreAllImplementationsAssumedToBeProvided, MarkAllImplementationsAsProvided, ResolveTypegenMeta, TypegenDisabled } from './typegenTypes.ts';
-import type { ActorContext, ActorMap, ActorBehavior, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineTypes, NoInfer, StateConfig, StateMachineDefinition, StateValue, TransitionDefinition, PersistedMachineState, ParameterizedObject, AnyActorContext } from './types.ts';
+import { State } from "./State.js";
+import { StateNode } from "./StateNode.js";
+import type { AreAllImplementationsAssumedToBeProvided, MarkAllImplementationsAsProvided, ResolveTypegenMeta, TypegenDisabled } from "./typegenTypes.js";
+import type { ActorContext, ActorMap, ActorBehavior, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineTypes, NoInfer, StateConfig, StateMachineDefinition, StateValue, TransitionDefinition, PersistedMachineState, ParameterizedObject, AnyActorContext } from "./types.js";
 export declare const NULL_EVENT = "";
 export declare const STATE_IDENTIFIER = "#";
 export declare const WILDCARD = "*";

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

@@ -1,6 +1,6 @@
-import type { EventObject, StateNodeDefinition, TransitionDefinition, DelayedTransitionDefinition, StateNodeConfig, StateNodesConfig, InvokeDefinition, Mapper, PropertyMapper, TransitionDefinitionMap, InitialTransitionDefinition, MachineContext, BaseActionObject } from './types.ts';
-import type { State } from './State.ts';
-import type { StateMachine } from './StateMachine.ts';
+import type { EventObject, StateNodeDefinition, TransitionDefinition, DelayedTransitionDefinition, StateNodeConfig, StateNodesConfig, InvokeDefinition, Mapper, PropertyMapper, TransitionDefinitionMap, InitialTransitionDefinition, MachineContext, BaseActionObject } from "./types.js";
+import type { State } from "./State.js";
+import type { StateMachine } from "./StateMachine.js";
 interface StateNodeOptions<TContext extends MachineContext, TEvent extends EventObject> {
     _key: string;
     _parent?: StateNode<TContext, TEvent>;

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

@@ -1,4 +1,4 @@
-import { ActionTypes } from './types.ts';
+import { ActionTypes } from "./types.js";
 export declare const stop = ActionTypes.Stop;
 export declare const raise = ActionTypes.Raise;
 export declare const send = ActionTypes.Send;

package/dist/declarations/src/actions/assign.d.ts

@@ -1,4 +1,4 @@
-import type { EventObject, Assigner, PropertyAssigner, MachineContext, DynamicAssignAction, LowInfer } from '../types.ts';
+import type { EventObject, Assigner, PropertyAssigner, MachineContext, DynamicAssignAction, LowInfer } from "../types.js";
 /**
  * Updates the current context of the machine.
  *

package/dist/declarations/src/actions/cancel.d.ts

@@ -1,5 +1,5 @@
-import { EventObject, ExprWithMeta, MachineContext } from '../types.ts';
-import { BaseDynamicActionObject, CancelActionObject, DynamicCancelActionObject } from '../index.ts';
+import { EventObject, ExprWithMeta, MachineContext } from "../types.js";
+import { BaseDynamicActionObject, CancelActionObject, DynamicCancelActionObject } from "../index.js";
 /**
  * Cancels an in-flight `send(...)` action. A canceled sent action will not
  * be executed, nor will its event be sent, unless it has already been sent

package/dist/declarations/src/actions/choose.d.ts

@@ -1,3 +1,3 @@
-import { EventObject, ChooseCondition, MachineContext } from '../types.ts';
-import { BaseDynamicActionObject, ChooseAction, ResolvedChooseAction } from '../index.ts';
+import { EventObject, ChooseCondition, MachineContext } from "../types.js";
+import { BaseDynamicActionObject, ChooseAction, ResolvedChooseAction } from "../index.js";
 export declare function choose<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject>(guards: Array<ChooseCondition<TContext, TExpressionEvent>>): BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, ResolvedChooseAction, ChooseAction<TContext, TExpressionEvent>['params']>;

package/dist/declarations/src/actions/log.d.ts

@@ -1,5 +1,5 @@
-import { EventObject, LogExpr, MachineContext, LogActionObject } from '../types.ts';
-import { BaseDynamicActionObject, DynamicLogAction } from '../index.ts';
+import { EventObject, LogExpr, MachineContext, LogActionObject } from "../types.js";
+import { BaseDynamicActionObject, DynamicLogAction } from "../index.js";
 /**
  *
  * @param expr The expression function to evaluate which will be logged.

package/dist/declarations/src/actions/pure.d.ts

@@ -1,5 +1,5 @@
-import { EventObject, SingleOrArray, MachineContext } from '../types.ts';
-import { BaseActionObject, BaseDynamicActionObject, DynamicPureActionObject, PureActionObject } from '..';
+import { EventObject, SingleOrArray, MachineContext } from "../types.js";
+import { BaseActionObject, BaseDynamicActionObject, DynamicPureActionObject, PureActionObject } from "../index.js";
 export declare function pure<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent>(getActions: ({ context, event }: {
     context: TContext;
     event: TExpressionEvent;

package/dist/declarations/src/actions/raise.d.ts

@@ -1,4 +1,4 @@
-import { EventObject, MachineContext, RaiseActionObject, BaseDynamicActionObject, RaiseActionOptions, SendExpr, RaiseActionParams, NoInfer } from '../types.ts';
+import { EventObject, MachineContext, RaiseActionObject, BaseDynamicActionObject, RaiseActionOptions, SendExpr, RaiseActionParams, NoInfer } from "../types.js";
 /**
  * Raises an event. This places the event in the internal event queue, so that
  * the event is immediately consumed by the machine in the current step.

package/dist/declarations/src/actions/send.d.ts

@@ -1,5 +1,5 @@
-import { EventObject, SendActionParams, SendExpr, AnyEventObject, MachineContext } from '../types.ts';
-import { AnyActorRef, BaseDynamicActionObject, Cast, EventFrom, ExprWithMeta, InferEvent, SendActionObject, SendActionOptions } from '../index.ts';
+import { EventObject, SendActionParams, SendExpr, AnyEventObject, MachineContext } from "../types.js";
+import { AnyActorRef, BaseDynamicActionObject, Cast, EventFrom, ExprWithMeta, InferEvent, SendActionObject, SendActionOptions } from "../index.js";
 /**
  * Sends an event. This returns an action that will be read by an interpreter to
  * send the event in the next step, after the current step is finished executing.

package/dist/declarations/src/actions/stop.d.ts

@@ -1,4 +1,4 @@
-import { ActorRef, BaseDynamicActionObject, DynamicStopActionObject, EventObject, Expr, MachineContext, StopActionObject } from '../types.ts';
+import { ActorRef, BaseDynamicActionObject, DynamicStopActionObject, EventObject, Expr, MachineContext, StopActionObject } from "../types.js";
 /**
  * Stops an actor.
  *

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

@@ -1,13 +1,13 @@
-import { Action, EventObject, SingleOrArray, ActionFunction, ActionFunctionMap, ActionTypes, DoneEvent, ErrorPlatformEvent, DoneEventObject, MachineContext, BaseActionObject } from './types.ts';
-import * as actionTypes from './actionTypes.ts';
-export { send, sendTo, sendParent, forwardTo, escalate } from './actions/send.ts';
-export { stop } from './actions/stop.ts';
-export { log } from './actions/log.ts';
-export { cancel } from './actions/cancel.ts';
-export { assign } from './actions/assign.ts';
-export { raise } from './actions/raise.ts';
-export { choose } from './actions/choose.ts';
-export { pure } from './actions/pure.ts';
+import { Action, EventObject, SingleOrArray, ActionFunction, ActionFunctionMap, ActionTypes, DoneEvent, ErrorPlatformEvent, DoneEventObject, MachineContext, BaseActionObject } from "./types.js";
+import * as actionTypes from "./actionTypes.js";
+export { send, sendTo, sendParent, forwardTo, escalate } from "./actions/send.js";
+export { stop } from "./actions/stop.js";
+export { log } from "./actions/log.js";
+export { cancel } from "./actions/cancel.js";
+export { assign } from "./actions/assign.js";
+export { raise } from "./actions/raise.js";
+export { choose } from "./actions/choose.js";
+export { pure } from "./actions/pure.js";
 export { actionTypes };
 export declare const initEvent: {
     type: ActionTypes;

package/dist/declarations/src/actors/callback.d.ts

@@ -1,4 +1,4 @@
-import { InvokeCallback, ActorBehavior, EventObject } from '../types';
+import { InvokeCallback, ActorBehavior, EventObject } from "../types.js";
 export interface CallbackInternalState {
     canceled: boolean;
     receivers: Set<(e: EventObject) => void>;

package/dist/declarations/src/actors/index.d.ts

@@ -1,8 +1,8 @@
-import type { EventObject, ActorRef, BaseActorRef, AnyEventObject } from '../types.ts';
-export { fromTransition } from './transition.ts';
-export { fromPromise } from './promise.ts';
-export { fromObservable, fromEventObservable } from './observable.ts';
-export { fromCallback } from './callback.ts';
+import type { EventObject, ActorRef, BaseActorRef, AnyEventObject } from "../types.js";
+export { fromTransition } from "./transition.js";
+export { fromPromise } from "./promise.js";
+export { fromObservable, fromEventObservable } from "./observable.js";
+export { fromCallback } from "./callback.js";
 export declare const startSignalType = "xstate.init";
 export declare const stopSignalType = "xstate.stop";
 export declare const startSignal: StartSignal;

package/dist/declarations/src/actors/observable.d.ts

@@ -1,4 +1,4 @@
-import { Subscribable, ActorBehavior, EventObject, Subscription } from '../types';
+import { Subscribable, ActorBehavior, EventObject, Subscription } from "../types.js";
 export interface ObservableInternalState<T> {
     subscription: Subscription | undefined;
     status: 'active' | 'done' | 'error' | 'canceled';

package/dist/declarations/src/actors/promise.d.ts

@@ -1,4 +1,4 @@
-import { ActorBehavior } from '../types';
+import { ActorBehavior } from "../types.js";
 export interface PromiseInternalState<T> {
     status: 'active' | 'error' | 'done' | 'canceled';
     data: T | undefined;

package/dist/declarations/src/actors/transition.d.ts

@@ -1,4 +1,4 @@
-import { ActorBehavior, ActorContext, ActorSystem, EventObject } from '../types';
+import { ActorBehavior, ActorContext, ActorSystem, EventObject } from "../types.js";
 /**
  * Returns an actor behavior from a transition function and its initial state.
  *

package/dist/declarations/src/dev/index.d.ts

@@ -1,4 +1,4 @@
-import { AnyInterpreter, DevToolsAdapter } from '../types.ts';
+import { AnyInterpreter, DevToolsAdapter } from "../types.js";
 type ServiceListener = (service: AnyInterpreter) => void;
 export interface XStateDevInterface {
     register: (service: AnyInterpreter) => void;

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

@@ -1,5 +1,5 @@
-import type { EventObject, StateValue, BooleanGuardDefinition, GuardConfig, GuardDefinition, GuardPredicate, MachineContext } from './types.ts';
-import type { State } from './State.ts';
+import type { EventObject, StateValue, BooleanGuardDefinition, GuardConfig, GuardDefinition, GuardPredicate, MachineContext } from "./types.js";
+import type { State } from "./State.js";
 export declare function stateIn<TContext extends MachineContext, TEvent extends EventObject>(stateValue: StateValue): GuardDefinition<TContext, TEvent>;
 export declare function not<TContext extends MachineContext, TEvent extends EventObject>(guard: GuardConfig<TContext, TEvent>): BooleanGuardDefinition<TContext, TEvent>;
 export declare function and<TContext extends MachineContext, TEvent extends EventObject>(guards: Array<GuardConfig<TContext, TEvent>>): BooleanGuardDefinition<TContext, TEvent>;

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

@@ -1,26 +1,26 @@
-import { doneInvoke, forwardTo, sendParent, sendTo } from './actions.ts';
-export { assign } from './actions/assign.ts';
-export { cancel } from './actions/cancel.ts';
-export { choose } from './actions/choose.ts';
-export { log } from './actions/log.ts';
-export { pure } from './actions/pure.ts';
-export { raise } from './actions/raise.ts';
-export { stop } from './actions/stop.ts';
-import { interpret, Interpreter, ActorStatus } from './interpreter.ts';
-import { createMachine } from './Machine.ts';
-import { mapState } from './mapState.ts';
-import { State } from './State.ts';
-import { StateNode } from './StateNode.ts';
-export { SimulatedClock } from './SimulatedClock.ts';
-export { StateMachine } from './StateMachine.ts';
-export { getStateNodes } from './stateUtils.ts';
-export { waitFor } from './waitFor.ts';
-export * from './typegenTypes.ts';
-export * from './types.ts';
-export { matchesState, pathToStateValue, toObserver } from './utils.ts';
+import { doneInvoke, forwardTo, sendParent, sendTo } from "./actions.js";
+export { assign } from "./actions/assign.js";
+export { cancel } from "./actions/cancel.js";
+export { choose } from "./actions/choose.js";
+export { log } from "./actions/log.js";
+export { pure } from "./actions/pure.js";
+export { raise } from "./actions/raise.js";
+export { stop } from "./actions/stop.js";
+import { interpret, Interpreter, ActorStatus } from "./interpreter.js";
+import { createMachine } from "./Machine.js";
+import { mapState } from "./mapState.js";
+import { State } from "./State.js";
+import { StateNode } from "./StateNode.js";
+export { SimulatedClock } from "./SimulatedClock.js";
+export { StateMachine } from "./StateMachine.js";
+export { getStateNodes } from "./stateUtils.js";
+export { waitFor } from "./waitFor.js";
+export * from "./typegenTypes.js";
+export * from "./types.js";
+export { matchesState, pathToStateValue, toObserver } from "./utils.js";
 export { StateNode, State, mapState, sendTo, sendParent, forwardTo, interpret, Interpreter, ActorStatus as InterpreterStatus, doneInvoke, createMachine };
-export { fromPromise, fromObservable, fromCallback, fromEventObservable, fromTransition } from './actors/index.ts';
-export { stateIn, not, and, or } from './guards.ts';
+export { fromPromise, fromObservable, fromCallback, fromEventObservable, fromTransition } from "./actors/index.js";
+export { stateIn, not, and, or } from "./guards.js";
 declare global {
     interface SymbolConstructor {
         readonly observable: symbol;

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

@@ -1,7 +1,7 @@
-import { symbolObservable } from './symbolObservable.ts';
-import { AreAllImplementationsAssumedToBeProvided, MissingImplementationsError } from './typegenTypes.ts';
-import type { ActorSystem, AnyActorBehavior, AnyStateMachine, EventFromBehavior, InterpreterFrom, PersistedStateFrom, RaiseActionObject, SnapshotFrom } from './types.ts';
-import { ActorRef, EventObject, InteropSubscribable, InterpreterOptions, Observer, SendActionObject, Subscription } from './types.ts';
+import { symbolObservable } from "./symbolObservable.js";
+import { AreAllImplementationsAssumedToBeProvided, MissingImplementationsError } from "./typegenTypes.js";
+import type { ActorSystem, AnyActorBehavior, AnyStateMachine, EventFromBehavior, InterpreterFrom, PersistedStateFrom, RaiseActionObject, SnapshotFrom } from "./types.js";
+import { ActorRef, EventObject, InteropSubscribable, InterpreterOptions, Observer, SendActionObject, Subscription } from "./types.js";
 export type SnapshotListener<TBehavior extends AnyActorBehavior> = (state: SnapshotFrom<TBehavior>) => void;
 export type EventListener<TEvent extends EventObject = EventObject> = (event: TEvent) => void;
 export type Listener = () => void;

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

@@ -1,8 +1,8 @@
-import { BaseActionObject, EventObject, StateValue, TransitionConfig, TransitionDefinition, SingleOrArray, StateValueMap, InitialTransitionConfig, MachineContext } from './types.ts';
-import { State } from './State.ts';
-import { NULL_EVENT } from './constants.ts';
-import type { StateNode } from './StateNode.ts';
-import { AnyActorContext, AnyHistoryValue, AnyState, AnyStateMachine, AnyStateNode, AnyTransitionDefinition, DelayedTransitionDefinition, InitialTransitionDefinition, StateFromMachine } from '.';
+import { BaseActionObject, EventObject, StateValue, TransitionConfig, TransitionDefinition, SingleOrArray, StateValueMap, InitialTransitionConfig, MachineContext } from "./types.js";
+import { State } from "./State.js";
+import { NULL_EVENT } from "./constants.js";
+import type { StateNode } from "./StateNode.js";
+import { AnyActorContext, AnyHistoryValue, AnyState, AnyStateMachine, AnyStateNode, AnyTransitionDefinition, DelayedTransitionDefinition, InitialTransitionDefinition, StateFromMachine } from "./index.js";
 type Configuration<TContext extends MachineContext, TE extends EventObject> = Iterable<StateNode<TContext, TE>>;
 type AnyConfiguration = Configuration<any, any>;
 type AdjList = Map<AnyStateNode, Array<AnyStateNode>>;

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

@@ -1,4 +1,4 @@
-import { Compute, EventObject, IndexByType, IsNever, Prop, Values, IsAny, ActorMap, Cast, ParameterizedObject } from './types.ts';
+import { Compute, EventObject, IndexByType, IsNever, Prop, Values, IsAny, ActorMap, Cast, ParameterizedObject } from "./types.js";
 export interface TypegenDisabled {
     '@@xstate/typegen': false;
 }

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

@@ -1,9 +1,9 @@
-import type { StateNode } from './StateNode.ts';
-import type { State } from './State.ts';
-import type { ActorStatus, Clock, Interpreter } from './interpreter.ts';
-import type { StateMachine } from './StateMachine.ts';
-import type { LifecycleSignal } from './actors/index.ts';
-import { TypegenDisabled, ResolveTypegenMeta, TypegenConstraint, MarkAllImplementationsAsProvided, AreAllImplementationsAssumedToBeProvided } from './typegenTypes.ts';
+import type { StateNode } from "./StateNode.js";
+import type { State } from "./State.js";
+import type { ActorStatus, Clock, Interpreter } from "./interpreter.js";
+import type { StateMachine } from "./StateMachine.js";
+import type { LifecycleSignal } from "./actors/index.js";
+import { TypegenDisabled, ResolveTypegenMeta, TypegenConstraint, MarkAllImplementationsAsProvided, AreAllImplementationsAssumedToBeProvided } from "./typegenTypes.js";
 export type AnyFunction = (...args: any[]) => any;
 type ReturnTypeOrValue<T> = T extends AnyFunction ? ReturnType<T> : T;
 export type IsNever<T> = [T] extends [never] ? true : false;

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

@@ -1,7 +1,7 @@
-import { AnyActorBehavior, AnyState } from './index.ts';
-import { NULL_EVENT } from './constants.ts';
-import type { StateNode } from './StateNode.ts';
-import type { ActorBehavior, AnyEventObject, EventObject, EventType, InvokeConfig, MachineContext, Mapper, Observer, PropertyMapper, ErrorEvent, SingleOrArray, StateLike, StateValue, Subscribable, TransitionConfig, TransitionConfigTarget } from './types.ts';
+import { AnyActorBehavior, AnyState } from "./index.js";
+import { NULL_EVENT } from "./constants.js";
+import type { StateNode } from "./StateNode.js";
+import type { ActorBehavior, AnyEventObject, EventObject, EventType, InvokeConfig, MachineContext, Mapper, Observer, PropertyMapper, ErrorEvent, SingleOrArray, StateLike, StateValue, Subscribable, TransitionConfig, TransitionConfigTarget } from "./types.js";
 export declare function keys<T extends object>(value: T): Array<keyof T & string>;
 export declare function matchesState(parentStateId: StateValue, childStateId: StateValue, delimiter?: string): boolean;
 export declare function toStatePath(stateId: string | string[], delimiter: string): string[];

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

@@ -1,4 +1,4 @@
-import { ActorRef, SnapshotFrom } from './types.ts';
+import { ActorRef, SnapshotFrom } from "./types.js";
 interface WaitForOptions {
     /**
      * How long to wait before rejecting, if no emitted

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xstate",
-  "version": "5.0.0-beta.12",
+  "version": "5.0.0-beta.13",
   "description": "Finite State Machines and Statecharts for the Modern Web.",
   "main": "dist/xstate.cjs.js",
   "module": "dist/xstate.esm.js",