fatcher/dist/index.d.ts

/**
 * Confirm a data can be transform.
 * @param response
 * @returns
 */
declare function canActivate(data: unknown): data is Response;

/**
 * Confirm an error whether is DOMException
 * @param error
 * @returns
 *
 * @deprecated use `@import('@fatcherjs/middleware-aborter').isAbortError` instead.
 */
declare function isAbortError(error: unknown): error is DOMException;

declare type MaybePromise<T> = T | Promise<T>;
/**
 *  HTTP Request Methods
 */
declare type RequestMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'HEAD' | 'OPTIONS' | 'PATCH';
/**
 * Middleware Context
 */
interface Context extends Omit<RequestOptions, 'middlewares'> {
    body?: BodyInit | null;
    /**
     * A map of http request headers.
     *
     * @description Some headers name cannot be modified programmatically.
     * @see https://developer.mozilla.org/en-US/docs/Glossary/Forbidden_header_name
     */
    requestHeaders: Headers;
    /**
     * Request Headers
     *
     * @deprecated use `requestHeaders` instead.
     */
    headers?: RequestHeaders;
}
/**
 * Request Headers
 *
 * Will filter null value before fetch.
 */
declare type RequestHeaders = Record<string, string | null>;
/**
 * Response Result
 */
interface ResponseResult<T = any> {
    data: T;
    headers: Headers;
    status: number;
    statusText: string;
    options: RequestOptions;
    url: string;
}
/**
 * Middlewares Response Result
 */
interface MiddlewareResult extends Omit<ResponseResult, 'options' | 'data'> {
    data?: any;
}
declare type PatchContext = Partial<Context>;
/**
 * Middleware Next
 *
 * Should call by using middleware for get response.
 */
declare type MiddlewareNext = (patchContext?: PatchContext) => MaybePromise<MiddlewareResult>;
/**
 * Middleware
 */
interface Middleware {
    name: `fatcher-middleware-${string}`;
    use(context: Readonly<Context>, next: MiddlewareNext): MaybePromise<MiddlewareResult>;
    /**
     * Current middleware needs some middlewares
     */
    presets?: UnregisteredMiddlewares;
}
/**
 * A Middleware or a series of Middlewares
 *
 * Will flatten into a array of middlewares.
 */
declare type UnregisteredMiddlewares = ((() => MaybePromise<Middleware>) | Middleware | ((() => MaybePromise<Middleware>) | Middleware)[])[];
/**
 * Request Options for fetch
 */
interface RequestOptions extends Omit<RequestInit, 'body' | 'headers'> {
    /**
     * Base url to fetch.
     *
     * @default '/'
     */
    baseUrl?: string;
    /**
     * Url to fetch
     */
    url?: string;
    /**
     * HTTP Request Method for current request.
     *
     * @default 'GET'
     */
    method?: RequestMethod;
    /**
     * Query string for request url
     */
    params?: Record<string, string>;
    /**
     * An array of function with `pre` or `post` request.
     *
     * Middlewares will compose into an async function.
     *
     * @default []
     */
    middlewares?: UnregisteredMiddlewares;
    /**
     * Request Payload
     */
    payload?: Record<string, any> | null;
    /**
     * Request Headers
     *
     * @default
     * {
     *   'Content-Type': 'application/x-www-form-urlencoded'
     * }
     */
    headers?: RequestHeaders;
    /**
     * Custom validate status code
     *
     * If status code not in range, throw a `FatcherError`
     *
     * @default
     * ```
     * (statusCode) => 200 <= statusCode < 300
     * ```
     */
    validateCode?: (statusCode: number) => boolean;
}

/**
 * Read a readable stream by chunk
 * @param readableStream
 * @param callback
 * @returns
 */
declare function readStreamByChunk<T = Uint8Array, K = void>(readableStream: ReadableStream<T>, callback: (chunk: T) => MaybePromise<K>): Promise<void>;
/**
 * Read a readable stream by chunk
 * @param readableStream
 * @param callback
 * @returns
 *
 * @deprecated Use `readStreamByChunk` instead.
 */
declare const chunkStreamReader: typeof readStreamByChunk;

/**
 * Fatcher error
 */
declare class FatcherError extends Error {
    constructor(context: Context, response: Response);
    readonly name = "FatcherError";
    readonly __isFatcherError__ = true;
    private readonly _response;
    private readonly _context;
    toJSON(): {
        status: number;
        statusText: string;
        context: Context;
        headers: Record<string, string>;
        data: ReadableStream<Uint8Array> | null;
    };
}

/**
 * Confirm an error whether is FatcherError
 * @param error
 * @returns
 */
declare function isFatcherError(error: Error): error is FatcherError;

declare function mergeOptions(options: RequestOptions, ...patchOptions: Partial<RequestOptions>[]): RequestOptions;

/**
 * Set Default Fatcher Request Options.
 *
 * Tips:
 *
 * If change default options, will `effect` any fatcher instances.
 *
 * If you want to have a scope options with fatcher. Use `createScopedRequest` instead.
 *
 * Inline Options `>` Scoped Options `>` Default Options
 */
declare function setDefaultOptions<T extends RequestOptions>(patchRequestOptions: Partial<T>): void;

/**
 * Send HTTP request with custom options.
 */
declare function fatcher<T = any>(inlineOptions?: RequestOptions): Promise<ResponseResult<T>>;

/**
 * Create a scope fatcher request.
 * @param scopedOptions
 * @returns
 */
declare function createScopedRequest<K = any>(scopedOptions?: RequestOptions): <T = K>(url: string, payload?: any, inlineOptions?: RequestOptions) => Promise<ResponseResult<T>>;

export { Context, FatcherError, MaybePromise, Middleware, MiddlewareNext, MiddlewareResult, PatchContext, RequestHeaders, RequestMethod, RequestOptions, ResponseResult, UnregisteredMiddlewares, canActivate, chunkStreamReader, createScopedRequest, fatcher, isAbortError, isFatcherError, mergeOptions, readStreamByChunk, setDefaultOptions };