@jonloucks/concurrency-ts 0.4.0

package/auxiliary/Checks.js

@@ -0,0 +1,145 @@
+import { MAX_TIMEOUT } from "@jonloucks/concurrency-ts/api/Types";
+import { illegalCheck, presentCheck, configCheck } from "@jonloucks/contracts-ts/auxiliary/Checks";
+export { presentCheck, illegalCheck, configCheck };
+/**
+ * Check that a state is present
+ *
+ * @param state the state to check
+ * @return the state if present
+ * @throws IllegalArgumentException if the state is not present
+ */
+export function stateCheck(state) {
+    return presentCheck(state, "State must be present.");
+}
+/**
+ * Check that an event is present
+ *
+ * @param event the event to check
+ * @return the event if present
+ * @throws IllegalArgumentException if the event is not present
+ */
+export function eventCheck(event) {
+    return presentCheck(event, "Event must be present.");
+}
+/**
+ * Check that a rule is present
+ *
+ * @param rule the rule to check
+ * @return the rule if present
+ * @throws IllegalArgumentException if the rule is not present
+ */
+export function ruleCheck(rule) {
+    return presentCheck(rule, "Rule must be present.");
+}
+/**
+ * Check that rules are present
+ *
+ * @param rules the rules to check
+ * @return the rules if present
+ * @throws IllegalArgumentException if the rules are not present
+ */
+export function rulesCheck(rules) {
+    return presentCheck(rules, "Rules must be present.");
+}
+/**
+ * Check that a listener is present
+ *
+ * @param consumer the listener to check
+ * @return the listener if present
+ * @throws IllegalArgumentException if the listener is not present
+ */
+export function listenerCheck(consumer) {
+    return presentCheck(consumer, "Listener must be present.");
+}
+/**
+ * Check that a timeout is valid
+ *
+ * @param timeout the timeout to check
+ * @return the timeout if valid
+ * @throws IllegalArgumentException if the timeout is not valid
+ */
+export function timeoutCheck(timeout) {
+    const presentTimeout = presentCheck(timeout, "Timeout must be present.");
+    illegalCheck(timeout, timeout.milliSeconds < 0, "Timeout must not be negative.");
+    illegalCheck(timeout, timeout.milliSeconds > MAX_TIMEOUT.milliSeconds, "Timeout must be less than or equal to maximum time.");
+    return presentTimeout;
+}
+/**
+ * Check that a completion value is present
+ *
+ * @param completion the completion value to check
+ * @return the completion value if present
+ * @throws IllegalArgumentException if the completion value is not present
+ */
+export function completionCheck(completion) {
+    return presentCheck(completion, "Completion must be present.");
+}
+/**
+ * Check that an onCompletion consumer is present
+ *
+ * @param onCompletion the onCompletion consumer to check
+ * @return the onCompletion consumer if present
+ * @throws IllegalArgumentException if the onCompletion consumer is not present
+ */
+export function onCompletionCheck(onCompletion) {
+    return presentCheck(onCompletion, "OnCompletion consumer must be present.");
+}
+/**
+ * Check that a finally block is present
+ *
+ * @param block the finally block to check
+ * @return the finally block if present
+ * @throws IllegalArgumentException if the finally block is not present
+ */
+export function finallyBlockCheck(block) {
+    return presentCheck(block, "OnFinally consumer must be present.");
+}
+/**
+ * Check that a success block is present
+ *
+ * @param onSuccess the success block to check
+ * @return the success block if present
+ * @throws IllegalArgumentException if the success block is not present
+ */
+export function successBlockCheck(onSuccess) {
+    return presentCheck(onSuccess, "OnSuccess consumer must be present.");
+}
+/**
+ * Check that a failure block is present
+ *
+ * @param onFailure the failure block to check
+ * @return the failure block if present
+ * @throws IllegalArgumentException if the failure block is not present
+ */
+export function failureBlockCheck(onFailure) {
+    return presentCheck(onFailure, "OnFailure consumer must be present.");
+}
+/**
+ * Check that a predicate is present
+ *
+ * @param predicate the predicate to check
+ * @return the predicate if present
+ * @throws IllegalArgumentException if the predicate is not present
+ */
+export function predicateCheck(predicate) {
+    return presentCheck(predicate, "Predicate must be present.");
+}
+/**
+ * Check that an initial value is present
+ *
+ * @param initialValue the initial value to check
+ * @return the initial value if present
+ * @throws IllegalArgumentException if the initial value is not present
+ */
+export function initialValueCheck(initialValue) {
+    return presentCheck(initialValue, "Initial value must be present.");
+}
+/**
+ * explicitly mark a value as used to avoid compiler warnings
+ * useful for "using" variable which are used for disposal or other side-effects
+ * but not directly referenced in code.
+ *
+ * @param value the value which you wish to declare as used
+ */
+export const used = (value) => { void value; };
+//# sourceMappingURL=Checks.js.map

