@uuxxx/fsm 1.2.3 → 1.3.0

package/README.md

@@ -2,7 +2,16 @@
 
 [![npm version](https://badge.fury.io/js/@uuxxx%2Ffsm.svg)](https://badge.fury.io/js/@uuxxx%2Ffsm)
 
-A lightweight, type-safe finite state machine library for JavaScript/TypeScript with plugin support and lifecycle hooks.
+A lightweight, type-safe finite state machine library for TypeScript with plugin support, lifecycle hooks, and full type inference.
+
+## Features
+
+- **Full type inference** — transition methods, states, and plugin APIs are auto-generated from config
+- **Multiple transition types** — static, dynamic, async, wildcard (`*`), and multi-source
+- **Lifecycle hooks** — `onBeforeTransition` (with veto) and `onAfterTransition`
+- **Plugin system** — extend your FSM with custom APIs
+- **Custom error handling** — provide an `onError` callback or let errors throw
+- **Zero dependencies** aside from `@uuxxx/utils`
 
 ## Installation
 
@@ -21,70 +30,66 @@ import { makeFsm } from '@uuxxx/fsm';
 
 type State = 'idle' | 'loading' | 'success' | 'error';
 
-const STATES: State[] = ['idle', 'loading', 'success', 'error']
-
 const fsm = makeFsm({
-  init: 'idle',
-  states: STATES,
-  transitions: {
-    start: {
-      from: 'idle',
-      to: 'loading',
-    },
-    succeed: {
-      from: 'loading',
-      to: 'success',
-    },
-    fail: {
-      from: 'loading',
-      to: 'error',
-    },
-    reset: {
-      from: ['success', 'error'],
-      to: 'idle',
-    },
-    goto: {
-      from: '*',
-      to: (state: State) => state
-    }
-  },
+	init: 'idle',
+	states: ['idle', 'loading', 'success', 'error'] as State[],
+	transitions: {
+		start: {
+			from: 'idle',
+			to: 'loading',
+		},
+		succeed: {
+			from: 'loading',
+			to: 'success',
+		},
+		fail: {
+			from: 'loading',
+			to: 'error',
+		},
+		reset: {
+			from: ['success', 'error'],
+			to: 'idle',
+		},
+		goto: {
+			from: '*',
+			to: (state: State) => state,
+		},
+	},
 });
 
-// Check current state
-console.log(fsm.state()); // 'idle'
-
-// Perform transitions
-fsm.start();
-console.log(fsm.state()); // 'loading'
-
-fsm.succeed();
-console.log(fsm.state()); // 'success'
-
-fsm.reset()
-console.log(fsm.state()) // 'idle'
-
-fsm.goto('error')
-console.log(fsm.state()) // 'error'
+fsm.state(); // 'idle'
+fsm.start(); // 'loading'
+fsm.succeed(); // 'success'
+fsm.reset(); // 'idle'
+fsm.goto('error'); // 'error'
 ```
 
+Each transition key becomes a method on the FSM instance with the correct type signature inferred from config.
+
 ## API Reference
 
 ### `makeFsm(config)`
 
 Creates a new finite state machine instance.
 
-#### Parameters
+#### Config
 
-- `config`: Configuration object with the following properties:
-  - `init`: Initial state
-  - `states`: Array of all possible states
-  - `transitions`: Object defining state transitions
-  - `methods?`: Optional lifecycle methods
-  - `plugins?`: Optional array of plugins
+| Property      | Type                                          | Required | Description                                                                   |
+| ------------- | --------------------------------------------- | -------- | ----------------------------------------------------------------------------- |
+| `init`        | `TState`                                      | Yes      | Initial state                                                                 |
+| `states`      | `TState[]`                                    | Yes      | All valid states                                                              |
+| `transitions` | `Record<string, Transition<TState>>`          | Yes      | Transition definitions (keys become methods)                                  |
+| `methods`     | `{ onBeforeTransition?, onAfterTransition? }` | No       | Lifecycle hooks                                                               |
+| `plugins`     | `Plugin[]`                                    | No       | Array of plugins                                                              |
+| `onError`     | `(msg: string) => void`                       | No       | Custom error handler. By default, errors throw `Error` with a `[FSM]:` prefix |
 
 #### Returns
 
-An FSM instance with transition methods, state methods, and plugin APIs.
+An FSM instance combining:
+
+- **State methods** — `state()`, `allStates()`
+- **Transition methods** — one per key in `transitions`
+- **Plugin APIs** — one namespace per plugin
 
 ### State Methods
 
@@ -92,17 +97,9 @@ An FSM instance with transition methods, state methods, and plugin APIs.
 
 Returns the current state.
 
-```typescript
-const currentState = fsm.state();
-```
-
 #### `fsm.allStates()`
 
-Returns an array of all possible states.
-
-```typescript
-const allStates = fsm.allStates();
-```
+Returns an array of all valid states.
 
 ### Transitions
 
@@ -110,204 +107,252 @@ Transitions are defined as objects with `from` and `to` properties:
 
 ```typescript
 type Transition<TState> = {
-  from: '*' | TState | TState[];
-  to: TState | ((...args: any[]) => TState | Promise<TState>);
+	from: '*' | TState | TState[];
+	to: TState | ((...args: any[]) => TState | Promise<TState>);
 };
 ```
 
-- `from`: The state(s) this transition can occur from
-  - Single state: `'idle'`
-  - Multiple states: `['loading', 'error']`
-  - Any state: `'*'`
-- `to`: The target state or a function returning the target state
-  - Static: `'loading'`
-  - Dynamic: `(userId: string) => \`user_\${userId}\``
-  - Async: `async (data) => await apiCall(data)`
+#### `from` — source state(s)
+
+| Form            | Example                | Description           |
+| --------------- | ---------------------- | --------------------- |
+| Single state    | `'idle'`               | Only from this state  |
+| Multiple states | `['loading', 'error']` | From any listed state |
+| Wildcard        | `'*'`                  | From any state        |
+
+#### `to` — target state
+
+| Form    | Example                           | Description                      |
+| ------- | --------------------------------- | -------------------------------- |
+| Static  | `'loading'`                       | Always transitions to this state |
+| Dynamic | `(id: string) => \`user\_${id}\`` | Compute target from arguments    |
+| Async   | `async () => await fetchState()`  | Returns `Promise<TState>`        |
+
+#### Transition behavior
+
+- **Circular transitions are skipped** — if `from === to`, the transition is silently canceled with a warning.
+- **Concurrent async transitions are blocked** — starting a new transition while an async one is pending triggers an error.
+- **Invalid target states** — transitioning to a state not in `states` triggers an error.
+- **Forbidden transitions** — calling a transition from a state not matching `from` triggers an error.
+- **Return value** — every transition method returns the new state (or `Promise<TState>` for async transitions).
 
 #### Examples
 
 ```typescript
 const transitions = {
-  // Simple transition
-  'idle -> loading': {
-    from: 'idle',
-    to: 'loading',
-  },
-
-  // Multiple source states
-  reset: {
-    from: ['success', 'error'],
-    to: 'idle',
-  },
-
-  // Wildcard (from any state)
-  goto: {
-    from: '*',
-    to: (targetState: State) => targetState,
-  },
-
-  // Async transition
-  'async fetch': {
-    from: 'idle',
-    to: async () => {
-      const result = await fetchData();
-      return result.success ? 'success' : 'error';
-    },
-  },
+	// Static transition
+	start: {
+		from: 'idle',
+		to: 'loading',
+	},
+
+	// Multiple source states
+	reset: {
+		from: ['success', 'error'],
+		to: 'idle',
+	},
+
+	// Wildcard (from any state)
+	goto: {
+		from: '*',
+		to: (target: State) => target,
+	},
+
+	// Async transition
+	fetch: {
+		from: 'idle',
+		to: async () => {
+			const result = await fetchData();
+			return result.ok ? 'success' : 'error';
+		},
+	},
 };
 ```
 
+### Error Handling
+
+By default, the FSM throws on errors (forbidden transitions, invalid states, concurrent transitions). You can provide a custom `onError` handler to change this behavior:
+
+```typescript
+const fsm = makeFsm({
+	init: 'idle',
+	states: ['idle', 'loading'],
+	transitions: {
+		start: { from: 'idle', to: 'loading' },
+		stop: { from: 'loading', to: 'idle' },
+	},
+	onError: (msg) => {
+		console.warn(msg); // Handle gracefully instead of throwing
+	},
+});
+
+// Won't throw — calls onError instead
+fsm.stop(); // "idle" → "idle" via "stop" is forbidden (from doesn't match)
+```
+
+When `onError` is provided, the FSM state remains unchanged after an error.
+
 ### Lifecycle Methods
 
-Lifecycle methods can be attached to the FSM configuration:
+Lifecycle methods hook into the transition process:
 
 ```typescript
-const config = {
-  // ... other config
-  methods: {
-    onBeforeTransition: (event) => {
-      console.log('About to transition:', event);
-      // Return false to cancel the transition
-      return true;
-    },
-    onAfterTransition: (event) => {
-      console.log('Transition completed:', event);
-    },
-  },
-};
+const fsm = makeFsm({
+	// ...
+	methods: {
+		onBeforeTransition: (event) => {
+			console.log(`${event.from} → ${event.to} via ${event.transition}`);
+			return false; // Return false to cancel the transition
+		},
+		onAfterTransition: (event) => {
+			console.log('Transition complete:', event.transition);
+		},
+	},
+});
 ```
 
-#### `onBeforeTransition(event)`
+#### Lifecycle event object
 
-Called before a transition occurs. Return `false` to cancel the transition.
+| Property     | Type                 | Description                             |
+| ------------ | -------------------- | --------------------------------------- |
+| `transition` | `string`             | Name of the transition (the config key) |
+| `from`       | `TState`             | State before the transition             |
+| `to`         | `TState`             | Target state                            |
+| `args`       | `any[] \| undefined` | Arguments passed to dynamic transitions |
 
-**Parameters:**
-- `event`: Object with `transition`, `from`, `to`, and optional `args`
+#### `onBeforeTransition(event)`
 
-#### `onAfterTransition(event)`
+Called before a transition. Return `false` to veto (cancel) the transition.
 
-Called after a successful transition.
+#### `onAfterTransition(event)`
 
-**Parameters:**
-- `event`: Object with `transition`, `from`, `to`, and optional `args`
+Called after a successful transition. The FSM state is already updated at this point.
 
 ## Plugins
 
-Plugins extend the FSM with additional functionality. Each plugin receives an API object and returns a plugin definition.
+Plugins extend the FSM with additional methods, grouped under a namespace.
 
 ### Plugin API
 
-Plugins have access to:
+Each plugin receives an `api` object with:
 
-- `api.state()`: Get current state
-- `api.allStates()`: Get all states
-- `api.init(callback)`: Register initialization callback
-- `api.onBeforeTransition(callback)`: Register before transition callback
-- `api.onAfterTransition(callback)`: Register after transition callback
+| Method                             | Description                                                       |
+| ---------------------------------- | ----------------------------------------------------------------- |
+| `api.state()`                      | Get current state                                                 |
+| `api.allStates()`                  | Get all valid states                                              |
+| `api.init(callback)`               | Run callback when FSM is created (receives initial state)         |
+| `api.onBeforeTransition(callback)` | Register before-transition listener. Returns unsubscribe function |
+| `api.onAfterTransition(callback)`  | Register after-transition listener. Returns unsubscribe function  |
+| `api.onError(callback)`            | Register error listener. Returns unsubscribe function             |
 
 ### Creating a Plugin
 
 ```typescript
-const myPlugin = (options) => (api) => {
-  // Plugin initialization
-  api.init((initialState) => {
-    console.log('FSM initialized with state:', initialState);
-  });
-
-  // Listen to transitions
-  api.onBeforeTransition((event) => {
-    console.log('Transition starting:', event);
-  });
-
-  // Return plugin definition
-  return {
-    name: 'my-plugin',
-    api: {
-      // Custom methods exposed on fsm['my-plugin']
-      doSomething: () => {
-        return api.state();
-      },
-    },
-  };
-};
+import type { FsmLabel, FsmPlugin, FsmTransition } from '@uuxxx/fsm';
+
+export const myPlugin = <TState extends FsmLabel, TTransitions extends Record<string, FsmTransition<TState>>>() =>
+	((api) => {
+		let count = 0;
+
+		api.onAfterTransition(() => {
+			count++;
+		});
+
+		return {
+			name: 'counter' as const,
+			api: {
+				getCount: () => count,
+			},
+		};
+	}) satisfies FsmPlugin<TState, TTransitions>;
 ```
 
 ### Using Plugins
 
 ```typescript
-const config = {
-  // ... other config
-  plugins: [myPlugin({ someOption: true })],
-};
-
-const fsm = makeFsm(config);
+const fsm = makeFsm({
+	// ...
+	plugins: [myPlugin()],
+});
 
-// Access plugin API
-const currentState = fsm['my-plugin'].doSomething();
+fsm.start();
+fsm.counter.getCount(); // 1
 ```
 
+Plugin names must be unique — registering two plugins with the same name triggers an error.
+
 ## Built-in Plugins
 
 ### History Plugin
 
-Tracks state history and provides navigation methods.
+Tracks state history with pointer-based navigation.
 
 ```typescript
-import { makeFsm, historyPlugin } from '@uuxxx/fsm';
-
-const config = {
-  // ... config
-  plugins: [historyPlugin()],
-};
-
-const fsm = makeFsm(config);
+import { makeFsm } from '@uuxxx/fsm';
+import { fsmHistoryPlugin } from '@uuxxx/fsm/history-plugin';
 
-// Navigate
-fsm.goto('state1');
-fsm.goto('state2');
+const fsm = makeFsm({
+	init: 'a',
+	states: ['a', 'b', 'c'],
+	transitions: {
+		goto: { from: '*', to: (s: 'a' | 'b' | 'c') => s },
+	},
+	plugins: [fsmHistoryPlugin()],
+});
 
-// History API
-console.log(fsm.history.get()); // ['initial', 'state1', 'state2']
+fsm.goto('b');
+fsm.goto('c');
+fsm.history.get(); // ['a', 'b', 'c']
 
-fsm.history.back(1); // Go back 1 step
-fsm.history.forward(1); // Go forward 1 step
+fsm.history.back(1); // returns 'b'
+fsm.history.back(1); // returns 'a'
+fsm.history.forward(2); // returns 'c'
 ```
 
-#### History API Methods
+#### History API
+
+| Method                       | Returns    | Description                                                                        |
+| ---------------------------- | ---------- | ---------------------------------------------------------------------------------- |
+| `fsm.history.get()`          | `TState[]` | Full history array                                                                 |
+| `fsm.history.back(steps)`    | `TState`   | Move pointer back by `steps`, returns the state at that position. Clamps to start  |
+| `fsm.history.forward(steps)` | `TState`   | Move pointer forward by `steps`, returns the state at that position. Clamps to end |
 
-- `fsm.history.get()`: Get the full history array
-- `fsm.history.back(steps?)`: Go back N steps (default: 1)
-- `fsm.history.forward(steps?)`: Go forward N steps (default: 1)
+> **Note:** `back()` and `forward()` move the internal history pointer and return the state at that position. They do **not** trigger a state transition on the FSM — use transition methods if you need to change the actual FSM state.
 
-## Error Handling
+When a transition occurs, any forward history after the current pointer is discarded (like browser navigation).
 
-The FSM throws errors in the following cases:
+## Exported Types
 
-- Invalid transition (current state doesn't match `from`)
-- Pending async transition when starting a new sync transition
-- Invalid target state
-- Duplicate plugin names
+The library exports the following types for use in plugins and generic code:
 
 ```typescript
-try {
-  fsm.invalidTransition();
-} catch (error) {
-  console.error(error.message); // [FSM]: Transition: "invalidTransition" is forbidden
-}
+import type {
+	FsmConfig, // Config<TState, TTransitions, TPlugins>
+	FsmTransition, // Transition<TState>
+	FsmPlugin, // Plugin<TState, TTransitions>
+	FsmLabel, // string (state label type)
+} from '@uuxxx/fsm';
 ```
 
 ## TypeScript Support
 
-The library is fully typed. Type inference works automatically:
+The library is built with TypeScript-first design. All types are inferred from config — no manual type annotations needed:
 
 ```typescript
 const fsm = makeFsm({
-  init: 'idle',
-  states: ['idle', 'running', 'stopped'],
-  transitions: {
-    start: { from: 'idle', to: 'running' },
-    stop: { from: 'running', to: 'stopped' },
-  },
+	init: 'idle',
+	states: ['idle', 'running', 'stopped'],
+	transitions: {
+		start: { from: 'idle', to: 'running' },
+		stop: { from: 'running', to: 'stopped' },
+	},
 });
-// fsm is fully typed - autocomplete works for transitions and states
+
+fsm.start(); // ✓ typed — only callable from 'idle'
+fsm.stop(); // ✓ typed — only callable from 'running'
+fsm.state(); // ✓ returns 'idle' | 'running' | 'stopped'
 ```
+
+## License
+
+[MIT](./LICENSE)

package/dist/index.d.ts

@@ -1,15 +1,89 @@
-import { a as Transition, c as KeyOf, i as LifecycleMethods, l as Rec, n as Plugin, o as Label, r as StateMethods, s as EmptyArray } from "./Plugin-DGULTFg-.js";
+type AnyFn = (...args: any[]) => any; //#endregion
+type Rec<T = unknown> = Record<string, T>; //#endregion
+type KeyOf<T extends Rec> = keyof T; //#endregion
+type Noop = () => void; //#endregion
+type Key = string | number | symbol; //#endregion
+type Vdx<T> = T | void; //#endregion
+type EmptyArray = []; //#endregion
+type Entries<T extends Rec> = { [K in KeyOf<T>]: [K, T[K]] }[KeyOf<T>]; //#endregion
+type Label = string;
+/**
+ * Defines a single state transition.
+ *
+ * - `from` — source state(s): a single state, an array of states, or `'*'` for any state.
+ * - `to` — target: a static state, a function returning a state, or an async function returning `Promise<TState>`.
+ */
+type Transition<TState extends Label> = {
+  from: '*' | TState | TState[];
+  to: TState | ((...args: any[]) => TState | Promise<TState>);
+};
+/** Event object passed to lifecycle hooks during a transition. */
+type Lifecycle<TState extends Label, TEntry extends [Key, Transition<Label>]> = {
+  args?: Parameters<Extract<TEntry[1]['to'], AnyFn>>;
+  transition: TEntry[0];
+  from: TState;
+  to: TState;
+};
+type LifecycleMethod<TState extends Label, TTransitions extends Rec<Transition<TState>>> = (lifecycle: Lifecycle<TState, Entries<TTransitions>>) => void;
+type CancelableLifecycleMethod<TState extends Label, TTransitions extends Rec<Transition<TState>>> = (lifecycle: Lifecycle<TState, Entries<TTransitions>>) => Vdx<boolean>;
+type LifecycleMethods<TState extends Label, TTransitions extends Rec<Transition<TState>>> = {
+  onBeforeTransition?: CancelableLifecycleMethod<TState, TTransitions>;
+  onAfterTransition?: LifecycleMethod<TState, TTransitions>;
+};
+type StateMethods<TState extends Label> = {
+  state: () => TState;
+  allStates: () => TState[];
+};
+/** API object passed to each plugin during registration. Provides state access, lifecycle hooks, and error listeners. */
+type ApiForPlugin<TState extends Label, TTransitions extends Rec<Transition<TState>>> = {
+  init: (listener: (state: TState) => void) => void;
+  onError: (listener: (msg: string) => void) => Noop;
+} & StateMethods<TState> & { [K in KeyOf<LifecycleMethods<TState, TTransitions>>]-?: (listener: LifecycleMethods<TState, TTransitions>[K]) => Noop };
+type PluginApi = {
+  name: string;
+  api: Rec<AnyFn>;
+};
+/**
+ * A plugin is a function that receives the {@link ApiForPlugin} and returns
+ * `{ name, api }` — the name becomes a namespace on the FSM instance,
+ * and `api` methods are accessible under that namespace.
+ */
+type Plugin<TState extends Label = Label, TTransitions extends Rec<Transition<TState>> = Rec<Transition<TState>>> = (api: ApiForPlugin<TState, TTransitions>) => PluginApi;
+/** Configuration object for {@link makeFsm}. */
 type Config<TState extends Label, TTransitions extends Rec<Transition<TState>>, TPlugins extends Array<Plugin<TState, TTransitions>> = EmptyArray> = {
-  init: TState;
-  states: TState[];
-  transitions: TTransitions;
-  methods?: LifecycleMethods<TState, TTransitions>;
-  plugins?: TPlugins;
+  /** Initial state of the FSM. */init: TState; /** All valid states. The FSM will reject transitions to states not in this list. */
+  states: TState[]; /** Transition definitions. Each key becomes a method on the FSM instance. */
+  transitions: TTransitions; /** Optional lifecycle hooks (`onBeforeTransition`, `onAfterTransition`). */
+  methods?: LifecycleMethods<TState, TTransitions>; /** Optional plugins to extend the FSM with additional APIs. */
+  plugins?: TPlugins; /** Custom error handler. By default, errors throw with a `[FSM]:` prefix. */
+  onError?: (msg: string) => void;
 };
 type TransitionMethods<TTransitions extends Rec<Transition<Label>>> = { [K in KeyOf<TTransitions>]: TTransitions[K]['to'] extends Label ? () => TTransitions[K]['to'] : TTransitions[K]['to'] };
 type PluginsMethods<TState extends Label, TTransitions extends Rec<Transition<TState>>, TPlugins extends Array<Plugin<TState, TTransitions>>> = { [K in ReturnType<TPlugins[number]>['name']]: Extract<ReturnType<TPlugins[number]>, {
   name: K;
 }>['api'] };
 type Methods<TState extends Label, TTransitions extends Rec<Transition<TState>>, TPlugins extends Array<Plugin<TState, TTransitions>>> = TransitionMethods<TTransitions> & StateMethods<TState> & PluginsMethods<TState, TTransitions, TPlugins>;
+/**
+ * Creates a finite state machine instance from the given configuration.
+ *
+ * Returns an object combining state methods (`state()`, `allStates()`),
+ * auto-generated transition methods (one per key in `config.transitions`),
+ * and plugin APIs (one namespace per plugin).
+ *
+ * @example
+ * ```ts
+ * const fsm = makeFsm({
+ *   init: 'idle',
+ *   states: ['idle', 'loading', 'done'],
+ *   transitions: {
+ *     start: { from: 'idle', to: 'loading' },
+ *     finish: { from: 'loading', to: 'done' },
+ *   },
+ * });
+ *
+ * fsm.start();  // 'loading'
+ * fsm.finish(); // 'done'
+ * ```
+ */
 declare const makeFsm: <TState extends Label, TTransitions extends Rec<Transition<TState>>, TPlugins extends Array<Plugin<TState, TTransitions>>>(config: Config<TState, TTransitions, TPlugins>) => Methods<TState, TTransitions, TPlugins>;
 export { type Config as FsmConfig, type Label as FsmLabel, type Plugin as FsmPlugin, type Transition as FsmTransition, makeFsm };

package/dist/index.js

@@ -1,4 +1,4 @@
-let t={nlx:t=>null===t,ulx:t=>void 0===t,nil:e=>t.nlx(e)||t.ulx(e),not:{nlx:t=>null!==t,ulx:t=>void 0!==t,nil:e=>t.not.nlx(e)&&t.not.ulx(e)},array:t=>Array.isArray(t),string:t=>"string"==typeof t,function:t=>"function"==typeof t,promise:t=>t instanceof Promise,boolean:t=>"boolean"==typeof t,false:t=>!1===t,true:t=>!0===t};function e(t){return(e="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function r(t,e){var r=Object.keys(t);if(Object.getOwnPropertySymbols){var n=Object.getOwnPropertySymbols(t);e&&(n=n.filter(function(e){return Object.getOwnPropertyDescriptor(t,e).enumerable})),r.push.apply(r,n)}return r}function n(t){for(var n=1;n<arguments.length;n++){var i=null!=arguments[n]?arguments[n]:{};n%2?r(Object(i),!0).forEach(function(r){!function(t,r,n){var i;(i=function(t,r){if("object"!=e(t)||!t)return t;var n=t[Symbol.toPrimitive];if(void 0!==n){var i=n.call(t,r||"default");if("object"!=e(i))return i;throw TypeError("@@toPrimitive must return a primitive value.")}return("string"===r?String:Number)(t)}(r,"string"),(r="symbol"==e(i)?i:i+"")in t)?Object.defineProperty(t,r,{value:n,enumerable:!0,configurable:!0,writable:!0}):t[r]=n}(t,r,i[r])}):Object.getOwnPropertyDescriptors?Object.defineProperties(t,Object.getOwnPropertyDescriptors(i)):r(Object(i)).forEach(function(e){Object.defineProperty(t,e,Object.getOwnPropertyDescriptor(i,e))})}return t}let i=e=>{var r,i,o;let l,s,a,u,f,c,m=e.init,b=e.states.includes(e.init)?[...e.states]:[...e.states,e.init],p=(l=new Map,{listen(t,e){var r;return l.has(t)||l.set(t,[]),null==(r=l.get(t))||r.push(e),()=>{this.unlisten(t,e)}},unlisten(t,e){let r=l.get(t);if(!r)return;let n=r.filter(t=>t!==e);n.length?l.set(t,n):l.delete(t)},emit(e,...r){var n,i;return null!=(n=null==(i=l.get(e))?void 0:i.map(t=>t(...r)).filter(t.not.ulx))?n:[]},unlistenAll(t){l.delete(t)}});Object.entries(null!=(r=e.methods)?r:{}).forEach(([t,e])=>{p.listen(t,e)}),p.listen("onAfterTransition",({to:t})=>{m=t}),p.listen("error",t=>{throw Error(`[FSM]: ${t}`)});let y={state:()=>m,allStates:()=>b},g=(i=e.transitions,s=((e,{state:r,allStates:n})=>{let i,o={},l={register(s,a){let u=r=>{n().includes(r.to)?r.to===r.from?e.emit("warn",`
+let t={nlx:t=>null===t,ulx:t=>void 0===t,nil:e=>t.nlx(e)||t.ulx(e),not:{nlx:t=>null!==t,ulx:t=>void 0!==t,nil:e=>t.not.nlx(e)&&t.not.ulx(e)},array:t=>Array.isArray(t),string:t=>"string"==typeof t,function:t=>"function"==typeof t,promise:t=>t instanceof Promise,boolean:t=>"boolean"==typeof t,false:t=>!1===t,true:t=>!0===t};function e(t){return(e="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function r(t,e){var r=Object.keys(t);if(Object.getOwnPropertySymbols){var n=Object.getOwnPropertySymbols(t);e&&(n=n.filter(function(e){return Object.getOwnPropertyDescriptor(t,e).enumerable})),r.push.apply(r,n)}return r}function n(t){for(var n=1;n<arguments.length;n++){var i=null!=arguments[n]?arguments[n]:{};n%2?r(Object(i),!0).forEach(function(r){!function(t,r,n){var i;(i=function(t,r){if("object"!=e(t)||!t)return t;var n=t[Symbol.toPrimitive];if(void 0!==n){var i=n.call(t,r||"default");if("object"!=e(i))return i;throw TypeError("@@toPrimitive must return a primitive value.")}return("string"===r?String:Number)(t)}(r,"string"),(r="symbol"==e(i)?i:i+"")in t)?Object.defineProperty(t,r,{value:n,enumerable:!0,configurable:!0,writable:!0}):t[r]=n}(t,r,i[r])}):Object.getOwnPropertyDescriptors?Object.defineProperties(t,Object.getOwnPropertyDescriptors(i)):r(Object(i)).forEach(function(e){Object.defineProperty(t,e,Object.getOwnPropertyDescriptor(i,e))})}return t}let i=e=>{var r,i,o,l;let s,a,u,f,c,m,b=e.init,p=e.states.includes(e.init)?[...e.states]:[...e.states,e.init],y=(s=new Map,{listen(t,e){var r;return s.has(t)||s.set(t,[]),null==(r=s.get(t))||r.push(e),()=>{this.unlisten(t,e)}},unlisten(t,e){let r=s.get(t);if(!r)return;let n=r.filter(t=>t!==e);n.length?s.set(t,n):s.delete(t)},emit(e,...r){var n,i;return null!=(n=null==(i=s.get(e))?void 0:i.map(t=>t(...r)).filter(t.not.ulx))?n:[]},unlistenAll(t){s.delete(t)}});Object.entries(null!=(r=e.methods)?r:{}).forEach(([t,e])=>{y.listen(t,e)}),y.listen("onAfterTransition",({to:t})=>{b=t}),y.listen("error",null!=(i=e.onError)?i:t=>{throw Error(`[FSM]: ${t}`)});let g={state:()=>b,allStates:()=>p},d=(o=e.transitions,a=((e,{state:r,allStates:n})=>{let i,o={},l={register(s,a){let u=r=>{n().includes(r.to)?r.to===r.from?e.emit("warn",`
 						Transition: "${s}" is canceled because it's circular.
 						Current state is ${r.from}. Transition target state is ${r.to}
-					`):e.emit("onBeforeTransition",r).filter(t.boolean).every(t.true)&&e.emit("onAfterTransition",r):e.emit("error",`Transition: "${s}" can't be executed. It has invalid "to": "${r.to}"`)};return o[s]=(...n)=>{if(t.array(a.from)?!a.from.includes(r()):"*"!==a.from&&a.from!==r())return e.emit("error",`Transition: "${s}" is forbidden`),r();if(i)return e.emit("error",`Transition: "${s}" can't be made. Has pending transtion: "${i}"`),r();if(!t.function(a.to))return u({transition:s,from:r(),to:a.to}),r();let o=a.to(...n);return t.promise(o)?(i=s,o.then(t=>(i=void 0,u({transition:s,from:r(),to:t,args:n}),r()))):(u({transition:s,from:r(),to:o,args:n}),r())},l},make:()=>o};return l})(p,y),Object.entries(i).forEach(([t,e])=>s.register(t,e)),s.make()),d=(o=e.plugins,a={},u=n({init(t){p.listen("init",t)},onBeforeTransition:t=>p.listen("onBeforeTransition",t),onAfterTransition:t=>p.listen("onAfterTransition",t)},y),c=f={register(t){let{name:e,api:r}=t(u);return e in a&&p.emit("error",`There are at least two plugins with the same name: "${e}"`),a[e]=r,f},make:()=>a},(null!=o?o:[]).forEach(c.register),c.make());return p.emit("init",m),n(n(n({},y),d),g)};export{i as makeFsm};
+					`):e.emit("onBeforeTransition",r).filter(t.boolean).every(t.true)&&e.emit("onAfterTransition",r):e.emit("error",`Transition: "${s}" can't be executed. It has invalid "to": "${r.to}"`)};return o[s]=(...n)=>{if(t.array(a.from)?!a.from.includes(r()):"*"!==a.from&&a.from!==r())return e.emit("error",`Transition: "${s}" is forbidden`),r();if(i)return e.emit("error",`Transition: "${s}" can't be made. Has pending transtion: "${i}"`),r();if(!t.function(a.to))return u({transition:s,from:r(),to:a.to}),r();let o=a.to(...n);return t.promise(o)?(i=s,o.then(t=>(i=void 0,u({transition:s,from:r(),to:t,args:n}),r()))):(u({transition:s,from:r(),to:o,args:n}),r())},l},make:()=>o};return l})(y,g),Object.entries(o).forEach(([t,e])=>a.register(t,e)),a.make()),v=(l=e.plugins,u={},f=n({init(t){y.listen("init",t)},onError:t=>y.listen("error",t),onBeforeTransition:t=>y.listen("onBeforeTransition",t),onAfterTransition:t=>y.listen("onAfterTransition",t)},g),m=c={register(t){let{name:e,api:r}=t(f);return e in u&&y.emit("error",`There are at least two plugins with the same name: "${e}"`),u[e]=r,c},make:()=>u},(null!=l?l:[]).forEach(m.register),m.make());return y.emit("init",b),n(n(n({},g),v),d)};export{i as makeFsm};

