@naturalcycles/js-lib 15.32.0 → 15.33.1

package/dist/http/fetcher.d.ts

@@ -4,7 +4,7 @@
 import type { ReadableStream as WebReadableStream } from 'node:stream/web';
 import { HttpRequestError } from '../error/error.util.js';
 import type { ErrorDataTuple } from '../types.js';
-import type { FetcherAfterResponseHook, FetcherBeforeRequestHook, FetcherBeforeRetryHook, FetcherCfg, FetcherGraphQLOptions, FetcherNormalizedCfg, FetcherOnErrorHook, FetcherOptions, FetcherResponse, RequestInitNormalized } from './fetcher.model.js';
+import type { FetcherAfterResponseHook, FetcherBeforeRequestHook, FetcherBeforeRetryHook, FetcherCfg, FetcherGraphQLOptions, FetcherNormalizedCfg, FetcherOnErrorHook, FetcherOptions, FetcherResponse, FetchFunction, RequestInitNormalized } from './fetcher.model.js';
 /**
  * Experimental wrapper around Fetch.
  * Works in both Browser and Node, using `globalThis.fetch`.
@@ -92,7 +92,7 @@ export declare class Fetcher {
      * This method exists to be able to easily mock it.
      * It is static, so mocking applies to ALL instances (even future ones) of Fetcher at once.
      */
-    static callNativeFetch(url: string, init: RequestInitNormalized): Promise<Response>;
+    static callNativeFetch(url: string, init: RequestInitNormalized, fetchFn?: FetchFunction): Promise<Response>;
     private onNotOkResponse;
     private processRetry;
     private getRetryTimeout;

package/dist/http/fetcher.js