package/auxiliary/Checks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Checks.js","sourceRoot":"","sources":["../../src/auxiliary/Checks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,WAAW,EAA8B,MAAM,qCAAqC,CAAC;AACxG,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,0CAA0C,CAAC;AAEnG,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,WAAW,EAAC,CAAC;AAElD;;;;;;GAMG;AACH,MAAM,UAAU,UAAU,CAAI,KAAQ;IACpC,OAAO,YAAY,CAAC,KAAK,EAAE,wBAAwB,CAAC,CAAC;AACvD,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,UAAU,CAAC,KAAa;IACtC,OAAO,YAAY,CAAC,KAAK,EAAE,wBAAwB,CAAC,CAAC;AACvD,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,SAAS,CAAI,IAAO;IAClC,OAAO,YAAY,CAAC,IAAI,EAAE,uBAAuB,CAAC,CAAC;AACrD,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,UAAU,CAAI,KAAmB;IAC/C,OAAO,YAAY,CAAC,KAAK,EAAE,wBAAwB,CAAC,CAAC;AACvD,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAI,QAAW;IAC1C,OAAO,YAAY,CAAC,QAAQ,EAAE,2BAA2B,CAAC,CAAC;AAC7D,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAAC,OAAiB;IAC5C,MAAM,cAAc,GAAG,YAAY,CAAC,OAAO,EAAE,0BAA0B,CAAC,CAAC;IACzE,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,YAAY,GAAG,CAAC,EAAE,+BAA+B,CAAC,CAAC;IACjF,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,YAAY,GAAG,WAAW,CAAC,YAAY,EAAE,qDAAqD,CAAC,CAAC;IAC9H,OAAO,cAAc,CAAC;AACxB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAAI,UAA2B;IAC5D,OAAO,YAAY,CAAC,UAAU,EAAE,6BAA6B,CAAC,CAAC;AACjE,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,iBAAiB,CAAI,YAA6B;IAChE,OAAO,YAAY,CAAC,YAAY,EAAE,wCAAwC,CAAC,CAAC;AAC9E,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,iBAAiB,CAAI,KAAsB;IACzD,OAAO,YAAY,CAAC,KAAK,EAAE,qCAAqC,CAAC,CAAC;AACpE,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,iBAAiB,CAAI,SAA0B;IAC7D,OAAO,YAAY,CAAC,SAAS,EAAE,qCAAqC,CAAC,CAAC;AACxE,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,iBAAiB,CAAI,SAA0B;IAC7D,OAAO,YAAY,CAAC,SAAS,EAAE,qCAAqC,CAAC,CAAC;AACxE,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAAI,SAA0B;IAC1D,OAAO,YAAY,CAAC,SAAS,EAAE,4BAA4B,CAAC,CAAC;AAC/D,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,iBAAiB,CAAI,YAA6B;IAChE,OAAO,YAAY,CAAC,YAAY,EAAE,gCAAgC,CAAC,CAAC;AACtE,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,IAAI,GAEb,CAAC,KAAc,EAAE,EAAE,GAAG,KAAK,KAAK,CAAC,CAAC,CAAC,CAAA"}

