@jonloucks/concurrency-ts 0.4.0

package/api/Types.d.ts

@@ -0,0 +1,27 @@
+export { type Consumer, type Method as ConsumerFunction, guard as consumerGuard, type Type as ConsumerType } from "@jonloucks/concurrency-ts/auxiliary/Consumer";
+export { type Predicate, type Method as PredicateFunction, guard as predicateGuard, type Type as PredicateType } from "@jonloucks/concurrency-ts/auxiliary/Predicate";
+export { type Supplier, type Method as SupplierFunction, guard as supplierGuard, type Type as SupplierType, toValue as supplierToValue } from "@jonloucks/concurrency-ts/auxiliary/Supplier";
+export { guardFunctions, isNotPresent, isNumber, isPresent, isString, type OptionalType, type RequiredType } from "@jonloucks/contracts-ts/api/Types";
+/**
+ * A type that can be a value of type T, null, or undefined
+ */
+export type Throwable<T> = T | null | undefined;
+/**
+ * Type guard to determine if a value is Throwable
+ *
+ * @param value the value to check
+ * @return true if the value is Throwable
+ */
+export declare function isThrowable<T>(value: unknown): value is Throwable<T>;
+export interface Duration {
+    get milliSeconds(): number;
+}
+/**
+ * The minimum timeout duration
+ */
+export declare const MIN_TIMEOUT: Duration;
+/**
+ * The maximum timeout duration
+ */
+export declare const MAX_TIMEOUT: Duration;
+//# sourceMappingURL=Types.d.ts.map

package/api/Types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Types.d.ts","sourceRoot":"","sources":["../../src/api/Types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,MAAM,IAAI,gBAAgB,EAAE,KAAK,IAAI,aAAa,EAAE,KAAK,IAAI,IAAI,YAAY,EAAE,MAAM,8CAA8C,CAAC;AACjK,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,MAAM,IAAI,iBAAiB,EAAE,KAAK,IAAI,cAAc,EAAE,KAAK,IAAI,IAAI,aAAa,EAAE,MAAM,+CAA+C,CAAC;AACtK,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,MAAM,IAAI,gBAAgB,EAAE,KAAK,IAAI,aAAa,EAAE,KAAK,IAAI,IAAI,YAAY,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,8CAA8C,CAAC;AAC7L,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAGtJ;;GAEG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC;AAEhD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,CAAC,CAAC,CAAC,CAAiB;AAItF,MAAM,WAAW,QAAQ;IACvB,IAAI,YAAY,IAAI,MAAM,CAAC;CAC5B;AAED;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,QAIzB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,QAIzB,CAAC"}

package/api/Types.js

@@ -0,0 +1,28 @@
+export { guard as consumerGuard } from "@jonloucks/concurrency-ts/auxiliary/Consumer";
+export { guard as predicateGuard } from "@jonloucks/concurrency-ts/auxiliary/Predicate";
+export { guard as supplierGuard, toValue as supplierToValue } from "@jonloucks/concurrency-ts/auxiliary/Supplier";
+export { guardFunctions, isNotPresent, isNumber, isPresent, isString } from "@jonloucks/contracts-ts/api/Types";
+/**
+ * Type guard to determine if a value is Throwable
+ *
+ * @param value the value to check
+ * @return true if the value is Throwable
+ */
+export function isThrowable(value) { return true; }
+/**
+ * The minimum timeout duration
+ */
+export const MIN_TIMEOUT = {
+    get milliSeconds() {
+        return 0;
+    }
+};
+/**
+ * The maximum timeout duration
+ */
+export const MAX_TIMEOUT = {
+    get milliSeconds() {
+        return Number.MAX_SAFE_INTEGER;
+    }
+};
+//# sourceMappingURL=Types.js.map

