@vsirotin/ts-stop 1.13.1 → 2.4.2

package/lib/esm/sfsm/ExternalWorldHub.js

@@ -1,80 +0,0 @@
-/**
- * Wiring hub between the SFSM and the "external world".
- *
- * - registerSignalSender(signals, sender) — declares which signal names a sender may emit.
- * - registerCommandReceiver(commands, receiver) — declares which commands a receiver handles.
- * - connectTo(sfsm) — wires everything: sets itself as the SFSM command receiver and
- *   calls connectSignalTarget(sfsm) on every registered signal sender.
- *
- * The explicit signal/command name lists enable precise runtime error messages and
- * provide a foundation for FA-vs-wiring validation.
- *
- * Fluent API:
- *   new ExternalWorldHub()
- *     .registerSignalSender(['TS.s'], service)
- *     .registerSignalSender(['TS.to', 'TS.ps'], device)
- *     .registerCommandReceiver(['TS.ut', 'TS.l'], device)
- *     .connectTo(sfsm);
- */
-export class ExternalWorldHub {
-    constructor() {
-        this.commandRoutes = new Map();
-        this.signalSenders = [];
-    }
-    /**
-     * Register a command receiver for the given list of exact command names.
-     * Throws if any command name is already registered.
-     * Fluent — returns this.
-     */
-    registerCommandReceiver(commands, receiver) {
-        for (const cmd of commands) {
-            if (this.commandRoutes.has(cmd)) {
-                throw new Error(`ExternalWorldHub: command "${cmd}" is already registered`);
-            }
-            this.commandRoutes.set(cmd, receiver);
-        }
-        return this;
-    }
-    /**
-     * Register a signal sender for the given list of signal names.
-     * Duplicate signal names across registrations are allowed (same sender may be
-     * registered multiple times for documentation clarity), but will not cause
-     * double-wiring — connectSignalTarget is called once per registerSignalSender call.
-     * Fluent — returns this.
-     */
-    registerSignalSender(signals, sender) {
-        this.signalSenders.push({ signals, sender });
-        return this;
-    }
-    /**
-     * Wire this hub to the given SFSM instance:
-     * 1. Sets this hub as the SFSM's command receiver.
-     * 2. Calls connectSignalTarget(sfsm) on every registered signal sender.
-     * Fluent — returns this.
-     */
-    connectTo(sfsm) {
-        sfsm.setCommandReceiver(this);
-        for (const { sender } of this.signalSenders) {
-            sender.connectSignalTarget(sfsm);
-        }
-        return this;
-    }
-    /** ICommandReceiver implementation — dispatches command to the registered receiver. */
-    receiveCommand(command, data) {
-        const receiver = this.commandRoutes.get(command);
-        if (!receiver) {
-            const registered = [...this.commandRoutes.keys()].join(', ');
-            throw new Error(`ExternalWorldHub: no receiver registered for command "${command}". ` +
-                `Registered commands: [${registered}]`);
-        }
-        receiver.receiveCommand(command, data);
-    }
-    /** Returns all command names that have a registered receiver (for diagnostics / validation). */
-    getRegisteredCommands() {
-        return [...this.commandRoutes.keys()];
-    }
-    /** Returns all signal names that have a registered sender (for diagnostics / validation). */
-    getRegisteredSignals() {
-        return this.signalSenders.flatMap(e => e.signals);
-    }
-}

package/lib/esm/sfsm/index.browser.js

@@ -1,5 +0,0 @@
-export { ExternalWorldHub } from './ExternalWorldHub';
-export { FaResolver } from './FaResolver';
-export { Sfsm } from './Sfsm';
-export { reduceFA } from './FaReducer';
-export { updateCompactFA, updateFullFA } from './FaUpdater';

package/lib/fa/DefaultState.d.ts

@@ -1,9 +0,0 @@
-/**
- * Marker base class for states that should be used processed by invalid signals and
- * in situation, then no transitions set for pair (current signal, current state).
- * Only one state in a state machine can have this role.
- */
-export declare abstract class DefaultState {
-    isDefaultState(): boolean;
-}
-//# sourceMappingURL=DefaultState.d.ts.map