package/auxiliary/Consumer.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Consumer.ts
+ * Candidate for inclusion in api-ts
+ * Defines a Consumer type that can consume values of type T.
+ */
+import { RequiredType } from "@jonloucks/contracts-ts/api/Types";
+/**
+ * A method that consumes a value of type T
+ */
+export type Method<T> = (value: T) => void;
+/**
+ * A Consumer that consumes values of type T
+ */
+export interface Consumer<T> {
+    consume(value: T): void;
+}
+/**
+ * A type that can be either a Method or a Consumer
+ */
+export type Type<T> = Method<T> | Consumer<T>;
+/**
+ * Duck type guard check for Consumer
+ *
+ * @param instance the instance to check
+ * @param <T> the type of value consumed
+ * @returns true if instance is a Consumer, false otherwise
+ */
+export declare function guard<T>(instance: unknown): instance is RequiredType<Consumer<T>>;
+/**
+ * Convert a Type to a Consumer
+ *
+ * @param type the type to convert
+ * @param <T> the type of value consumed
+ * @returns a Consumer that consumes values of type T
+ */
+export declare function fromType<T>(type: Type<T>): RequiredType<Consumer<T>>;
+/**
+ * Check that a Consumer is present
+ *
+ * @param consumer the consumer to check
+ * @return the consumer if present
+ * @throws IllegalArgumentException if the consumer is not present
+ */
+export declare function check<T>(consumer: Type<T>): Type<T>;
+//# sourceMappingURL=Consumer.d.ts.map

package/auxiliary/Consumer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Consumer.d.ts","sourceRoot":"","sources":["../../src/auxiliary/Consumer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAkB,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAGjF;;GAEG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;AAE3C;;GAEG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC;IAAI,OAAO,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;CAAE;AAEzD;;GAEG;AACH,MAAM,MAAM,IAAI,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;AAE9C;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,GAAG,QAAQ,IAAI,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAEjF;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAQpE;AAED;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAEnD"}

package/auxiliary/Consumer.js

@@ -0,0 +1,45 @@
+/**
+ * Consumer.ts
+ * Candidate for inclusion in api-ts
+ * Defines a Consumer type that can consume values of type T.
+ */
+import { guardFunctions } from "@jonloucks/contracts-ts/api/Types";
+import { presentCheck } from "@jonloucks/contracts-ts/auxiliary/Checks";
+/**
+ * Duck type guard check for Consumer
+ *
+ * @param instance the instance to check
+ * @param <T> the type of value consumed
+ * @returns true if instance is a Consumer, false otherwise
+ */
+export function guard(instance) {
+    return guardFunctions(instance, 'consume');
+}
+/**
+ * Convert a Type to a Consumer
+ *
+ * @param type the type to convert
+ * @param <T> the type of value consumed
+ * @returns a Consumer that consumes values of type T
+ */
+export function fromType(type) {
+    if (guard(type)) {
+        return type;
+    }
+    else {
+        return {
+            consume: type
+        };
+    }
+}
+/**
+ * Check that a Consumer is present
+ *
+ * @param consumer the consumer to check
+ * @return the consumer if present
+ * @throws IllegalArgumentException if the consumer is not present
+ */
+export function check(consumer) {
+    return presentCheck(consumer, "Consumer must be present.");
+}
+//# sourceMappingURL=Consumer.js.map