package/api/Types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Types.js","sourceRoot":"","sources":["../../src/api/Types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkD,KAAK,IAAI,aAAa,EAA6B,MAAM,8CAA8C,CAAC;AACjK,OAAO,EAAoD,KAAK,IAAI,cAAc,EAA8B,MAAM,+CAA+C,CAAC;AACtK,OAAO,EAAkD,KAAK,IAAI,aAAa,EAA6B,OAAO,IAAI,eAAe,EAAE,MAAM,8CAA8C,CAAC;AAC7L,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAwC,MAAM,mCAAmC,CAAC;AAQtJ;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CAAI,KAAc,IAA2B,OAAO,IAAI,CAAC,CAAC,CAAC;AAQtF;;GAEG;AACH,MAAM,CAAC,MAAM,WAAW,GAAa;IACnC,IAAI,YAAY;QACd,OAAO,CAAC,CAAC;IACX,CAAC;CACF,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,WAAW,GAAa;IACnC,IAAI,YAAY;QACd,OAAO,MAAM,CAAC,gBAAgB,CAAC;IACjC,CAAC;CACF,CAAC"}

package/api/Waitable.d.ts

@@ -0,0 +1,39 @@
+import { WaitableConsumer } from "@jonloucks/concurrency-ts/api/WaitableConsumer";
+import { WaitableNotify } from "@jonloucks/concurrency-ts/api/WaitableNotify";
+import { WaitableSupplier } from "@jonloucks/concurrency-ts/api/WaitableSupplier";
+import { OptionalType, RequiredType } from "@jonloucks/concurrency-ts/api/Types";
+import { Open } from "@jonloucks/contracts-ts/api/Open";
+import { Contracts } from "@jonloucks/contracts-ts";
+/**
+ * Configuration for creating a Waitable
+ */
+export interface Config<T> {
+    /**
+     * Optional contracts for validation or other purposes
+     */
+    contracts?: Contracts;
+    /**
+     * Optional initial value of the Waitable
+     */
+    initialValue?: OptionalType<T>;
+}
+/**
+ * Export Waitable Config type
+ */
+export { type Config as WaitableConfig };
+/**
+ * Provides mutable reference that allows other threads to wait until
+ * the value satisfies a given condition.
+ *
+ * @param <T> the type of references
+ */
+export interface Waitable<T> extends Open, WaitableSupplier<T>, WaitableConsumer<T>, WaitableNotify<T> {
+}
+/**
+ * Determine if the given instance is a Waitable
+ *
+ * @param instance the instance to check
+ * @return true if the instance is a Waitable
+ */
+export declare function guard<T>(instance: unknown): instance is RequiredType<Waitable<T>>;
+//# sourceMappingURL=Waitable.d.ts.map

package/api/Waitable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Waitable.d.ts","sourceRoot":"","sources":["../../src/api/Waitable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAkC,MAAM,gDAAgD,CAAC;AAClH,OAAO,EAAE,cAAc,EAAgC,MAAM,8CAA8C,CAAC;AAC5G,OAAO,EAAE,gBAAgB,EAAkC,MAAM,gDAAgD,CAAC;AAClH,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,qCAAqC,CAAC;AACjG,OAAO,EAAE,IAAI,EAAE,MAAM,kCAAkC,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEpD;;GAEG;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;;GAEG;AACH,OAAO,EAAE,KAAK,MAAM,IAAI,cAAc,EAAE,CAAE;AAE1C;;;;;GAKG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC,CAAE,SAAQ,IAAI,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC;CACrG;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,GAAG,QAAQ,IAAI,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAKjF"}

package/api/Waitable.js

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

package/api/Waitable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Waitable.js","sourceRoot":"","sources":["../../src/api/Waitable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,IAAI,qBAAqB,EAAE,MAAM,gDAAgD,CAAC;AAClH,OAAO,EAAkB,KAAK,IAAI,mBAAmB,EAAE,MAAM,8CAA8C,CAAC;AAC5G,OAAO,EAAoB,KAAK,IAAI,qBAAqB,EAAE,MAAM,gDAAgD,CAAC;AAClH,OAAO,EAA8B,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAiCjG;;;;;GAKG;AACH,MAAM,UAAU,KAAK,CAAI,QAAiB;IACxC,OAAO,cAAc,CAAC,QAAQ,EAAE,MAAM,CAAC;WAClC,qBAAqB,CAAI,QAAQ,CAAC;WAClC,mBAAmB,CAAI,QAAQ,CAAC;WAChC,qBAAqB,CAAI,QAAQ,CAAC,CAAC;AAC1C,CAAC"}