package/lib/fa/DefaultState.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DefaultState.d.ts","sourceRoot":"","sources":["../../src/fa/DefaultState.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,8BAAsB,YAAY;IAC9B,cAAc,IAAI,OAAO;CAG5B"}

package/lib/fa/DefaultState.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultState = void 0;
-/**
- * Marker base class for states that should be used processed by invalid signals and
- * in situation, then no transitions set for pair (current signal, current state).
- * Only one state in a state machine can have this role.
- */
-class DefaultState {
-    isDefaultState() {
-        return true;
-    }
-}
-exports.DefaultState = DefaultState;
-//# sourceMappingURL=DefaultState.js.map

package/lib/fa/DefaultState.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"DefaultState.js","sourceRoot":"","sources":["../../src/fa/DefaultState.ts"],"names":[],"mappings":";;;AAAA;;;;GAIG;AACH,MAAsB,YAAY;IAC9B,cAAc;QACV,OAAO,IAAI,CAAC;IAChB,CAAC;CACJ;AAJD,oCAIC"}

package/lib/fa/FiniteStateMachine.d.ts

@@ -1,227 +0,0 @@
-import { DefaultState } from './DefaultState';
-import { IStateWithAfterEntryAction, IStateWithBeforeExitAction } from './IStateWithActions';
-/**
- * Represents a transition in a finite state machine.
- *
- * @template STATE - The type representing possible states
- * @template SIGNAL - The type representing signals/events
- */
-export interface ITransition<STATE, SIGNAL> {
-    from: STATE;
-    signal: SIGNAL;
-    to: STATE;
-}
-/**
- * Interface defining the contract for a finite state machine.
- *
- * @template STATE - The type representing possible states in the state machine
- * @template SIGNAL - The type representing signals/events that trigger state transitions
- */
-export interface IFiniteStateMachine<STATE> {
-    /**
-     * Gets the current state of the state machine.
-     *
-     * @returns The current state
-     */
-    getCurrentState(): STATE;
-}
-/**
- * Concrete implementation of a finite state machine with optional state actions.
- *
- * This class supports states that can optionally implement action interfaces:
- * - IStateWithAfterEntryAction: Execute action when entering the state
- * - IStateWithBeforeExitAction: Execute action when exiting the state
- * - Both interfaces: Execute both entry and exit actions
- * - Neither interface: Traditional state machine behavior (no actions)
- *
- * @template STATE - The type representing possible states
- * @template SIGNAL - The type representing signals/events
- *
- * @example
- * ```typescript
- * // Basic string-based turnstile (traditional approach)
- * class Turnstile extends FiniteStateMachine<string, string> {
- *     constructor() {
- *         super(
- *             ['locked', 'unlocked'],
- *             ['coin', 'push'],
- *             [
- *                 { from: 'locked', signal: 'coin', to: 'unlocked' },
- *                 { from: 'unlocked', signal: 'push', to: 'locked' }
- *             ],
- *             'locked'
- *         );
- *     }
- *
- * ...
- * }
- *
- 
- *
- * class TurnstileWithActions extends FiniteStateMachine<ActionState, string> {
- *     private locked = new ActionState('locked', 'Payment required');
- *     private unlocked = new ActionState('unlocked', 'Please proceed');
- *
- *     constructor() {
- *         super(
- *             [this.locked, this.unlocked],
- *             ['coin', 'push'],
- *             [
- *                 { from: this.locked, signal: 'coin', to: this.unlocked },
- *                 { from: this.unlocked, signal: 'push', to: this.locked }
- *             ],
- *             this.locked
- *         );
- *     }
- *
- *     insertCoin(): ActionState { return this.sendSignal('coin'); }
- *     pushThrough(): ActionState { return this.sendSignal('push'); }
- * }
- *
- * ```
- */
-export declare abstract class FiniteStateMachine<STATE, SIGNAL> implements IFiniteStateMachine<STATE> {
-    protected states: STATE[];
-    protected signals: SIGNAL[];
-    protected transitions: ITransition<STATE, SIGNAL>[];
-    protected startState: STATE;
-    /**
-     * The current state of the state machine.
-     * Protected to allow subclass access while maintaining encapsulation.
-     */
-    protected currentState: STATE;
-    /**
- * The default state that handles invalid signals.
- * Set to null if no state implements IDefaultState.
- */
-    private defaultState;
-    /**
-     * Creates a new finite state machine.
-     *
-     * @param states - Array of all possible states
-     * @param signals - Array of all possible signals/events
-     * @param transitions - Array of transition rules defining how signals move between states
-     * @param startState - The initial state of the machine
-     * @param skipValidation - When true, all structural validations are skipped (default: false)
-     */
-    constructor(states: STATE[], signals: SIGNAL[], transitions: ITransition<STATE, SIGNAL>[], startState: STATE, skipValidation?: boolean);
-    /**
-     * Gets the current state of the state machine.
-     *
-     * @returns The current state
-     */
-    getCurrentState(): STATE;
-    /**
-     * Processes a signal and potentially transitions to a new state with action execution.
-     *
-     * This method:
-     * 1. Finds a matching transition for the current state and signal
-     * 2. If found and the target state is different:
-     *    a. Executes beforeExitAction on current state (if implemented)
-     *    b. Changes to the new state
-     *    c. Executes afterEntryAction on new state (if implemented)
-     * 3. Returns the resulting state
-     *
-     * @param signal - The signal/event to process
-     * @returns The resulting state after processing the signal
-     */
-    protected sendSignal(signal: SIGNAL): STATE;
-    private tryProcessStateWithOutputSignal;
-    private validateUnreachableStates;
-    private validateDanglingReferences;
-    private validateOutputSignalStates;
-    private validateOutputSignalCycles;
-    private isStateWithOutputSignal;
-    private executeStateTransition;
-    private executeStateActions;
-    /**
-     * Type guard to check if a state is an instance of DefaultState class.
-     *
-     * @param state - The state to check
-     * @returns true if the state is an instance of DefaultState
-     */
-    protected isDefaultState(state: STATE): boolean;
-    /**
-     * Type guard to check if a state implements IStateWithAfterEntryAction.
-     *
-     * @param state - The state to check
-     * @returns true if the state implements afterEntryAction method
-     */
-    protected hasAfterEntryAction(state: STATE): state is STATE & IStateWithAfterEntryAction;
-    /**
-     * Type guard to check if a state implements IStateWithBeforeExitAction.
-     *
-     * @param state - The state to check
-     * @returns true if the state implements beforeExitAction method
-     */
-    protected hasBeforeExitAction(state: STATE): state is STATE & IStateWithBeforeExitAction;
-    /**
-     * Executes the afterEntryAction on a state if it implements IStateWithAfterEntryAction.
-     *
-     * @param state - The state to execute the entry action on
-     */
-    private executeEntryAction;
-    /**
-     * Executes the beforeExitAction on a state if it implements IStateWithBeforeExitAction.
-     *
-     * @param state - The state to execute the exit action on
-     */
-    private executeExitAction;
-    /**
-     * Gets all possible states.
-     *
-     * @returns Array of all states
-     */
-    getAllStates(): STATE[];
-    /**
-     * Gets all possible signals.
-     *
-     * @returns Array of all signals
-     */
-    getAllSignals(): SIGNAL[];
-    /**
-     * Checks if a given signal is valid from the current state.
-     *
-     * @param signal - The signal to check
-     * @returns true if the signal can trigger a transition from the current state
-     */
-    isValidSignalFromCurrentState(signal: SIGNAL): boolean;
-    /**
-     * Gets all valid signals from the current state.
-     *
-     * @returns Array of signals that can trigger transitions from the current state
-     */
-    getValidSignalsFromCurrentState(): SIGNAL[];
-    /**
-     * Gets all transitions.
-     *
-     * @returns Array of all transitions
-     */
-    getTransitions(): ITransition<STATE, SIGNAL>[];
-    /**
-     * Checks if a signal is valid in the state machine.
-     * @param signal - The signal to check
-     * @returns True if the signal is valid, false otherwise.
-     */
-    hasSignal(signal: SIGNAL): boolean;
-    /**
-     * Checks if a given state exists in the state machine.
-     *
-     * @param state - The state to check
-     * @returns true if the state exists, false otherwise
-     */
-    hasState(state: STATE): boolean;
-    /**
- * Gets the default state that handles invalid signals.
- *
- * @returns The default state or null if none exists
- */
-    getDefaultState(): DefaultState | null;
-    /**
-     * Checks if the state machine has a default state.
-     *
-     * @returns true if a default state exists
-     */
-    hasDefaultState(): boolean;
-}
-//# sourceMappingURL=FiniteStateMachine.d.ts.map