package/auxiliary/Consumer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Consumer.js","sourceRoot":"","sources":["../../src/auxiliary/Consumer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,cAAc,EAAgB,MAAM,mCAAmC,CAAC;AACjF,OAAO,EAAE,YAAY,EAAE,MAAM,0CAA0C,CAAC;AAiBxE;;;;;;GAMG;AACH,MAAM,UAAU,KAAK,CAAI,QAAiB;IACxC,OAAO,cAAc,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;AAC7C,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,QAAQ,CAAI,IAAa;IACvC,IAAI,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;QAChB,OAAO,IAAI,CAAC;IACd,CAAC;SAAM,CAAC;QACN,OAAO;YACL,OAAO,EAAE,IAAI;SACd,CAAC;IACJ,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,KAAK,CAAI,QAAiB;IACxC,OAAO,YAAY,CAAC,QAAQ,EAAE,2BAA2B,CAAC,CAAC;AAC7D,CAAC"}

package/auxiliary/Predicate.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Predicate.ts
+ *
+ * Candidate for inclusion in api-ts
+ * Defines a Predicate type that can test values of type T.
+ */
+import { OptionalType, RequiredType } from "@jonloucks/contracts-ts/api/Types";
+/**
+ * A method that tests a value of type T and returns a boolean
+ */
+export type Method<T> = (value: T) => boolean;
+/**
+ * A Predicate that tests values of type T
+ */
+export interface Predicate<T> {
+    test(value: T): boolean;
+}
+/**
+ * A type that can be a Method, Predicate, or a boolean
+ */
+export type Type<T> = Method<T> | Predicate<T> | boolean;
+/**
+ * Duck type guard check for Predicate
+ *
+ * @param instance the instance to check
+ * @param <T> the type of value tested
+ * @returns true if instance is a Predicate, false otherwise
+ */
+export declare function guard<T>(instance: unknown): instance is Predicate<T>;
+/**
+ * Convert a Type to a Predicate
+ *
+ * @param type the type to convert
+ * @param <T> the type of value tested
+ * @returns a Predicate that tests values of type T
+ */
+export declare function fromType<T>(type: Type<T>): Predicate<T>;
+/**
+ * Test a value against a Predicate Type
+ *
+ * @param type the Predicate Type
+ * @param value the value to test
+ * @param <T> the type of value tested
+ * @returns true if the value satisfies the Predicate, false otherwise
+ */
+export declare function toValue<T>(type: Type<T>, value: T): boolean;
+/**
+ * Check that a predicate is present
+ *
+ * @param predicate the predicate to check
+ * @return the predicate if present
+ * @throws IllegalArgumentException if the predicate is not present
+ */
+export declare function check<T>(predicate: OptionalType<Predicate<T>>): RequiredType<Predicate<T>>;
+//# sourceMappingURL=Predicate.d.ts.map

package/auxiliary/Predicate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Predicate.d.ts","sourceRoot":"","sources":["../../src/auxiliary/Predicate.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAkB,YAAY,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAG/F;;GAEG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC;AAE9C;;GAEG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC;IAAI,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC;CAAE;AAE1D;;GAEG;AACH,MAAM,MAAM,IAAI,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;AAEzD;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,GAAG,QAAQ,IAAI,SAAS,CAAC,CAAC,CAAC,CAEpE;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAevD;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAQ3D;AAED;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,SAAS,EAAE,YAAY,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAE1F"}

package/auxiliary/Predicate.js

