gingersnap 0.22.0

package/functools/index.d.ts

@@ -0,0 +1,31 @@
+import { Stream } from "../stream";
+import { Future } from "../future";
+/**
+ * Returns true if all elements of the stream match the predicate, false if there are any that don't.
+ */
+export declare const all: <T>(predicate: (v: T) => boolean | Future<boolean>, stream: Stream<T>) => Future<boolean>;
+/**
+ * Returns a new stream containing the contents of the given stream, followed by the given element.
+ */
+export declare const append: <T>(value: T | Future<T>, stream: Stream<T>) => Stream<T>;
+/**
+ * Returns a new stream with the given element at the front, followed by the contents of the stream.
+ */
+export declare const prepend: <T>(value: T | Future<T>, stream: Stream<T>) => Stream<T>;
+/**
+ * Returns the result of concatenating the given streams.
+ */
+export declare const concat: <T>(value: Stream<T>, stream: Stream<T>) => Stream<T>;
+export declare const head: <T>(stream: Stream<T>) => Future<T>;
+export declare const tail: <T>(stream: Stream<T>) => Future<T>;
+export declare const filter: <T>(predicate: (v: T) => boolean | Future<boolean>, stream: Stream<T>) => Stream<T>;
+export declare const map: <T, V>(predicate: (v: T) => V | Future<V>, stream: Stream<T>) => Stream<import("../typing/types").InferStreamResult<V>>;
+export declare const insert: <T>(index: number, value: T | Future<T>, stream: Stream<T>) => Stream<T>;
+export declare const insertAll: <T>(index: number, value: Future<T>[] | Stream<T> | T[], stream: Stream<T>) => Stream<T>;
+export declare const slice: <T>(start: number, end: number, stream: Stream<T>) => Stream<T>;
+export declare const repeat: <T>(value: Future<T>, count: number) => Stream<T>;
+export declare const join: (separator: string, stream: Stream<string>) => Future<string>;
+export declare const without: <T>(value: T[] | Future<T[]>, stream: Stream<T>) => Stream<T> | Stream<Awaited<T>>;
+export declare const repeatUntilSuccess: <T>(retries: number, waitPeriodInSeconds: number, backoffFactor: number, functor: () => Future<T>) => Future<T>;
+export declare const range: (start: number, stop?: number | undefined, step?: number) => Stream<number>;
+export declare const nth: <T>(index: number, stream: Stream<T>) => Future<T>;

package/functools.cjs

