@jonloucks/concurrency-ts 0.4.0

package/api/Concurrency.js

@@ -0,0 +1,19 @@
+import { guardFunctions } from "@jonloucks/concurrency-ts/api/Types";
+import { createContract } from "@jonloucks/contracts-ts";
+/**
+ * Determine if the given instance is a Concurrency
+ *
+ * @param instance the instance to test
+ * @return true if the instance is a Concurrency
+ */
+export function guard(instance) {
+    return guardFunctions(instance, 'createWaitable', 'createStateMachine', 'createCompletable', 'completeLater', 'completeNow', 'open');
+}
+/**
+ * The Concurrency contract
+ */
+export const CONTRACT = createContract({
+    name: "Concurrency",
+    test: guard
+});
+//# sourceMappingURL=Concurrency.js.map

package/api/Concurrency.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Concurrency.js","sourceRoot":"","sources":["../../src/api/Concurrency.ts"],"names":[],"mappings":"AAIA,OAAO,EAA0B,cAAc,EAAsD,MAAM,qCAAqC,CAAC;AAGjJ,OAAO,EAAuB,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAgG9E;;;;;GAKG;AACH,MAAM,UAAU,KAAK,CAAC,QAAiB;IACrC,OAAO,cAAc,CAAC,QAAQ,EAC5B,gBAAgB,EAChB,oBAAoB,EACpB,mBAAmB,EACnB,eAAe,EACf,aAAa,EACb,MAAM,CACP,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,QAAQ,GAA0B,cAAc,CAAc;IACzE,IAAI,EAAE,aAAa;IACnB,IAAI,EAAE,KAAK;CACZ,CAAC,CAAC"}

package/api/ConcurrencyException.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Runtime exception thrown for Concurrency related problems.
+ */
+export declare class ConcurrencyException extends Error {
+    /**
+     * Passthrough for {@link Error(String, Throwable)}
+     *
+     * @param message the message for this exception
+     * @param thrown  the cause of this exception, null is allowed
+     */
+    constructor(message: string, thrown?: Error | null);
+    /**
+     * Ensure something that was caught is rethrown as a ConcurrencyException
+     * @param caught the caught value
+     * @param message the optional message to use if caught is not an ConcurrencyException
+     */
+    static rethrow(caught: unknown, message?: string): never;
+    private static throwUnknown;
+}
+/**
+ * Determine if an instance is a ConcurrencyException
+ *
+ * @param instance the instance to check
+ * @returns true if the instance is a ConcurrencyException
+ */
+export declare function guard(instance: unknown): instance is ConcurrencyException;
+//# sourceMappingURL=ConcurrencyException.d.ts.map

package/api/ConcurrencyException.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConcurrencyException.d.ts","sourceRoot":"","sources":["../../src/api/ConcurrencyException.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;IAE7C;;;;;OAKG;gBACgB,OAAO,EAAE,MAAM,EAAE,MAAM,GAAE,KAAK,GAAG,IAAW;IAQ/D;;;;OAIG;IACH,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,KAAK;IAYxD,OAAO,CAAC,MAAM,CAAC,YAAY;CAG5B;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,QAAQ,EAAE,OAAO,GAAG,QAAQ,IAAI,oBAAoB,CAEzE"}

package/api/ConcurrencyException.js

@@ -0,0 +1,53 @@
+import { messageCheck } from "@jonloucks/contracts-ts/auxiliary/Checks";
+import { isNotPresent } from "@jonloucks/contracts-ts/api/Types";
+import { used } from "@jonloucks/contracts-ts/auxiliary/Checks";
+/**
+ * Runtime exception thrown for Concurrency related problems.
+ */
+export class ConcurrencyException extends Error {
+    /**
+     * Passthrough for {@link Error(String, Throwable)}
+     *
+     * @param message the message for this exception
+     * @param thrown  the cause of this exception, null is allowed
+     */
+    constructor(message, thrown = null) {
+        // super(messageCheck(message), thrown || undefined);
+        super(messageCheck(message));
+        used(thrown);
+        this.name = "ConcurrencyException";
+        Object.setPrototypeOf(this, ConcurrencyException.prototype);
+    }
+    /**
+     * Ensure something that was caught is rethrown as a ConcurrencyException
+     * @param caught the caught value
+     * @param message the optional message to use if caught is not an ConcurrencyException
+     */
+    static rethrow(caught, message) {
+        if (isNotPresent(caught)) {
+            this.throwUnknown(message);
+        }
+        else if (guard(caught)) {
+            throw caught;
+        }
+        else if (caught instanceof Error) {
+            throw new ConcurrencyException(message ?? caught.message, caught);
+        }
+        else {
+            this.throwUnknown(message);
+        }
+    }
+    static throwUnknown(message) {
+        throw new ConcurrencyException(message ?? "Unknown type of caught value.");
+    }
+}
+/**
+ * Determine if an instance is a ConcurrencyException
+ *
+ * @param instance the instance to check
+ * @returns true if the instance is a ConcurrencyException
+ */
+export function guard(instance) {
+    return instance instanceof ConcurrencyException;
+}
+//# sourceMappingURL=ConcurrencyException.js.map

