xstate 6.0.0-alpha.2 → 6.0.0-alpha.21

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "xstate",
-  "version": "6.0.0-alpha.2",
+  "version": "6.0.0-alpha.21",
   "description": "Finite State Machines and Statecharts for the Modern Web.",
   "main": "dist/xstate.cjs.js",
+  "bin": {
+    "xstate": "./bin/xstate.js"
+  },
   "module": "dist/xstate.esm.js",
   "umd:main": "dist/xstate.umd.min.js",
   "exports": {
@@ -68,7 +71,8 @@
     "invoke",
     "guards",
     "dev",
-    "graph"
+    "graph",
+    "bin"
   ],
   "keywords": [
     "statechart",

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

@@ -1,81 +0,0 @@
-type Observer<T> = {
-    next?: (value: T) => void;
-    error?: (err: unknown) => void;
-    complete?: () => void;
-};
-interface Subscription {
-    unsubscribe(): void;
-}
-interface Readable<T> extends Subscribable<T> {
-    get: () => T;
-}
-interface Subscribable<T> {
-    subscribe(observer: Observer<T>): Subscription;
-    subscribe(next: (value: T) => void, error?: (error: any) => void, complete?: () => void): Subscription;
-}
-export interface BaseAtom<T> extends Subscribable<T>, Readable<T> {
-}
-export interface Atom<T> extends BaseAtom<T> {
-    set: (valueOrFn: T | ((prev: T) => T)) => void;
-}
-export interface ReducerAtom<TState, TEvent> extends BaseAtom<TState> {
-    send: (event: TEvent) => void;
-}
-export interface AtomOptions<T> {
-    compare?: (a: T, b: T) => boolean;
-}
-export interface AtomConfig<TValue, TInput> {
-    createAtom: undefined extends TInput ? (input?: TInput) => Atom<TValue> : (input: TInput) => Atom<TValue>;
-}
-export type AnyAtomConfig = AtomConfig<any, any>;
-export type ValueFromAtomConfig<TConfig extends AnyAtomConfig> = TConfig extends AtomConfig<infer TValue, any> ? TValue : never;
-export type InputFromAtomConfig<TConfig extends AnyAtomConfig> = TConfig extends AtomConfig<any, infer TInput> ? TInput : never;
-export type AnyAtom = BaseAtom<any>;
-export interface ReadonlyAtom<T> extends BaseAtom<T> {
-}
-/**
- * Returns `true` if the value is an atom (writable, computed, async, or
- * reducer). Lets actor-consuming APIs (e.g. `enq.subscribeTo`) accept atoms
- * directly.
- */
-export declare function isAtom(value: unknown): value is AnyAtom;
-/** The current state of an async atom. */
-export type AsyncAtomState<Data, Error = unknown> = {
-    status: 'pending';
-} | {
-    status: 'done';
-    data: Data;
-} | {
-    status: 'error';
-    error: Error;
-};
-/** Options passed to an async atom getter. */
-export interface AsyncAtomOptions {
-    /** Signal aborted when the async atom recomputes before this run settles. */
-    signal: AbortSignal;
-}
-/**
- * Creates a read-only atom whose value is loaded from an async getter.
- *
- * The getter receives an `AbortSignal`; when the async atom recomputes, the
- * previous signal is aborted and stale resolutions are ignored.
- */
-export declare function createAsyncAtom<T>(getValue: (options: AsyncAtomOptions) => Promise<T>, options?: AtomOptions<AsyncAtomState<T>>): ReadonlyAtom<AsyncAtomState<T>>;
-/**
- * Creates an atom.
- *
- * Pass a value for a writable atom or a getter for a computed read-only atom.
- */
-export declare function createAtom<T>(getValue: (prev?: T) => T, options?: AtomOptions<T>): ReadonlyAtom<T>;
-export declare function createAtom<T>(initialValue: T, options?: AtomOptions<T>): Atom<T>;
-/**
- * Creates an inert atom config that can be instantiated later.
- *
- * Useful for framework hooks that need to create a stable local atom from
- * component input.
- */
-export declare function createAtomConfig<T, TInput>(getInitialValue: (input: TInput) => T, options?: AtomOptions<T>): AtomConfig<T, TInput>;
-export declare function createAtomConfig<T>(initialValue: T, options?: AtomOptions<T>): AtomConfig<T, undefined>;
-/** Creates an atom whose updates are handled by a reducer function. */
-export declare function createReducerAtom<TState, TEvent>(initialValue: TState, reducer: (state: TState, event: TEvent) => TState, options?: AtomOptions<TState>): ReducerAtom<TState, TEvent>;
-export {};