package/package.json

@@ -1,68 +1,48 @@
 {
   "name": "@uuxxx/fsm",
-  "version": "1.2.3",
-  "author": "Artem Tryapichnikov <golysheeet@gmail.com>",
-  "license": "MIT",
-  "description": "Javascript library for creating finite state machine",
-  "homepage": "https://github.com/uuxxx/fsm/blob/main/README.md",
-  "type": "module",
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/uuxxx/fsm.git"
-  },
+  "version": "1.3.0",
+  "description": "Lightweight, type-safe finite state machine for TypeScript with plugin support and lifecycle hooks",
   "keywords": [
     "finite state machine",
-    "fsm"
+    "fsm",
+    "lifecycle",
+    "plugins",
+    "state machine",
+    "type-safe",
+    "typescript"
   ],
-  "engines": {
-    "node": ">= 20",
-    "pnpm": ">= 10"
+  "homepage": "https://github.com/uuxxx/fsm/blob/main/packages/core/README.md",
+  "license": "MIT",
+  "author": "Artem Tryapichnikov <golysheeet@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/uuxxx/fsm.git",
+    "directory": "packages/core"
   },
   "files": [
     "dist",
     "README.md",
     "LICENSE"
   ],
+  "type": "module",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
-    },
-    "./history-plugin": {
-      "types": "./dist/history-plugin.d.ts",
-      "default": "./dist/history-plugin.js"
     }
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "devDependencies": {
-    "@babel/core": "^7.28.4",
-    "@babel/preset-env": "^7.28.3",
-    "@babel/preset-typescript": "^7.27.1",
-    "@changesets/cli": "^2.29.7",
     "@swc/core": "^1.13.5",
-    "eslint": "^9.37.0",
-    "eslint-config-xo-typescript": "^9.0.0",
-    "lefthook": "^2.0.2",
     "rolldown": "^1.0.0-beta.41",
     "rolldown-plugin-dts": "^0.22.1",
     "rollup-plugin-swc3": "^0.12.1",
-    "ts-node": "^10.9.2",
-    "tslib": "^2.8.1",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.18"
-  },
-  "dependencies": {
-    "@uuxxx/utils": "^0.0.3"
+    "tslib": "^2.8.1"
   },
   "scripts": {
     "build": "rolldown -c rolldown.config.ts",
-    "changeset:version": "changeset version && git add --all && git commit -m 'chore: bump'",
-    "changeset:publish": "changeset publish",
-    "test": "vitest run",
-    "lint": "eslint",
-    "lint:fix": "eslint --fix",
     "check:types": "tsc --noEmit"
   }
 }