package/api/ConcurrencyException.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConcurrencyException.js","sourceRoot":"","sources":["../../src/api/ConcurrencyException.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,0CAA0C,CAAA;AACvE,OAAO,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AACjE,OAAO,EAAE,IAAI,EAAE,MAAM,0CAA0C,CAAC;AAEhE;;GAEG;AACH,MAAM,OAAO,oBAAqB,SAAQ,KAAK;IAE7C;;;;;OAKG;IACH,YAAmB,OAAe,EAAE,SAAuB,IAAI;QAC7D,qDAAqD;QACrD,KAAK,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC;QAC7B,IAAI,CAAC,MAAM,CAAC,CAAC;QACb,IAAI,CAAC,IAAI,GAAG,sBAAsB,CAAC;QACnC,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,oBAAoB,CAAC,SAAS,CAAC,CAAA;IAC7D,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,OAAO,CAAC,MAAe,EAAE,OAAgB;QAC9C,IAAI,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC;YACxB,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QAC9B,CAAC;aAAM,IAAI,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC;YACzB,MAAM,MAAM,CAAC;QACf,CAAC;aAAM,IAAI,MAAM,YAAY,KAAK,EAAE,CAAC;YACnC,MAAM,IAAI,oBAAoB,CAAC,OAAO,IAAI,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QACpE,CAAC;aAAM,CAAC;YACL,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QAC9B,CAAC;IACH,CAAC;IAEO,MAAM,CAAC,YAAY,CAAE,OAAgB;QAC3C,MAAM,IAAI,oBAAoB,CAAC,OAAO,IAAI,+BAA+B,CAAC,CAAC;IAC7E,CAAC;CACF;AAED;;;;;GAKG;AACH,MAAM,UAAU,KAAK,CAAC,QAAiB;IACrC,OAAO,QAAQ,YAAY,oBAAoB,CAAC;AAClD,CAAC"}

package/api/ConcurrencyFactory.d.ts

@@ -0,0 +1,41 @@
+import { Concurrency, Config as ConcurrencyConfig } from "@jonloucks/concurrency-ts/api/Concurrency";
+import { Contract } from "@jonloucks/contracts-ts";
+import { RequiredType } from "@jonloucks/concurrency-ts/api/Types";
+import { Repository } from "@jonloucks/contracts-ts/api/Repository";
+/**
+ * Responsible for creating new instances of Concurrency
+ */
+export interface ConcurrencyFactory {
+    /**
+     * Create a new instance of Concurrency
+     * <p>
+     *     Note: caller is responsible for calling Open.open and calling
+     *     the AutoClose.close when done with the instance.
+     * </p>
+     * @param config the Concurrency configuration for the new instance
+     * @return the new Concurrency instance
+     * @throws IllegalArgumentException if config is null or when configuration is invalid
+     */
+    createConcurrency(config?: ConcurrencyConfig): Concurrency;
+    /**
+     * Install all the requirements and promises to the given Contracts Repository.
+     * Include Concurrency#CONTRACT which will provide a unique
+     *
+     * @param repository the repository to add requirements and promises to
+     * @param config the Concurrency config
+     * @throws IllegalArgumentException if config is null, config is invalid, or repository is null
+     */
+    install(repository: RequiredType<Repository>, config?: ConcurrencyConfig): void;
+}
+/**
+ * Determine if the given instance is a ConcurrencyFactory
+ *
+ * @param instance the instance to check
+ * @return true if instance is a ConcurrencyFactory, false otherwise
+ */
+export declare function guard(instance: unknown): instance is RequiredType<ConcurrencyFactory>;
+/**
+ * The Contract for ConcurrencyFactory
+ */
+export declare const CONTRACT: Contract<ConcurrencyFactory>;
+//# sourceMappingURL=ConcurrencyFactory.d.ts.map

