gingersnap 0.22.0

package/future/group.cjs

@@ -0,0 +1,180 @@
+'use strict';
+
+var R = require('ramda');
+var future = require('./future.cjs');
+var synchronize = require('../synchronize.cjs');
+var stream = require('../stream.cjs');
+var stream_state = require('../stream/state.cjs');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var R__namespace = /*#__PURE__*/_interopNamespaceDefault(R);
+
+/**
+ * Groups one or more futures for collective operations
+ */
+class FutureGroup {
+    constructor() {
+        this.futures = [];
+        this.closedEvent = new synchronize.FutureEvent();
+    }
+    /**
+     * Check if the group can accept more futures
+     */
+    get open() {
+        return !this.closedEvent.isSet;
+    }
+    /**
+     * Total number of futures that completed
+     */
+    get totalCompleted() {
+        return this.futures.reduce((total, future) => total + (future.done ? 1 : 0), 0);
+    }
+    /**
+     * Total number of futures that failed
+     */
+    get totalFailed() {
+        return this.futures.reduce((total, future) => total + (future.error ? 1 : 0), 0);
+    }
+    /**
+     * Total number of futures current executing
+     */
+    get totalRunning() {
+        return this.futures.reduce((total, future) => total + (future.running ? 1 : 0), 0);
+    }
+    /**
+     * Adds a future to the group
+     * @param future
+     */
+    add(future) {
+        this.futures.push(future);
+    }
+    /**
+     * Marks the group as closed, indicating that all the necessary futures to monitor have been added
+     */
+    done() {
+        this.closedEvent.set();
+    }
+    /**
+     * Waits for all the futures in the group to complete
+     */
+    allCompleted() {
+        return this.closedEvent
+            .wait()
+            .thenApply(() => future.Future.collect(this.futures))
+            .thenApply(() => this);
+    }
+    /**
+     * Waits for all the futures to complete and collect the results in an array
+     */
+    collect() {
+        return this.closedEvent.wait().thenApply(() => future.Future.collect(this.futures));
+    }
+    /**
+     * Waits for the first future to complete
+     */
+    firstCompleted() {
+        return this.asCompleted().future;
+    }
+    /**
+     * Waits for the first future to fail
+     */
+    firstFailed() {
+        return this.asFailed().future;
+    }
+    /**
+     * Stream of all the futures that failed
+     */
+    asFailed() {
+        const pendingPromises = [];
+        const lookup = { pendingPromises };
+        const createPromises = R__namespace.once(() => {
+            lookup.pendingPromises = this.futures.map((future, index) => {
+                return future
+                    .run()
+                    .then(() => ({ index }))
+                    .catch(() => ({ future, index }));
+            });
+        });
+        return this.streamPendingFutures(lookup, createPromises);
+    }
+    /**
+     * Stream of all the futures that completed
+     */
+    asCompleted() {
+        const pendingPromises = [];
+        const lookup = { pendingPromises };
+        const createPromises = R__namespace.once(() => {
+            lookup.pendingPromises = this.futures.map((future, index) => {
+                return future
+                    .run()
+                    .then(() => ({ index, future }))
+                    .catch(() => ({ index }));
+            });
+        });
+        return this.streamPendingFutures(lookup, createPromises);
+    }
+    /**
+     * Stream of all the futures either completed or failed
+     */
+    asSettled() {
+        const pendingPromises = [];
+        const lookup = { pendingPromises };
+        const createPromises = R__namespace.once(() => {
+            lookup.pendingPromises = this.futures.map((future, index) => {
+                return future
+                    .run()
+                    .then(() => ({ index, future }))
+                    .catch(() => ({ index, future }));
+            });
+        });
+        return this.streamPendingFutures(lookup, createPromises);
+    }
+    /**
+     * Waits for all the futures to run and either complete or fail
+     */
+    allSettled() {
+        return this.closedEvent
+            .wait()
+            .thenApply(() => future.Future.collectSettled(this.futures))
+            .thenApply(() => this);
+    }
+    /**
+     * Cancels every running future that is in the group
+     */
+    cancel() {
+        this.futures.forEach((future) => future.cancel());
+    }
+    streamPendingFutures(lookup, setup) {
+        return new stream.Stream(() => {
+            setup();
+            if (!lookup.pendingPromises.length) {
+                return new stream_state.ExecutorState(true);
+            }
+            return this.closedEvent.wait().thenApply(() => Promise.any(lookup.pendingPromises).then((result) => {
+                lookup.pendingPromises = lookup.pendingPromises.filter((_, index) => index !== result.index);
+                if (result.future) {
+                    return { future: result.future };
+                }
+                return undefined;
+            }));
+        });
+    }
+}
+
+exports.FutureGroup = FutureGroup;

package/future/group.d.ts