@@ -0,0 +1,73 @@
+/**
+ * Predicate.ts
+ *
+ * Candidate for inclusion in api-ts
+ * Defines a Predicate type that can test values of type T.
+ */
+import { guardFunctions } from "@jonloucks/contracts-ts/api/Types";
+import { presentCheck, used } from "@jonloucks/contracts-ts/auxiliary/Checks";
+/**
+ * Duck type guard check for Predicate
+ *
+ * @param instance the instance to check
+ * @param <T> the type of value tested
+ * @returns true if instance is a Predicate, false otherwise
+ */
+export function guard(instance) {
+    return guardFunctions(instance, 'test');
+}
+/**
+ * Convert a Type to a Predicate
+ *
+ * @param type the type to convert
+ * @param <T> the type of value tested
+ * @returns a Predicate that tests values of type T
+ */
+export function fromType(type) {
+    if (guard(type)) {
+        return type;
+    }
+    else if (typeof type === 'boolean') {
+        return {
+            test: (value) => {
+                used(value);
+                return type;
+            }
+        };
+    }
+    else {
+        return {
+            test: type
+        };
+    }
+}
+/**
+ * Test a value against a Predicate Type
+ *
+ * @param type the Predicate Type
+ * @param value the value to test
+ * @param <T> the type of value tested
+ * @returns true if the value satisfies the Predicate, false otherwise
+ */
+export function toValue(type, value) {
+    if (guard(type)) {
+        return type.test(value);
+    }
+    else if (typeof type === 'boolean') {
+        return type;
+    }
+    else {
+        return type(value);
+    }
+}
+/**
+ * Check that a predicate is present
+ *
+ * @param predicate the predicate to check
+ * @return the predicate if present
+ * @throws IllegalArgumentException if the predicate is not present
+ */
+export function check(predicate) {
+    return presentCheck(predicate, "Predicate must be Present.");
+}
+//# sourceMappingURL=Predicate.js.map

package/auxiliary/Predicate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Predicate.js","sourceRoot":"","sources":["../../src/auxiliary/Predicate.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,cAAc,EAA8B,MAAM,mCAAmC,CAAC;AAC/F,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,0CAA0C,CAAC;AAiB9E;;;;;;GAMG;AACH,MAAM,UAAU,KAAK,CAAI,QAAiB;IACxC,OAAO,cAAc,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;AAC1C,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,QAAQ,CAAI,IAAa;IACvC,IAAI,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;QAChB,OAAO,IAAI,CAAC;IACd,CAAC;SAAM,IAAI,OAAO,IAAI,KAAK,SAAS,EAAE,CAAC;QACrC,OAAO;YACL,IAAI,EAAE,CAAC,KAAQ,EAAY,EAAE;gBAC3B,IAAI,CAAC,KAAK,CAAC,CAAC;gBACZ,OAAO,IAAI,CAAC;YACd,CAAC;SACF,CAAC;IACJ,CAAC;SAAM,CAAC;QACN,OAAO;YACL,IAAI,EAAE,IAAI;SACX,CAAC;IACJ,CAAC;AACH,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,OAAO,CAAI,IAAa,EAAE,KAAQ;IAChD,IAAI,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;QAChB,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC1B,CAAC;SAAM,IAAI,OAAO,IAAI,KAAK,SAAS,EAAE,CAAC;QACrC,OAAO,IAAI,CAAC;IACd,CAAC;SAAM,CAAC;QACN,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC;IACrB,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,KAAK,CAAI,SAAqC;IAC5D,OAAO,YAAY,CAAC,SAAS,EAAE,4BAA4B,CAAC,CAAC;AAC/D,CAAC"}

package/auxiliary/Supplier.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Supplier.ts
+ * Candidate for inclusion in api-ts
+ * Defines a Supplier type that can supply values of type T.
+ */
+import { RequiredType } from "@jonloucks/contracts-ts/api/Types";
+/**
+ * A method that supplies a value of type T
+ */
+export type Method<T> = () => T;
+/**
+ * A Supplier that supplies values of type T
+ */
+export interface Supplier<T> {
+    supply(): T;
+}
+/**
+ * A type that can be a Method, Supplier, or a value of type T
+ */
+export type Type<T> = Method<T> | Supplier<T> | T;
+/**
+ * Duck type guard check for Supplier
+ *
+ * @param instance the instance to check
+ * @param <T> the type of value supplied
+ * @returns true if instance is a Supplier, false otherwise
+ */
+export declare function guard<T>(instance: unknown): instance is RequiredType<Supplier<T>>;
+/**
+ * Convert a Type to a Supplier
+ * @param type the type to convert
+ * @param <T> the type of value supplied
+ * @returns a Supplier that supplies values of type T
+ */
+export declare function fromType<T>(type: Type<T>): RequiredType<Supplier<T>>;
+/**
+ * Get the value from a Supplier Type
+ *
+ * @param type the Supplier Type
+ * @param <T> the type of value supplied
+ * @returns the value supplied by the Supplier Type
+ */
+export declare function toValue<T>(type: Type<T>): T;
+/**
+ * Check that a Supplier is present
+ *
+ * @param supplier the supplier to check
+ * @return the supplier if present
+ * @throws IllegalArgumentException if the supplier is not present
+ */
+export declare function check<T>(supplier: Type<T>): Type<T>;
+//# sourceMappingURL=Supplier.d.ts.map