package/api/ConcurrencyFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConcurrencyFactory.d.ts","sourceRoot":"","sources":["../../src/api/ConcurrencyFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,IAAI,iBAAiB,EAAE,MAAM,2CAA2C,CAAC;AACrG,OAAO,EAAE,QAAQ,EAAkB,MAAM,yBAAyB,CAAC;AACnE,OAAO,EAAE,YAAY,EAAkB,MAAM,qCAAqC,CAAC;AACnF,OAAO,EAAE,UAAU,EAAE,MAAM,wCAAwC,CAAC;AAEpE;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAEjC;;;;;;;;;OASG;IACH,iBAAiB,CAAC,MAAM,CAAC,EAAE,iBAAiB,GAAG,WAAW,CAAC;IAE3D;;;;;;;OAOG;IACH,OAAO,CAAC,UAAU,EAAE,YAAY,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAAC;CACjF;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,QAAQ,EAAE,OAAO,GAAG,QAAQ,IAAI,YAAY,CAAC,kBAAkB,CAAC,CAErF;AAED;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAAC,kBAAkB,CAGhD,CAAC"}

package/api/ConcurrencyFactory.js

@@ -0,0 +1,19 @@
+import { createContract } from "@jonloucks/contracts-ts";
+import { guardFunctions } from "@jonloucks/concurrency-ts/api/Types";
+/**
+ * Determine if the given instance is a ConcurrencyFactory
+ *
+ * @param instance the instance to check
+ * @return true if instance is a ConcurrencyFactory, false otherwise
+ */
+export function guard(instance) {
+    return guardFunctions(instance, 'createConcurrency', 'install');
+}
+/**
+ * The Contract for ConcurrencyFactory
+ */
+export const CONTRACT = createContract({
+    name: "ConcurrencyFactory",
+    test: guard
+});
+//# sourceMappingURL=ConcurrencyFactory.js.map

package/api/ConcurrencyFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConcurrencyFactory.js","sourceRoot":"","sources":["../../src/api/ConcurrencyFactory.ts"],"names":[],"mappings":"AACA,OAAO,EAAY,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,EAAgB,cAAc,EAAE,MAAM,qCAAqC,CAAC;AA+BnF;;;;;GAKG;AACH,MAAM,UAAU,KAAK,CAAC,QAAiB;IACrC,OAAO,cAAc,CAAC,QAAQ,EAAE,mBAAmB,EAAE,SAAS,CAAC,CAAC;AAClE,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAiC,cAAc,CAAC;IACnE,IAAI,EAAE,oBAAoB;IAC1B,IAAI,EAAE,KAAK;CACZ,CAAC,CAAC"}

package/api/IsCompleted.d.ts

@@ -0,0 +1,20 @@
+import { RequiredType } from "@jonloucks/concurrency-ts/api/Types";
+/**
+ * An interface to determine if an action or activity is completed
+ */
+export interface IsCompleted {
+    /**
+     * Is the action or activity completed
+     *
+     * @return true if completed, false otherwise
+     */
+    isCompleted(): boolean;
+}
+/**
+ * Determine if the given instance is an IsCompleted
+ *
+ * @param instance the instance to check
+ * @return true if instance is an IsCompleted, false otherwise
+ */
+export declare function guard(instance: unknown): instance is RequiredType<IsCompleted>;
+//# sourceMappingURL=IsCompleted.d.ts.map

package/api/IsCompleted.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsCompleted.d.ts","sourceRoot":"","sources":["../../src/api/IsCompleted.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAkB,MAAM,qCAAqC,CAAC;AAEnF;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,WAAW,IAAI,OAAO,CAAC;CACxB;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,QAAQ,EAAE,OAAO,GAAG,QAAQ,IAAI,YAAY,CAAC,WAAW,CAAC,CAE9E"}

package/api/IsCompleted.js

@@ -0,0 +1,11 @@
+import { guardFunctions } from "@jonloucks/concurrency-ts/api/Types";
+/**
+ * Determine if the given instance is an IsCompleted
+ *
+ * @param instance the instance to check
+ * @return true if instance is an IsCompleted, false otherwise
+ */
+export function guard(instance) {
+    return guardFunctions(instance, 'isCompleted');
+}
+//# sourceMappingURL=IsCompleted.js.map

