@jonloucks/concurrency-ts 0.4.0

package/README.md

@@ -0,0 +1,248 @@
+# @jonloucks/concurrency-ts
+
+## Badges
+[![CI](https://github.com/jonloucks/concurrency-ts/workflows/main-push/badge.svg)](https://github.com/jonloucks/concurrency-ts/actions)
+[![npm version](https://raw.githubusercontent.com/jonloucks/concurrency-ts/refs/heads/badges/main-npm.svg)](https://www.npmjs.com/package/@jonloucks/concurrency-ts)
+[![Coverage Badge](https://raw.githubusercontent.com/jonloucks/concurrency-ts/refs/heads/badges/main-coverage.svg)](https://jonloucks.github.io/concurrency-ts/lcov-report/)
+[![Typedoc Badge](https://raw.githubusercontent.com/jonloucks/concurrency-ts/refs/heads/badges/main-typedoc.svg)](https://jonloucks.github.io/concurrency-ts/typedoc/)
+
+
+A TypeScript library that provides powerful abstractions for managing asynchronous concurrency, state machines, and completion patterns. It offers type-safe primitives for building concurrent applications with guaranteed completion semantics.
+
+## Key Features
+
+- **Type-safe concurrency primitives** - Fully typed interfaces for concurrent operations
+- **Waitable references** - Thread-safe mutable references that allow waiting for condition changes
+- **Completables** - Observe activities from start to finish with guaranteed completion
+- **State machines** - User-defined states with transition rules and validation
+- **Guaranteed execution** - Patterns ensuring completion callbacks are always invoked
+- **Resource management** - Automatic cleanup via the `Open` interface
+
+## Documentation
+* [Complete Documentation](DOCUMENTATION.md) - **Comprehensive guide with examples**
+* [License](LICENSE.md)
+* [Contributing](CONTRIBUTING.md)
+* [Code of conduct](CODE_OF_CONDUCT.md)
+* [Coding standards](CODING_STANDARDS.md)
+* [Security policy](SECURITY.md)
+* [Pull request template](PULL_REQUEST_TEMPLATE.md)
+* [How to use API](https://jonloucks.github.io/concurrency-ts/typedoc/)
+* [Test coverage report](https://jonloucks.github.io/concurrency-ts/lcov-report)
+
+## Installation
+
+```bash
+npm install @jonloucks/concurrency-ts
+```
+
+## Usage
+
+For comprehensive examples and detailed API documentation, see [DOCUMENTATION.md](DOCUMENTATION.md).
+
+### Quick Start
+
+```typescript
+import { createConcurrency, Waitable, Completable, StateMachine } from '@jonloucks/concurrency-ts';
+
+// Create a Concurrency instance
+const concurrency = createConcurrency({});
+using closeConcurrency = concurrency.open();
+
+// Create a Waitable for thread-safe value storage
+const waitable: Waitable<number> = concurrency.createWaitable({ initialValue: 0 });
+using closeWaitable = waitable.open();
+
+waitable.consume(42);
+console.log(waitable.supply()); // 42
+
+// Create a Completable to track async operations
+const completable: Completable<string> = concurrency.createCompletable({});
+using closeCompletable = completable.open();
+
+completable.onCompletion((completion) => {
+  console.log('Task completed:', completion.state, completion.value);
+});
+
+completable.notify({ state: 'SUCCEEDED', value: 'Done!' });
+
+// Create a StateMachine for state management
+type AppState = 'IDLE' | 'RUNNING' | 'STOPPED';
+
+const stateMachine: StateMachine<AppState> = concurrency.createStateMachine({
+  initialValue: 'IDLE',
+  states: ['IDLE', 'RUNNING', 'STOPPED'],
+  getStateRules: (state) => {
+    switch (state) {
+      case 'IDLE':
+        return [{ event: 'start', allowedStates: ['RUNNING'] }];
+      case 'RUNNING':
+        return [{ event: 'stop', allowedStates: ['STOPPED'] }];
+      default:
+        return [];
+    }
+  }
+});
+
+using closeStateMachine = stateMachine.open();
+
+console.log(stateMachine.getState()); // 'IDLE'
+stateMachine.setState('start', 'RUNNING');
+console.log(stateMachine.getState()); // 'RUNNING'
+```
+
+See [DOCUMENTATION.md](DOCUMENTATION.md) for more examples and advanced usage patterns.
+
+## Development
+
+<details markdown="1"><summary>Install dependencies</summary>
+
+```bash
+npm install
+```
+</details>
+
+<details markdown="1"><summary>Build the project</summary>
+
+```bash
+npm run build
+```
+</details>
+
+<details markdown="1"><summary>Run tests</summary>
+
+```bash
+npm test
+```
+</details>
+
+<details markdown="1"><summary>Run tests in watch mode</summary>
+
+```bash
+npm run test:watch
+```
+</details>
+
+<details markdown="1"><summary>Run test coverage</summary>
+
+```bash
+npm run test:coverage
+```
+</details>
+
+<details markdown="1"><summary>Lint the code</summary>
+
+```bash
+npm run lint
+```
+</details>
+
+<details markdown="1"><summary>Fix linting issues</summary>
+
+```bash
+npm run lint:fix
+```
+</details>
+
+<details markdown="1"><summary>Generate documents</summary>
+
+```bash
+npm run docs
+```
+</details>
+
+<details markdown="1"><summary>Generate badges</summary>
+
+```bash
+npm run badges
+```
+</details>
+
+<details markdown="1"><summary>Project Structure</summary>
+
+* All tests must have suffix of -test.ts or -spec.ts
+* Tests that validate supported APIs go in src/test
+* Tests that validate internal implementation details go in src/impl
+
+```
+concurrency-ts
+├── .github
+│   ├── ISSUE_TEMPLATE
+│   │   ├── bug_report.md
+│   │   └── feature_request.md
+│   └── workflows
+│       ├── main-pull-request-matrix.yml
+│       ├── main-pull-request.yml
+│       ├── main-push.yml
+│       └── main-release.yml
+├── CODE_OF_CONDUCT.md
+├── CODING_STANDARDS.md
+├── CONTRIBUTING.md
+├── editorconfig
+├── eslint.config.mjs
+├── jest.config.js
+├── LICENSE
+├── package-lock.json
+├── package.json
+├── PULL_REQUEST_TEMPLATE.md
+├── README.md
+├── scripts
+│   ├── badge-template.svg.dat
+│   └── tsconfig.json
+├── SECURITY.md
+├── src
+│   ├── index.ts
+│   ├── version.ts
+│   ├── api
+│   │   ├── *.ts
+│   │   ├── *.api.ts
+│   ├── auxiliary
+│   │   ├── *.ts
+│   │   ├── *.impl.ts
+│   │   ├── *.test.ts    // internal implementation specific
+│   │   └── *.api.ts
+│   ├── impl
+│   │   ├── *.ts
+│   │   ├── *.impl.ts
+│   │   ├── *.test.ts    // internal implementation specific
+│   │   └── *.api.ts
+│   ├── test
+│   │   └── *.test.ts
+│   └── never-publish             // non shippable development scripts
+│       ├── *.ts
+│       ├── *.*.                  // data files etc
+│       └── *.test.ts
+├── tsconfig.json
+└── typedoc.json
+```
+</details>
+
+## GitHub Workflows
+
+<details markdown="1"><summary>CI Workflow</summary>
+
+The CI workflow runs on every push and pull request to `main` branch. It:
+- Tests against Node.js versions 18.x, 20.x, and 22.x
+- Runs linting
+- Builds the project
+- Runs tests with coverage
+- Uploads coverage to Codecov (optional)
+
+</details>
+
+<details markdown="1"><summary>Publish Workflow</summary>
+
+The GitHub publishings workflows are run to make an official release.
+- If all scanning and tests pass it is published. There is no other way allowed.
+- Publishing authentication is done using ([OIDC trusted publishing](https://docs.npmjs.com/trusted-publishers))
+
+To set up your own publishing:
+1. Publishing this project as is intentionally disabled
+2. You are welcome to fork this repository and publish where you want.
+3. Run `npm pkg delete private` to remove the `private` flag from the package.
+4. Change the `name` field in `package.json` to your desired package name.
+
+</details>
+
+## License
+
+MIT

package/api/Completable.d.ts

@@ -0,0 +1,51 @@
+import { Completion, CompletionState } from "@jonloucks/concurrency-ts/api/Completion";
+import { CompletionNotify } from "@jonloucks/concurrency-ts/api/CompletionNotify";
+import { IsCompleted } from "@jonloucks/concurrency-ts/api/IsCompleted";
+import { OnCompletion } from "@jonloucks/concurrency-ts/api/OnCompletion";
+import { OptionalType, RequiredType } from "@jonloucks/concurrency-ts/api/Types";
+import { WaitableNotify } from "@jonloucks/concurrency-ts/api/WaitableNotify";
+import { Contracts } from "@jonloucks/contracts-ts/api/Contracts";
+import { Open } from "@jonloucks/contracts-ts/api/Open";
+/**
+ * Configuration for a Completable
+ *
+ * @param <T> the type of completion value
+ */
+export interface Config<T> {
+    /**
+     * Optional contracts for validation or other purposes
+     */
+    contracts?: Contracts;
+    /**
+     * Optional initial value for the completable
+     */
+    initialValue?: OptionalType<T>;
+}
+export { type Config as CompletableConfig };
+/**
+ * Responsibility: Observe a single activity from start to finish
+ *
+ * @param <T> the type of completion value
+ */
+export interface Completable<T> extends Open, CompletionNotify<T>, OnCompletion<T>, IsCompleted {
+    /**
+     * @return observe state change
+     */
+    notifyState(): WaitableNotify<CompletionState>;
+    /**
+     * @return Observe the completed value
+     */
+    notifyValue(): WaitableNotify<T>;
+    /**
+     * @return the current completion state
+     */
+    getCompletion(): OptionalType<Completion<T>>;
+}
+/**
+ * Determine if an instance implements Completable
+ *
+ * @param instance the instance to check
+ * @returns true if the instance implements Completable
+ */
+export declare function guard<T>(instance: unknown): instance is RequiredType<Completable<T>>;
+//# sourceMappingURL=Completable.d.ts.map

package/api/Completable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Completable.d.ts","sourceRoot":"","sources":["../../src/api/Completable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,0CAA0C,CAAC;AACvF,OAAO,EAAE,gBAAgB,EAAE,MAAM,gDAAgD,CAAC;AAClF,OAAO,EAAE,WAAW,EAAE,MAAM,2CAA2C,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAC;AAC1E,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,qCAAqC,CAAC;AACjG,OAAO,EAAE,cAAc,EAAE,MAAM,8CAA8C,CAAC;AAC9E,OAAO,EAAE,SAAS,EAAE,MAAM,uCAAuC,CAAC;AAClE,OAAO,EAAE,IAAI,EAAE,MAAM,kCAAkC,CAAC;AAExD;;;;GAIG;AACH,MAAM,WAAW,MAAM,CAAC,CAAC;IACvB;;OAEG;IACH,SAAS,CAAC,EAAE,SAAS,CAAC;IAEtB;;OAEG;IACH,YAAY,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;CAChC;AAED,OAAO,EAAE,KAAK,MAAM,IAAI,iBAAiB,EAAE,CAAC;AAE5C;;;;GAIG;AACH,MAAM,WAAW,WAAW,CAAC,CAAC,CAAE,SAAQ,IAAI,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,WAAW;IAE7F;;OAEG;IACH,WAAW,IAAI,cAAc,CAAC,eAAe,CAAC,CAAC;IAE/C;;OAEG;IACH,WAAW,IAAI,cAAc,CAAC,CAAC,CAAC,CAAC;IAEjC;;OAEG;IACH,aAAa,IAAI,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;CAC9C;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,GAAG,QAAQ,IAAI,YAAY,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAUpF"}

package/api/Completable.js

@@ -0,0 +1,11 @@
+import { guardFunctions } from "@jonloucks/concurrency-ts/api/Types";
+/**
+ * Determine if an instance implements Completable
+ *
+ * @param instance the instance to check
+ * @returns true if the instance implements Completable
+ */
+export function guard(instance) {
+    return guardFunctions(instance, 'open', 'notifyState', 'notifyValue', 'getCompletion', 'isCompleted', 'onCompletion', 'notify');
+}
+//# sourceMappingURL=Completable.js.map

package/api/Completable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Completable.js","sourceRoot":"","sources":["../../src/api/Completable.ts"],"names":[],"mappings":"AAIA,OAAO,EAA8B,cAAc,EAAE,MAAM,qCAAqC,CAAC;AA+CjG;;;;;GAKG;AACH,MAAM,UAAU,KAAK,CAAI,QAAiB;IACxC,OAAO,cAAc,CAAC,QAAQ,EAC5B,MAAM,EACN,aAAa,EACb,aAAa,EACb,eAAe,EACf,aAAa,EACb,cAAc,EACd,QAAQ,CACT,CAAC;AACJ,CAAC"}

package/api/CompletableFactory.d.ts

@@ -0,0 +1,29 @@
+import { Completable, Config } from "@jonloucks/concurrency-ts/api/Completable";
+import { Contract } from "@jonloucks/contracts-ts";
+import { RequiredType } from "@jonloucks/concurrency-ts/api/Types";
+export { type Completable, type Config } from "@jonloucks/concurrency-ts/api/Completable";
+/**
+ * Responsibility: Creating a new Completable
+ */
+export interface CompletableFactory {
+    /**
+     * Create a new Completable
+     *
+     * @param config the completable configuration
+     * @return the new Completable
+     * @param <T> the type of completion value
+     */
+    createCompletable<T>(config?: Config<T>): Completable<T>;
+}
+/**
+ * Determine if an instance implements CompletableFactory
+ *
+ * @param instance the instance to check
+ * @returns true if the instance implements CompletableFactory
+ */
+export declare function guard(instance: unknown): instance is RequiredType<CompletableFactory>;
+/**
+ * The CompletableFactory contract
+ */
+export declare const CONTRACT: Contract<CompletableFactory>;
+//# sourceMappingURL=CompletableFactory.d.ts.map

package/api/CompletableFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CompletableFactory.d.ts","sourceRoot":"","sources":["../../src/api/CompletableFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAChF,OAAO,EAAE,QAAQ,EAAkB,MAAM,yBAAyB,CAAC;AACnE,OAAO,EAAE,YAAY,EAAkB,MAAM,qCAAqC,CAAC;AAEnF,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAE1F;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAEjC;;;;;;OAMG;IACH,iBAAiB,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAA;CACzD;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/CompletableFactory.js

@@ -0,0 +1,19 @@
+import { createContract } from "@jonloucks/contracts-ts";
+import { guardFunctions } from "@jonloucks/concurrency-ts/api/Types";
+/**
+ * Determine if an instance implements CompletableFactory
+ *
+ * @param instance the instance to check
+ * @returns true if the instance implements CompletableFactory
+ */
+export function guard(instance) {
+    return guardFunctions(instance, 'createCompletable');
+}
+/**
+ * The CompletableFactory contract
+ */
+export const CONTRACT = createContract({
+    name: "CompletableFactory",
+    test: guard
+});
+//# sourceMappingURL=CompletableFactory.js.map

package/api/CompletableFactory.js.map

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

package/api/Completion.d.ts

@@ -0,0 +1,18 @@
+import { OptionalType, RequiredType, Throwable } from "@jonloucks/concurrency-ts/api/Types";
+import { CompletionState } from "@jonloucks/concurrency-ts/api/CompletionState";
+export { type CompletionState };
+/** Completion
+ *
+ * @param <T> the type of completion value
+ */
+export interface Completion<T> {
+    /** The completion state */
+    state: RequiredType<CompletionState>;
+    /** The optional thrown exception */
+    thrown?: OptionalType<Throwable<unknown>>;
+    /** The optional completion value */
+    value?: OptionalType<T>;
+    /** The optional associated Future */
+    promise?: OptionalType<Promise<T>>;
+}
+//# sourceMappingURL=Completion.d.ts.map

package/api/Completion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Completion.d.ts","sourceRoot":"","sources":["../../src/api/Completion.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,qCAAqC,CAAC;AAC5F,OAAO,EAAE,eAAe,EAAE,MAAM,+CAA+C,CAAC;AAEhF,OAAO,EAAE,KAAK,eAAe,EAAE,CAAC;AAEhC;;;GAGG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC;IAE3B,2BAA2B;IAC3B,KAAK,EAAE,YAAY,CAAC,eAAe,CAAC,CAAC;IAErC,oCAAoC;IACpC,MAAM,CAAC,EAAE,YAAY,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC;IAE1C,oCAAoC;IACpC,KAAK,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;IAExB,qCAAqC;IACrC,OAAO,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;CACpC"}

package/api/Completion.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Completion.js.map

package/api/Completion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Completion.js","sourceRoot":"","sources":["../../src/api/Completion.ts"],"names":[],"mappings":""}

package/api/CompletionNotify.d.ts

@@ -0,0 +1,23 @@
+import { OnCompletion } from "@jonloucks/concurrency-ts/api/OnCompletion";
+import { AutoClose } from "@jonloucks/contracts-ts/api/AutoClose";
+import { RequiredType } from "@jonloucks/concurrency-ts/api/Types";
+/**
+ * Responsibility: Dispatch Completion status to subscribers
+ */
+export interface CompletionNotify<T> {
+    /**
+     * Open a notification subscription for receive completions
+     *
+     * @param onCompletion the completion
+     * @return the
+     */
+    notify(onCompletion: OnCompletion<T>): AutoClose;
+}
+/**
+ * Determine if an instance implements CompletionNotify
+ *
+ * @param instance the instance to check
+ * @returns true if the instance implements CompletionNotify
+ */
+export declare function guard<T>(instance: unknown): instance is RequiredType<CompletionNotify<T>>;
+//# sourceMappingURL=CompletionNotify.d.ts.map

package/api/CompletionNotify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CompletionNotify.d.ts","sourceRoot":"","sources":["../../src/api/CompletionNotify.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAC;AAC1E,OAAO,EAAE,SAAS,EAAE,MAAM,uCAAuC,CAAC;AAClE,OAAO,EAAkB,YAAY,EAAE,MAAM,qCAAqC,CAAC;AAEnF;;GAEG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC;IAEjC;;;;;OAKG;IACH,MAAM,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;CAClD;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,GAAG,QAAQ,IAAI,YAAY,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAIzF"}

package/api/CompletionNotify.js

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

package/api/CompletionNotify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CompletionNotify.js","sourceRoot":"","sources":["../../src/api/CompletionNotify.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAgB,MAAM,qCAAqC,CAAC;AAgBnF;;;;;GAKG;AACH,MAAM,UAAU,KAAK,CAAI,QAAiB;IACxC,OAAO,cAAc,CAAC,QAAQ,EAC5B,QAAQ,CACT,CAAC;AACJ,CAAC"}

package/api/CompletionState.d.ts

@@ -0,0 +1,35 @@
+import { Rule } from "@jonloucks/concurrency-ts/api/Rule";
+import { Config } from "@jonloucks/concurrency-ts/api/StateMachine";
+/**
+ * The possible states of a Completion
+ */
+export declare const STATES: string[];
+/**
+ * The possible states of a Completion
+ */
+export type State = typeof STATES[number];
+/** The CompletionState type */
+export { type State as CompletionState };
+/** The starting state for a Completion */
+export declare const START_STATE: State;
+/**
+ * Get the state transition rules for a given Completion state
+ *
+ * @param state the state to get rules for
+ * @return the array of rules for the given state
+ */
+export declare function getStateRules(state: State): Array<Rule<State>>;
+/**
+ * Get the default StateMachine configuration for a Completion
+ *
+ * @return the default StateMachine configuration
+ */
+export declare function getStateMachineConfig(): Config<State>;
+/**
+ * Determine if a state is a terminal state
+ *
+ * @param state the state to check
+ * @return true if terminal state
+ */
+export declare function isTerminalState(state: State): boolean;
+//# sourceMappingURL=CompletionState.d.ts.map

package/api/CompletionState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CompletionState.d.ts","sourceRoot":"","sources":["../../src/api/CompletionState.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,oCAAoC,CAAC;AAC1D,OAAO,EAAE,MAAM,EAAE,MAAM,4CAA4C,CAAC;AAGpE;;GAEG;AACH,eAAO,MAAM,MAAM,EAAE,MAAM,EAA6D,CAAC;AAEzF;;GAEG;AACH,MAAM,MAAM,KAAK,GAAG,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC;AAE1C,+BAA+B;AAC/B,OAAO,EAAE,KAAK,KAAK,IAAI,eAAe,EAAE,CAAC;AAEzC,0CAA0C;AAC1C,eAAO,MAAM,WAAW,EAAE,KAAiB,CAAC;AAE5C;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CA2B9D;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,IAAI,MAAM,CAAC,KAAK,CAAC,CAMrD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAErD"}

package/api/CompletionState.js

@@ -0,0 +1,64 @@
+import { used } from "@jonloucks/concurrency-ts/auxiliary/Checks";
+/**
+ * The possible states of a Completion
+ */
+export const STATES = ['PENDING', 'FAILED', 'CANCELLED', 'SUCCEEDED'];
+/** The starting state for a Completion */
+export const START_STATE = 'PENDING';
+/**
+ * Get the state transition rules for a given Completion state
+ *
+ * @param state the state to get rules for
+ * @return the array of rules for the given state
+ */
+export function getStateRules(state) {
+    switch (state) {
+        case 'PENDING':
+            return [
+                {
+                    canTransition: (event, goal) => {
+                        used(event);
+                        return goal === 'FAILED' || goal === 'CANCELLED' || goal === 'SUCCEEDED';
+                    }
+                }
+            ];
+        case 'FAILED':
+        case 'CANCELLED':
+        case 'SUCCEEDED':
+            return [
+                {
+                    canTransition: (event, goal) => {
+                        used(event);
+                        used(goal);
+                        return false;
+                    },
+                    isTerminal: true
+                }
+            ];
+        default:
+            return [];
+    }
+}
+;
+/**
+ * Get the default StateMachine configuration for a Completion
+ *
+ * @return the default StateMachine configuration
+ */
+export function getStateMachineConfig() {
+    return {
+        initialValue: START_STATE,
+        states: STATES,
+        getStateRules: getStateRules
+    };
+}
+/**
+ * Determine if a state is a terminal state
+ *
+ * @param state the state to check
+ * @return true if terminal state
+ */
+export function isTerminalState(state) {
+    return state === 'FAILED' || state === 'CANCELLED' || state === 'SUCCEEDED';
+}
+//# sourceMappingURL=CompletionState.js.map

package/api/CompletionState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CompletionState.js","sourceRoot":"","sources":["../../src/api/CompletionState.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,MAAM,4CAA4C,CAAC;AAElE;;GAEG;AACH,MAAM,CAAC,MAAM,MAAM,GAAa,CAAC,SAAS,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,CAAU,CAAC;AAUzF,0CAA0C;AAC1C,MAAM,CAAC,MAAM,WAAW,GAAU,SAAS,CAAC;AAE5C;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAAC,KAAY;IACxC,QAAQ,KAAK,EAAE,CAAC;QACd,KAAK,SAAS;YACZ,OAAO;gBACL;oBACE,aAAa,EAAE,CAAC,KAAa,EAAE,IAAW,EAAW,EAAE;wBACrD,IAAI,CAAC,KAAK,CAAC,CAAC;wBACZ,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,WAAW,IAAI,IAAI,KAAK,WAAW,CAAC;oBAC3E,CAAC;iBACF;aACF,CAAC;QACJ,KAAK,QAAQ,CAAC;QACd,KAAK,WAAW,CAAC;QACjB,KAAK,WAAW;YACd,OAAO;gBACL;oBACE,aAAa,EAAE,CAAC,KAAa,EAAE,IAAW,EAAW,EAAE;wBACrD,IAAI,CAAC,KAAK,CAAC,CAAC;wBACZ,IAAI,CAAC,IAAI,CAAC,CAAC;wBACX,OAAO,KAAK,CAAC;oBACf,CAAC;oBACD,UAAU,EAAE,IAAI;iBACjB;aACF,CAAC;QACJ;YACE,OAAO,EAAE,CAAC;IACd,CAAC;AACH,CAAC;AAAA,CAAC;AAEF;;;;GAIG;AACH,MAAM,UAAU,qBAAqB;IACnC,OAAO;QACL,YAAY,EAAE,WAAW;QACzB,MAAM,EAAE,MAAM;QACd,aAAa,EAAE,aAAa;KAC7B,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,eAAe,CAAC,KAAY;IAC1C,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,WAAW,IAAI,KAAK,KAAK,WAAW,CAAC;AAC9E,CAAC"}

package/api/Concurrency.d.ts

@@ -0,0 +1,90 @@
+import { Completable, Config as CompletableConfig } from "@jonloucks/concurrency-ts/api/Completable";
+import { Completion } from "@jonloucks/concurrency-ts/api/Completion";
+import { OnCompletion } from "@jonloucks/concurrency-ts/api/OnCompletion";
+import { StateMachine, Config as StateMachineConfig } from "@jonloucks/concurrency-ts/api/StateMachine";
+import { Consumer, ConsumerType, OptionalType, RequiredType, Supplier, SupplierType } from "@jonloucks/concurrency-ts/api/Types";
+import { Waitable, Config as WaitableConfig } from "@jonloucks/concurrency-ts/api/Waitable";
+import { Open } from "@jonloucks/contracts-ts/api/Open";
+import { Contract, Contracts } from "@jonloucks/contracts-ts";
+export type { Completable, CompletableConfig, Completion, StateMachine, StateMachineConfig, Waitable, WaitableConfig, OnCompletion, Consumer, ConsumerType, Supplier, SupplierType, Contracts };
+/**
+ * The configuration used to create a new Concurrency instance.
+ */
+export interface Config {
+    /**
+     * @return the contracts, some use case have their own Contracts instance.
+     */
+    contracts?: Contracts;
+    /**
+   * an optional list of events that when fired will shutdown Contracts
+   * the default is no events.
+   * It can be a custom event or system events like 'beforeExit', 'SIGINT', 'SIGTERM'
+   * @return list of shutdown event names
+   */
+    shutdownEvents?: string[];
+}
+export { type Config as ConcurrencyConfig };
+/**
+ * The Concurrency API
+ */
+export interface Concurrency extends Open {
+    /**
+     * Create a new Waitable with the given configuration
+     *
+     * @param config the waitable configuration
+     * @return the waitable
+     * @param <T> the type of waitable
+     */
+    createWaitable<T>(config: WaitableConfig<T>): RequiredType<Waitable<T>>;
+    /**
+     * Create a new StateMachine
+     *
+     * @param config the state machine configuration
+     * @return the new StateMachine
+     * @param <T> the type of each state
+     * @throws IllegalArgumentException if initialState is null
+     */
+    createStateMachine<T>(config: StateMachineConfig<T>): RequiredType<StateMachine<T>>;
+    /**
+     * Create a new Completable
+     *
+     * @param config the completable configuration
+     * @return the new Completable
+     * @param <T> the type of completion value
+     */
+    createCompletable<T>(config: CompletableConfig<T>): RequiredType<Completable<T>>;
+    /**
+     * Guaranteed execution: complete later block.
+     * Either the delegate successfully takes ownership of the OnCompletion or
+     * a final FAILED completion is dispatched
+     *
+     * @param onCompletion the OnCompletion callback
+     * @param delegate the intended delegate to receive the OnCompletion
+     * @param <T> the completion value type
+     */
+    completeLater<T>(onCompletion: RequiredType<OnCompletion<T>>, delegate: RequiredType<ConsumerType<OnCompletion<T>>>): void;
+    /**
+     * Guaranteed execution: complete now block
+     * When this method finishes, it is guaranteed the OnCompletion will have received a final completion.
+     * Exceptions will result in a FAILED completion
+     * Exceptions will be rethrown.
+     *
+     * @param onCompletion the OnCompletion callback
+     * @param successBlock executed to determine the final completion value for an activity
+     * @return the final completion value
+     * @param <T> the completion value type
+     */
+    completeNow<T>(onCompletion: RequiredType<OnCompletion<T>>, successBlock: RequiredType<SupplierType<T>>): OptionalType<T>;
+}
+/**
+ * Determine if the given instance is a Concurrency
+ *
+ * @param instance the instance to test
+ * @return true if the instance is a Concurrency
+ */
+export declare function guard(instance: unknown): instance is RequiredType<Concurrency>;
+/**
+ * The Concurrency contract
+ */
+export declare const CONTRACT: Contract<Concurrency>;
+//# sourceMappingURL=Concurrency.d.ts.map

package/api/Concurrency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Concurrency.d.ts","sourceRoot":"","sources":["../../src/api/Concurrency.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,IAAI,iBAAiB,EAAE,MAAM,2CAA2C,CAAC;AACrG,OAAO,EAAE,UAAU,EAAE,MAAM,0CAA0C,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAC;AAC1E,OAAO,EAAE,YAAY,EAAE,MAAM,IAAI,kBAAkB,EAAE,MAAM,4CAA4C,CAAC;AACxG,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAkB,YAAY,EAAE,YAAY,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AACjJ,OAAO,EAAE,QAAQ,EAAE,MAAM,IAAI,cAAc,EAAE,MAAM,wCAAwC,CAAC;AAC5F,OAAO,EAAE,IAAI,EAAE,MAAM,kCAAkC,CAAC;AACxD,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAkB,MAAM,yBAAyB,CAAC;AAE9E,YAAY,EACV,WAAW,EACX,iBAAiB,EACjB,UAAU,EACV,YAAY,EACZ,kBAAkB,EAClB,QAAQ,EACR,cAAc,EACd,YAAY,EACZ,QAAQ,EACR,YAAY,EACZ,QAAQ,EACR,YAAY,EACZ,SAAS,EACV,CAAA;AAED;;GAEG;AACH,MAAM,WAAW,MAAM;IACrB;;OAEG;IACH,SAAS,CAAC,EAAE,SAAS,CAAC;IAEpB;;;;;KAKC;IACH,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;CAC3B;AAED,OAAO,EAAE,KAAK,MAAM,IAAI,iBAAiB,EAAE,CAAC;AAE5C;;GAEG;AACH,MAAM,WAAW,WAAY,SAAQ,IAAI;IAEvC;;;;;;OAMG;IACH,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;IAExE;;;;;;;OAOG;IACH,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;IAEpF;;;;;;OAMG;IACH,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;IAEjF;;;;;;;;OAQG;IACH,aAAa,CAAC,CAAC,EAAE,YAAY,EAAE,YAAY,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,YAAY,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAE3H;;;;;;;;;;OAUG;IACH,WAAW,CAAC,CAAC,EAAE,YAAY,EAAE,YAAY,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,YAAY,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;CAC3H;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,QAAQ,EAAE,OAAO,GAAG,QAAQ,IAAI,YAAY,CAAC,WAAW,CAAC,CAS9E;AAED;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAAC,WAAW,CAGzC,CAAC"}