package/auxiliary/Supplier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Supplier.d.ts","sourceRoot":"","sources":["../../src/auxiliary/Supplier.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAA8B,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAG7F;;GAEG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC;AAEhC;;GAEG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC;IAAI,MAAM,IAAI,CAAC,CAAC;CAAE;AAE7C;;GAEG;AACH,MAAM,MAAM,IAAI,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AAElD;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,GAAG,QAAQ,IAAI,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAEjF;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAYpE;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAQ3C;AAED;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAEnD"}

package/auxiliary/Supplier.js

@@ -0,0 +1,67 @@
+/**
+ * Supplier.ts
+ * Candidate for inclusion in api-ts
+ * Defines a Supplier type that can supply values of type T.
+ */
+import { guardFunctions, isFunction } from "@jonloucks/contracts-ts/api/Types";
+import { presentCheck } from "@jonloucks/contracts-ts/auxiliary/Checks";
+/**
+ * Duck type guard check for Supplier
+ *
+ * @param instance the instance to check
+ * @param <T> the type of value supplied
+ * @returns true if instance is a Supplier, false otherwise
+ */
+export function guard(instance) {
+    return guardFunctions(instance, 'supply');
+}
+/**
+ * Convert a Type to a Supplier
+ * @param type the type to convert
+ * @param <T> the type of value supplied
+ * @returns a Supplier that supplies values of type T
+ */
+export function fromType(type) {
+    if (guard(type)) {
+        return type;
+    }
+    else if (isFunction(type)) {
+        return {
+            supply: type
+        };
+    }
+    else {
+        return {
+            supply: () => type
+        };
+    }
+}
+/**
+ * Get the value from a Supplier Type
+ *
+ * @param type the Supplier Type
+ * @param <T> the type of value supplied
+ * @returns the value supplied by the Supplier Type
+ */
+export function toValue(type) {
+    if (guard(type)) {
+        return type.supply();
+    }
+    else if (isFunction(type)) {
+        return type();
+    }
+    else {
+        return type;
+    }
+}
+/**
+ * Check that a Supplier is present
+ *
+ * @param supplier the supplier to check
+ * @return the supplier if present
+ * @throws IllegalArgumentException if the supplier is not present
+ */
+export function check(supplier) {
+    return presentCheck(supplier, "Supplier must be Present.");
+}
+//# sourceMappingURL=Supplier.js.map

package/auxiliary/Supplier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Supplier.js","sourceRoot":"","sources":["../../src/auxiliary/Supplier.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,cAAc,EAAE,UAAU,EAAgB,MAAM,mCAAmC,CAAC;AAC7F,OAAO,EAAE,YAAY,EAAE,MAAM,0CAA0C,CAAC;AAiBxE;;;;;;GAMG;AACH,MAAM,UAAU,KAAK,CAAI,QAAiB;IACxC,OAAO,cAAc,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,QAAQ,CAAI,IAAa;IACvC,IAAI,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;QAChB,OAAO,IAAI,CAAC;IACd,CAAC;SAAM,IAAI,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QAC5B,OAAO;YACL,MAAM,EAAE,IAAI;SACb,CAAA;IACH,CAAC;SAAM,CAAC;QACN,OAAO;YACL,MAAM,EAAE,GAAG,EAAE,CAAC,IAAI;SACnB,CAAA;IACH,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,OAAO,CAAI,IAAa;IACtC,IAAI,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;QAChB,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC;IACvB,CAAC;SAAM,IAAI,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QAC5B,OAAO,IAAI,EAAE,CAAC;IAChB,CAAC;SAAM,CAAC;QACN,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,KAAK,CAAI,QAAiB;IACxC,OAAO,YAAY,CAAC,QAAQ,EAAE,2BAA2B,CAAC,CAAC;AAC7D,CAAC"}