package/lib/fa/FiniteStateMachine.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"FiniteStateMachine.d.ts","sourceRoot":"","sources":["../../src/fa/FiniteStateMachine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,0BAA0B,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AAG7F;;;;;GAKG;AACH,MAAM,WAAW,WAAW,CAAC,KAAK,EAAE,MAAM;IACtC,IAAI,EAAE,KAAK,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,EAAE,EAAE,KAAK,CAAC;CACb;AAED;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB,CAAC,KAAK;IACtC;;;;OAIG;IACH,eAAe,IAAI,KAAK,CAAC;CAE5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,8BAAsB,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAE,YAAW,mBAAmB,CAAC,KAAK,CAAC;IAuBrF,SAAS,CAAC,MAAM,EAAE,KAAK,EAAE;IACzB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE;IAC3B,SAAS,CAAC,WAAW,EAAE,WAAW,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE;IACnD,SAAS,CAAC,UAAU,EAAE,KAAK;IAzB/B;;;OAGG;IACH,SAAS,CAAC,YAAY,EAAE,KAAK,CAAC;IAE1B;;;GAGD;IACH,OAAO,CAAC,YAAY,CAA6B;IAEjD;;;;;;;;OAQG;gBAEW,MAAM,EAAE,KAAK,EAAE,EACf,OAAO,EAAE,MAAM,EAAE,EACjB,WAAW,EAAE,WAAW,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,EACzC,UAAU,EAAE,KAAK,EAC3B,cAAc,GAAE,OAAe;IA2CnC;;;;OAIG;IACH,eAAe,IAAI,KAAK;IAIxB;;;;;;;;;;;;;OAaG;IACH,SAAS,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK;IAqB3C,OAAO,CAAC,+BAA+B;IAcvC,OAAO,CAAC,yBAAyB;IA0BjC,OAAO,CAAC,0BAA0B;IAiClC,OAAO,CAAC,0BAA0B;IAelC,OAAO,CAAC,0BAA0B;IAmDlC,OAAO,CAAC,uBAAuB;IAS/B,OAAO,CAAC,sBAAsB;IAiB9B,OAAO,CAAC,mBAAmB;IAK3B;;;;;OAKG;IACH,SAAS,CAAC,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO;IAI/C;;;;;OAKG;IACH,SAAS,CAAC,mBAAmB,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,IAAI,KAAK,GAAG,0BAA0B;IAOxF;;;;;OAKG;IACH,SAAS,CAAC,mBAAmB,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,IAAI,KAAK,GAAG,0BAA0B;IAOxF;;;;OAIG;IACH,OAAO,CAAC,kBAAkB;IAM1B;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAMzB;;;;OAIG;IACH,YAAY,IAAI,KAAK,EAAE;IAIvB;;;;OAIG;IACH,aAAa,IAAI,MAAM,EAAE;IAIzB;;;;;OAKG;IACH,6BAA6B,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAMtD;;;;OAIG;IACH,+BAA+B,IAAI,MAAM,EAAE;IAM3C;;;;OAIG;IACH,cAAc,IAAI,WAAW,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE;IAI9C;;;;OAIG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAIlC;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO;IAI3B;;;;GAID;IACH,eAAe,IAAI,YAAY,GAAG,IAAI;IAItC;;;;OAIG;IACH,eAAe,IAAI,OAAO;CAG7B"}