package/api/WaitableConsumer.d.ts

@@ -0,0 +1,54 @@
+import { Consumer, Duration, OptionalType, PredicateType, RequiredType, SupplierType } from "@jonloucks/concurrency-ts/api/Types";
+/**
+ * Waitable consumer
+ * @param <T> the type of value
+ */
+export interface WaitableConsumer<T> extends Consumer<T> {
+    /**
+     * Assign a new value
+     *
+     * @param value the new value
+     * @throws IllegalArgumentException if value is null
+     */
+    consume(value: SupplierType<T>): void;
+    /**
+     * Consume a new value if conditions are satisfied
+     *
+     * In languages that support synchronization this method would lock
+     * before checking the predicate. In JavaScript/TypeScript this is not possible so
+     * if becomes a variant of an 'if' check followed by a 'set' operation.
+     *
+     * @param predicate the predicate to test if a value should be replaced
+     * @param value the new value
+     * @return the supplied value if and only if the condition is satisfied
+     * @throws IllegalArgumentException if predicate is null or if value is null
+     */
+    consumeIf(predicate: RequiredType<PredicateType<T>>, value: SupplierType<T>): OptionalType<T>;
+    /**
+     * Consume a new value when conditions are satisfied
+     *
+     * Create a one-time promise that evaluates the predicate against the current value.
+     * If the predicate is satisfied the value is replaced and the promise resolves with the previous value.
+     *
+     * if the predicate is not satisfied the promise remains pending until either:
+     * - another thread updates the value and the predicate is satisfied, or
+     * - the optional timeout elapses
+     *
+     * In languages that support synchronization this method would lock
+     *
+     * @param predicate the predicate to test if a value should be replaced
+     * @param value the new value
+     * @param timeout how long to wait for the predicate to be satisfied
+     * @return the supplied value if and only if the condition is satisfied
+     * @throws IllegalArgumentException if predicate is not defined
+     */
+    consumeWhen(predicate: RequiredType<PredicateType<T>>, value: SupplierType<T>, timeout?: Duration): Promise<OptionalType<T>>;
+}
+/**
+ * Determine if the given instance is a WaitableConsumer
+ *
+ * @param instance the instance to check
+ * @return true if the instance is a WaitableConsumer
+ */
+export declare function guard<T>(instance: unknown): instance is RequiredType<WaitableConsumer<T>>;
+//# sourceMappingURL=WaitableConsumer.d.ts.map

package/api/WaitableConsumer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WaitableConsumer.d.ts","sourceRoot":"","sources":["../../src/api/WaitableConsumer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAAE,QAAQ,EAElB,YAAY,EAAE,aAAa,EAC3B,YAAY,EACZ,YAAY,EACb,MAAM,qCAAqC,CAAC;AAE7C;;;GAGG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC,CAAE,SAAQ,QAAQ,CAAC,CAAC,CAAC;IAEtD;;;;;OAKG;IACH,OAAO,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAEtC;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,SAAS,EAAE,YAAY,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;IAE9F;;;;;;;;;;;;;;;;;OAiBG;IACH,WAAW,CAAC,SAAS,EAAE,YAAY,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;CAC9H;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,GAAG,QAAQ,IAAI,YAAY,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAMzF"}

package/api/WaitableConsumer.js

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

package/api/WaitableConsumer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WaitableConsumer.js","sourceRoot":"","sources":["../../src/api/WaitableConsumer.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,cAAc,EAIf,MAAM,qCAAqC,CAAC;AAmD7C;;;;;GAKG;AACH,MAAM,UAAU,KAAK,CAAI,QAAiB;IACxC,OAAO,cAAc,CAAC,QAAQ,EAC5B,SAAS,EACT,WAAW,EACX,aAAa,CACd,CAAC;AACJ,CAAC"}

package/api/WaitableFactory.d.ts

