@naturalcycles/js-lib 14.197.0 → 14.199.0

package/dist/array/array.util.d.ts

@@ -171,3 +171,4 @@ export declare function _maxBy<T>(array: T[], mapper: Mapper<T, number | undefin
 export declare function _minBy<T>(array: T[], mapper: Mapper<T, number | undefined>): T;
 export declare function _maxByOrUndefined<T>(array: T[], mapper: Mapper<T, number | undefined>): T | undefined;
 export declare function _minByOrUndefined<T>(array: T[], mapper: Mapper<T, number | undefined>): T | undefined;
+export declare function _zip<T1, T2>(array1: T1[], array2: T2[]): [T1, T2][];

package/dist/array/array.util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._minByOrUndefined = exports._maxByOrUndefined = exports._minBy = exports._maxBy = exports._max = exports._maxOrUndefined = exports._min = exports._minOrUndefined = exports._lastOrUndefined = exports._last = exports._shuffle = exports._mapToObject = exports._sumBy = exports._sum = exports._difference = exports._intersection = exports._countBy = exports._dropRightWhile = exports._dropWhile = exports._takeRightWhile = exports._takeWhile = exports._findLast = exports._sortDescBy = exports._sortBy = exports._groupBy = exports._mapBy = exports._by = exports._uniqBy = exports._pushUniqBy = exports._pushUniq = exports._uniq = exports._chunk = void 0;
+exports._zip = exports._minByOrUndefined = exports._maxByOrUndefined = exports._minBy = exports._maxBy = exports._max = exports._maxOrUndefined = exports._min = exports._minOrUndefined = exports._lastOrUndefined = exports._last = exports._shuffle = exports._mapToObject = exports._sumBy = exports._sum = exports._difference = exports._intersection = exports._countBy = exports._dropRightWhile = exports._dropWhile = exports._takeRightWhile = exports._takeWhile = exports._findLast = exports._sortDescBy = exports._sortBy = exports._groupBy = exports._mapBy = exports._by = exports._uniqBy = exports._pushUniqBy = exports._pushUniq = exports._uniq = exports._chunk = void 0;
 const is_util_1 = require("../is.util");
 /**
  * Creates an array of elements split into groups the length of size. If collection can’t be split evenly, the
@@ -378,3 +378,12 @@ function _minByOrUndefined(array, mapper) {
     return minItem;
 }
 exports._minByOrUndefined = _minByOrUndefined;
+function _zip(array1, array2) {
+    const len = Math.min(array1.length, array2.length);
+    const res = [];
+    for (let i = 0; i < len; i++) {
+        res.push([array1[i], array2[i]]);
+    }
+    return res;
+}
+exports._zip = _zip;

package/dist/array/range.d.ts

@@ -1,3 +1,4 @@
+import { AsyncIterable2 } from '../iter/asyncIterable2';
 import { Iterable2 } from '../iter/iterable2';
 /**
  * Returns an array with ranges from `from` up to (but not including) `to`.
@@ -14,5 +15,10 @@ export declare function _range(fromIncl: number, toExcl: number, step?: number):
 /**
  * Like _range, but returns an Iterable2.
  */
-export declare function _rangeIt(toExcl: number): Iterable2<number>;
-export declare function _rangeIt(fromIncl: number, toExcl: number, step?: number): Iterable2<number>;
+export declare function _rangeIterable(toExcl: number): Iterable2<number>;
+export declare function _rangeIterable(fromIncl: number, toExcl: number, step?: number): Iterable2<number>;
+/**
+ * Like _range, but returns an AsyncIterable2.
+ */
+export declare function _rangeAsyncIterable(toExcl: number): AsyncIterable2<number>;
+export declare function _rangeAsyncIterable(fromIncl: number, toExcl: number, step?: number): AsyncIterable2<number>;

package/dist/array/range.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._rangeIt = exports._range = void 0;
+exports._rangeAsyncIterable = exports._rangeIterable = exports._range = void 0;
+const asyncIterable2_1 = require("../iter/asyncIterable2");
 const iterable2_1 = require("../iter/iterable2");
 function _range(fromIncl, toExcl, step = 1) {
     if (toExcl === undefined) {
@@ -9,7 +10,7 @@ function _range(fromIncl, toExcl, step = 1) {
     return Array.from({ length: Math.ceil((toExcl - fromIncl) / step) }, (_, i) => i * step + fromIncl);
 }
 exports._range = _range;
-function _rangeIt(fromIncl, toExcl, step = 1) {
+function _rangeIterable(fromIncl, toExcl, step = 1) {
     if (toExcl === undefined) {
         toExcl = fromIncl;
         fromIncl = 0;
@@ -22,4 +23,18 @@ function _rangeIt(fromIncl, toExcl, step = 1) {
         },
     });
 }
-exports._rangeIt = _rangeIt;
+exports._rangeIterable = _rangeIterable;
+function _rangeAsyncIterable(fromIncl, toExcl, step = 1) {
+    if (toExcl === undefined) {
+        toExcl = fromIncl;
+        fromIncl = 0;
+    }
+    return asyncIterable2_1.AsyncIterable2.of({
+        async *[Symbol.asyncIterator]() {
+            for (let i = fromIncl; i < toExcl; i += step) {
+                yield i;
+            }
+        },
+    });
+}
+exports._rangeAsyncIterable = _rangeAsyncIterable;

package/dist/datetime/localDate.d.ts

@@ -133,7 +133,7 @@ export declare function localDateRange(min: LocalDateInput, max: LocalDateInput,
 /**
  * Experimental, returns the range as Iterable2.
  */
-export declare function localDateRangeIt(min: LocalDateInput, max: LocalDateInput, incl?: Inclusiveness, step?: number, stepUnit?: LocalDateUnit): Iterable2<LocalDate>;
+export declare function localDateRangeIterable(min: LocalDateInput, max: LocalDateInput, incl?: Inclusiveness, step?: number, stepUnit?: LocalDateUnit): Iterable2<LocalDate>;
 /**
  * Convenience wrapper around `LocalDate.of`
  */

package/dist/datetime/localDate.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.localDateOrToday = exports.localDateOrUndefined = exports.localDateToday = exports.localDate = exports.localDateRangeIt = exports.localDateRange = exports.LocalDate = void 0;
+exports.localDateOrToday = exports.localDateOrUndefined = exports.localDateToday = exports.localDate = exports.localDateRangeIterable = exports.localDateRange = exports.LocalDate = void 0;
 const assert_1 = require("../error/assert");
 const iterable2_1 = require("../iter/iterable2");
 const localTime_1 = require("./localTime");
@@ -441,13 +441,13 @@ class LocalDate {
 }
 exports.LocalDate = LocalDate;
 function localDateRange(min, max, incl = '[)', step = 1, stepUnit = 'day') {
-    return localDateRangeIt(min, max, incl, step, stepUnit).toArray();
+    return localDateRangeIterable(min, max, incl, step, stepUnit).toArray();
 }
 exports.localDateRange = localDateRange;
 /**
  * Experimental, returns the range as Iterable2.
  */
-function localDateRangeIt(min, max, incl = '[)', step = 1, stepUnit = 'day') {
+function localDateRangeIterable(min, max, incl = '[)', step = 1, stepUnit = 'day') {
     if (stepUnit === 'week') {
         step *= 7;
         stepUnit = 'day';
@@ -474,7 +474,7 @@ function localDateRangeIt(min, max, incl = '[)', step = 1, stepUnit = 'day') {
         },
     });
 }
-exports.localDateRangeIt = localDateRangeIt;
+exports.localDateRangeIterable = localDateRangeIterable;
 /**
  * Convenience wrapper around `LocalDate.of`
  */

package/dist/index.d.ts

@@ -61,6 +61,7 @@ export * from './string/safeJsonStringify';
 export * from './promise/pQueue';
 export * from './promise/abortable';
 export * from './iter/iterable2';
+export * from './iter/asyncIterable2';
 export * from './math/stack.util';
 export * from './string/leven';
 export * from './datetime/localDate';

package/dist/index.js

@@ -65,6 +65,7 @@ tslib_1.__exportStar(require("./string/safeJsonStringify"), exports);
 tslib_1.__exportStar(require("./promise/pQueue"), exports);
 tslib_1.__exportStar(require("./promise/abortable"), exports);
 tslib_1.__exportStar(require("./iter/iterable2"), exports);
+tslib_1.__exportStar(require("./iter/asyncIterable2"), exports);
 tslib_1.__exportStar(require("./math/stack.util"), exports);
 tslib_1.__exportStar(require("./string/leven"), exports);
 tslib_1.__exportStar(require("./datetime/localDate"), exports);

package/dist/iter/asyncIterable2.d.ts

@@ -0,0 +1,27 @@
+import { Promisable } from '../typeFest';
+import { AbortableAsyncMapper, AbortableAsyncPredicate, END } from '../types';
+/**
+ * Similar to Iterable2, but for AsyncIterable.
+ *
+ * AsyncIterable2 is a wrapper around AsyncIterable that implements "Iterator Helpers proposal":
+ * https://github.com/tc39/proposal-iterator-helpers
+ *
+ * AsyncIterable2 can be removed after the proposal is widely implemented in Node & browsers.
+ *
+ * @experimental
+ */
+export declare class AsyncIterable2<T> implements AsyncIterable<T> {
+    private it;
+    private constructor();
+    static of<T>(it: AsyncIterable<T>): AsyncIterable2<T>;
+    static ofIterable<T>(it: Iterable<T>): AsyncIterable2<T>;
+    static empty<T>(): AsyncIterable2<T>;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    toArray(): Promise<T[]>;
+    forEach(cb: (v: T, i: number) => Promisable<any | typeof END>): Promise<void>;
+    some(cb: AbortableAsyncPredicate<T>): Promise<boolean>;
+    every(cb: AbortableAsyncPredicate<T>): Promise<boolean>;
+    find(cb: AbortableAsyncPredicate<T>): Promise<T | undefined>;
+    filter(cb: AbortableAsyncPredicate<T>): AsyncIterable2<T>;
+    map<OUT>(mapper: AbortableAsyncMapper<T, OUT>): AsyncIterable2<OUT>;
+}

package/dist/iter/asyncIterable2.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncIterable2 = void 0;
+const types_1 = require("../types");
+/**
+ * Similar to Iterable2, but for AsyncIterable.
+ *
+ * AsyncIterable2 is a wrapper around AsyncIterable that implements "Iterator Helpers proposal":
+ * https://github.com/tc39/proposal-iterator-helpers
+ *
+ * AsyncIterable2 can be removed after the proposal is widely implemented in Node & browsers.
+ *
+ * @experimental
+ */
+class AsyncIterable2 {
+    constructor(it) {
+        this.it = it;
+    }
+    static of(it) {
+        return new AsyncIterable2(it);
+    }
+    static ofIterable(it) {
+        return new AsyncIterable2({
+            async *[Symbol.asyncIterator]() {
+                yield* it;
+            },
+        });
+    }
+    static empty() {
+        return new AsyncIterable2({
+            async *[Symbol.asyncIterator]() { },
+        });
+    }
+    [Symbol.asyncIterator]() {
+        return this.it[Symbol.asyncIterator]();
+    }
+    async toArray() {
+        // todo: Array.fromAsync is not yet available, use that when it's ready
+        // return await Array.fromAsync(this.it)
+        const res = [];
+        for await (const item of this.it) {
+            res.push(item);
+        }
+        return res;
+    }
+    async forEach(cb) {
+        let i = 0;
+        for await (const v of this.it) {
+            if ((await cb(v, i++)) === types_1.END)
+                return;
+        }
+    }
+    async some(cb) {
+        return !!(await this.find(cb));
+    }
+    async every(cb) {
+        let i = 0;
+        for await (const v of this.it) {
+            const r = await cb(v, i++);
+            if (r === types_1.END || !r)
+                return false;
+        }
+        return true;
+    }
+    async find(cb) {
+        let i = 0;
+        for await (const v of this.it) {
+            const r = await cb(v, i++);
+            if (r === types_1.END)
+                return;
+            if (r)
+                return v;
+        }
+    }
+    filter(cb) {
+        const { it } = this;
+        return new AsyncIterable2({
+            async *[Symbol.asyncIterator]() {
+                let i = 0;
+                for await (const v of it) {
+                    const r = await cb(v, i++);
+                    if (r === types_1.END)
+                        return;
+                    if (r)
+                        yield v;
+                }
+            },
+        });
+    }
+    map(mapper) {
+        const { it } = this;
+        return new AsyncIterable2({
+            async *[Symbol.asyncIterator]() {
+                let i = 0;
+                for await (const v of it) {
+                    const r = await mapper(v, i++);
+                    if (r === types_1.END)
+                        return;
+                    if (r === types_1.SKIP)
+                        continue;
+                    yield r;
+                }
+            },
+        });
+    }
+}
+exports.AsyncIterable2 = AsyncIterable2;

package/dist-esm/array/array.util.js

@@ -343,3 +343,11 @@ export function _minByOrUndefined(array, mapper) {
     });
     return minItem;
 }
+export function _zip(array1, array2) {
+    const len = Math.min(array1.length, array2.length);
+    const res = [];
+    for (let i = 0; i < len; i++) {
+        res.push([array1[i], array2[i]]);
+    }
+    return res;
+}

package/dist-esm/array/range.js

@@ -1,3 +1,5 @@
+import { __asyncGenerator, __await } from "tslib";
+import { AsyncIterable2 } from '../iter/asyncIterable2';
 import { Iterable2 } from '../iter/iterable2';
 export function _range(fromIncl, toExcl, step = 1) {
     if (toExcl === undefined) {
@@ -5,7 +7,7 @@ export function _range(fromIncl, toExcl, step = 1) {
     }
     return Array.from({ length: Math.ceil((toExcl - fromIncl) / step) }, (_, i) => i * step + fromIncl);
 }
-export function _rangeIt(fromIncl, toExcl, step = 1) {
+export function _rangeIterable(fromIncl, toExcl, step = 1) {
     if (toExcl === undefined) {
         toExcl = fromIncl;
         fromIncl = 0;
@@ -18,3 +20,18 @@ export function _rangeIt(fromIncl, toExcl, step = 1) {
         },
     });
 }
+export function _rangeAsyncIterable(fromIncl, toExcl, step = 1) {
+    if (toExcl === undefined) {
+        toExcl = fromIncl;
+        fromIncl = 0;
+    }
+    return AsyncIterable2.of({
+        [Symbol.asyncIterator]() {
+            return __asyncGenerator(this, arguments, function* _a() {
+                for (let i = fromIncl; i < toExcl; i += step) {
+                    yield yield __await(i);
+                }
+            });
+        },
+    });
+}

package/dist-esm/datetime/localDate.js

@@ -437,12 +437,12 @@ export class LocalDate {
     }
 }
 export function localDateRange(min, max, incl = '[)', step = 1, stepUnit = 'day') {
-    return localDateRangeIt(min, max, incl, step, stepUnit).toArray();
+    return localDateRangeIterable(min, max, incl, step, stepUnit).toArray();
 }
 /**
  * Experimental, returns the range as Iterable2.
  */
-export function localDateRangeIt(min, max, incl = '[)', step = 1, stepUnit = 'day') {
+export function localDateRangeIterable(min, max, incl = '[)', step = 1, stepUnit = 'day') {
     if (stepUnit === 'week') {
         step *= 7;
         stepUnit = 'day';

package/dist-esm/index.js

@@ -61,6 +61,7 @@ export * from './string/safeJsonStringify';
 export * from './promise/pQueue';
 export * from './promise/abortable';
 export * from './iter/iterable2';
+export * from './iter/asyncIterable2';
 export * from './math/stack.util';
 export * from './string/leven';
 export * from './datetime/localDate';

package/dist-esm/iter/asyncIterable2.js

@@ -0,0 +1,188 @@
+import { __asyncDelegator, __asyncGenerator, __asyncValues, __await } from "tslib";
+import { END, SKIP } from '../types';
+/**
+ * Similar to Iterable2, but for AsyncIterable.
+ *
+ * AsyncIterable2 is a wrapper around AsyncIterable that implements "Iterator Helpers proposal":
+ * https://github.com/tc39/proposal-iterator-helpers
+ *
+ * AsyncIterable2 can be removed after the proposal is widely implemented in Node & browsers.
+ *
+ * @experimental
+ */
+export class AsyncIterable2 {
+    constructor(it) {
+        this.it = it;
+    }
+    static of(it) {
+        return new AsyncIterable2(it);
+    }
+    static ofIterable(it) {
+        return new AsyncIterable2({
+            [Symbol.asyncIterator]() {
+                return __asyncGenerator(this, arguments, function* _a() {
+                    yield __await(yield* __asyncDelegator(__asyncValues(it)));
+                });
+            },
+        });
+    }
+    static empty() {
+        return new AsyncIterable2({
+            [Symbol.asyncIterator]() { return __asyncGenerator(this, arguments, function* _a() { }); },
+        });
+    }
+    [Symbol.asyncIterator]() {
+        return this.it[Symbol.asyncIterator]();
+    }
+    async toArray() {
+        // todo: Array.fromAsync is not yet available, use that when it's ready
+        // return await Array.fromAsync(this.it)
+        var _a, e_1, _b, _c;
+        const res = [];
+        try {
+            for (var _d = true, _e = __asyncValues(this.it), _f; _f = await _e.next(), _a = _f.done, !_a; _d = true) {
+                _c = _f.value;
+                _d = false;
+                const item = _c;
+                res.push(item);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = _e.return)) await _b.call(_e);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return res;
+    }
+    async forEach(cb) {
+        var _a, e_2, _b, _c;
+        let i = 0;
+        try {
+            for (var _d = true, _e = __asyncValues(this.it), _f; _f = await _e.next(), _a = _f.done, !_a; _d = true) {
+                _c = _f.value;
+                _d = false;
+                const v = _c;
+                if ((await cb(v, i++)) === END)
+                    return;
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = _e.return)) await _b.call(_e);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    }
+    async some(cb) {
+        return !!(await this.find(cb));
+    }
+    async every(cb) {
+        var _a, e_3, _b, _c;
+        let i = 0;
+        try {
+            for (var _d = true, _e = __asyncValues(this.it), _f; _f = await _e.next(), _a = _f.done, !_a; _d = true) {
+                _c = _f.value;
+                _d = false;
+                const v = _c;
+                const r = await cb(v, i++);
+                if (r === END || !r)
+                    return false;
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = _e.return)) await _b.call(_e);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        return true;
+    }
+    async find(cb) {
+        var _a, e_4, _b, _c;
+        let i = 0;
+        try {
+            for (var _d = true, _e = __asyncValues(this.it), _f; _f = await _e.next(), _a = _f.done, !_a; _d = true) {
+                _c = _f.value;
+                _d = false;
+                const v = _c;
+                const r = await cb(v, i++);
+                if (r === END)
+                    return;
+                if (r)
+                    return v;
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = _e.return)) await _b.call(_e);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+    }
+    filter(cb) {
+        const { it } = this;
+        return new AsyncIterable2({
+            [Symbol.asyncIterator]() {
+                return __asyncGenerator(this, arguments, function* _a() {
+                    var _b, e_5, _c, _d;
+                    let i = 0;
+                    try {
+                        for (var _e = true, it_1 = __asyncValues(it), it_1_1; it_1_1 = yield __await(it_1.next()), _b = it_1_1.done, !_b; _e = true) {
+                            _d = it_1_1.value;
+                            _e = false;
+                            const v = _d;
+                            const r = yield __await(cb(v, i++));
+                            if (r === END)
+                                return yield __await(void 0);
+                            if (r)
+                                yield yield __await(v);
+                        }
+                    }
+                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                    finally {
+                        try {
+                            if (!_e && !_b && (_c = it_1.return)) yield __await(_c.call(it_1));
+                        }
+                        finally { if (e_5) throw e_5.error; }
+                    }
+                });
+            },
+        });
+    }
+    map(mapper) {
+        const { it } = this;
+        return new AsyncIterable2({
+            [Symbol.asyncIterator]() {
+                return __asyncGenerator(this, arguments, function* _a() {
+                    var _b, e_6, _c, _d;
+                    let i = 0;
+                    try {
+                        for (var _e = true, it_2 = __asyncValues(it), it_2_1; it_2_1 = yield __await(it_2.next()), _b = it_2_1.done, !_b; _e = true) {
+                            _d = it_2_1.value;
+                            _e = false;
+                            const v = _d;
+                            const r = yield __await(mapper(v, i++));
+                            if (r === END)
+                                return yield __await(void 0);
+                            if (r === SKIP)
+                                continue;
+                            yield yield __await(r);
+                        }
+                    }
+                    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                    finally {
+                        try {
+                            if (!_e && !_b && (_c = it_2.return)) yield __await(_c.call(it_2));
+                        }
+                        finally { if (e_6) throw e_6.error; }
+                    }
+                });
+            },
+        });
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/js-lib",
-  "version": "14.197.0",
+  "version": "14.199.0",
   "scripts": {
     "prepare": "husky install",
     "build-prod": "build-prod-esm-cjs",

package/src/array/array.util.ts

@@ -402,3 +402,14 @@ export function _minByOrUndefined<T>(
 
   return minItem
 }
+
+export function _zip<T1, T2>(array1: T1[], array2: T2[]): [T1, T2][] {
+  const len = Math.min(array1.length, array2.length)
+  const res: [T1, T2][] = []
+
+  for (let i = 0; i < len; i++) {
+    res.push([array1[i]!, array2[i]!])
+  }
+
+  return res
+}

package/src/array/range.ts

@@ -1,3 +1,4 @@
+import { AsyncIterable2 } from '../iter/asyncIterable2'
 import { Iterable2 } from '../iter/iterable2'
 
 /* eslint-disable no-redeclare, unicorn/no-new-array */
@@ -28,9 +29,9 @@ export function _range(fromIncl: number, toExcl?: number, step = 1): number[] {
 /**
  * Like _range, but returns an Iterable2.
  */
-export function _rangeIt(toExcl: number): Iterable2<number>
-export function _rangeIt(fromIncl: number, toExcl: number, step?: number): Iterable2<number>
-export function _rangeIt(fromIncl: number, toExcl?: number, step = 1): Iterable2<number> {
+export function _rangeIterable(toExcl: number): Iterable2<number>
+export function _rangeIterable(fromIncl: number, toExcl: number, step?: number): Iterable2<number>
+export function _rangeIterable(fromIncl: number, toExcl?: number, step = 1): Iterable2<number> {
   if (toExcl === undefined) {
     toExcl = fromIncl
     fromIncl = 0
@@ -44,3 +45,31 @@ export function _rangeIt(fromIncl: number, toExcl?: number, step = 1): Iterable2
     },
   })
 }
+
+/**
+ * Like _range, but returns an AsyncIterable2.
+ */
+export function _rangeAsyncIterable(toExcl: number): AsyncIterable2<number>
+export function _rangeAsyncIterable(
+  fromIncl: number,
+  toExcl: number,
+  step?: number,
+): AsyncIterable2<number>
+export function _rangeAsyncIterable(
+  fromIncl: number,
+  toExcl?: number,
+  step = 1,
+): AsyncIterable2<number> {
+  if (toExcl === undefined) {
+    toExcl = fromIncl
+    fromIncl = 0
+  }
+
+  return AsyncIterable2.of({
+    async *[Symbol.asyncIterator]() {
+      for (let i = fromIncl; i < toExcl!; i += step) {
+        yield i
+      }
+    },
+  })
+}

package/src/datetime/localDate.ts

@@ -539,13 +539,13 @@ export function localDateRange(
   step = 1,
   stepUnit: LocalDateUnit = 'day',
 ): LocalDate[] {
-  return localDateRangeIt(min, max, incl, step, stepUnit).toArray()
+  return localDateRangeIterable(min, max, incl, step, stepUnit).toArray()
 }
 
 /**
  * Experimental, returns the range as Iterable2.
  */
-export function localDateRangeIt(
+export function localDateRangeIterable(
   min: LocalDateInput,
   max: LocalDateInput,
   incl: Inclusiveness = '[)',

package/src/index.ts

@@ -61,6 +61,7 @@ export * from './string/safeJsonStringify'
 export * from './promise/pQueue'
 export * from './promise/abortable'
 export * from './iter/iterable2'
+export * from './iter/asyncIterable2'
 export * from './math/stack.util'
 export * from './string/leven'
 export * from './datetime/localDate'

package/src/iter/asyncIterable2.ts

@@ -0,0 +1,109 @@
+import { Promisable } from '../typeFest'
+import { AbortableAsyncMapper, AbortableAsyncPredicate, END, SKIP } from '../types'
+
+/**
+ * Similar to Iterable2, but for AsyncIterable.
+ *
+ * AsyncIterable2 is a wrapper around AsyncIterable that implements "Iterator Helpers proposal":
+ * https://github.com/tc39/proposal-iterator-helpers
+ *
+ * AsyncIterable2 can be removed after the proposal is widely implemented in Node & browsers.
+ *
+ * @experimental
+ */
+export class AsyncIterable2<T> implements AsyncIterable<T> {
+  private constructor(private it: AsyncIterable<T>) {}
+
+  static of<T>(it: AsyncIterable<T>): AsyncIterable2<T> {
+    return new AsyncIterable2(it)
+  }
+
+  static ofIterable<T>(it: Iterable<T>): AsyncIterable2<T> {
+    return new AsyncIterable2<T>({
+      async *[Symbol.asyncIterator]() {
+        yield* it
+      },
+    })
+  }
+
+  static empty<T>(): AsyncIterable2<T> {
+    return new AsyncIterable2<T>({
+      async *[Symbol.asyncIterator]() {},
+    })
+  }
+
+  [Symbol.asyncIterator](): AsyncIterator<T> {
+    return this.it[Symbol.asyncIterator]()
+  }
+
+  async toArray(): Promise<T[]> {
+    // todo: Array.fromAsync is not yet available, use that when it's ready
+    // return await Array.fromAsync(this.it)
+
+    const res: T[] = []
+    for await (const item of this.it) {
+      res.push(item)
+    }
+    return res
+  }
+
+  async forEach(cb: (v: T, i: number) => Promisable<any | typeof END>): Promise<void> {
+    let i = 0
+    for await (const v of this.it) {
+      if ((await cb(v, i++)) === END) return
+    }
+  }
+
+  async some(cb: AbortableAsyncPredicate<T>): Promise<boolean> {
+    return !!(await this.find(cb))
+  }
+
+  async every(cb: AbortableAsyncPredicate<T>): Promise<boolean> {
+    let i = 0
+    for await (const v of this.it) {
+      const r = await cb(v, i++)
+      if (r === END || !r) return false
+    }
+    return true
+  }
+
+  async find(cb: AbortableAsyncPredicate<T>): Promise<T | undefined> {
+    let i = 0
+    for await (const v of this.it) {
+      const r = await cb(v, i++)
+      if (r === END) return
+      if (r) return v
+    }
+  }
+
+  filter(cb: AbortableAsyncPredicate<T>): AsyncIterable2<T> {
+    const { it } = this
+
+    return new AsyncIterable2<T>({
+      async *[Symbol.asyncIterator]() {
+        let i = 0
+        for await (const v of it) {
+          const r = await cb(v, i++)
+          if (r === END) return
+          if (r) yield v
+        }
+      },
+    })
+  }
+
+  map<OUT>(mapper: AbortableAsyncMapper<T, OUT>): AsyncIterable2<OUT> {
+    const { it } = this
+
+    return new AsyncIterable2<OUT>({
+      async *[Symbol.asyncIterator]() {
+        let i = 0
+        for await (const v of it) {
+          const r = await mapper(v, i++)
+          if (r === END) return
+          if (r === SKIP) continue
+          yield r
+        }
+      },
+    })
+  }
+}