package/dist/Plugin-DGULTFg-.d.ts

@@ -1,38 +0,0 @@
-type AnyFn = (...args: any[]) => any; //#endregion
-type Rec<T = unknown> = Record<string, T>; //#endregion
-type KeyOf<T extends Rec> = keyof T; //#endregion
-type Noop = () => void; //#endregion
-type Key = string | number | symbol; //#endregion
-type Vdx<T> = T | void; //#endregion
-type EmptyArray = []; //#endregion
-type Entries<T extends Rec> = { [K in KeyOf<T>]: [K, T[K]] }[KeyOf<T>]; //#endregion
-type Label = string;
-type Transition<TState extends Label> = {
-  from: '*' | TState | TState[];
-  to: TState | ((...args: any[]) => TState | Promise<TState>);
-};
-type Lifecycle<TState extends Label, TEntry extends [Key, Transition<Label>]> = {
-  args?: Parameters<Extract<TEntry[1]['to'], AnyFn>>;
-  transition: TEntry[0];
-  from: TState;
-  to: TState;
-};
-type LifecycleMethod<TState extends Label, TTransitions extends Rec<Transition<TState>>> = (lifecycle: Lifecycle<TState, Entries<TTransitions>>) => void;
-type CancelableLifecycleMethod<TState extends Label, TTransitions extends Rec<Transition<TState>>> = (lifecycle: Lifecycle<TState, Entries<TTransitions>>) => Vdx<boolean>;
-type LifecycleMethods<TState extends Label, TTransitions extends Rec<Transition<TState>>> = {
-  onBeforeTransition?: CancelableLifecycleMethod<TState, TTransitions>;
-  onAfterTransition?: LifecycleMethod<TState, TTransitions>;
-};
-type StateMethods<TState extends Label> = {
-  state: () => TState;
-  allStates: () => TState[];
-};
-type ApiForPlugin<TState extends Label, TTransitions extends Rec<Transition<TState>>> = {
-  init: (listener: (state: TState) => void) => void;
-} & StateMethods<TState> & { [K in KeyOf<LifecycleMethods<TState, TTransitions>>]-?: (listener: LifecycleMethods<TState, TTransitions>[K]) => Noop };
-type PluginApi = {
-  name: string;
-  api: Rec<AnyFn>;
-};
-type Plugin<TState extends Label = Label, TTransitions extends Rec<Transition<TState>> = Rec<Transition<TState>>> = (api: ApiForPlugin<TState, TTransitions>) => PluginApi;
-export { Transition as a, KeyOf as c, LifecycleMethods as i, Rec as l, Plugin as n, Label as o, StateMethods as r, EmptyArray as s, ApiForPlugin as t };

package/dist/history-plugin.d.ts

@@ -1,10 +0,0 @@
-import { a as Transition, l as Rec, o as Label, t as ApiForPlugin } from "./Plugin-DGULTFg-.js";
-declare const historyPlugin: <TState extends Label, TTransitions extends Rec<Transition<TState>>>() => (api: ApiForPlugin<TState, TTransitions>) => {
-  name: "history";
-  api: {
-    get(): TState[];
-    back(steps: number): TState;
-    forward(steps: number): TState;
-  };
-};
-export { historyPlugin as fsmHistoryPlugin };

package/dist/history-plugin.js

@@ -1 +0,0 @@
-let t=()=>t=>{let i=[],n=0;return t.init(t=>i.push(t)),t.onAfterTransition(({to:t})=>{n++,i.splice(n,i.length-n,t)}),{name:"history",api:{get:()=>i,back:t=>i[n=Math.max(0,n-t)],forward:t=>(n=Math.min(i.length-1,n+t),i[n])}}};export{t as fsmHistoryPlugin};