package/api/IsCompleted.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsCompleted.js","sourceRoot":"","sources":["../../src/api/IsCompleted.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAcnF;;;;;GAKG;AACH,MAAM,UAAU,KAAK,CAAC,QAAiB;IACrC,OAAO,cAAc,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC;AACjD,CAAC"}

package/api/OnCompletion.d.ts

@@ -0,0 +1,23 @@
+import { Completion } from "@jonloucks/concurrency-ts/api/Completion";
+import { RequiredType } from "@jonloucks/concurrency-ts/api/Types";
+/**
+ * Responsibility: to receive the information when an action or activity has finished.
+ * Use for both asynchronous and synchronous actions. The only difference is when and on what
+ * thread the callback is executed on
+ * @param <T> the type of completion value
+ */
+export interface OnCompletion<T> {
+    /**
+     * Callback which receives the
+     * @param completion the completion information.
+     */
+    onCompletion(completion: RequiredType<Completion<T>>): void;
+}
+/**
+ * Determine if the given instance is an OnCompletion
+ *
+ * @param instance the instance to check
+ * @return true if instance is an OnCompletion, false otherwise
+ */
+export declare function guard<T>(instance: unknown): instance is RequiredType<OnCompletion<T>>;
+//# sourceMappingURL=OnCompletion.d.ts.map

package/api/OnCompletion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OnCompletion.d.ts","sourceRoot":"","sources":["../../src/api/OnCompletion.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,0CAA0C,CAAC;AACtE,OAAO,EAAE,YAAY,EAAkB,MAAM,qCAAqC,CAAC;AAEnF;;;;;GAKG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC;IAE7B;;;OAGG;IACH,YAAY,CAAC,UAAU,EAAE,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;CAC7D;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,GAAG,QAAQ,IAAI,YAAY,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAErF"}

package/api/OnCompletion.js

@@ -0,0 +1,12 @@
+import { guardFunctions } from "@jonloucks/concurrency-ts/api/Types";
+/**
+ * Determine if the given instance is an OnCompletion
+ *
+ * @param instance the instance to check
+ * @return true if instance is an OnCompletion, false otherwise
+ */
+export function guard(instance) {
+    return guardFunctions(instance, 'onCompletion');
+}
+;
+//# sourceMappingURL=OnCompletion.js.map

package/api/OnCompletion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OnCompletion.js","sourceRoot":"","sources":["../../src/api/OnCompletion.ts"],"names":[],"mappings":"AACA,OAAO,EAAgB,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAiBnF;;;;;GAKG;AACH,MAAM,UAAU,KAAK,CAAI,QAAiB;IACxC,OAAO,cAAc,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC;AAClD,CAAC;AAAA,CAAC"}

package/api/Rule.d.ts

@@ -0,0 +1,28 @@
+import { RequiredType } from "@jonloucks/concurrency-ts/api/Types";
+/**
+* Opt-in interface a state type can implement to assist in determining the valid transitions
+*/
+export interface Rule<T> {
+    /**
+     * Determine if 'this' state can transition to the target
+     *
+     * @param event the event name
+     * @param goal  the goal state
+     * @return true if the transition is valid
+     */
+    canTransition(event: string, goal: T): boolean;
+    /**
+     * Determine if the given state is a terminal state
+     *
+     * @return true if the state is terminal
+     */
+    isTerminal?: boolean;
+}
+/**
+ * Type guard to determine if an instance implements Rule
+ *
+ * @param instance the instance to check
+ * @return true if instance is a Rule
+ */
+export declare function guard<T>(instance: unknown): instance is RequiredType<Rule<T>>;
+//# sourceMappingURL=Rule.d.ts.map

package/api/Rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Rule.d.ts","sourceRoot":"","sources":["../../src/api/Rule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAkB,MAAM,qCAAqC,CAAC;AAEnF;;EAEE;AACF,MAAM,WAAW,IAAI,CAAC,CAAC;IAErB;;;;;;OAMG;IACH,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC;IAE/C;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,GAAG,QAAQ,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAE7E"}

package/api/Rule.js

@@ -0,0 +1,11 @@
+import { guardFunctions } from "@jonloucks/concurrency-ts/api/Types";
+/**
+ * Type guard to determine if an instance implements Rule
+ *
+ * @param instance the instance to check
+ * @return true if instance is a Rule
+ */
+export function guard(instance) {
+    return guardFunctions(instance, 'canTransition');
+}
+//# sourceMappingURL=Rule.js.map

