recker 1.0.79 → 1.0.80-next.70ea84d

package/dist/browser/browser/mini.d.ts

@@ -6,8 +6,8 @@ export declare class MiniRequestPromise<T = unknown> implements Promise<Response
     private readonly p;
     constructor(promise: Promise<Response>);
     get [Symbol.toStringTag](): string;
-    then<TResult1 = Response, TResult2 = never>(onfulfilled?: ((value: Response) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
-    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<Response | TResult>;
+    then<TResult1 = Response, TResult2 = never>(onfulfilled?: ((value: Response) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): Promise<Response | TResult>;
     finally(onfinally?: (() => void) | null): Promise<Response>;
     json<R = T>(): Promise<R>;
     text(): Promise<string>;

package/dist/browser/browser/recker-mini.d.ts

@@ -2,14 +2,14 @@ import { Client, type ExtendedClientOptions } from '../core/client.js';
 import { type RequestPromise } from '../core/request-promise.js';
 import type { RequestOptions } from '../types/index.js';
 import { simulateNetwork } from '../plugins/network-simulation.js';
-export declare function get(url: string, options?: RequestOptions): RequestPromise;
-export declare function post(url: string, options?: RequestOptions): RequestPromise;
-export declare function put(url: string, options?: RequestOptions): RequestPromise;
-export declare function patch(url: string, options?: RequestOptions): RequestPromise;
-export declare function del(url: string, options?: RequestOptions): RequestPromise;
-export declare function head(url: string, options?: RequestOptions): RequestPromise;
-export declare function options(url: string, options?: RequestOptions): RequestPromise;
-export declare function purge(url: string, options?: RequestOptions): RequestPromise;
+export declare function get<T = unknown>(url: string, options?: RequestOptions): RequestPromise<T>;
+export declare function post<T = unknown>(url: string, options?: RequestOptions): RequestPromise<T>;
+export declare function put<T = unknown>(url: string, options?: RequestOptions): RequestPromise<T>;
+export declare function patch<T = unknown>(url: string, options?: RequestOptions): RequestPromise<T>;
+export declare function del<T = unknown>(url: string, options?: RequestOptions): RequestPromise<T>;
+export declare function head<T = unknown>(url: string, options?: RequestOptions): RequestPromise<T>;
+export declare function options<T = unknown>(url: string, options?: RequestOptions): RequestPromise<T>;
+export declare function purge<T = unknown>(url: string, options?: RequestOptions): RequestPromise<T>;
 export declare function ws(url: string, protocols?: string | string[]): WebSocket;
 export declare const recker: {
     get: typeof get;

package/dist/browser/browser/recker.d.ts

@@ -4,14 +4,17 @@ import type { RequestOptions } from '../types/index.js';
 import { analyzeSeo } from '../seo/analyzer.js';
 import { createAI } from '../ai/index.js';
 import { simulateNetwork } from '../plugins/network-simulation.js';
-export declare function get(url: string, options?: RequestOptions): RequestPromise;
-export declare function post(url: string, options?: RequestOptions): RequestPromise;
-export declare function put(url: string, options?: RequestOptions): RequestPromise;
-export declare function patch(url: string, options?: RequestOptions): RequestPromise;
-export declare function del(url: string, options?: RequestOptions): RequestPromise;
-export declare function head(url: string, options?: RequestOptions): RequestPromise;
-export declare function options(url: string, options?: RequestOptions): RequestPromise;
-export declare function purge(url: string, options?: RequestOptions): RequestPromise;
+export declare function get<T = unknown>(url: string, options?: RequestOptions): RequestPromise<T>;
+export declare function post<T = unknown>(url: string, options?: RequestOptions): RequestPromise<T>;
+export declare function post<T = unknown>(url: string, body?: unknown, options?: RequestOptions): RequestPromise<T>;
+export declare function put<T = unknown>(url: string, options?: RequestOptions): RequestPromise<T>;
+export declare function put<T = unknown>(url: string, body?: unknown, options?: RequestOptions): RequestPromise<T>;
+export declare function patch<T = unknown>(url: string, options?: RequestOptions): RequestPromise<T>;
+export declare function patch<T = unknown>(url: string, body?: unknown, options?: RequestOptions): RequestPromise<T>;
+export declare function del<T = unknown>(url: string, options?: RequestOptions): RequestPromise<T>;
+export declare function head<T = unknown>(url: string, options?: RequestOptions): RequestPromise<T>;
+export declare function options<T = unknown>(url: string, options?: RequestOptions): RequestPromise<T>;
+export declare function purge<T = unknown>(url: string, options?: RequestOptions): RequestPromise<T>;
 export declare function ws(url: string, protocols?: string | string[]): WebSocket;
 export declare const recker: {
     get: typeof get;

package/dist/browser/browser/recker.js

@@ -5,6 +5,51 @@ import { createAI } from '../ai/index.js';
 import { harRecorder } from '../plugins/har-recorder.js';
 import { simulateNetwork } from '../plugins/network-simulation.js';
 let _defaultClient = null;
+const REQUEST_OPTIONS_HINTS = new Set([
+    'method',
+    'headers',
+    'body',
+    'json',
+    'form',
+    'xml',
+    'yaml',
+    'csv',
+    'timeout',
+    'params',
+    'searchParams',
+    'retry',
+    'hooks',
+    'throwHttpErrors',
+    'signal',
+    'http2',
+    'followRedirects',
+    'maxRedirects',
+    'beforeRedirect',
+    'maxResponseSize',
+    'useCurl',
+    'proxy',
+    'dns',
+    'tls',
+    'policySource',
+    'policyTags',
+    'traceId',
+    'correlationId',
+    'tenant',
+    'retryOn404',
+    'retryOn5xx',
+]);
+function isRequestOptions(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    return Object.keys(value).some((key) => REQUEST_OPTIONS_HINTS.has(key));
+}
+function resolveRequestBodyAndOptions(bodyOrOptions, options) {
+    if (options === undefined && isRequestOptions(bodyOrOptions)) {
+        return { body: undefined, options: bodyOrOptions };
+    }
+    return { body: bodyOrOptions, options: options || {} };
+}
 function getDefaultClient() {
     if (!_defaultClient) {
         _defaultClient = createClient({
@@ -16,14 +61,17 @@ function getDefaultClient() {
 export function get(url, options) {
     return getDefaultClient().get(url, options);
 }
-export function post(url, options) {
-    return getDefaultClient().post(url, options);
+export function post(url, bodyOrOptions, options) {
+    const resolved = resolveRequestBodyAndOptions(bodyOrOptions, options);
+    return getDefaultClient().post(url, resolved.body, resolved.options);
 }
-export function put(url, options) {
-    return getDefaultClient().put(url, options);
+export function put(url, bodyOrOptions, options) {
+    const resolved = resolveRequestBodyAndOptions(bodyOrOptions, options);
+    return getDefaultClient().put(url, resolved.body, resolved.options);
 }
-export function patch(url, options) {
-    return getDefaultClient().patch(url, options);
+export function patch(url, bodyOrOptions, options) {
+    const resolved = resolveRequestBodyAndOptions(bodyOrOptions, options);
+    return getDefaultClient().patch(url, resolved.body, resolved.options);
 }
 export function del(url, options) {
     return getDefaultClient().delete(url, options);

package/dist/browser/core/client.d.ts

@@ -22,6 +22,7 @@ interface BatchRequestOptions<T = ReckerResponse> {
     signal?: AbortSignal;
     deadlineMs?: number;
 }
+type RequestWithBodyOptions = Omit<RequestOptions, 'method'>;
 export interface ExtendedClientOptions extends ClientOptions {
     retry?: RetryOptions;
     cache?: ClientCacheConfig;
@@ -36,6 +37,7 @@ export declare class Client {
     private hooks;
     private transport;
     private curlTransport?;
+    private proxyConfig?;
     private defaultHeaders;
     private defaultHeadersObj;
     private defaultParams;
@@ -104,28 +106,31 @@ export declare class Client {
         };
     }>;
     private requestWithBody;
-    post<T = unknown>(path: string, body?: any, options?: Omit<RequestOptions, 'method' | 'body'>): RequestPromise<T>;
-    put<T = unknown>(path: string, body?: any, options?: Omit<RequestOptions, 'method' | 'body'>): RequestPromise<T>;
-    patch<T = unknown>(path: string, body?: any, options?: Omit<RequestOptions, 'method' | 'body'>): RequestPromise<T>;
+    post<T = unknown>(path: string, options?: RequestWithBodyOptions): RequestPromise<T>;
+    post<T = unknown>(path: string, body?: unknown, options?: RequestWithBodyOptions): RequestPromise<T>;
+    put<T = unknown>(path: string, options?: RequestWithBodyOptions): RequestPromise<T>;
+    put<T = unknown>(path: string, body?: unknown, options?: RequestWithBodyOptions): RequestPromise<T>;
+    patch<T = unknown>(path: string, options?: RequestWithBodyOptions): RequestPromise<T>;
+    patch<T = unknown>(path: string, body?: unknown, options?: RequestWithBodyOptions): RequestPromise<T>;
     delete<T = unknown>(path: string, options?: Omit<RequestOptions, 'method'>): RequestPromise<T>;
     head<T = unknown>(path: string, options?: Omit<RequestOptions, 'method'>): RequestPromise<T>;
     options<T = unknown>(path: string, options?: Omit<RequestOptions, 'method'>): RequestPromise<T>;
     trace<T = unknown>(path: string, options?: Omit<RequestOptions, 'method'>): RequestPromise<T>;
     connect<T = unknown>(path: string, options?: Omit<RequestOptions, 'method'>): RequestPromise<T>;
     purge<T = unknown>(path: string, options?: Omit<RequestOptions, 'method'>): RequestPromise<T>;
-    propfind<T = unknown>(path: string, body?: any, options?: Omit<RequestOptions, 'method' | 'body'>): RequestPromise<T>;
-    proppatch<T = unknown>(path: string, body?: any, options?: Omit<RequestOptions, 'method' | 'body'>): RequestPromise<T>;
+    propfind<T = unknown>(path: string, body?: unknown, options?: RequestWithBodyOptions): RequestPromise<T>;
+    proppatch<T = unknown>(path: string, body?: unknown, options?: RequestWithBodyOptions): RequestPromise<T>;
     mkcol<T = unknown>(path: string, options?: Omit<RequestOptions, 'method'>): RequestPromise<T>;
     copy<T = unknown>(path: string, options?: Omit<RequestOptions, 'method'>): RequestPromise<T>;
     move<T = unknown>(path: string, options?: Omit<RequestOptions, 'method'>): RequestPromise<T>;
-    lock<T = unknown>(path: string, body?: any, options?: Omit<RequestOptions, 'method' | 'body'>): RequestPromise<T>;
+    lock<T = unknown>(path: string, body?: unknown, options?: RequestWithBodyOptions): RequestPromise<T>;
     unlock<T = unknown>(path: string, options?: Omit<RequestOptions, 'method'>): RequestPromise<T>;
-    link<T = unknown>(path: string, body?: any, options?: Omit<RequestOptions, 'method' | 'body'>): RequestPromise<T>;
-    unlink<T = unknown>(path: string, body?: any, options?: Omit<RequestOptions, 'method' | 'body'>): RequestPromise<T>;
+    link<T = unknown>(path: string, body?: unknown, options?: RequestWithBodyOptions): RequestPromise<T>;
+    unlink<T = unknown>(path: string, body?: unknown, options?: RequestWithBodyOptions): RequestPromise<T>;
     scrape(path: string, options?: RequestOptions): ScrapePromise<ReckerResponse>;
     paginate<T>(path: string, options?: RequestOptions & PaginationOptions<T>): AsyncGenerator<T>;
-    pages<T = any>(path: string, options?: RequestOptions & PaginationOptions): AsyncGenerator<PageResult<T>>;
-    page<T = any>(path: string, pageNumber: number, options?: RequestOptions & {
+    pages<T = unknown>(path: string, options?: RequestOptions & PaginationOptions): AsyncGenerator<PageResult<T>>;
+    page<T = unknown>(path: string, pageNumber: number, options?: RequestOptions & {
         pageParam?: string;
     }): RequestPromise<T>;
     getAll<T>(path: string, options?: RequestOptions & PaginationOptions<T>): Promise<T[]>;

package/dist/browser/core/client.js

@@ -28,8 +28,34 @@ import { ReckerWebSocket } from '../websocket/client.js';
 import { whois as performWhois, isDomainAvailable } from '../utils/whois.js';
 import { MemoryCookieJar } from '../cookies/memory-cookie-jar.js';
 import { scrape as scrapeHelper } from '../plugins/scrape.js';
+const toError = (error) => error instanceof Error ? error : new Error(String(error));
+const BODY_OPTION_HINTS = [
+    'json',
+    'form',
+    'xml',
+    'yaml',
+    'csv',
+    'body',
+    'headers',
+    'timeout',
+    'retry',
+    'hooks',
+    'searchParams',
+    'params',
+    'beforeRedirect',
+    'maxRedirects',
+    'followRedirects',
+    'http2',
+    'useCurl',
+];
 function isNodeRuntime() {
-    return typeof globalThis !== 'undefined' && Boolean(globalThis.process?.versions?.node);
+    const maybeNodeGlobal = globalThis;
+    return typeof globalThis !== 'undefined' && Boolean(maybeNodeGlobal.process?.versions?.node);
+}
+function isRequestWithBodyOptions(value) {
+    if (!isPlainObject(value))
+        return false;
+    return BODY_OPTION_HINTS.some((key) => Object.prototype.hasOwnProperty.call(value, key));
 }
 class LazyTransport {
     factory;
@@ -67,7 +93,7 @@ class LazyTransport {
         await this.resolving;
     }
 }
-function createLazyCurlTransport() {
+function createLazyCurlTransport(proxy) {
     if (!isNodeRuntime()) {
         return {
             async dispatch(req) {
@@ -77,7 +103,7 @@ function createLazyCurlTransport() {
     }
     return new LazyTransport(async () => {
         const { CurlTransport } = await import('../transport/curl.js');
-        return new CurlTransport();
+        return new CurlTransport(proxy);
     });
 }
 class LazyCacheStorage {
@@ -179,6 +205,7 @@ export class Client {
     hooks;
     transport;
     curlTransport;
+    proxyConfig;
     defaultHeaders;
     defaultHeadersObj;
     defaultParams;
@@ -222,6 +249,7 @@ export class Client {
         this.defaultParams = options.defaults?.params || {};
         this.paginationConfig = options.pagination;
         this.maxResponseSize = options.maxResponseSize;
+        this.proxyConfig = options.proxy;
         const runtimeEventBus = options.runtimeEventBus;
         if (runtimeEventBus) {
             this.runtimeEventBus = {
@@ -254,7 +282,7 @@ export class Client {
         else if (options.useCurl) {
             if (this.debugEnabled)
                 console.log('[DEBUG] Using Curl Transport');
-            this.transport = createLazyCurlTransport();
+            this.transport = createLazyCurlTransport(options.proxy);
             this.transportKind = 'curl';
         }
         else if (isNodeRuntime()) {
@@ -290,8 +318,9 @@ export class Client {
             this.transportKind = 'undici';
         }
         else {
-            if (this.debugEnabled)
-                console.log('[DEBUG] Using Fetch Transport');
+            if (this.debugEnabled && this.logger) {
+                this.logger.debug('Using Fetch Transport');
+            }
             this.transport = new FetchTransport();
             this.transportKind = 'fetch';
         }
@@ -317,7 +346,8 @@ export class Client {
                 interval: this.concurrencyConfig.interval
             });
             registerPlugin((client) => {
-                client.middlewares.unshift(this.requestPool.asMiddleware());
+                const pluginClient = client;
+                pluginClient.middlewares?.unshift(this.requestPool.asMiddleware());
             }, {
                 name: 'recker:request-pool',
                 priority: 130,
@@ -525,7 +555,7 @@ export class Client {
         try {
             if (req.useCurl && this.transportKind !== 'curl') {
                 if (!this.curlTransport) {
-                    this.curlTransport = createLazyCurlTransport();
+                    this.curlTransport = createLazyCurlTransport(this.proxyConfig);
                 }
                 const response = await this.curlTransport.dispatch(req);
                 if (context) {
@@ -552,7 +582,7 @@ export class Client {
                 this.runtimeEventBus.emit('transport:error', {
                     context,
                     req,
-                    error: error instanceof Error ? error : new Error(String(error))
+                    error: toError(error)
                 });
             }
             throw error;
@@ -768,7 +798,7 @@ export class Client {
                     });
                     return response;
                 }, (error) => {
-                    const requestError = error instanceof Error ? error : new Error(String(error));
+                    const requestError = toError(error);
                     this.runtimeEventBus.emit('request:failed', {
                         context: requestContext,
                         req,
@@ -849,7 +879,7 @@ export class Client {
                 });
                 return response;
             }, (error) => {
-                const requestError = error instanceof Error ? error : new Error(String(error));
+                const requestError = toError(error);
                 this.runtimeEventBus.emit('request:failed', {
                     context: requestContext,
                     req,
@@ -873,8 +903,9 @@ export class Client {
         return this.request(path, { ...options, method: 'GET' });
     }
     async warmup() {
-        if (this.transport && 'warmup' in this.transport && typeof this.transport.warmup === 'function') {
-            await this.transport.warmup();
+        const transport = this.transport;
+        if (transport?.warmup) {
+            await transport.warmup();
         }
     }
     async batch(requests, options = {}) {
@@ -899,29 +930,14 @@ export class Client {
     }
     requestWithBody(method, path, bodyOrOptions, options) {
         let actualBody = bodyOrOptions;
-        let actualOptions = options;
-        const isOptionsEmpty = actualOptions === undefined ||
-            (typeof actualOptions === 'object' && actualOptions !== null && Object.keys(actualOptions).length === 0);
-        if (isOptionsEmpty && isPlainObject(bodyOrOptions)) {
-            const potentialOptions = bodyOrOptions;
-            if (potentialOptions.json !== undefined ||
-                potentialOptions.form !== undefined ||
-                potentialOptions.xml !== undefined ||
-                potentialOptions.yaml !== undefined ||
-                potentialOptions.csv !== undefined ||
-                potentialOptions.body !== undefined ||
-                potentialOptions.headers !== undefined ||
-                potentialOptions.timeout !== undefined ||
-                potentialOptions.retry !== undefined ||
-                potentialOptions.hooks !== undefined ||
-                potentialOptions.searchParams !== undefined ||
-                potentialOptions.params !== undefined) {
-                actualOptions = bodyOrOptions;
-                actualBody = undefined;
-            }
-        }
-        actualOptions = actualOptions || {};
-        const { json, form, xml, yaml, csv, ...restOptions } = actualOptions;
+        let actualOptions = options || {};
+        const isOptionsEmpty = options === undefined
+            || (isPlainObject(options) && Object.keys(options).length === 0);
+        if (isOptionsEmpty && isRequestWithBodyOptions(bodyOrOptions)) {
+            actualOptions = bodyOrOptions;
+            actualBody = undefined;
+        }
+        const { json, form, xml, yaml, csv, body: explicitBody, ...restOptions } = actualOptions;
         let finalBody = actualBody;
         let explicitContentType;
         if (form !== undefined) {
@@ -944,8 +960,8 @@ export class Client {
             finalBody = serializeCsv(csv);
             explicitContentType = 'text/csv';
         }
-        else if (restOptions.body !== undefined) {
-            finalBody = restOptions.body;
+        else if (explicitBody !== undefined) {
+            finalBody = explicitBody;
         }
         const { body: processedBody, contentType } = processBody(finalBody);
         const headers = new Headers(restOptions.headers);