@@ -0,0 +1,82 @@
+import { Future } from "./future";
+import { Stream } from "../stream";
+/**
+ * Groups one or more futures for collective operations
+ */
+export declare class FutureGroup<T = any> {
+    readonly futures: Array<Future<T>>;
+    private readonly closedEvent;
+    constructor();
+    /**
+     * Check if the group can accept more futures
+     */
+    get open(): boolean;
+    /**
+     * Total number of futures that completed
+     */
+    get totalCompleted(): number;
+    /**
+     * Total number of futures that failed
+     */
+    get totalFailed(): number;
+    /**
+     * Total number of futures current executing
+     */
+    get totalRunning(): number;
+    /**
+     * Adds a future to the group
+     * @param future
+     */
+    add(future: Future<T>): void;
+    /**
+     * Marks the group as closed, indicating that all the necessary futures to monitor have been added
+     */
+    done(): void;
+    /**
+     * Waits for all the futures in the group to complete
+     */
+    allCompleted(): Future<FutureGroup>;
+    /**
+     * Waits for all the futures to complete and collect the results in an array
+     */
+    collect(): Future<T[]>;
+    /**
+     * Waits for the first future to complete
+     */
+    firstCompleted(): Future<{
+        future: Future<T>;
+    }>;
+    /**
+     * Waits for the first future to fail
+     */
+    firstFailed(): Future<{
+        future: Future<T>;
+    }>;
+    /**
+     * Stream of all the futures that failed
+     */
+    asFailed(): Stream<{
+        future: Future<T>;
+    }>;
+    /**
+     * Stream of all the futures that completed
+     */
+    asCompleted(): Stream<{
+        future: Future<T>;
+    }>;
+    /**
+     * Stream of all the futures either completed or failed
+     */
+    asSettled(): Stream<{
+        future: Future<T>;
+    }>;
+    /**
+     * Waits for all the futures to run and either complete or fail
+     */
+    allSettled(): Future<FutureGroup>;
+    /**
+     * Cancels every running future that is in the group
+     */
+    cancel(): void;
+    private streamPendingFutures;
+}

package/future/group.mjs

@@ -0,0 +1,159 @@
+import * as R from 'ramda';
+import { Future } from './future.mjs';
+import { FutureEvent } from '../synchronize.mjs';
+import { Stream } from '../stream.mjs';
+import { ExecutorState } from '../stream/state.mjs';
+
+/**
+ * Groups one or more futures for collective operations
+ */
+class FutureGroup {
+    constructor() {
+        this.futures = [];
+        this.closedEvent = new FutureEvent();
+    }
+    /**
+     * Check if the group can accept more futures
+     */
+    get open() {
+        return !this.closedEvent.isSet;
+    }
+    /**
+     * Total number of futures that completed
+     */
+    get totalCompleted() {
+        return this.futures.reduce((total, future) => total + (future.done ? 1 : 0), 0);
+    }
+    /**
+     * Total number of futures that failed
+     */
+    get totalFailed() {
+        return this.futures.reduce((total, future) => total + (future.error ? 1 : 0), 0);
+    }
+    /**
+     * Total number of futures current executing
+     */
+    get totalRunning() {
+        return this.futures.reduce((total, future) => total + (future.running ? 1 : 0), 0);
+    }
+    /**
+     * Adds a future to the group
+     * @param future
+     */
+    add(future) {
+        this.futures.push(future);
+    }
+    /**
+     * Marks the group as closed, indicating that all the necessary futures to monitor have been added
+     */
+    done() {
+        this.closedEvent.set();
+    }
+    /**
+     * Waits for all the futures in the group to complete
+     */
+    allCompleted() {
+        return this.closedEvent
+            .wait()
+            .thenApply(() => Future.collect(this.futures))
+            .thenApply(() => this);
+    }
+    /**
+     * Waits for all the futures to complete and collect the results in an array
+     */
+    collect() {
+        return this.closedEvent.wait().thenApply(() => Future.collect(this.futures));
+    }
+    /**
+     * Waits for the first future to complete
+     */
+    firstCompleted() {
+        return this.asCompleted().future;
+    }
+    /**
+     * Waits for the first future to fail
+     */
+    firstFailed() {
+        return this.asFailed().future;
+    }
+    /**
+     * Stream of all the futures that failed
+     */
+    asFailed() {
+        const pendingPromises = [];
+        const lookup = { pendingPromises };
+        const createPromises = R.once(() => {
+            lookup.pendingPromises = this.futures.map((future, index) => {
+                return future
+                    .run()
+                    .then(() => ({ index }))
+                    .catch(() => ({ future, index }));
+            });
+        });
+        return this.streamPendingFutures(lookup, createPromises);
+    }
+    /**
+     * Stream of all the futures that completed
+     */
+    asCompleted() {
+        const pendingPromises = [];
+        const lookup = { pendingPromises };
+        const createPromises = R.once(() => {
+            lookup.pendingPromises = this.futures.map((future, index) => {
+                return future
+                    .run()
+                    .then(() => ({ index, future }))
+                    .catch(() => ({ index }));
+            });
+        });
+        return this.streamPendingFutures(lookup, createPromises);
+    }
+    /**
+     * Stream of all the futures either completed or failed
+     */
+    asSettled() {
+        const pendingPromises = [];
+        const lookup = { pendingPromises };
+        const createPromises = R.once(() => {
+            lookup.pendingPromises = this.futures.map((future, index) => {
+                return future
+                    .run()
+                    .then(() => ({ index, future }))
+                    .catch(() => ({ index, future }));
+            });
+        });
+        return this.streamPendingFutures(lookup, createPromises);
+    }
+    /**
+     * Waits for all the futures to run and either complete or fail
+     */
+    allSettled() {
+        return this.closedEvent
+            .wait()
+            .thenApply(() => Future.collectSettled(this.futures))
+            .thenApply(() => this);
+    }
+    /**
+     * Cancels every running future that is in the group
+     */
+    cancel() {
+        this.futures.forEach((future) => future.cancel());
+    }
+    streamPendingFutures(lookup, setup) {
+        return new Stream(() => {
+            setup();
+            if (!lookup.pendingPromises.length) {
+                return new ExecutorState(true);
+            }
+            return this.closedEvent.wait().thenApply(() => Promise.any(lookup.pendingPromises).then((result) => {
+                lookup.pendingPromises = lookup.pendingPromises.filter((_, index) => index !== result.index);
+                if (result.future) {
+                    return { future: result.future };
+                }
+                return undefined;
+            }));
+        });
+    }
+}
+
+export { FutureGroup };

