hook-fetch 0.0.1-beta

package/dist/es/plugins/index.js

@@ -0,0 +1,5 @@
+import { sseTextDecoderPlugin } from "./sse.js";
+export {
+  sseTextDecoderPlugin
+};
+//# sourceMappingURL=index.js.map

package/dist/es/plugins/sse.js

@@ -0,0 +1,16 @@
+const decoder = new TextDecoder("utf-8");
+const sseTextDecoderPlugin = () => {
+  return {
+    name: "sse",
+    async transformStreamChunk(chunk) {
+      if (!chunk.error) {
+        chunk.result = decoder.decode(chunk.result, { stream: true });
+      }
+      return chunk;
+    }
+  };
+};
+export {
+  sseTextDecoderPlugin
+};
+//# sourceMappingURL=sse.js.map

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "hook-fetch",
+  "description": "A lightweight and modern HTTP request library developed based on the native Fetch API of the browser, providing a user-friendly interface similar to Axios and powerful extensibility.",
+  "version": "0.0.1-beta",
+  "type": "module",
+  "files": [
+    "dist",
+    "types",
+    "!dist/**/*.map",
+    "README.md",
+    "LICENSE",
+    "README.en.md"
+  ],
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/es/index.js",
+  "types": "./types/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./cjs/index.js",
+      "import": "./es/index.js",
+      "types": "./es/index.d.ts"
+    },
+    "./plugins": {
+      "require": "./cjs/plugins/index.js",
+      "import": "./es/plugins/index.js",
+      "types": "./types/plugins/index.d.ts"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "bugs": {
+    "url": "https://github.com/JsonLee12138/hook-fetch/issues",
+    "email": "lijunsong2@gmail.com"
+  },
+  "license": "MIT",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc && vite build",
+    "ci:publish": "pnpm changeset publish -r",
+    "test": "vitest"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.28.1",
+    "@types/qs": "^6.9.18",
+    "terser": "^5.39.0",
+    "typescript": "^5.7.3",
+    "typescript-api-pro": "workspace:^",
+    "vite": "^6.1.1",
+    "vite-plugin-dts": "^4.5.3",
+    "vitest": "^3.0.8"
+  },
+  "dependencies": {
+    "qs": "^6.14.0",
+    "radash": "^12.1.0"
+  }
+}

package/types/index.d.ts

@@ -0,0 +1,23 @@
+import { AnyObject } from 'typescript-api-pro';
+import { BaseOptions, HookFetchPlugin, RequestUseOptions } from './types';
+import { HookFetch } from './utils';
+declare class Base {
+    #private;
+    constructor({ timeout, baseURL, headers, plugins, withCredentials }: BaseOptions);
+    use(plugin: HookFetchPlugin<any, any, any, any>): this;
+    request<R = AnyObject, P = AnyObject, D = AnyObject, E = AnyObject>(url: string, { timeout, headers, method, params, data, qsArrayFormat, withCredentials, extra }?: RequestUseOptions<P, D, E>): HookFetch<R, E>;
+    get<R = AnyObject, P = AnyObject, E = AnyObject>(url: string, params?: P, options?: Omit<RequestUseOptions<P, never, E>, 'params'>): HookFetch<R, E>;
+    head<R = AnyObject, P = AnyObject, E = AnyObject>(url: string, params?: P, options?: Omit<RequestUseOptions<P, never, E>, 'params'>): HookFetch<R, E>;
+    options<R = AnyObject, P = AnyObject, E = AnyObject>(url: string, params?: P, options?: Omit<RequestUseOptions<P, never, E>, 'params'>): HookFetch<R, E>;
+    delete<R = AnyObject, P = AnyObject, E = AnyObject>(url: string, options?: RequestUseOptions<P, never, E>): HookFetch<R, E>;
+    post<R = AnyObject, D = AnyObject, P = AnyObject, E = AnyObject>(url: string, data?: D, options?: Omit<RequestUseOptions<P, D, E>, 'data'>): HookFetch<R, E>;
+    put<R = AnyObject, D = AnyObject, P = AnyObject, E = AnyObject>(url: string, data?: D, options?: Omit<RequestUseOptions<P, D, E>, 'data'>): HookFetch<R, E>;
+    patch<R = AnyObject, D = AnyObject, P = AnyObject, E = AnyObject>(url: string, data?: D, options?: Omit<RequestUseOptions<P, D, E>, 'data'>): HookFetch<R, E>;
+    abortAll(): void;
+}
+declare const useRequest: <R = AnyObject, P = AnyObject, D = AnyObject, E = AnyObject>(url: string, options?: RequestUseOptions<P, D, E>) => HookFetch<R, E>;
+type ExportDefault = typeof useRequest & {
+    create: (options: BaseOptions) => Base;
+};
+declare const _default: ExportDefault;
+export default _default;

