1 | import { StateMachine, Event, EventObject, DefaultContext, StateSchema, StateValue, InterpreterOptions, SingleOrArray, DoneEvent, MachineOptions, SCXML, EventData, Observer, Spawnable, Typestate, ActorRef, ActorRefFrom, Behavior, Subscription, StateConfig, InteropSubscribable } from './types';
|
2 | import { State } from './State';
|
3 | import { symbolObservable } from './utils';
|
4 | import { AreAllImplementationsAssumedToBeProvided, TypegenDisabled } from './typegenTypes';
|
5 | export declare type StateListener<TContext, TEvent extends EventObject, TStateSchema extends StateSchema<TContext> = any, TTypestate extends Typestate<TContext> = {
|
6 | value: any;
|
7 | context: TContext;
|
8 | }, TResolvedTypesMeta = TypegenDisabled> = (state: State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>, event: TEvent) => void;
|
9 | export declare type ContextListener<TContext = DefaultContext> = (context: TContext, prevContext: TContext | undefined) => void;
|
10 | export declare type EventListener<TEvent extends EventObject = EventObject> = (event: TEvent) => void;
|
11 | export declare type Listener = () => void;
|
12 | export interface Clock {
|
13 | setTimeout(fn: (...args: any[]) => void, timeout: number): any;
|
14 | clearTimeout(id: any): void;
|
15 | }
|
16 | interface SpawnOptions {
|
17 | name?: string;
|
18 | autoForward?: boolean;
|
19 | sync?: boolean;
|
20 | }
|
21 | export declare enum InterpreterStatus {
|
22 | NotStarted = 0,
|
23 | Running = 1,
|
24 | Stopped = 2
|
25 | }
|
26 | export declare class Interpreter<TContext, TStateSchema extends StateSchema = any, TEvent extends EventObject = EventObject, TTypestate extends Typestate<TContext> = {
|
27 | value: any;
|
28 | context: TContext;
|
29 | }, TResolvedTypesMeta = TypegenDisabled> implements ActorRef<TEvent, State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>> {
|
30 | machine: StateMachine<TContext, TStateSchema, TEvent, TTypestate, any, any, TResolvedTypesMeta>;
|
31 | |
32 |
|
33 |
|
34 |
|
35 |
|
36 |
|
37 | static defaultOptions: {
|
38 | execute: boolean;
|
39 | deferEvents: boolean;
|
40 | clock: Clock;
|
41 | logger: any;
|
42 | devTools: boolean;
|
43 | };
|
44 | |
45 |
|
46 |
|
47 | private _state?;
|
48 | private _initialState?;
|
49 | |
50 |
|
51 |
|
52 | clock: Clock;
|
53 | options: Readonly<InterpreterOptions>;
|
54 | private scheduler;
|
55 | private delayedEventsMap;
|
56 | private listeners;
|
57 | private contextListeners;
|
58 | private stopListeners;
|
59 | private doneListeners;
|
60 | private eventListeners;
|
61 | private sendListeners;
|
62 | private logger;
|
63 | |
64 |
|
65 |
|
66 | initialized: boolean;
|
67 | status: InterpreterStatus;
|
68 | parent?: Interpreter<any>;
|
69 | id: string;
|
70 | |
71 |
|
72 |
|
73 | sessionId: string;
|
74 | children: Map<string | number, ActorRef<any>>;
|
75 | private forwardTo;
|
76 | private devTools?;
|
77 | |
78 |
|
79 |
|
80 |
|
81 |
|
82 |
|
83 | constructor(machine: StateMachine<TContext, TStateSchema, TEvent, TTypestate, any, any, TResolvedTypesMeta>, options?: InterpreterOptions);
|
84 | get initialState(): State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>;
|
85 | get state(): State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>;
|
86 | static interpret: typeof interpret;
|
87 | /**
|
88 | * Executes the actions of the given state, with that state's `context` and `event`.
|
89 | *
|
90 | * @param state The state whose actions will be executed
|
91 | * @param actionsConfig The action implementations to use
|
92 | */
|
93 | execute(state: State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>, actionsConfig?: MachineOptions<TContext, TEvent>['actions']): void;
|
94 | private update;
|
95 | onTransition(listener: StateListener<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>): this;
|
96 | subscribe(observer: Observer<State<TContext, TEvent, any, TTypestate, TResolvedTypesMeta>>): Subscription;
|
97 | subscribe(nextListener?: (state: State<TContext, TEvent, any, TTypestate, TResolvedTypesMeta>) => void, errorListener?: (error: any) => void, completeListener?: () => void): Subscription;
|
98 | /**
|
99 | * Adds an event listener that is notified whenever an event is sent to the running interpreter.
|
100 | * @param listener The event listener
|
101 | */
|
102 | onEvent(listener: EventListener): this;
|
103 | /**
|
104 | * Adds an event listener that is notified whenever a `send` event occurs.
|
105 | * @param listener The event listener
|
106 | */
|
107 | onSend(listener: EventListener): this;
|
108 | /**
|
109 | * Adds a context listener that is notified whenever the state context changes.
|
110 | * @param listener The context listener
|
111 | */
|
112 | onChange(listener: ContextListener<TContext>): this;
|
113 | /**
|
114 | * Adds a listener that is notified when the machine is stopped.
|
115 | * @param listener The listener
|
116 | */
|
117 | onStop(listener: Listener): this;
|
118 | /**
|
119 | * Adds a state listener that is notified when the statechart has reached its final state.
|
120 | * @param listener The state listener
|
121 | */
|
122 | onDone(listener: EventListener<DoneEvent>): this;
|
123 | /**
|
124 | * Removes a listener.
|
125 | * @param listener The listener to remove
|
126 | */
|
127 | off(listener: (...args: any[]) => void): this;
|
128 | /**
|
129 | * Alias for Interpreter.prototype.start
|
130 | */
|
131 | init: (initialState?: StateValue | State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta> | StateConfig<TContext, TEvent> | undefined) => this;
|
132 | /**
|
133 | * Starts the interpreter from the given state, or the initial state.
|
134 | * @param initialState The state to start the statechart from
|
135 | */
|
136 | start(initialState?: State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta> | StateConfig<TContext, TEvent> | StateValue): this;
|
137 | /**
|
138 | * Stops the interpreter and unsubscribe all listeners.
|
139 | *
|
140 | * This will also notify the `onStop` listeners.
|
141 | */
|
142 | stop(): this;
|
143 | /**
|
144 | * Sends an event to the running interpreter to trigger a transition.
|
145 | *
|
146 | * An array of events (batched) can be sent as well, which will send all
|
147 | * batched events to the running interpreter. The listeners will be
|
148 | * notified only **once** when all events are processed.
|
149 | *
|
150 | * @param event The event(s) to send
|
151 | */
|
152 | send: (event: SingleOrArray<Event<TEvent>> | SCXML.Event<TEvent>, payload?: EventData | undefined) => State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>;
|
153 | private batch;
|
154 | /**
|
155 | * Returns a send function bound to this interpreter instance.
|
156 | *
|
157 | * @param event The event to be sent by the sender.
|
158 | */
|
159 | sender(event: Event<TEvent>): () => State<TContext, TEvent, TStateSchema, TTypestate>;
|
160 | private sendTo;
|
161 | /**
|
162 | * Returns the next state given the interpreter's current state and the event.
|
163 | *
|
164 | * This is a pure method that does _not_ update the interpreter's state.
|
165 | *
|
166 | * @param event The event to determine the next state
|
167 | */
|
168 | nextState(event: Event<TEvent> | SCXML.Event<TEvent>): State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>;
|
169 | private forward;
|
170 | private defer;
|
171 | private cancel;
|
172 | private exec;
|
173 | private removeChild;
|
174 | private stopChild;
|
175 | spawn(entity: Spawnable, name: string, options?: SpawnOptions): ActorRef<any>;
|
176 | spawnMachine<TChildContext, TChildStateSchema, TChildEvent extends EventObject>(machine: StateMachine<TChildContext, TChildStateSchema, TChildEvent>, options?: {
|
177 | id?: string;
|
178 | autoForward?: boolean;
|
179 | sync?: boolean;
|
180 | }): ActorRef<TChildEvent, State<TChildContext, TChildEvent>>;
|
181 | private spawnBehavior;
|
182 | private spawnPromise;
|
183 | private spawnCallback;
|
184 | private spawnObservable;
|
185 | private spawnActor;
|
186 | private spawnActivity;
|
187 | private spawnEffect;
|
188 | private attachDev;
|
189 | toJSON(): {
|
190 | id: string;
|
191 | };
|
192 | [Symbol.observable](): InteropSubscribable<State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>>;
|
193 | getSnapshot(): State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>;
|
194 | }
|
195 | export declare function spawn<T extends Behavior<any, any>>(entity: T, nameOrOptions?: string | SpawnOptions): ActorRefFrom<T>;
|
196 | export declare function spawn<TC, TE extends EventObject>(entity: StateMachine<TC, any, TE, any, any, any, any>, nameOrOptions?: string | SpawnOptions): ActorRefFrom<StateMachine<TC, any, TE, any, any, any, any>>;
|
197 | export declare function spawn(entity: Spawnable, nameOrOptions?: string | SpawnOptions): ActorRef<any>;
|
198 |
|
199 |
|
200 |
|
201 |
|
202 |
|
203 |
|
204 | export declare function interpret<TContext = DefaultContext, TStateSchema extends StateSchema = any, TEvent extends EventObject = EventObject, TTypestate extends Typestate<TContext> = {
|
205 | value: any;
|
206 | context: TContext;
|
207 | }, TResolvedTypesMeta = TypegenDisabled>(machine: AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends true ? StateMachine<TContext, TStateSchema, TEvent, TTypestate, any, any, TResolvedTypesMeta> : 'Some implementations missing', options?: InterpreterOptions): Interpreter<TContext, TStateSchema, TEvent, TTypestate, TResolvedTypesMeta>;
|
208 | export {};
|
209 |
|
\ | No newline at end of file |