@@ -283,8 +283,7 @@ export class Fetcher {
                 }
             }
             try {
-                // Calls cfg.fetchFn if set, otherwise Fetcher.callNativeFetch
-                res.fetchResponse = await (this.cfg.fetchFn || Fetcher.callNativeFetch)(req.fullUrl, req.init);
+                res.fetchResponse = await Fetcher.callNativeFetch(req.fullUrl, req.init, this.cfg.fetchFn);
                 res.ok = res.fetchResponse.ok;
                 // important to set it to undefined, otherwise it can keep the previous value (from previous try)
                 res.err = undefined;
@@ -400,8 +399,8 @@ export class Fetcher {
      * This method exists to be able to easily mock it.
      * It is static, so mocking applies to ALL instances (even future ones) of Fetcher at once.
      */
-    static async callNativeFetch(url, init) {
-        return await globalThis.fetch(url, init);
+    static async callNativeFetch(url, init, fetchFn = globalThis.fetch) {
+        return (await fetchFn(url, init));
     }
     async onNotOkResponse(res) {
         let cause;

package/dist/http/fetcher.model.d.ts

@@ -284,7 +284,26 @@ export type FetcherResponseType = 'json' | 'text' | 'void' | 'arrayBuffer' | 'bl
  * Used to be able to override and provide a different implementation,
  * e.g when mocking.
  */
-export type FetchFunction = (url: string, init: RequestInitNormalized) => Promise<Response>;
+export type FetchFunction = (url: string, init: RequestInitCrossPlatform) => Promise<ResponseCrossPlatform>;
+/**
+ * A subset of RequestInit that would match both:
+ *
+ * 1. RequestInit from dom types
+ * 2. RequestInit from undici types
+ */
+export interface RequestInitCrossPlatform {
+    method?: string;
+    referrer?: string;
+    keepalive?: boolean;
+}
+/**
+ * A subset of Response type that matches both dom and undici types.
+ */
+export interface ResponseCrossPlatform {
+    ok: boolean;
+    status: number;
+    statusText: string;
+}
 export type GraphQLResponse<DATA> = GraphQLSuccessResponse<DATA> | GraphQLErrorResponse;
 export interface GraphQLSuccessResponse<DATA> {
     data: DATA;

package/dist/iter/asyncIterable2.d.ts

@@ -1,4 +1,4 @@
-import type { AbortableAsyncMapper, AbortableAsyncPredicate, Promisable } from '../types.js';
+import type { AbortableAsyncMapper, AbortableAsyncPredicate, AbortableMapper, AbortablePredicate, Promisable } from '../types.js';
 import { END } from '../types.js';
 /**
  * Similar to Iterable2, but for AsyncIterable.
@@ -20,8 +20,13 @@ export declare class AsyncIterable2<T> implements AsyncIterable<T> {
     toArray(): Promise<T[]>;
     forEach(cb: (v: T, i: number) => Promisable<any | typeof END>): Promise<void>;
     some(cb: AbortableAsyncPredicate<T>): Promise<boolean>;
+    someSync(cb: AbortablePredicate<T>): Promise<boolean>;
     every(cb: AbortableAsyncPredicate<T>): Promise<boolean>;
+    everySync(cb: AbortablePredicate<T>): Promise<boolean>;
     find(cb: AbortableAsyncPredicate<T>): Promise<T | undefined>;
+    findSync(cb: AbortablePredicate<T>): Promise<T | undefined>;
     filter(cb: AbortableAsyncPredicate<T>): AsyncIterable2<T>;
+    filterSync(cb: AbortablePredicate<T>): AsyncIterable2<T>;
     map<OUT>(mapper: AbortableAsyncMapper<T, OUT>): AsyncIterable2<OUT>;
+    mapSync<OUT>(mapper: AbortableMapper<T, OUT>): AsyncIterable2<OUT>;
 }

package/dist/iter/asyncIterable2.js

@@ -51,6 +51,9 @@ export class AsyncIterable2 {
     async some(cb) {
         return !!(await this.find(cb));
     }
+    async someSync(cb) {
+        return !!(await this.findSync(cb));
+    }
     async every(cb) {
         let i = 0;
         for await (const v of this.it) {
@@ -60,6 +63,15 @@ export class AsyncIterable2 {
         }
         return true;
     }
+    async everySync(cb) {
+        let i = 0;
+        for await (const v of this.it) {
+            const r = cb(v, i++);
+            if (r === END || !r)
+                return false;
+        }
+        return true;
+    }
     async find(cb) {
         let i = 0;
         for await (const v of this.it) {
@@ -70,6 +82,16 @@ export class AsyncIterable2 {
                 return v;
         }
     }
+    async findSync(cb) {
+        let i = 0;
+        for await (const v of this.it) {
+            const r = cb(v, i++);
+            if (r === END)
+                return;
+            if (r)
+                return v;
+        }
+    }
     filter(cb) {
         const { it } = this;
         return new AsyncIterable2({
@@ -85,6 +107,21 @@ export class AsyncIterable2 {
             },
         });
     }
+    filterSync(cb) {
+        const { it } = this;
+        return new AsyncIterable2({
+            async *[Symbol.asyncIterator]() {
+                let i = 0;
+                for await (const v of it) {
+                    const r = cb(v, i++);
+                    if (r === END)
+                        return;
+                    if (r)
+                        yield v;
+                }
+            },
+        });
+    }
     map(mapper) {
         const { it } = this;
         return new AsyncIterable2({
@@ -101,4 +138,20 @@ export class AsyncIterable2 {
             },
         });
     }
+    mapSync(mapper) {
+        const { it } = this;
+        return new AsyncIterable2({
+            async *[Symbol.asyncIterator]() {
+                let i = 0;
+                for await (const v of it) {
+                    const r = mapper(v, i++);
+                    if (r === END)
+                        return;
+                    if (r === SKIP)
+                        continue;
+                    yield r;
+                }
+            },
+        });
+    }
 }

package/dist/types.d.ts

@@ -114,10 +114,10 @@ export declare const SKIP: unique symbol;
  */
 export declare const MISS: unique symbol;
 /**
- * Function which is called for every item in `input`. Expected to return a `Promise` or value.
+ * Function which is called for every item in `input`. Expected to return a `Promise`.
  */
-export type AsyncMapper<IN = any, OUT = any> = (input: IN) => OUT | PromiseLike<OUT>;
-export type AsyncIndexedMapper<IN = any, OUT = any> = (input: IN, index: number) => OUT | PromiseLike<OUT>;
+export type AsyncMapper<IN = any, OUT = any> = (input: IN) => PromiseLike<OUT>;
+export type AsyncIndexedMapper<IN = any, OUT = any> = (input: IN, index: number) => PromiseLike<OUT>;
 export type Mapper<IN = any, OUT = any> = (input: IN) => OUT;
 export type IndexedMapper<IN = any, OUT = any> = (input: IN, index: number) => OUT;
 export declare const _passthroughMapper: IndexedMapper;
@@ -127,11 +127,11 @@ export declare const _passUndefinedMapper: IndexedMapper<any, void>;
  */
 export declare const _noop: (..._args: any[]) => undefined;
 export type Predicate<T> = (item: T, index: number) => boolean;
-export type AsyncPredicate<T> = (item: T, index: number) => boolean | PromiseLike<boolean>;
+export type AsyncPredicate<T> = (item: T, index: number) => PromiseLike<boolean>;
 export type AbortablePredicate<T> = (item: T, i: number) => boolean | typeof END;
-export type AbortableAsyncPredicate<T> = (item: T, i: number) => Promisable<boolean | typeof END>;
+export type AbortableAsyncPredicate<T> = (item: T, i: number) => PromiseLike<boolean | typeof END>;
 export type AbortableMapper<IN = any, OUT = any> = (input: IN, i: number) => OUT | typeof SKIP | typeof END;
-export type AbortableAsyncMapper<IN = any, OUT = any> = (input: IN, i: number) => Promisable<OUT | typeof SKIP | typeof END>;
+export type AbortableAsyncMapper<IN = any, OUT = any> = (input: IN, i: number) => PromiseLike<OUT | typeof SKIP | typeof END>;
 export declare const _passthroughPredicate: Predicate<any>;
 export declare const _passNothingPredicate: Predicate<any>;
 export interface BatchResult<RES = any, ERR = Error> {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/js-lib",
   "type": "module",
-  "version": "15.32.0",
+  "version": "15.33.1",
   "dependencies": {
     "tslib": "^2",
     "undici": "^7",

package/src/http/fetcher.model.ts

@@ -364,7 +364,31 @@ export type FetcherResponseType =
  * Used to be able to override and provide a different implementation,
  * e.g when mocking.
  */
-export type FetchFunction = (url: string, init: RequestInitNormalized) => Promise<Response>
+export type FetchFunction = (
+  url: string,
+  init: RequestInitCrossPlatform,
+) => Promise<ResponseCrossPlatform>
+
+/**
+ * A subset of RequestInit that would match both:
+ *
+ * 1. RequestInit from dom types
+ * 2. RequestInit from undici types
+ */
+export interface RequestInitCrossPlatform {
+  method?: string
+  referrer?: string
+  keepalive?: boolean
+}
+
+/**
+ * A subset of Response type that matches both dom and undici types.
+ */
+export interface ResponseCrossPlatform {
+  ok: boolean
+  status: number
+  statusText: string
+}
 
 export type GraphQLResponse<DATA> = GraphQLSuccessResponse<DATA> | GraphQLErrorResponse
 

package/src/http/fetcher.ts

@@ -49,6 +49,7 @@ import type {
   FetcherResponse,
   FetcherResponseType,
   FetcherRetryOptions,
+  FetchFunction,
   GraphQLResponse,
   RequestInitNormalized,
 } from './fetcher.model.js'
@@ -369,11 +370,7 @@ export class Fetcher {
       }
 
       try {
-        // Calls cfg.fetchFn if set, otherwise Fetcher.callNativeFetch
-        res.fetchResponse = await (this.cfg.fetchFn || Fetcher.callNativeFetch)(
-          req.fullUrl,
-          req.init,
-        )
+        res.fetchResponse = await Fetcher.callNativeFetch(req.fullUrl, req.init, this.cfg.fetchFn)
         res.ok = res.fetchResponse.ok
         // important to set it to undefined, otherwise it can keep the previous value (from previous try)
         res.err = undefined
@@ -502,8 +499,12 @@ export class Fetcher {
    * This method exists to be able to easily mock it.
    * It is static, so mocking applies to ALL instances (even future ones) of Fetcher at once.
    */
-  static async callNativeFetch(url: string, init: RequestInitNormalized): Promise<Response> {
-    return await globalThis.fetch(url, init)
+  static async callNativeFetch(
+    url: string,
+    init: RequestInitNormalized,
+    fetchFn: FetchFunction = globalThis.fetch,
+  ): Promise<Response> {
+    return (await fetchFn(url, init)) as Response
   }
 
   private async onNotOkResponse(res: FetcherResponse): Promise<void> {

package/src/iter/asyncIterable2.ts

@@ -1,4 +1,10 @@
-import type { AbortableAsyncMapper, AbortableAsyncPredicate, Promisable } from '../types.js'
+import type {
+  AbortableAsyncMapper,
+  AbortableAsyncPredicate,
+  AbortableMapper,
+  AbortablePredicate,
+  Promisable,
+} from '../types.js'
 import { END, SKIP } from '../types.js'
 
 /**
@@ -58,6 +64,10 @@ export class AsyncIterable2<T> implements AsyncIterable<T> {
     return !!(await this.find(cb))
   }
 
+  async someSync(cb: AbortablePredicate<T>): Promise<boolean> {
+    return !!(await this.findSync(cb))
+  }
+
   async every(cb: AbortableAsyncPredicate<T>): Promise<boolean> {
     let i = 0
     for await (const v of this.it) {
@@ -67,6 +77,15 @@ export class AsyncIterable2<T> implements AsyncIterable<T> {
     return true
   }
 
+  async everySync(cb: AbortablePredicate<T>): Promise<boolean> {
+    let i = 0
+    for await (const v of this.it) {
+      const r = 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) {
@@ -76,6 +95,15 @@ export class AsyncIterable2<T> implements AsyncIterable<T> {
     }
   }
 
+  async findSync(cb: AbortablePredicate<T>): Promise<T | undefined> {
+    let i = 0
+    for await (const v of this.it) {
+      const r = cb(v, i++)
+      if (r === END) return
+      if (r) return v
+    }
+  }
+
   filter(cb: AbortableAsyncPredicate<T>): AsyncIterable2<T> {
     const { it } = this
 
@@ -91,6 +119,21 @@ export class AsyncIterable2<T> implements AsyncIterable<T> {
     })
   }
 
+  filterSync(cb: AbortablePredicate<T>): AsyncIterable2<T> {
+    const { it } = this
+
+    return new AsyncIterable2<T>({
+      async *[Symbol.asyncIterator]() {
+        let i = 0
+        for await (const v of it) {
+          const r = cb(v, i++)
+          if (r === END) return
+          if (r) yield v
+        }
+      },
+    })
+  }
+
   map<OUT>(mapper: AbortableAsyncMapper<T, OUT>): AsyncIterable2<OUT> {
     const { it } = this
 
@@ -106,4 +149,20 @@ export class AsyncIterable2<T> implements AsyncIterable<T> {
       },
     })
   }
+
+  mapSync<OUT>(mapper: AbortableMapper<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 = mapper(v, i++)
+          if (r === END) return
+          if (r === SKIP) continue
+          yield r
+        }
+      },
+    })
+  }
 }

package/src/types.ts

@@ -141,13 +141,10 @@ export const SKIP = Symbol('SKIP')
 export const MISS = Symbol('MISS')
 
 /**
- * Function which is called for every item in `input`. Expected to return a `Promise` or value.
+ * Function which is called for every item in `input`. Expected to return a `Promise`.
  */
-export type AsyncMapper<IN = any, OUT = any> = (input: IN) => OUT | PromiseLike<OUT>
-export type AsyncIndexedMapper<IN = any, OUT = any> = (
-  input: IN,
-  index: number,
-) => OUT | PromiseLike<OUT>
+export type AsyncMapper<IN = any, OUT = any> = (input: IN) => PromiseLike<OUT>
+export type AsyncIndexedMapper<IN = any, OUT = any> = (input: IN, index: number) => PromiseLike<OUT>
 export type Mapper<IN = any, OUT = any> = (input: IN) => OUT
 export type IndexedMapper<IN = any, OUT = any> = (input: IN, index: number) => OUT
 
@@ -160,10 +157,10 @@ export const _passUndefinedMapper: IndexedMapper<any, void> = () => undefined
 export const _noop = (..._args: any[]): undefined => undefined
 
 export type Predicate<T> = (item: T, index: number) => boolean
-export type AsyncPredicate<T> = (item: T, index: number) => boolean | PromiseLike<boolean>
+export type AsyncPredicate<T> = (item: T, index: number) => PromiseLike<boolean>
 
 export type AbortablePredicate<T> = (item: T, i: number) => boolean | typeof END
-export type AbortableAsyncPredicate<T> = (item: T, i: number) => Promisable<boolean | typeof END>
+export type AbortableAsyncPredicate<T> = (item: T, i: number) => PromiseLike<boolean | typeof END>
 export type AbortableMapper<IN = any, OUT = any> = (
   input: IN,
   i: number,
@@ -171,7 +168,7 @@ export type AbortableMapper<IN = any, OUT = any> = (
 export type AbortableAsyncMapper<IN = any, OUT = any> = (
   input: IN,
   i: number,
-) => Promisable<OUT | typeof SKIP | typeof END>
+) => PromiseLike<OUT | typeof SKIP | typeof END>
 
 export const _passthroughPredicate: Predicate<any> = () => true
 export const _passNothingPredicate: Predicate<any> = () => false