@@ -0,0 +1,29 @@
+import { Contract } from "@jonloucks/contracts-ts";
+import { RequiredType } from "@jonloucks/concurrency-ts/api/Types";
+import { Waitable, Config } from "@jonloucks/concurrency-ts/api/Waitable";
+/**
+ * Waitable Factory
+ */
+export interface WaitableFactory {
+    /**
+     * Create a new Waitable with the given initial value
+     *
+     * @param config the configuration for the waitable (null is not allowed)
+     * @return the waitable
+     * @param <T> the type of waitable
+     * @throws IllegalArgumentException if initialValue is null
+     */
+    createWaitable<T>(config?: Config<T>): RequiredType<Waitable<T>>;
+}
+/**
+ * Determine if the given instance is a WaitableFactory
+ *
+ * @param instance the instance to check
+ * @return true if the instance is a WaitableFactory
+ */
+export declare function guard(instance: unknown): instance is RequiredType<WaitableFactory>;
+/**
+ * Contract for WaitableFactory
+ */
+export declare const CONTRACT: Contract<WaitableFactory>;
+//# sourceMappingURL=WaitableFactory.d.ts.map

package/api/WaitableFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WaitableFactory.d.ts","sourceRoot":"","sources":["../../src/api/WaitableFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAkB,MAAM,yBAAyB,CAAC;AACnE,OAAO,EAAkB,YAAY,EAAE,MAAM,qCAAqC,CAAC;AACnF,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,wCAAwC,CAAC;AAE1E;;GAEG;AACH,MAAM,WAAW,eAAe;IAE9B;;;;;;;OAOG;IACH,cAAc,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;CAClE;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,QAAQ,EAAE,OAAO,GAAG,QAAQ,IAAI,YAAY,CAAC,eAAe,CAAC,CAElF;AAED;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAAC,eAAe,CAG7C,CAAC"}

package/api/WaitableFactory.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 WaitableFactory
+ *
+ * @param instance the instance to check
+ * @return true if the instance is a WaitableFactory
+ */
+export function guard(instance) {
+    return guardFunctions(instance, 'createWaitable');
+}
+/**
+ * Contract for WaitableFactory
+ */
+export const CONTRACT = createContract({
+    name: "WaitableFactory",
+    test: guard
+});
+//# sourceMappingURL=WaitableFactory.js.map

package/api/WaitableFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WaitableFactory.js","sourceRoot":"","sources":["../../src/api/WaitableFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,EAAE,cAAc,EAAgB,MAAM,qCAAqC,CAAC;AAmBnF;;;;;GAKG;AACH,MAAM,UAAU,KAAK,CAAC,QAAiB;IACrC,OAAO,cAAc,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAC;AACpD,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,QAAQ,GAA8B,cAAc,CAAC;IAChE,IAAI,EAAE,iBAAiB;IACvB,IAAI,EAAE,KAAK;CACZ,CAAC,CAAC"}

package/api/WaitableNotify.d.ts

@@ -0,0 +1,31 @@
+import { RequiredType } from "@jonloucks/concurrency-ts/api/Types";
+import { Type as ConsumerType } from "@jonloucks/concurrency-ts/auxiliary/Consumer";
+import { Type as PredicateType } from "@jonloucks/concurrency-ts/auxiliary/Predicate";
+import { AutoClose } from "@jonloucks/contracts-ts/api/AutoClose";
+export { type AutoClose, type ConsumerType, type PredicateType, type RequiredType };
+/**
+ * Notify lister when condition is satisfied
+ * @param <T> the type of value
+ */
+export interface WaitableNotify<T> {
+    /**
+     * When condition is satisfied the listener is invoked
+     * Note: It is likely the listener will be called within a write lock context.
+     * Deadlocks could happen of listener is waiting on another thread to acquire a lock to this WaitableNotify
+     *
+     * @param predicate the predicate to test if the value should be passed to listener
+     * @param listener the listener
+     * @return AutoClose which removes the listener
+     * @throws IllegalArgumentException if predicate is null or the listener is null
+   */
+    notifyWhile(predicate: RequiredType<PredicateType<T>>, listener: RequiredType<ConsumerType<T>>): RequiredType<AutoClose>;
+}
+/**
+ * Duck type guard check for WaitableNotify
+ *
+ * @param value  the value to check
+ * @param <T>    the type of value
+ * @returns true if value is WaitableNotify, false otherwise
+ */
+export declare function guard<T>(value: unknown): value is RequiredType<WaitableNotify<T>>;
+//# sourceMappingURL=WaitableNotify.d.ts.map

