@camcima/finita 2.0.0 → 2.1.0

package/dist/index.d.ts

@@ -1,22 +1,525 @@
-export type { MaybePromise } from "./MaybePromise.js";
-export { Event } from "./Event.js";
-export { State } from "./State.js";
-export { Transition } from "./Transition.js";
-export { StateCollection } from "./StateCollection.js";
-export { Process } from "./Process.js";
-export { Statemachine } from "./Statemachine.js";
-export { Dispatcher } from "./Dispatcher.js";
-export type { Named, Metadata, Weighted, Observer, ObservableSubject, ConditionInterface, EventInterface, TransitionInterface, StateInterface, StateCollectionInterface, ProcessInterface, StatemachineInterface, MutexInterface, MutexFactoryInterface, LockAdapterInterface, TransitionSelectorInterface, ProcessDetectorInterface, StateNameDetectorInterface, FactoryInterface, StatefulInterface, LastStateHasChangedDateInterface, DispatcherInterface, CallbackInterface, LoggerInterface, } from "./interfaces/index.js";
-export { Tautology, Contradiction, CallbackCondition, Timeout, AndComposite, OrComposite, Not, } from "./condition/index.js";
-export type { ConditionCallbackFn } from "./condition/index.js";
-export { CallbackObserver, StatefulStatusChanger, OnEnterObserver, TransitionLogger, } from "./observer/index.js";
-export { ActiveTransitionFilter, FilterStateByEvent, FilterStateByTransition, FilterStateByFinalState, FilterTransitionByEvent, } from "./filter/index.js";
-export { OneOrNoneActiveTransition, ScoreTransition, WeightTransition, } from "./selector/index.js";
-export { NullMutex, LockAdapterMutex, MutexFactory } from "./mutex/index.js";
-export type { StringConverter } from "./mutex/index.js";
-export { Factory, SingleProcessDetector, AbstractNamedProcessDetector, StatefulStateNameDetector, } from "./factory/index.js";
-export { SetupHelper, StateCollectionMerger } from "./util/index.js";
-export { GraphBuilder } from "./graph/index.js";
-export type { Graph, GraphNode, GraphEdge, DotOptions, MermaidOptions, } from "./graph/index.js";
-export { WrongEventForStateError, LockCanNotBeAcquiredError, DuplicateStateError, } from "./error/index.js";
-//# sourceMappingURL=index.d.ts.map
+type MaybePromise<T> = T | Promise<T>;
+
+interface Named {
+    getName(): string;
+}
+
+interface Metadata {
+    getMetadata(): Record<string, unknown>;
+}
+
+interface Observer {
+    update(subject: ObservableSubject): MaybePromise<void>;
+}
+interface ObservableSubject {
+    attach(observer: Observer): void;
+    detach(observer: Observer): void;
+    notify(): Promise<void>;
+    getObservers(): Iterable<Observer>;
+}
+
+interface EventInterface extends Named, Metadata, ObservableSubject {
+    getInvokeArgs(): unknown[];
+    invoke(...args: unknown[]): Promise<void>;
+    getMetadataValue(key: string): unknown;
+    setMetadataValue(key: string, value: unknown): void;
+    hasMetadataValue(key: string): boolean;
+    deleteMetadataValue(key: string): void;
+}
+
+declare class Event implements EventInterface {
+    private readonly name;
+    private readonly observers;
+    private readonly metadata;
+    private invokeArgs;
+    constructor(name: string);
+    getName(): string;
+    getInvokeArgs(): unknown[];
+    invoke(...args: unknown[]): Promise<void>;
+    attach(observer: Observer): void;
+    detach(observer: Observer): void;
+    notify(): Promise<void>;
+    getObservers(): Iterable<Observer>;
+    getMetadata(): Record<string, unknown>;
+    getMetadataValue(key: string): unknown;
+    setMetadataValue(key: string, value: unknown): void;
+    hasMetadataValue(key: string): boolean;
+    deleteMetadataValue(key: string): void;
+}
+
+interface Weighted {
+    getWeight(): number;
+}
+
+interface ConditionInterface<TSubject = unknown> extends Named {
+    checkCondition(subject: TSubject, context: Map<string, unknown>): MaybePromise<boolean>;
+}
+
+interface TransitionInterface<TSubject = unknown> extends Weighted {
+    getTargetState(): StateInterface;
+    getEventName(): string | null;
+    getConditionName(): string | null;
+    getCondition(): ConditionInterface<TSubject> | null;
+    isActive(subject: TSubject, context: Map<string, unknown>, event?: EventInterface): Promise<boolean>;
+}
+
+interface StateInterface extends Named, Metadata {
+    getTransitions(): Iterable<TransitionInterface>;
+    addTransition(transition: TransitionInterface): void;
+    getEventNames(): string[];
+    hasEvent(name: string): boolean;
+    getEvent(name: string): EventInterface;
+    getMetadataValue(key: string): unknown;
+    setMetadataValue(key: string, value: unknown): void;
+    hasMetadataValue(key: string): boolean;
+    deleteMetadataValue(key: string): void;
+}
+
+declare class State implements StateInterface {
+    private readonly name;
+    private readonly transitions;
+    private readonly events;
+    private readonly metadata;
+    constructor(name: string);
+    getName(): string;
+    getTransitions(): Iterable<TransitionInterface>;
+    addTransition(transition: TransitionInterface): void;
+    getEventNames(): string[];
+    hasEvent(name: string): boolean;
+    getEvent(name: string): EventInterface;
+    getMetadata(): Record<string, unknown>;
+    getMetadataValue(key: string): unknown;
+    setMetadataValue(key: string, value: unknown): void;
+    hasMetadataValue(key: string): boolean;
+    deleteMetadataValue(key: string): void;
+}
+
+declare class Transition<TSubject = unknown> implements TransitionInterface<TSubject> {
+    private readonly targetState;
+    private readonly eventName;
+    private readonly condition;
+    private weight;
+    constructor(targetState: StateInterface, eventName?: string | null, condition?: ConditionInterface<TSubject> | null);
+    getTargetState(): StateInterface;
+    getEventName(): string | null;
+    getConditionName(): string | null;
+    getCondition(): ConditionInterface<TSubject> | null;
+    isActive(subject: TSubject, context: Map<string, unknown>, event?: EventInterface): Promise<boolean>;
+    getWeight(): number;
+    setWeight(weight: number): void;
+}
+
+interface StateCollectionInterface {
+    getStates(): Iterable<StateInterface>;
+    getState(name: string): StateInterface;
+    hasState(name: string): boolean;
+}
+
+declare class StateCollectionMerger {
+    private readonly targetCollection;
+    private stateNamePrefix;
+    constructor(targetCollection: StateCollection);
+    getStateNamePrefix(): string;
+    setStateNamePrefix(prefix: string): void;
+    getTargetCollection(): StateCollection;
+    protected createState(name: string): StateInterface;
+    protected findOrCreateState(name: string): StateInterface;
+    protected createCondition(sourceTransition: TransitionInterface): ConditionInterface | null;
+    protected createTransition(sourceTransition: TransitionInterface): Transition;
+    protected mergeMetadata(source: StateInterface, target: StateInterface): void;
+    protected mergeEvent(source: StateInterface, target: StateInterface, eventName: string): void;
+    protected mergeState(sourceState: StateInterface): void;
+    merge(source: StateCollectionInterface | StateInterface): void;
+}
+
+declare class StateCollection implements StateCollectionInterface {
+    private readonly states;
+    private stateCollectionMerger;
+    getState(name: string): StateInterface;
+    getStates(): Iterable<StateInterface>;
+    hasState(name: string): boolean;
+    addState(state: StateInterface): void;
+    getStateCollectionMerger(): StateCollectionMerger;
+    merge(source: StateCollectionInterface): void;
+}
+
+interface ProcessInterface extends Named, StateCollectionInterface {
+    getInitialState(): StateInterface;
+}
+
+declare class Process implements ProcessInterface {
+    private readonly name;
+    private readonly initialState;
+    private readonly states;
+    constructor(name: string, initialState: StateInterface);
+    private registerState;
+    getName(): string;
+    getInitialState(): StateInterface;
+    getStates(): Iterable<StateInterface>;
+    getState(name: string): StateInterface;
+    hasState(name: string): boolean;
+}
+
+interface StatemachineInterface<TSubject = unknown> extends ObservableSubject {
+    getCurrentState(): StateInterface;
+    getSubject(): TSubject;
+    getProcess(): ProcessInterface;
+    triggerEvent(name: string, context?: Map<string, unknown>): Promise<void>;
+    checkTransitions(context?: Map<string, unknown>): Promise<void>;
+    getSelectedTransition(): TransitionInterface<TSubject> | null;
+    getLastState(): StateInterface | null;
+    getCurrentContext(): Map<string, unknown> | null;
+    acquireLock(): Promise<boolean>;
+    releaseLock(): Promise<void>;
+    isLockAcquired(): boolean;
+    isAutoreleaseLock(): boolean;
+    setAutoreleaseLock(autorelease: boolean): void;
+}
+
+interface MutexInterface {
+    acquireLock(): MaybePromise<boolean>;
+    releaseLock(): MaybePromise<boolean>;
+    isAcquired(): boolean;
+    isLocked(): MaybePromise<boolean>;
+}
+
+interface TransitionSelectorInterface<TSubject = unknown> {
+    selectTransition(transitions: Iterable<TransitionInterface<TSubject>>): TransitionInterface<TSubject> | null;
+}
+
+interface CallbackInterface {
+    invoke(): MaybePromise<void>;
+}
+interface DispatcherInterface extends CallbackInterface {
+    dispatch(event: EventInterface, args?: unknown[], onReadyCallback?: CallbackInterface): void;
+    isReady(): boolean;
+    invoke(): Promise<void>;
+}
+
+declare class Statemachine<TSubject = unknown> implements StatemachineInterface<TSubject> {
+    private readonly subject;
+    private currentState;
+    private lastState;
+    private readonly transitionSelector;
+    private selectedTransition;
+    private readonly process;
+    private readonly mutex;
+    private autoreleaseLock;
+    private dispatcher;
+    private currentEvent;
+    private currentContext;
+    private readonly observers;
+    constructor(subject: TSubject, process: ProcessInterface, stateName?: string | null, transitionSelector?: TransitionSelectorInterface<TSubject> | null, mutex?: MutexInterface | null);
+    getProcess(): ProcessInterface;
+    getCurrentState(): StateInterface;
+    getLastState(): StateInterface | null;
+    getSubject(): TSubject;
+    getSelectedTransition(): TransitionInterface<TSubject> | null;
+    getCurrentContext(): Map<string, unknown> | null;
+    private doCheckTransitions;
+    private onDispatcherReady;
+    dispatchEvent(dispatcher: DispatcherInterface, name: string, context?: Map<string, unknown>): Promise<void>;
+    triggerEvent(name: string, context?: Map<string, unknown>): Promise<void>;
+    checkTransitions(context?: Map<string, unknown>): Promise<void>;
+    private acquireLockOrThrowException;
+    isAutoreleaseLock(): boolean;
+    setAutoreleaseLock(autorelease: boolean): void;
+    acquireLock(): Promise<boolean>;
+    releaseLock(): Promise<void>;
+    isLockAcquired(): boolean;
+    attach(observer: Observer): void;
+    detach(observer: Observer): void;
+    notify(): Promise<void>;
+    getObservers(): Iterable<Observer>;
+}
+
+declare class Dispatcher implements DispatcherInterface {
+    private commands;
+    private onReadyCallbacks;
+    private ready;
+    dispatch(event: EventInterface, args?: unknown[], onReadyCallback?: CallbackInterface): void;
+    invoke(): Promise<void>;
+    isReady(): boolean;
+}
+
+interface MutexFactoryInterface<TSubject = unknown> {
+    createMutex(subject: TSubject): MaybePromise<MutexInterface>;
+}
+
+interface LockAdapterInterface {
+    acquireLock(resourceName: string): MaybePromise<boolean>;
+    releaseLock(resourceName: string): MaybePromise<boolean>;
+    isLocked(resourceName: string): MaybePromise<boolean>;
+}
+
+interface ProcessDetectorInterface<TSubject = unknown> {
+    detectProcess(subject: TSubject): ProcessInterface;
+}
+
+interface StateNameDetectorInterface<TSubject = unknown> {
+    detectCurrentStateName(subject: TSubject): string | null;
+}
+
+interface FactoryInterface<TSubject = unknown> {
+    createStatemachine(subject: TSubject): Promise<StatemachineInterface<TSubject>>;
+    setMutexFactory(factory: MutexFactoryInterface<TSubject> | null): void;
+    setTransitionSelector(selector: TransitionSelectorInterface<TSubject>): void;
+    attachStatemachineObserver(observer: Observer): void;
+    detachStatemachineObserver(observer: Observer): void;
+    getStatemachineObservers(): Iterable<Observer>;
+}
+
+interface StatefulInterface {
+    getCurrentStateName(): string;
+    setCurrentStateName(stateName: string): void;
+}
+
+interface LastStateHasChangedDateInterface {
+    getLastStateHasChangedDate(): Date;
+}
+
+interface LoggerInterface {
+    log(level: string, message: string, context?: Record<string, unknown>): void;
+}
+
+declare class Tautology implements ConditionInterface {
+    private readonly name;
+    constructor(name?: string);
+    getName(): string;
+    checkCondition(_subject: unknown, _context: Map<string, unknown>): boolean;
+}
+
+declare class Contradiction implements ConditionInterface {
+    private readonly name;
+    constructor(name?: string);
+    getName(): string;
+    checkCondition(_subject: unknown, _context: Map<string, unknown>): boolean;
+}
+
+type ConditionCallbackFn<TSubject = unknown> = (subject: TSubject, context: Map<string, unknown>) => MaybePromise<boolean>;
+declare class CallbackCondition<TSubject = unknown> implements ConditionInterface<TSubject> {
+    private readonly name;
+    private readonly callable;
+    constructor(name: string, callable: ConditionCallbackFn<TSubject>);
+    getName(): string;
+    checkCondition(subject: TSubject, context: Map<string, unknown>): MaybePromise<boolean>;
+}
+
+declare class Timeout implements ConditionInterface {
+    private readonly timeoutMs;
+    private readonly label;
+    constructor(timeoutMs: number, label?: string);
+    getName(): string;
+    protected getLastStateHasChangedDate(subject: unknown, _context: Map<string, unknown>): Date;
+    checkCondition(subject: unknown, context: Map<string, unknown>): boolean;
+}
+
+declare class AndComposite<TSubject = unknown> implements ConditionInterface<TSubject> {
+    private readonly conditions;
+    constructor(condition: ConditionInterface<TSubject>);
+    addAnd(condition: ConditionInterface<TSubject>): this;
+    getName(): string;
+    checkCondition(subject: TSubject, context: Map<string, unknown>): Promise<boolean>;
+}
+
+declare class OrComposite<TSubject = unknown> implements ConditionInterface<TSubject> {
+    private readonly conditions;
+    constructor(condition: ConditionInterface<TSubject>);
+    addOr(condition: ConditionInterface<TSubject>): this;
+    getName(): string;
+    checkCondition(subject: TSubject, context: Map<string, unknown>): Promise<boolean>;
+}
+
+declare class Not<TSubject = unknown> implements ConditionInterface<TSubject> {
+    private readonly condition;
+    constructor(condition: ConditionInterface<TSubject>);
+    getName(): string;
+    checkCondition(subject: TSubject, context: Map<string, unknown>): Promise<boolean>;
+}
+
+declare class CallbackObserver implements Observer {
+    private readonly callback;
+    constructor(callback: (...args: unknown[]) => MaybePromise<void>);
+    update(subject: ObservableSubject): MaybePromise<void>;
+}
+
+declare class StatefulStatusChanger implements Observer {
+    update(subject: ObservableSubject): void;
+}
+
+declare class OnEnterObserver implements Observer {
+    static readonly DEFAULT_EVENT_NAME = "onEnter";
+    private readonly eventName;
+    constructor(eventName?: string);
+    update(subject: ObservableSubject): Promise<void>;
+}
+
+declare class TransitionLogger implements Observer {
+    private readonly logger;
+    private readonly loggerLevel;
+    constructor(logger: LoggerInterface, loggerLevel?: string);
+    update(subject: ObservableSubject): void;
+}
+
+declare class ActiveTransitionFilter {
+    static filter<TSubject = unknown>(transitions: Iterable<TransitionInterface<TSubject>>, subject: TSubject, context: Map<string, unknown>, event?: EventInterface): Promise<TransitionInterface<TSubject>[]>;
+}
+
+declare class FilterStateByEvent {
+    static filter(states: Iterable<StateInterface>, eventName: string): Iterable<StateInterface>;
+}
+
+/**
+ * Filters states that have at least one automatic transition (no event name).
+ */
+declare class FilterStateByTransition {
+    static filter(states: Iterable<StateInterface>): Iterable<StateInterface>;
+}
+
+declare class FilterStateByFinalState {
+    static filter(states: Iterable<StateInterface>): Iterable<StateInterface>;
+}
+
+declare class FilterTransitionByEvent {
+    static filter(transitions: Iterable<TransitionInterface>, eventName: string): Iterable<TransitionInterface>;
+}
+
+declare class OneOrNoneActiveTransition<TSubject = unknown> implements TransitionSelectorInterface<TSubject> {
+    selectTransition(transitions: Iterable<TransitionInterface<TSubject>>): TransitionInterface<TSubject> | null;
+}
+
+declare class ScoreTransition<TSubject = unknown> implements TransitionSelectorInterface<TSubject> {
+    private readonly innerSelector;
+    constructor(innerSelector?: TransitionSelectorInterface<TSubject>);
+    protected calculateScore(transition: TransitionInterface<TSubject>): number;
+    selectTransition(transitions: Iterable<TransitionInterface<TSubject>>): TransitionInterface<TSubject> | null;
+}
+
+declare class WeightTransition<TSubject = unknown> implements TransitionSelectorInterface<TSubject> {
+    private readonly innerSelector;
+    private readonly epsilon;
+    constructor(innerSelector?: TransitionSelectorInterface<TSubject>, epsilon?: number);
+    selectTransition(transitions: Iterable<TransitionInterface<TSubject>>): TransitionInterface<TSubject> | null;
+}
+
+declare class NullMutex implements MutexInterface {
+    private acquired;
+    acquireLock(): boolean;
+    releaseLock(): boolean;
+    isAcquired(): boolean;
+    isLocked(): boolean;
+}
+
+declare class LockAdapterMutex implements MutexInterface {
+    private readonly lockAdapter;
+    private readonly resourceName;
+    private acquired;
+    constructor(lockAdapter: LockAdapterInterface, resourceName: string);
+    acquireLock(): Promise<boolean>;
+    releaseLock(): Promise<boolean>;
+    isAcquired(): boolean;
+    isLocked(): Promise<boolean>;
+}
+
+type StringConverter<TSubject = unknown> = (subject: TSubject) => string;
+declare class MutexFactory<TSubject = unknown> implements MutexFactoryInterface<TSubject> {
+    private readonly lockAdapter;
+    private readonly stringConverter;
+    constructor(lockAdapter: LockAdapterInterface, stringConverter: StringConverter<TSubject>);
+    createMutex(subject: TSubject): MutexInterface;
+}
+
+declare class Factory<TSubject = unknown> implements FactoryInterface<TSubject> {
+    private readonly processDetector;
+    private readonly stateNameDetector;
+    private readonly statemachineObservers;
+    private transitionSelector;
+    private mutexFactory;
+    constructor(processDetector: ProcessDetectorInterface<TSubject>, stateNameDetector?: StateNameDetectorInterface<TSubject> | null);
+    setMutexFactory(factory: MutexFactoryInterface<TSubject> | null): void;
+    setTransitionSelector(selector: TransitionSelectorInterface<TSubject>): void;
+    attachStatemachineObserver(observer: Observer): void;
+    detachStatemachineObserver(observer: Observer): void;
+    getStatemachineObservers(): Iterable<Observer>;
+    createStatemachine(subject: TSubject): Promise<StatemachineInterface<TSubject>>;
+}
+
+declare class SingleProcessDetector<TSubject = unknown> implements ProcessDetectorInterface<TSubject> {
+    private readonly process;
+    constructor(process: ProcessInterface);
+    detectProcess(_subject: TSubject): ProcessInterface;
+}
+
+declare abstract class AbstractNamedProcessDetector<TSubject = unknown> implements ProcessDetectorInterface<TSubject> {
+    private readonly processes;
+    protected abstract detectProcessName(subject: TSubject): string;
+    addProcess(process: ProcessInterface): void;
+    hasProcess(name: string): boolean;
+    detectProcess(subject: TSubject): ProcessInterface;
+}
+
+declare class StatefulStateNameDetector implements StateNameDetectorInterface<StatefulInterface> {
+    detectCurrentStateName(subject: StatefulInterface): string | null;
+}
+
+declare class SetupHelper {
+    protected readonly stateCollection: StateCollection;
+    constructor(stateCollection: StateCollection);
+    findOrCreateState(name: string): StateInterface;
+    protected findTransition(sourceState: StateInterface, targetState: StateInterface, eventName?: string | null, condition?: ConditionInterface | null): TransitionInterface | null;
+    findOrCreateTransition(sourceStateName: string, targetStateName: string, eventName?: string | null, condition?: ConditionInterface | null): TransitionInterface;
+    findOrCreateEvent(sourceStateName: string, eventName: string): EventInterface;
+    addCommand(sourceStateName: string, eventName: string, command: Observer): void;
+    addCommandAndSelfTransition(sourceStateName: string, eventName: string, command: Observer): void;
+}
+
+interface GraphNode {
+    id: string;
+    label: string;
+    metadata: Record<string, unknown>;
+}
+interface GraphEdge {
+    source: string;
+    target: string;
+    label: string;
+    metadata: Record<string, unknown>;
+}
+interface Graph {
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+}
+interface DotOptions {
+    rankdir?: string;
+}
+interface MermaidOptions {
+    direction?: string;
+}
+declare class GraphBuilder {
+    private readonly nodes;
+    private readonly edges;
+    private getOrCreateNode;
+    protected getTransitionLabel(state: StateInterface, transition: TransitionInterface): string;
+    addState(state: StateInterface): void;
+    addStates(states: Iterable<StateInterface>): void;
+    addStateCollection(stateCollection: StateCollectionInterface): void;
+    getGraph(): Graph;
+    toDot(options?: DotOptions): string;
+    toMermaid(options?: MermaidOptions): string;
+}
+
+declare class WrongEventForStateError extends Error {
+    readonly stateName: string;
+    readonly eventName: string;
+    constructor(stateName: string, eventName: string);
+}
+
+declare class LockCanNotBeAcquiredError extends Error {
+    constructor(message?: string);
+}
+
+declare class DuplicateStateError extends Error {
+    readonly stateName: string;
+    constructor(stateName: string);
+}
+
+export { AbstractNamedProcessDetector, ActiveTransitionFilter, AndComposite, CallbackCondition, type CallbackInterface, CallbackObserver, type ConditionCallbackFn, type ConditionInterface, Contradiction, Dispatcher, type DispatcherInterface, type DotOptions, DuplicateStateError, Event, type EventInterface, Factory, type FactoryInterface, FilterStateByEvent, FilterStateByFinalState, FilterStateByTransition, FilterTransitionByEvent, type Graph, GraphBuilder, type GraphEdge, type GraphNode, type LastStateHasChangedDateInterface, type LockAdapterInterface, LockAdapterMutex, LockCanNotBeAcquiredError, type LoggerInterface, type MaybePromise, type MermaidOptions, type Metadata, MutexFactory, type MutexFactoryInterface, type MutexInterface, type Named, Not, NullMutex, type ObservableSubject, type Observer, OnEnterObserver, OneOrNoneActiveTransition, OrComposite, Process, type ProcessDetectorInterface, type ProcessInterface, ScoreTransition, SetupHelper, SingleProcessDetector, State, StateCollection, type StateCollectionInterface, StateCollectionMerger, type StateInterface, type StateNameDetectorInterface, type StatefulInterface, StatefulStateNameDetector, StatefulStatusChanger, Statemachine, type StatemachineInterface, type StringConverter, Tautology, Timeout, Transition, type TransitionInterface, TransitionLogger, type TransitionSelectorInterface, WeightTransition, type Weighted, WrongEventForStateError };