package/types/plugins/index.d.ts

@@ -0,0 +1 @@
+export * from './sse';

package/types/plugins/sse.d.ts

@@ -0,0 +1,2 @@
+import { HookFetchPlugin } from '../types';
+export declare const sseTextDecoderPlugin: () => HookFetchPlugin;

package/types/types.d.ts

@@ -0,0 +1,100 @@
+import { default as QueryString } from 'qs';
+import { AnyObject } from 'typescript-api-pro';
+import { ResponseError } from './utils';
+export interface RequestConfig<P, D, E = AnyObject> extends Omit<RequestInit, 'body' | 'signal' | 'credentials' | 'method'> {
+    url: string;
+    baseURL: string;
+    params?: P;
+    data?: D;
+    withCredentials?: boolean;
+    extra?: E;
+    method: RequestMethod;
+    qsArrayFormat?: QueryString.IStringifyOptions['arrayFormat'];
+}
+export interface FetchPluginContext<T = unknown, E = unknown, P = unknown, D = unknown> {
+    config: RequestConfig<P, D, E>;
+    response: Response;
+    result?: T;
+    controller: AbortController;
+}
+export interface StreamContext<T = unknown> {
+    result: T;
+    source: Uint8Array<ArrayBufferLike>;
+    error: unknown | null;
+}
+type BeforeRequestHandler<E = unknown, P = unknown, D = unknown> = (config: RequestConfig<E, P, D>) => Promise<RequestConfig<E, P, D>>;
+type AfterResponseHandler<T = unknown> = (context: FetchPluginContext<T>) => Promise<FetchPluginContext<any>>;
+type TransformStreamChunkHandler = (chunk: StreamContext<any>) => Promise<StreamContext>;
+export type OnFinallyHandler<E = unknown, P = unknown, D = unknown> = (res: Pick<FetchPluginContext<unknown, E, P, D>, 'config' | 'response'>) => Promise<void>;
+export type HookFetchPlugin<T = unknown, E = unknown, P = unknown, D = unknown> = {
+    /** 插件名称 */
+    name: string;
+    /** 优先级 */
+    priority?: number;
+    beforeRequest?: BeforeRequestHandler<E, P, D>;
+    afterResponse?: AfterResponseHandler<T>;
+    transformStreamChunk?: TransformStreamChunkHandler;
+    onError?: (error: Error) => Promise<Error | void | ResponseError<E>>;
+    onFinally?: OnFinallyHandler<E, P, D>;
+};
+export interface OptionProps {
+    baseURL: string;
+    timeout: number;
+    headers: HeadersInit;
+    plugins: Array<HookFetchPlugin>;
+    withCredentials: boolean;
+}
+export type BaseOptions = Partial<OptionProps>;
+export type BaseRequestOptions<P, D, E = AnyObject> = Partial<{
+    plugins: Array<HookFetchPlugin>;
+    timeout: number;
+    params: P;
+    data: D;
+    controller: AbortController;
+    extra: E;
+    qsArrayFormat: QueryString.IStringifyOptions['arrayFormat'];
+    withCredentials: boolean;
+    method: RequestMethod;
+}> & Omit<RequestInit, 'body' | 'method'> & {
+    url: string;
+    baseURL: string;
+};
+export type RequestMethodWithParams = 'GET' | 'DELETE' | 'OPTIONS' | 'HEAD';
+export type RequestMethodWithBody = 'PUT' | 'PATCH' | 'POST';
+export type RequestMethod = RequestMethodWithParams | RequestMethodWithBody;
+export declare enum Method {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    DELETE = "DELETE",
+    PATCH = "PATCH",
+    HEAD = "HEAD",
+    OPTIONS = "OPTIONS"
+}
+export declare enum ContentType {
+    JSON = "application/json",
+    FORM_URLENCODED = "application/x-www-form-urlencoded",
+    FORM_DATA = "multipart/form-data",
+    TEXT = "text/plain",
+    HTML = "text/html",
+    XML = "text/xml",
+    CSV = "text/csv",
+    STREAM = "application/octet-stream"
+}
+export declare enum StatusCode {
+    TIME_OUT = 408,
+    ABORTED = 499,
+    NETWORK_ERROR = 599,
+    BODY_NULL = 502,
+    UNKNOWN = 601
+}
+export type RequestUseOptions<P, D, E> = Omit<BaseRequestOptions<P, D, E>, 'url' | 'plugins' | 'baseURL' | 'controller'>;
+export interface ResponseErrorOptions<E = unknown> {
+    name?: string;
+    message: string;
+    status?: number;
+    statusText?: string;
+    response?: Response;
+    config?: RequestConfig<unknown, unknown, E>;
+}
+export {};

