gingersnap 0.22.0

package/functools.mjs

@@ -0,0 +1,334 @@
+import { __asyncGenerator, __awaiter, __asyncValues, __await } from './_virtual/_tslib.mjs';
+import * as R from 'ramda';
+import { Stream } from './stream.mjs';
+import { Future } from './future/future.mjs';
+import { Collectors } from './stream/collector.mjs';
+import { FutureCancelled } from './errors/FutureCancelled.mjs';
+
+/**
+ * Returns true if all elements of the stream match the predicate, false if there are any that don't.
+ */
+const all = (predicate, stream) => stream
+    .map(predicate)
+    .skipWhile(R.equals(true))
+    .take(1)
+    .collect(Collectors.counting())
+    .thenApply(({ value }) => value === 0);
+/**
+ * Returns a new stream containing the contents of the given stream, followed by the given element.
+ */
+const append = (value, stream) => {
+    return Stream.of(function (signal) {
+        return __asyncGenerator(this, arguments, function* () {
+            var _a, e_1, _b, _c;
+            stream.cancelOnSignal(signal);
+            try {
+                for (var _d = true, stream_1 = __asyncValues(stream), stream_1_1; stream_1_1 = yield __await(stream_1.next()), _a = stream_1_1.done, !_a;) {
+                    _c = stream_1_1.value;
+                    _d = false;
+                    try {
+                        const data = _c;
+                        yield yield __await(data);
+                    }
+                    finally {
+                        _d = true;
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = stream_1.return)) yield __await(_b.call(stream_1));
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            if (value instanceof Future) {
+                yield yield __await(yield __await(value));
+            }
+            else {
+                yield yield __await(value);
+            }
+        });
+    });
+};
+/**
+ * Returns a new stream with the given element at the front, followed by the contents of the stream.
+ */
+const prepend = (value, stream) => {
+    return Stream.of(function (signal) {
+        return __asyncGenerator(this, arguments, function* () {
+            var _a, e_2, _b, _c;
+            stream.cancelOnSignal(signal);
+            if (value instanceof Future) {
+                yield yield __await(yield __await(value));
+            }
+            else {
+                yield yield __await(value);
+            }
+            try {
+                for (var _d = true, stream_2 = __asyncValues(stream), stream_2_1; stream_2_1 = yield __await(stream_2.next()), _a = stream_2_1.done, !_a;) {
+                    _c = stream_2_1.value;
+                    _d = false;
+                    try {
+                        const data = _c;
+                        yield yield __await(data);
+                    }
+                    finally {
+                        _d = true;
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = stream_2.return)) yield __await(_b.call(stream_2));
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        });
+    });
+};
+/**
+ * Returns the result of concatenating the given streams.
+ */
+const concat = (value, stream) => {
+    return Stream.of(function (signal) {
+        return __asyncGenerator(this, arguments, function* () {
+            var _a, e_3, _b, _c, _d, e_4, _e, _f;
+            value.cancelOnSignal(signal);
+            stream.cancelOnSignal(signal);
+            try {
+                for (var _g = true, value_1 = __asyncValues(value), value_1_1; value_1_1 = yield __await(value_1.next()), _a = value_1_1.done, !_a;) {
+                    _c = value_1_1.value;
+                    _g = false;
+                    try {
+                        const data = _c;
+                        yield yield __await(data);
+                    }
+                    finally {
+                        _g = true;
+                    }
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (!_g && !_a && (_b = value_1.return)) yield __await(_b.call(value_1));
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            try {
+                for (var _h = true, stream_3 = __asyncValues(stream), stream_3_1; stream_3_1 = yield __await(stream_3.next()), _d = stream_3_1.done, !_d;) {
+                    _f = stream_3_1.value;
+                    _h = false;
+                    try {
+                        const data = _f;
+                        yield yield __await(data);
+                    }
+                    finally {
+                        _h = true;
+                    }
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (!_h && !_d && (_e = stream_3.return)) yield __await(_e.call(stream_3));
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+        });
+    });
+};
+const head = (stream) => stream.head().execute();
+const tail = (stream) => stream.tail().execute();
+const filter = (predicate, stream) => stream.filter(predicate);
+const map = (predicate, stream) => stream.map(predicate);
+const insert = (index, value, stream) => Stream.of(function (signal) {
+    return __asyncGenerator(this, arguments, function* () {
+        var _a, e_5, _b, _c;
+        stream.cancelOnSignal(signal);
+        let i = -1;
+        let inserted = false;
+        try {
+            for (var _d = true, stream_4 = __asyncValues(stream), stream_4_1; stream_4_1 = yield __await(stream_4.next()), _a = stream_4_1.done, !_a;) {
+                _c = stream_4_1.value;
+                _d = false;
+                try {
+                    const data = _c;
+                    if (!inserted) {
+                        i++;
+                    }
+                    if (i === index) {
+                        inserted = true;
+                        if (value instanceof Future) {
+                            yield yield __await(yield __await(value));
+                        }
+                        else {
+                            yield yield __await(value);
+                        }
+                    }
+                    yield yield __await(data);
+                }
+                finally {
+                    _d = true;
+                }
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = stream_4.return)) yield __await(_b.call(stream_4));
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+    });
+});
+const insertAll = (index, value, stream) => Stream.of(function (signal) {
+    return __asyncGenerator(this, arguments, function* () {
+        var _a, e_6, _b, _c, _d, e_7, _e, _f;
+        stream.cancelOnSignal(signal);
+        let i = -1;
+        let inserted = false;
+        try {
+            for (var _g = true, stream_5 = __asyncValues(stream), stream_5_1; stream_5_1 = yield __await(stream_5.next()), _a = stream_5_1.done, !_a;) {
+                _c = stream_5_1.value;
+                _g = false;
+                try {
+                    const data = _c;
+                    if (!inserted) {
+                        i++;
+                    }
+                    if (i === index) {
+                        inserted = true;
+                        if (value instanceof Stream) {
+                            value.cancelOnSignal(signal);
+                            try {
+                                for (var _h = true, value_2 = (e_7 = void 0, __asyncValues(value)), value_2_1; value_2_1 = yield __await(value_2.next()), _d = value_2_1.done, !_d;) {
+                                    _f = value_2_1.value;
+                                    _h = false;
+                                    try {
+                                        const data = _f;
+                                        yield yield __await(data);
+                                    }
+                                    finally {
+                                        _h = true;
+                                    }
+                                }
+                            }
+                            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                            finally {
+                                try {
+                                    if (!_h && !_d && (_e = value_2.return)) yield __await(_e.call(value_2));
+                                }
+                                finally { if (e_7) throw e_7.error; }
+                            }
+                        }
+                        else {
+                            for (const data of value) {
+                                if (data instanceof Future) {
+                                    yield yield __await(yield __await(data));
+                                }
+                                else {
+                                    yield yield __await(data);
+                                }
+                            }
+                        }
+                    }
+                    yield yield __await(data);
+                }
+                finally {
+                    _g = true;
+                }
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (!_g && !_a && (_b = stream_5.return)) yield __await(_b.call(stream_5));
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+    });
+});
+const slice = (start, end, stream) => stream.skip(start).take(end - start);
+const repeat = (value, count) => Stream.of(function (signal) {
+    return __asyncGenerator(this, arguments, function* () {
+        const result = yield __await(value.registerSignal(signal));
+        for (let i = 0; i < count; i++) {
+            yield yield __await(result);
+        }
+    });
+});
+const join = (separator, stream) => {
+    let result = "";
+    return stream
+        .forEach((value) => {
+        result += value + separator;
+    })
+        .thenApply(() => {
+        if (result !== "") {
+            return result.substring(0, result.lastIndexOf(separator));
+        }
+        return result;
+    });
+};
+const without = (value, stream) => value instanceof Future
+    ? Stream.of(function (signal) {
+        return __asyncGenerator(this, arguments, function* () {
+            var _a, e_8, _b, _c;
+            const result = yield __await(value.registerSignal(signal));
+            try {
+                for (var _d = true, _e = __asyncValues(stream.filter((v) => !result.includes(v))), _f; _f = yield __await(_e.next()), _a = _f.done, !_a;) {
+                    _c = _f.value;
+                    _d = false;
+                    try {
+                        const v = _c;
+                        yield yield __await(v);
+                    }
+                    finally {
+                        _d = true;
+                    }
+                }
+            }
+            catch (e_8_1) { e_8 = { error: e_8_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
+                }
+                finally { if (e_8) throw e_8.error; }
+            }
+        });
+    })
+    : stream.filter((v) => !value.includes(v));
+const repeatUntilSuccess = (retries, waitPeriodInSeconds, backoffFactor, functor) => Future.of((_, __, signal) => __awaiter(void 0, void 0, void 0, function* () {
+    let lastError;
+    let i = 0;
+    let waitPeriod = waitPeriodInSeconds;
+    while (i < retries && !signal.aborted) {
+        try {
+            return yield functor().registerSignal(signal);
+        }
+        catch (e) {
+            lastError = e;
+            i++;
+            yield Future.sleep({ seconds: waitPeriod });
+            waitPeriod *= backoffFactor;
+        }
+    }
+    throw lastError || new FutureCancelled();
+}));
+const range = (start, stop = undefined, step = 1) => Stream.of(function (signal) {
+    return __asyncGenerator(this, arguments, function* () {
+        const begin = stop === undefined ? 0 : start;
+        const end = stop !== null && stop !== void 0 ? stop : start;
+        for (let i = begin; i < end; i += step) {
+            if (signal.aborted)
+                break;
+            yield yield __await(i);
+        }
+    });
+});
+const nth = (index, stream) => stream.skip(index).future;
+
+export { all, append, concat, filter, head, insert, insertAll, join, map, nth, prepend, range, repeat, repeatUntilSuccess, slice, tail, without };