package/impl/Completable.impl.d.ts

@@ -0,0 +1,10 @@
+import { Completable, Config } from "@jonloucks/concurrency-ts/api/Completable";
+/**
+ * Create a new Completable
+ *
+ * @param config the completable configuration
+ * @return the new Completable
+ * @param <T> the type of completion value
+ */
+export declare function create<T>(config: Config<T>): Completable<T>;
+//# sourceMappingURL=Completable.impl.d.ts.map

package/impl/Completable.impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Completable.impl.d.ts","sourceRoot":"","sources":["../../src/impl/Completable.impl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAoBhF;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAE3D"}

package/impl/Completable.impl.js

@@ -0,0 +1,136 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _CompletableImpl_completionStateMachine, _CompletableImpl_idempotent, _CompletableImpl_completion, _CompletableImpl_waitableValue, _CompletableImpl_closeMany, _CompletableImpl_observers;
+import { getStateMachineConfig as getCompletionStateConfig } from "@jonloucks/concurrency-ts/api/CompletionState";
+import { completionCheck, onCompletionCheck } from "@jonloucks/concurrency-ts/auxiliary/Checks";
+import { inlineAutoClose } from "@jonloucks/contracts-ts/api/AutoClose";
+import { contractsCheck } from "@jonloucks/contracts-ts/auxiliary/Checks";
+import { createAtomicBoolean, createIdempotent } from "@jonloucks/contracts-ts/auxiliary/Convenience";
+import { IllegalStateException } from "@jonloucks/contracts-ts/auxiliary/IllegalStateException";
+import { create as createStateMachine } from "./StateMachine.impl.js";
+import { create as createWaitable } from "./Waitable.impl.js";
+import { isPresent } from "@jonloucks/contracts-ts/api/Types";
+import { CONTRACT as AUTO_CLOSE_FACTORY } from "@jonloucks/contracts-ts/api/AutoCloseFactory";
+/**
+ * Create a new Completable
+ *
+ * @param config the completable configuration
+ * @return the new Completable
+ * @param <T> the type of completion value
+ */
+export function create(config) {
+    return CompletableImpl.internalCreate(config);
+}
+;
+class CompletableImpl {
+    open() {
+        return __classPrivateFieldGet(this, _CompletableImpl_idempotent, "f").open();
+    }
+    notifyState() {
+        return __classPrivateFieldGet(this, _CompletableImpl_completionStateMachine, "f");
+    }
+    notifyValue() {
+        return __classPrivateFieldGet(this, _CompletableImpl_waitableValue, "f");
+    }
+    getCompletion() {
+        return __classPrivateFieldGet(this, _CompletableImpl_completion, "f");
+    }
+    notify(onCompletion) {
+        const referentOnCompletion = onCompletionCheck(onCompletion);
+        const firstClose = createAtomicBoolean(true);
+        const isLive = createAtomicBoolean(true);
+        const removeObserver = (v) => {
+            __classPrivateFieldGet(this, _CompletableImpl_observers, "f").delete(v);
+        };
+        const observer = {
+            onCompletion: function (completion) {
+                if (isLive.get()) {
+                    referentOnCompletion.onCompletion(completion);
+                }
+            },
+            close: function () {
+                if (firstClose.compareAndSet(true, false)) {
+                    isLive.set(false);
+                    removeObserver(this);
+                }
+            }
+        };
+        __classPrivateFieldGet(this, _CompletableImpl_observers, "f").add(observer);
+        if (isPresent(__classPrivateFieldGet(this, _CompletableImpl_completion, "f"))) {
+            try {
+                observer.onCompletion(__classPrivateFieldGet(this, _CompletableImpl_completion, "f"));
+            }
+            catch (e) {
+                removeObserver(observer);
+                throw e;
+            }
+        }
+        return inlineAutoClose(() => {
+            observer.close();
+        });
+    }
+    onCompletion(completion) {
+        const validCompletion = completionCheck(completion);
+        this.assertNotRejecting();
+        if (__classPrivateFieldGet(this, _CompletableImpl_completionStateMachine, "f").setState("onCompletion", validCompletion.state)) {
+            __classPrivateFieldSet(this, _CompletableImpl_completion, validCompletion, "f");
+            const value = validCompletion.value;
+            if (this.isCompleted() && isPresent(value)) {
+                __classPrivateFieldGet(this, _CompletableImpl_waitableValue, "f").consume(value);
+            }
+            this.notifyObservers(validCompletion);
+        }
+    }
+    isCompleted() {
+        return __classPrivateFieldGet(this, _CompletableImpl_completionStateMachine, "f").isCompleted();
+    }
+    realOpen() {
+        __classPrivateFieldGet(this, _CompletableImpl_closeMany, "f").add(__classPrivateFieldGet(this, _CompletableImpl_waitableValue, "f").open());
+        __classPrivateFieldGet(this, _CompletableImpl_closeMany, "f").add(__classPrivateFieldGet(this, _CompletableImpl_completionStateMachine, "f").open());
+        return inlineAutoClose(() => {
+            __classPrivateFieldGet(this, _CompletableImpl_closeMany, "f").close();
+        });
+    }
+    notifyObservers(newValue) {
+        for (const observer of __classPrivateFieldGet(this, _CompletableImpl_observers, "f")) {
+            observer.onCompletion(newValue);
+        }
+    }
+    assertNotRejecting() {
+        switch (__classPrivateFieldGet(this, _CompletableImpl_idempotent, "f").getState()) {
+            case 'OPENABLE':
+            case 'DESTROYED':
+            case 'CLOSED':
+                throw new IllegalStateException("Completable is rejecting.");
+        }
+    }
+    static internalCreate(config) {
+        return new CompletableImpl(config);
+    }
+    constructor(config) {
+        _CompletableImpl_completionStateMachine.set(this, void 0);
+        _CompletableImpl_idempotent.set(this, void 0);
+        _CompletableImpl_completion.set(this, null);
+        _CompletableImpl_waitableValue.set(this, void 0);
+        _CompletableImpl_closeMany.set(this, void 0);
+        _CompletableImpl_observers.set(this, new Set());
+        const contracts = contractsCheck(config.contracts);
+        const closeFactory = contracts.enforce(AUTO_CLOSE_FACTORY);
+        __classPrivateFieldSet(this, _CompletableImpl_closeMany, closeFactory.createAutoCloseMany(), "f");
+        __classPrivateFieldSet(this, _CompletableImpl_waitableValue, createWaitable({ contracts: contracts, initialValue: config.initialValue }), "f");
+        __classPrivateFieldSet(this, _CompletableImpl_idempotent, createIdempotent({ contracts: contracts, open: () => this.realOpen() }), "f");
+        __classPrivateFieldSet(this, _CompletableImpl_completionStateMachine, createStateMachine(getCompletionStateConfig()), "f");
+    }
+}
+_CompletableImpl_completionStateMachine = new WeakMap(), _CompletableImpl_idempotent = new WeakMap(), _CompletableImpl_completion = new WeakMap(), _CompletableImpl_waitableValue = new WeakMap(), _CompletableImpl_closeMany = new WeakMap(), _CompletableImpl_observers = new WeakMap();
+;
+//# sourceMappingURL=Completable.impl.js.map