package/api/Rule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Rule.js","sourceRoot":"","sources":["../../src/api/Rule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAwBnF;;;;;GAKG;AACH,MAAM,UAAU,KAAK,CAAI,QAAiB;IACxC,OAAO,cAAc,CAAC,QAAQ,EAAE,eAAe,CAAC,CAAC;AACnD,CAAC"}

package/api/StateMachine.d.ts

@@ -0,0 +1,95 @@
+import { Rule } from "@jonloucks/concurrency-ts/api/Rule";
+import { Transition } from "@jonloucks/concurrency-ts/api/Transition";
+import { OptionalType, RequiredType } from "@jonloucks/concurrency-ts/api/Types";
+import { WaitableNotify } from "@jonloucks/concurrency-ts/api/WaitableNotify";
+import { WaitableSupplier } from "@jonloucks/concurrency-ts/api/WaitableSupplier";
+import { Open } from "@jonloucks/contracts-ts/api/Open";
+import { IsCompleted } from "@jonloucks/concurrency-ts/api/IsCompleted";
+import { Contracts } from "@jonloucks/contracts-ts/api/Contracts";
+/**
+ * State machine.
+ * User defined states with rules to restrict state transitions.
+ *
+ * @param <T> the user defined state type
+ */
+export interface StateMachine<T> extends Open, WaitableSupplier<T>, WaitableNotify<T>, IsCompleted {
+    /**
+     * Set the current state, state must already exist and be an allowed transition
+     *
+     * @param event the event name
+     * @param state the new state
+     * @return true if state was changed
+     * @throws IllegalArgumentException when event is null, state is null, or unknown
+     */
+    setState(event: string, state: T): boolean;
+    /**
+     * Get the current state
+     *
+     * @return the current state, never null
+     */
+    getState(): T;
+    /**
+     * Determine if the given state is known
+     *
+     * @param state the state to check
+     * @return true if and only if the state is known
+     * @throws IllegalArgumentException when state is null
+     */
+    hasState(state: T): boolean;
+    /**
+     * Determine if a transition is allowed from the current state to a new one.
+     *
+     * @param event the event that is triggering the transition
+     * @param state the candidate state to transition to
+     * @return if transition event is allowed to change the current state to the given state
+     * @throws IllegalArgumentException when event is null, state is null, or unknown
+     */
+    isTransitionAllowed(event: string, state: T): boolean;
+    /**
+     * Execute a transition from the current state to another
+     *
+     * @param transition the transition to execute
+     * @param <R>        the return type of the transition. For example, a Closeable during open.
+     * @return the transition return value
+     * @throws IllegalArgumentException when transition is null or required fields are not present.
+     */
+    transition<R>(transition: Transition<T, R>): OptionalType<R>;
+}
+/**
+ * StateMachine configuration
+ *
+ * @param <T> the type of each state
+ */
+export interface Config<T> {
+    /**
+     * The contracts to use
+     */
+    contracts?: Contracts;
+    /**
+     * Return the initial value. It is required, the use of required is because
+     * the builder may not have provided a value
+     *
+     * @return the optional initial state
+     */
+    initialValue: RequiredType<T>;
+    /**
+     * @return the list of states in the state machine
+     */
+    states: readonly T[];
+    /**
+     * Get all the rules for a specified state
+     *
+     * @param state the state
+     * @return the rules of the state
+     */
+    getStateRules?(state: T): ReadonlyArray<Rule<T>>;
+}
+export { type Config as StateMachineConfig };
+/**
+ * Determine if the given instance is a StateMachine
+ *
+ * @param instance the instance to check
+ * @return true if the instance is a StateMachine
+ */
+export declare function guard<T>(instance: unknown): instance is RequiredType<StateMachine<T>>;
+//# sourceMappingURL=StateMachine.d.ts.map