@@ -0,0 +1,371 @@
+'use strict';
+
+var _tslib = require('./_virtual/_tslib.cjs');
+var R = require('ramda');
+var stream = require('./stream.cjs');
+var future = require('./future/future.cjs');
+var stream_collector = require('./stream/collector.cjs');
+var FutureCancelled = require('./errors/FutureCancelled.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);
+
+/**
+ * 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__namespace.equals(true))
+    .take(1)
+    .collect(stream_collector.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$1) => {
+    return stream.Stream.of(function (signal) {
+        return _tslib.__asyncGenerator(this, arguments, function* () {
+            var _a, e_1, _b, _c;
+            stream$1.cancelOnSignal(signal);
+            try {
+                for (var _d = true, stream_1 = _tslib.__asyncValues(stream$1), stream_1_1; stream_1_1 = yield _tslib.__await(stream_1.next()), _a = stream_1_1.done, !_a;) {
+                    _c = stream_1_1.value;
+                    _d = false;
+                    try {
+                        const data = _c;
+                        yield yield _tslib.__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 _tslib.__await(_b.call(stream_1));
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            if (value instanceof future.Future) {
+                yield yield _tslib.__await(yield _tslib.__await(value));
+            }
+            else {
+                yield yield _tslib.__await(value);
+            }
+        });
+    });
+};
+/**
+ * Returns a new stream with the given element at the front, followed by the contents of the stream.
+ */
+const prepend = (value, stream$1) => {
+    return stream.Stream.of(function (signal) {
+        return _tslib.__asyncGenerator(this, arguments, function* () {
+            var _a, e_2, _b, _c;
+            stream$1.cancelOnSignal(signal);
+            if (value instanceof future.Future) {
+                yield yield _tslib.__await(yield _tslib.__await(value));
+            }
+            else {
+                yield yield _tslib.__await(value);
+            }
+            try {
+                for (var _d = true, stream_2 = _tslib.__asyncValues(stream$1), stream_2_1; stream_2_1 = yield _tslib.__await(stream_2.next()), _a = stream_2_1.done, !_a;) {
+                    _c = stream_2_1.value;
+                    _d = false;
+                    try {
+                        const data = _c;
+                        yield yield _tslib.__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 _tslib.__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$1) => {
+    return stream.Stream.of(function (signal) {
+        return _tslib.__asyncGenerator(this, arguments, function* () {
+            var _a, e_3, _b, _c, _d, e_4, _e, _f;
+            value.cancelOnSignal(signal);
+            stream$1.cancelOnSignal(signal);
+            try {
+                for (var _g = true, value_1 = _tslib.__asyncValues(value), value_1_1; value_1_1 = yield _tslib.__await(value_1.next()), _a = value_1_1.done, !_a;) {
+                    _c = value_1_1.value;
+                    _g = false;
+                    try {
+                        const data = _c;
+                        yield yield _tslib.__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 _tslib.__await(_b.call(value_1));
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            try {
+                for (var _h = true, stream_3 = _tslib.__asyncValues(stream$1), stream_3_1; stream_3_1 = yield _tslib.__await(stream_3.next()), _d = stream_3_1.done, !_d;) {
+                    _f = stream_3_1.value;
+                    _h = false;
+                    try {
+                        const data = _f;
+                        yield yield _tslib.__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 _tslib.__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$1) => stream.Stream.of(function (signal) {
+    return _tslib.__asyncGenerator(this, arguments, function* () {
+        var _a, e_5, _b, _c;
+        stream$1.cancelOnSignal(signal);
+        let i = -1;
+        let inserted = false;
+        try {
+            for (var _d = true, stream_4 = _tslib.__asyncValues(stream$1), stream_4_1; stream_4_1 = yield _tslib.__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.Future) {
+                            yield yield _tslib.__await(yield _tslib.__await(value));
+                        }
+                        else {
+                            yield yield _tslib.__await(value);
+                        }
+                    }
+                    yield yield _tslib.__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 _tslib.__await(_b.call(stream_4));
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+    });
+});
+const insertAll = (index, value, stream$1) => stream.Stream.of(function (signal) {
+    return _tslib.__asyncGenerator(this, arguments, function* () {
+        var _a, e_6, _b, _c, _d, e_7, _e, _f;
+        stream$1.cancelOnSignal(signal);
+        let i = -1;
+        let inserted = false;
+        try {
+            for (var _g = true, stream_5 = _tslib.__asyncValues(stream$1), stream_5_1; stream_5_1 = yield _tslib.__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.Stream) {
+                            value.cancelOnSignal(signal);
+                            try {
+                                for (var _h = true, value_2 = (e_7 = void 0, _tslib.__asyncValues(value)), value_2_1; value_2_1 = yield _tslib.__await(value_2.next()), _d = value_2_1.done, !_d;) {
+                                    _f = value_2_1.value;
+                                    _h = false;
+                                    try {
+                                        const data = _f;
+                                        yield yield _tslib.__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 _tslib.__await(_e.call(value_2));
+                                }
+                                finally { if (e_7) throw e_7.error; }
+                            }
+                        }
+                        else {
+                            for (const data of value) {
+                                if (data instanceof future.Future) {
+                                    yield yield _tslib.__await(yield _tslib.__await(data));
+                                }
+                                else {
+                                    yield yield _tslib.__await(data);
+                                }
+                            }
+                        }
+                    }
+                    yield yield _tslib.__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 _tslib.__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.Stream.of(function (signal) {
+    return _tslib.__asyncGenerator(this, arguments, function* () {
+        const result = yield _tslib.__await(value.registerSignal(signal));
+        for (let i = 0; i < count; i++) {
+            yield yield _tslib.__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$1) => value instanceof future.Future
+    ? stream.Stream.of(function (signal) {
+        return _tslib.__asyncGenerator(this, arguments, function* () {
+            var _a, e_8, _b, _c;
+            const result = yield _tslib.__await(value.registerSignal(signal));
+            try {
+                for (var _d = true, _e = _tslib.__asyncValues(stream$1.filter((v) => !result.includes(v))), _f; _f = yield _tslib.__await(_e.next()), _a = _f.done, !_a;) {
+                    _c = _f.value;
+                    _d = false;
+                    try {
+                        const v = _c;
+                        yield yield _tslib.__await(v);
+                    }
+                    finally {
+                        _d = true;
+                    }
+                }
+            }
+            catch (e_8_1) { e_8 = { error: e_8_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield _tslib.__await(_b.call(_e));
+                }
+                finally { if (e_8) throw e_8.error; }
+            }
+        });
+    })
+    : stream$1.filter((v) => !value.includes(v));
+const repeatUntilSuccess = (retries, waitPeriodInSeconds, backoffFactor, functor) => future.Future.of((_, __, signal) => _tslib.__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.Future.sleep({ seconds: waitPeriod });
+            waitPeriod *= backoffFactor;
+        }
+    }
+    throw lastError || new FutureCancelled.FutureCancelled();
+}));
+const range = (start, stop = undefined, step = 1) => stream.Stream.of(function (signal) {
+    return _tslib.__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 _tslib.__await(i);
+        }
+    });
+});
+const nth = (index, stream) => stream.skip(index).future;
+
+exports.all = all;
+exports.append = append;
+exports.concat = concat;
+exports.filter = filter;
+exports.head = head;
+exports.insert = insert;
+exports.insertAll = insertAll;
+exports.join = join;
+exports.map = map;
+exports.nth = nth;
+exports.prepend = prepend;
+exports.range = range;
+exports.repeat = repeat;
+exports.repeatUntilSuccess = repeatUntilSuccess;
+exports.slice = slice;
+exports.tail = tail;
+exports.without = without;