package/types/utils.d.ts

@@ -0,0 +1,39 @@
+import { default as QueryString } from 'qs';
+import { AnyObject } from 'typescript-api-pro';
+import { HookFetchPlugin, BaseRequestOptions, OnFinallyHandler, RequestConfig, RequestMethod, ResponseErrorOptions, StreamContext } from './types';
+export declare const delay: (ms: number) => Promise<unknown>;
+export declare const timeoutCallback: (controller: AbortController) => void;
+export declare class ResponseError<E = unknown> extends Error {
+    #private;
+    constructor({ message, status, statusText, response, config, name }: ResponseErrorOptions<E>);
+    get message(): string;
+    get status(): number | undefined;
+    get statusText(): string | undefined;
+    get response(): Response | undefined;
+    get config(): RequestConfig<unknown, unknown, E> | undefined;
+    get name(): string;
+}
+export declare const parsePlugins: (plugins: HookFetchPlugin[]) => {
+    beforeRequestPlugins: ((config: RequestConfig<unknown, unknown, unknown>) => Promise<RequestConfig<unknown, unknown, unknown>>)[];
+    afterResponsePlugins: ((context: import('./types').FetchPluginContext<unknown, unknown, unknown, unknown>) => Promise<import('./types').FetchPluginContext<any>>)[];
+    errorPlugins: ((error: Error) => Promise<void | Error | ResponseError<unknown>>)[];
+    finallyPlugins: OnFinallyHandler<unknown, unknown, unknown>[];
+    transformStreamChunkPlugins: ((chunk: StreamContext<any>) => Promise<StreamContext>)[];
+};
+export declare const buildUrl: (url: string, params?: AnyObject, qsArrayFormat?: QueryString.IStringifyOptions["arrayFormat"]) => string;
+export declare const mergeHeaders: (_baseHeaders?: HeadersInit | Headers, _newHeaders?: HeadersInit | Headers) => Headers;
+export declare const getBody: (body: AnyObject, method: RequestMethod, headers?: HeadersInit, qsArrayFormat?: QueryString.IStringifyOptions["arrayFormat"]) => BodyInit | null;
+export declare class HookFetch<T, E> implements PromiseLike<T> {
+    #private;
+    constructor(options: BaseRequestOptions<unknown, unknown, E>);
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null | undefined): PromiseLike<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null | undefined): Promise<T | TResult>;
+    finally(onfinally?: (() => void) | null | undefined): Promise<T>;
+    abort(): void;
+    blob(): Promise<Blob>;
+    text(): Promise<string>;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    formData(): Promise<FormData>;
+    bytes(): Promise<Uint8Array<ArrayBufferLike>>;
+    stream<T>(): AsyncGenerator<StreamContext<T> | StreamContext<null>, void, unknown>;
+}