package/api/StateMachine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StateMachine.d.ts","sourceRoot":"","sources":["../../src/api/StateMachine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,oCAAoC,CAAC;AAC1D,OAAO,EAAE,UAAU,EAAE,MAAM,0CAA0C,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,qCAAqC,CAAC;AACjG,OAAO,EAAE,cAAc,EAAgC,MAAM,8CAA8C,CAAC;AAC5G,OAAO,EAAE,gBAAgB,EAAkC,MAAM,gDAAgD,CAAC;AAClH,OAAO,EAAE,IAAI,EAAE,MAAM,kCAAkC,CAAC;AACxD,OAAO,EAAE,WAAW,EAAE,MAAM,2CAA2C,CAAC;AACxE,OAAO,EAAE,SAAS,EAAE,MAAM,uCAAuC,CAAC;AAElE;;;;;GAKG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC,CAAE,SAAQ,IAAI,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,WAAW;IAEhG;;;;;;;OAOG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC;IAE3C;;;;OAIG;IACH,QAAQ,IAAI,CAAC,CAAC;IAEd;;;;;;OAMG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC;IAE5B;;;;;;;OAOG;IACH,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC;IAEtD;;;;;;;OAOG;IACH,UAAU,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;CAC9D;AAED;;;;GAIG;AACH,MAAM,WAAW,MAAM,CAAC,CAAC;IAEvB;;OAEG;IACH,SAAS,CAAC,EAAE,SAAS,CAAC;IAEtB;;;;;OAKG;IACH,YAAY,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;IAE9B;;OAEG;IACH,MAAM,EAAE,SAAS,CAAC,EAAE,CAAC;IAErB;;;;;OAKG;IACH,aAAa,CAAC,CAAC,KAAK,EAAE,CAAC,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;CAClD;AAED,OAAO,EAAE,KAAK,MAAM,IAAI,kBAAkB,EAAE,CAAE;AAE9C;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,GAAG,QAAQ,IAAI,YAAY,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAUrF"}

package/api/StateMachine.js

@@ -0,0 +1,13 @@
+import { guardFunctions } from "@jonloucks/concurrency-ts/api/Types";
+import { guard as guardWaitableNotify } from "@jonloucks/concurrency-ts/api/WaitableNotify";
+import { guard as guardWaitableSupplier } from "@jonloucks/concurrency-ts/api/WaitableSupplier";
+/**
+ * Determine if the given instance is a StateMachine
+ *
+ * @param instance the instance to check
+ * @return true if the instance is a StateMachine
+ */
+export function guard(instance) {
+    return guardFunctions(instance, 'isTransitionAllowed', 'isCompleted', 'getState', 'setState', 'hasState', 'transition', 'open') && guardWaitableNotify(instance) && guardWaitableSupplier(instance);
+}
+//# sourceMappingURL=StateMachine.js.map

package/api/StateMachine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StateMachine.js","sourceRoot":"","sources":["../../src/api/StateMachine.ts"],"names":[],"mappings":"AAEA,OAAO,EAA8B,cAAc,EAAE,MAAM,qCAAqC,CAAC;AACjG,OAAO,EAAkB,KAAK,IAAI,mBAAmB,EAAE,MAAM,8CAA8C,CAAC;AAC5G,OAAO,EAAoB,KAAK,IAAI,qBAAqB,EAAE,MAAM,gDAAgD,CAAC;AAgGlH;;;;;GAKG;AACH,MAAM,UAAU,KAAK,CAAI,QAAiB;IACxC,OAAO,cAAc,CAAC,QAAQ,EAC5B,qBAAqB,EACrB,aAAa,EACb,UAAU,EACV,UAAU,EACV,UAAU,EACV,YAAY,EACZ,MAAM,CACP,IAAI,mBAAmB,CAAI,QAAQ,CAAC,IAAI,qBAAqB,CAAI,QAAQ,CAAC,CAAC;AAC9E,CAAC"}

package/api/StateMachineFactory.d.ts

@@ -0,0 +1,29 @@
+import { Contract } from "@jonloucks/contracts-ts";
+import { RequiredType } from "@jonloucks/concurrency-ts/api/Types";
+import { Config, StateMachine } from "@jonloucks/concurrency-ts/api/StateMachine";
+/**
+ * Rule machine, containing a set of sets that can be transitioned to by events/actions
+ */
+export interface StateMachineFactory {
+    /**
+     * Create a new StateMachine by configuration
+     *
+     * @param config the configuration
+     * @return the new StateMachine
+     * @param <T> the type of each state
+     * @throws IllegalArgumentException if config is null or configuration is invalid
+     */
+    createStateMachine<T>(config: Config<T>): RequiredType<StateMachine<T>>;
+}
+/**
+ * Determine if the given instance is a StateMachineFactory
+ *
+ * @param instance the instance to check
+ * @return true if the instance is a StateMachineFactory
+ */
+export declare function guard(instance: unknown): instance is RequiredType<StateMachineFactory>;
+/**
+ * Contract for StateMachineFactory
+ */
+export declare const CONTRACT: Contract<StateMachineFactory>;
+//# sourceMappingURL=StateMachineFactory.d.ts.map