package/api/WaitableNotify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WaitableNotify.d.ts","sourceRoot":"","sources":["../../src/api/WaitableNotify.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,YAAY,EAAE,MAAM,qCAAqC,CAAC;AACnF,OAAO,EAAE,IAAI,IAAI,YAAY,EAAE,MAAM,8CAA8C,CAAC;AACpF,OAAO,EAAE,IAAI,IAAI,aAAa,EAAE,MAAM,+CAA+C,CAAC;AACtF,OAAO,EAAE,SAAS,EAAE,MAAM,uCAAuC,CAAC;AAElE,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,YAAY,EAAE,KAAK,aAAa,EAAE,KAAK,YAAY,EAAE,CAAC;AAEpF;;;GAGG;AACH,MAAM,WAAW,cAAc,CAAC,CAAC;IAE/B;;;;;;;;;KASC;IACD,WAAW,CAAC,SAAS,EAAE,YAAY,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,YAAY,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,SAAS,CAAC,CAAC;CAC1H;AAED;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAEjF"}

package/api/WaitableNotify.js

@@ -0,0 +1,12 @@
+import { guardFunctions } from "@jonloucks/concurrency-ts/api/Types";
+/**
+ * Duck type guard check for WaitableNotify
+ *
+ * @param value  the value to check
+ * @param <T>    the type of value
+ * @returns true if value is WaitableNotify, false otherwise
+ */
+export function guard(value) {
+    return guardFunctions(value, 'notifyWhile');
+}
+//# sourceMappingURL=WaitableNotify.js.map

package/api/WaitableNotify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WaitableNotify.js","sourceRoot":"","sources":["../../src/api/WaitableNotify.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAgB,MAAM,qCAAqC,CAAC;AA0BnF;;;;;;GAMG;AACH,MAAM,UAAU,KAAK,CAAI,KAAc;IACrC,OAAO,cAAc,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC;AAC9C,CAAC"}

package/api/WaitableSupplier.d.ts

@@ -0,0 +1,53 @@
+import { Duration, OptionalType, RequiredType } from "@jonloucks/concurrency-ts/api/Types";
+import { Type as PredicateType } from "@jonloucks/concurrency-ts/auxiliary/Predicate";
+import { Supplier } from "@jonloucks/concurrency-ts/auxiliary/Supplier";
+export { type RequiredType, type OptionalType, type Duration, type PredicateType, type Supplier };
+/**
+ * Waitable supplier
+ * @param <T> the type of value supplied
+ */
+export interface WaitableSupplier<T> extends Supplier<T> {
+    /**
+     * @return Get current value
+     */
+    supply(): T;
+    /**
+     * Gets the current value if it satisfies a condition
+     *
+     * In languages that support synchronization this method would lock before checking the predicate. In JavaScript/TypeScript this is not possible so
+     * this method creates a one-time promise that evaluates the predicate against the current value.
+     * If the predicate is satisfied the promise resolves with the current value.
+     *
+     * @param predicate the predicate
+     * @return the current value if and only if the condition is satisfied
+     * @throws IllegalArgumentException if predicate is null or if value is null
+     */
+    supplyIf(predicate: PredicateType<T>): OptionalType<T>;
+    /**
+     * Waits until the current value if it satisfies a condition or a timeout is reached
+     *
+     * In languages that support synchronization this method would lock before checking the predicate. In JavaScript/TypeScript this is not possible so
+     * this method creates a one-time promise that evaluates the predicate against the current value.
+     * If the predicate is satisfied the promise resolves with the current value.
+     *
+     * if the predicate is not satisfied the promise remains pending until either:
+     * - another thread updates the value and the predicate is satisfied, or
+     * - the optional timeout elapses
+     *
+     * In languages that support synchronization this method would lock
+     *
+     * @param predicate the predicate to test if the value satisfies the stop waiting condition
+     * @param timeout the time to wait for the value to satisfy the predicate
+     * @return the current value if and only if the condition is satisfied
+     * @throws IllegalArgumentException if predicate is null, duration is null, or duration is negative
+     */
+    supplyWhen(predicate: RequiredType<PredicateType<T>>, timeout?: Duration): Promise<T>;
+}
+/**
+ * Determine if the given instance is a WaitableSupplier
+ *
+ * @param instance the instance to check
+ * @return true if the instance is a WaitableSupplier
+ */
+export declare function guard<T>(instance: unknown): instance is RequiredType<WaitableSupplier<T>>;
+//# sourceMappingURL=WaitableSupplier.d.ts.map