package/future/index.d.ts

@@ -0,0 +1,3 @@
+export { Future, WaitPeriod } from "./future";
+export { FutureResult } from "./result";
+export { FutureGroup } from "./group";

package/future/result.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+/**
+ * Result returned when 1 step of a future completes and the result is passed on to the next step in the future
+ * (thenApply)
+ */
+class FutureResult {
+    /**
+     *
+     * @param value The returned value from teh previous step in the future
+     * @param signal the future signal
+     */
+    constructor(value, signal) {
+        this.value = value;
+        this.signal = signal;
+    }
+}
+
+exports.FutureResult = FutureResult;

package/future/result.d.ts

@@ -0,0 +1,18 @@
+import { Future } from "./future";
+import { InferStreamResult } from "../typing/types";
+import { Stream } from "../stream";
+export type InferredFutureResult<T> = T extends FutureResult<infer U> ? InferredFutureResult<U> : T extends Promise<infer U> ? InferredFutureResult<U> : T extends Future<infer U> ? InferredFutureResult<U> : T extends Stream<any> ? InferStreamResult<T> : T;
+/**
+ * Result returned when 1 step of a future completes and the result is passed on to the next step in the future
+ * (thenApply)
+ */
+export declare class FutureResult<T> {
+    readonly value: T;
+    readonly signal: AbortSignal;
+    /**
+     *
+     * @param value The returned value from teh previous step in the future
+     * @param signal the future signal
+     */
+    constructor(value: T, signal: AbortSignal);
+}

package/future/result.mjs

@@ -0,0 +1,17 @@
+/**
+ * Result returned when 1 step of a future completes and the result is passed on to the next step in the future
+ * (thenApply)
+ */
+class FutureResult {
+    /**
+     *
+     * @param value The returned value from teh previous step in the future
+     * @param signal the future signal
+     */
+    constructor(value, signal) {
+        this.value = value;
+        this.signal = signal;
+    }
+}
+
+export { FutureResult };

package/future.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var future = require('./future/future.cjs');
+var result = require('./future/result.cjs');
+var group = require('./future/group.cjs');
+
+
+
+exports.Future = future.Future;
+exports.FutureResult = result.FutureResult;
+exports.FutureGroup = group.FutureGroup;

package/future.mjs

@@ -0,0 +1,3 @@
+export { Future } from './future/future.mjs';
+export { FutureResult } from './future/result.mjs';
+export { FutureGroup } from './future/group.mjs';

package/managers/context.d.ts

@@ -0,0 +1,8 @@
+import { Future, FutureResult } from "../future";
+/**
+ * Context managers allow you to allocate and release resources irrespective of
+ * an executor failing to complete successfully
+ */
+export interface ContextManager<T> {
+    with: (functor: (value: FutureResult<T>) => any) => Future<any>;
+}

package/managers/index.d.ts

@@ -0,0 +1 @@
+export * from "./context";

package/managers.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/managers.mjs

@@ -0,0 +1 @@
+