package/api/StateMachineFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StateMachineFactory.d.ts","sourceRoot":"","sources":["../../src/api/StateMachineFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAiB,MAAM,yBAAyB,CAAC;AAClE,OAAO,EAAE,YAAY,EAAkB,MAAM,qCAAqC,CAAC;AACnF,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAC;AAElF;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;;;;OAOG;IACH,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;CACzE;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,QAAQ,EAAE,OAAO,GAAG,QAAQ,IAAI,YAAY,CAAC,mBAAmB,CAAC,CAEtF;AAED;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAAC,mBAAmB,CAGjD,CAAC"}

package/api/StateMachineFactory.js

@@ -0,0 +1,19 @@
+import { createContract } from "@jonloucks/contracts-ts";
+import { guardFunctions } from "@jonloucks/concurrency-ts/api/Types";
+/**
+ * Determine if the given instance is a StateMachineFactory
+ *
+ * @param instance the instance to check
+ * @return true if the instance is a StateMachineFactory
+ */
+export function guard(instance) {
+    return guardFunctions(instance, 'createStateMachine');
+}
+/**
+ * Contract for StateMachineFactory
+ */
+export const CONTRACT = createContract({
+    name: "StateMachineFactory",
+    test: guard
+});
+//# sourceMappingURL=StateMachineFactory.js.map

package/api/StateMachineFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StateMachineFactory.js","sourceRoot":"","sources":["../../src/api/StateMachineFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,cAAc,EAAC,MAAM,yBAAyB,CAAC;AAClE,OAAO,EAAgB,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAkBnF;;;;;GAKG;AACH,MAAM,UAAU,KAAK,CAAC,QAAiB;IACrC,OAAO,cAAc,CAAC,QAAQ,EAAE,oBAAoB,CAAC,CAAC;AACxD,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAkC,cAAc,CAAC;IACpE,IAAI,EAAE,qBAAqB;IAC3B,IAAI,EAAE,KAAK;CACZ,CAAC,CAAC"}

package/api/TimeoutException.d.ts

@@ -0,0 +1,21 @@
+import { ConcurrencyException } from "@jonloucks/concurrency-ts/api/ConcurrencyException";
+/**
+ * Runtime exception thrown for Concurrency timeout related problems.
+ */
+export declare class TimeoutException extends ConcurrencyException {
+    /**
+     * Passthrough for {@link Error(String, Throwable)}
+     *
+     * @param message the message for this exception
+     * @param thrown  the cause of this exception, null is allowed
+     */
+    constructor(message: string, thrown?: Error | null);
+}
+/**
+ * Determine if an instance is a TimeoutException
+ *
+ * @param instance the instance to check
+ * @returns true if the instance is a TimeoutException
+ */
+export declare function guard(instance: unknown): instance is TimeoutException;
+//# sourceMappingURL=TimeoutException.d.ts.map

package/api/TimeoutException.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TimeoutException.d.ts","sourceRoot":"","sources":["../../src/api/TimeoutException.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,oDAAoD,CAAC;AAE1F;;GAEG;AACH,qBAAa,gBAAiB,SAAQ,oBAAoB;IAExD;;;;;OAKG;gBACgB,OAAO,EAAE,MAAM,EAAE,MAAM,GAAE,KAAK,GAAG,IAAW;CAKhE;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,QAAQ,EAAE,OAAO,GAAG,QAAQ,IAAI,gBAAgB,CAErE"}

package/api/TimeoutException.js

@@ -0,0 +1,27 @@
+import { ConcurrencyException } from "@jonloucks/concurrency-ts/api/ConcurrencyException";
+/**
+ * Runtime exception thrown for Concurrency timeout related problems.
+ */
+export class TimeoutException extends ConcurrencyException {
+    /**
+     * Passthrough for {@link Error(String, Throwable)}
+     *
+     * @param message the message for this exception
+     * @param thrown  the cause of this exception, null is allowed
+     */
+    constructor(message, thrown = null) {
+        super(message, thrown);
+        this.name = "TimeoutException";
+        Object.setPrototypeOf(this, TimeoutException.prototype);
+    }
+}
+/**
+ * Determine if an instance is a TimeoutException
+ *
+ * @param instance the instance to check
+ * @returns true if the instance is a TimeoutException
+ */
+export function guard(instance) {
+    return instance instanceof TimeoutException;
+}
+//# sourceMappingURL=TimeoutException.js.map