package/api/WaitableSupplier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WaitableSupplier.d.ts","sourceRoot":"","sources":["../../src/api/WaitableSupplier.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,qCAAqC,CAAC;AAE3G,OAAO,EAAE,IAAI,IAAI,aAAa,EAAE,MAAM,+CAA+C,CAAC;AACtF,OAAO,EAAE,QAAQ,EAAE,MAAM,8CAA8C,CAAC;AAExE,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,KAAK,QAAQ,EAAE,KAAK,aAAa,EAAE,KAAK,QAAQ,EAAE,CAAA;AAEjG;;;GAGG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC,CAAE,SAAQ,QAAQ,CAAC,CAAC,CAAC;IAEtD;;OAEG;IACH,MAAM,IAAI,CAAC,CAAC;IAEZ;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;IAEvD;;;;;;;;;;;;;;;;;OAiBG;IACH,UAAU,CAAC,SAAS,EAAE,YAAY,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CACvF;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,GAAG,QAAQ,IAAI,YAAY,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAMzF"}

package/api/WaitableSupplier.js

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

package/api/WaitableSupplier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WaitableSupplier.js","sourceRoot":"","sources":["../../src/api/WaitableSupplier.ts"],"names":[],"mappings":"AACA,OAAO,EAAwC,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAoD3G;;;;;GAKG;AACH,MAAM,UAAU,KAAK,CAAI,QAAiB;IACxC,OAAO,cAAc,CAAC,QAAQ,EAC5B,QAAQ,EACR,UAAU,EACV,YAAY,CACb,CAAC;AACJ,CAAC"}

package/auxiliary/Checks.d.ts

@@ -0,0 +1,116 @@
+import { Duration, OptionalType, RequiredType } 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 declare function stateCheck<T>(state: T): T;
+/**
+ * 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 declare function eventCheck(event: string): string;
+/**
+ * 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 declare function ruleCheck<T>(rule: T): T;
+/**
+ * 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 declare function rulesCheck<T>(rules: readonly T[]): readonly T[];
+/**
+ * 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 declare function listenerCheck<T>(consumer: T): T;
+/**
+ * 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 declare function timeoutCheck(timeout: Duration): Duration;
+/**
+ * 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 declare function completionCheck<T>(completion: OptionalType<T>): RequiredType<T>;
+/**
+ * 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 declare function onCompletionCheck<T>(onCompletion: OptionalType<T>): RequiredType<T>;
+/**
+ * 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 declare function finallyBlockCheck<T>(block: OptionalType<T>): RequiredType<T>;
+/**
+ * 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 declare function successBlockCheck<T>(onSuccess: OptionalType<T>): RequiredType<T>;
+/**
+ * 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 declare function failureBlockCheck<T>(onFailure: OptionalType<T>): RequiredType<T>;
+/**
+ * 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 predicateCheck<T>(predicate: OptionalType<T>): RequiredType<T>;
+/**
+ * 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 declare function initialValueCheck<T>(initialValue: OptionalType<T>): RequiredType<T>;
+/**
+ * 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 declare const used: (value: unknown) => void;
+//# sourceMappingURL=Checks.d.ts.map

package/auxiliary/Checks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Checks.d.ts","sourceRoot":"","sources":["../../src/auxiliary/Checks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAe,YAAY,EAAE,YAAY,EAAE,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,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAEzC;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,CAEvC;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,GAAG,SAAS,CAAC,EAAE,CAE/D;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,CAAC,CAE/C;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,QAAQ,GAAG,QAAQ,CAKxD;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,UAAU,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAE/E;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,YAAY,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAEnF;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAE5E;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAEhF;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAEhF;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAE7E;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,YAAY,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAEnF;AAED;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,EAAE,CAAC,KAAK,EAAE,OAAO,KAC7B,IACkC,CAAA"}