@naturalcycles/js-lib 14.196.0 → 14.198.0

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/json-schema/jsonSchemaBuilder.d.ts

@@ -116,8 +116,8 @@ export declare class JsonSchemaObjectBuilder<T extends AnyObject> extends JsonSc
     minProps(minProperties: number): this;
     maxProps(maxProperties: number): this;
     additionalProps(additionalProperties: boolean): this;
-    baseDBEntity<ID extends string | number = string>(idType?: string): JsonSchemaObjectBuilder<T & BaseDBEntity<ID>>;
-    savedDBEntity<ID extends string | number = string>(idType?: string): JsonSchemaObjectBuilder<T & SavedDBEntity<ID>>;
+    baseDBEntity(): JsonSchemaObjectBuilder<T & BaseDBEntity>;
+    savedDBEntity(): JsonSchemaObjectBuilder<T & SavedDBEntity>;
     extend<T2 extends AnyObject>(s2: JsonSchemaObjectBuilder<T2>): JsonSchemaObjectBuilder<T & T2>;
 }
 export declare class JsonSchemaArrayBuilder<ITEM> extends JsonSchemaAnyBuilder<ITEM[], JsonSchemaArray<ITEM>> {

package/dist/json-schema/jsonSchemaBuilder.js

@@ -311,16 +311,16 @@ class JsonSchemaObjectBuilder extends JsonSchemaAnyBuilder {
         Object.assign(this.schema, { additionalProperties });
         return this;
     }
-    baseDBEntity(idType = 'string') {
+    baseDBEntity() {
         Object.assign(this.schema.properties, {
-            id: { type: idType },
+            id: { type: 'string' },
             created: { type: 'number', format: 'unixTimestamp2000' },
             updated: { type: 'number', format: 'unixTimestamp2000' },
         });
         return this;
     }
-    savedDBEntity(idType = 'string') {
-        return this.baseDBEntity(idType).addRequired(['id', 'created', 'updated']);
+    savedDBEntity() {
+        return this.baseDBEntity().addRequired(['id', 'created', 'updated']);
     }
     extend(s2) {
         const builder = new JsonSchemaObjectBuilder();

package/dist/types.d.ts

@@ -19,19 +19,19 @@ export type CreatedUpdated = {
     created: number;
     updated: number;
 };
-export interface CreatedUpdatedId<ID extends string | number = string | number> extends CreatedUpdated {
-    id: ID;
+export interface CreatedUpdatedId extends CreatedUpdated {
+    id: string;
 }
-export type ObjectWithId<ID extends string | number = string | number> = {
-    id: ID;
+export type ObjectWithId = {
+    id: string;
 };
-export interface AnyObjectWithId<ID extends string | number = string | number> extends AnyObject, ObjectWithId<ID> {
+export interface AnyObjectWithId extends AnyObject, ObjectWithId {
 }
 /**
  * Base interface for any Entity that was saved to DB.
  */
-export type SavedDBEntity<ID extends string | number = string> = {
-    id: ID;
+export type SavedDBEntity = {
+    id: string;
     /**
      * unixTimestamp of when the entity was first created (in the DB).
      */
@@ -47,8 +47,8 @@ export type SavedDBEntity<ID extends string | number = string> = {
  * hence `id`, `created` and `updated` fields CAN BE undefined (yet).
  * When it's known to be saved - `SavedDBEntity` interface can be used instead.
  */
-export type BaseDBEntity<ID extends string | number = string> = {
-    id?: ID;
+export type BaseDBEntity = {
+    id?: string;
     /**
      * unixTimestamp of when the entity was first created (in the DB).
      */
@@ -58,8 +58,8 @@ export type BaseDBEntity<ID extends string | number = string> = {
      */
     updated?: UnixTimestampNumber;
 };
-export type Saved<T extends Partial<ObjectWithId>> = T extends AnyObject ? Omit<T, 'id' | 'created' | 'updated'> & SavedDBEntity<NonNullable<T['id']>> : T;
-export type Unsaved<T extends Partial<ObjectWithId>> = T extends AnyObject ? Omit<T, 'id' | 'created' | 'updated'> & BaseDBEntity<NonNullable<T['id']>> : T;
+export type Saved<T extends Partial<ObjectWithId>> = T extends AnyObject ? Omit<T, 'id' | 'created' | 'updated'> & SavedDBEntity : T;
+export type Unsaved<T extends Partial<ObjectWithId>> = T extends AnyObject ? Omit<T, 'id' | 'created' | 'updated'> & BaseDBEntity : T;
 export type UnsavedId<T extends Partial<ObjectWithId>> = Omit<T, 'id'> & {
     id?: T['id'];
 };

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/dist-esm/json-schema/jsonSchemaBuilder.js

@@ -306,16 +306,16 @@ export class JsonSchemaObjectBuilder extends JsonSchemaAnyBuilder {
         Object.assign(this.schema, { additionalProperties });
         return this;
     }
-    baseDBEntity(idType = 'string') {
+    baseDBEntity() {
         Object.assign(this.schema.properties, {
-            id: { type: idType },
+            id: { type: 'string' },
             created: { type: 'number', format: 'unixTimestamp2000' },
             updated: { type: 'number', format: 'unixTimestamp2000' },
         });
         return this;
     }
-    savedDBEntity(idType = 'string') {
-        return this.baseDBEntity(idType).addRequired(['id', 'created', 'updated']);
+    savedDBEntity() {
+        return this.baseDBEntity().addRequired(['id', 'created', 'updated']);
     }
     extend(s2) {
         const builder = new JsonSchemaObjectBuilder();

package/package.json

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

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
+        }
+      },
+    })
+  }
+}

package/src/json-schema/jsonSchemaBuilder.ts

@@ -368,11 +368,9 @@ export class JsonSchemaObjectBuilder<T extends AnyObject> extends JsonSchemaAnyB
     return this
   }
 
-  baseDBEntity<ID extends string | number = string>(
-    idType = 'string',
-  ): JsonSchemaObjectBuilder<T & BaseDBEntity<ID>> {
+  baseDBEntity(): JsonSchemaObjectBuilder<T & BaseDBEntity> {
     Object.assign(this.schema.properties, {
-      id: { type: idType },
+      id: { type: 'string' },
       created: { type: 'number', format: 'unixTimestamp2000' },
       updated: { type: 'number', format: 'unixTimestamp2000' },
     })
@@ -380,10 +378,8 @@ export class JsonSchemaObjectBuilder<T extends AnyObject> extends JsonSchemaAnyB
     return this
   }
 
-  savedDBEntity<ID extends string | number = string>(
-    idType = 'string',
-  ): JsonSchemaObjectBuilder<T & SavedDBEntity<ID>> {
-    return this.baseDBEntity(idType).addRequired(['id', 'created', 'updated']) as any
+  savedDBEntity(): JsonSchemaObjectBuilder<T & SavedDBEntity> {
+    return this.baseDBEntity().addRequired(['id', 'created', 'updated']) as any
   }
 
   extend<T2 extends AnyObject>(s2: JsonSchemaObjectBuilder<T2>): JsonSchemaObjectBuilder<T & T2> {

package/src/types.ts

@@ -25,26 +25,23 @@ export type CreatedUpdated = {
   updated: number
 }
 
-export interface CreatedUpdatedId<ID extends string | number = string | number>
-  extends CreatedUpdated {
-  id: ID
+export interface CreatedUpdatedId extends CreatedUpdated {
+  id: string
 }
 
 // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
-export type ObjectWithId<ID extends string | number = string | number> = {
-  id: ID
+export type ObjectWithId = {
+  id: string
 }
 
-export interface AnyObjectWithId<ID extends string | number = string | number>
-  extends AnyObject,
-    ObjectWithId<ID> {}
+export interface AnyObjectWithId extends AnyObject, ObjectWithId {}
 
 /**
  * Base interface for any Entity that was saved to DB.
  */
 // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
-export type SavedDBEntity<ID extends string | number = string> = {
-  id: ID
+export type SavedDBEntity = {
+  id: string
 
   /**
    * unixTimestamp of when the entity was first created (in the DB).
@@ -64,8 +61,8 @@ export type SavedDBEntity<ID extends string | number = string> = {
  * When it's known to be saved - `SavedDBEntity` interface can be used instead.
  */
 // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
-export type BaseDBEntity<ID extends string | number = string> = {
-  id?: ID
+export type BaseDBEntity = {
+  id?: string
 
   /**
    * unixTimestamp of when the entity was first created (in the DB).
@@ -79,11 +76,11 @@ export type BaseDBEntity<ID extends string | number = string> = {
 }
 
 export type Saved<T extends Partial<ObjectWithId>> = T extends AnyObject
-  ? Omit<T, 'id' | 'created' | 'updated'> & SavedDBEntity<NonNullable<T['id']>>
+  ? Omit<T, 'id' | 'created' | 'updated'> & SavedDBEntity
   : T
 
 export type Unsaved<T extends Partial<ObjectWithId>> = T extends AnyObject
-  ? Omit<T, 'id' | 'created' | 'updated'> & BaseDBEntity<NonNullable<T['id']>>
+  ? Omit<T, 'id' | 'created' | 'updated'> & BaseDBEntity
   : T
 
 export type UnsavedId<T extends Partial<ObjectWithId>> = Omit<T, 'id'> & {