package/api/TimeoutException.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TimeoutException.js","sourceRoot":"","sources":["../../src/api/TimeoutException.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,oDAAoD,CAAC;AAE1F;;GAEG;AACH,MAAM,OAAO,gBAAiB,SAAQ,oBAAoB;IAExD;;;;;OAKG;IACH,YAAmB,OAAe,EAAE,SAAuB,IAAI;QAC7D,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QACvB,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAC;QAC/B,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,gBAAgB,CAAC,SAAS,CAAC,CAAA;IACzD,CAAC;CACF;AAED;;;;;GAKG;AACH,MAAM,UAAU,KAAK,CAAC,QAAiB;IACrC,OAAO,QAAQ,YAAY,gBAAgB,CAAC;AAC9C,CAAC"}

package/api/Transition.d.ts

@@ -0,0 +1,44 @@
+import { RequiredType } from "@jonloucks/concurrency-ts/api/Types";
+/**
+ * Defines how a transition between states will be done
+ *
+ * @param <R> return type of the transition
+ */
+export interface Transition<S, R> {
+    /**
+     * @return the name of the event
+     */
+    event: string;
+    /**
+     * @return the goal state of this transition
+     */
+    successState: S;
+    /**
+     * @return the optional state if an exception is thrown
+     */
+    errorState?: S;
+    /**
+     * The optional state if the transition is not allowed.
+     */
+    failedState?: S;
+    /**
+     * @return the optional return value on success
+     */
+    getSuccessValue?(): R;
+    /**
+     * @return the optional return value on exception thrown
+     */
+    getErrorValue?(): R;
+    /**
+     * @return the optional return value if transition is not allowed
+     */
+    getFailedValue?(): R;
+}
+/**
+ * Type guard to determine if an instance implements Transition
+ *
+ * @param instance the instance to check
+ * @return true if instance is a Transition
+ */
+export declare function guard<S, R>(instance: unknown): instance is RequiredType<Transition<S, R>>;
+//# sourceMappingURL=Transition.d.ts.map

package/api/Transition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Transition.d.ts","sourceRoot":"","sources":["../../src/api/Transition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAkB,MAAM,qCAAqC,CAAC;AAEnF;;;;GAIG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC,EAAE,CAAC;IAE9B;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,YAAY,EAAE,CAAC,CAAC;IAEhB;;OAEG;IACH,UAAU,CAAC,EAAE,CAAC,CAAA;IAEd;;OAEG;IACH,WAAW,CAAC,EAAE,CAAC,CAAA;IAEf;;OAEG;IACH,eAAe,CAAC,IAAI,CAAC,CAAC;IAEtB;;OAEG;IACH,aAAa,CAAC,IAAI,CAAC,CAAC;IAEpB;;OAEG;IACH,cAAc,CAAC,IAAI,CAAC,CAAC;CACtB;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,EAAE,OAAO,GAAG,QAAQ,IAAI,YAAY,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAWzF"}

package/api/Transition.js

@@ -0,0 +1,11 @@
+import { guardFunctions } from "@jonloucks/concurrency-ts/api/Types";
+/**
+ * Type guard to determine if an instance implements Transition
+ *
+ * @param instance the instance to check
+ * @return true if instance is a Transition
+ */
+export function guard(instance) {
+    return guardFunctions(instance, 'event', 'goalState', 'errorState', 'failedState', 'getSuccessValue', 'getErrorValue', 'getFailedValue');
+}
+//# sourceMappingURL=Transition.js.map

package/api/Transition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Transition.js","sourceRoot":"","sources":["../../src/api/Transition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,cAAc,EAAE,MAAM,qCAAqC,CAAC;AA6CnF;;;;;GAKG;AACH,MAAM,UAAU,KAAK,CAAO,QAAiB;IAC3C,OAAO,cAAc,CACnB,QAAQ,EACR,OAAO,EACP,WAAW,EACX,YAAY,EACZ,aAAa,EACb,iBAAiB,EACjB,eAAe,EACf,gBAAgB,CACjB,CAAC;AACJ,CAAC"}