hook-fetch 0.0.2-beta → 0.0.2

package/package.json

@@ -1,7 +1,24 @@
 {
   "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.2-beta",
+  "keywords": [
+    "fetch",
+    "axios",
+    "request",
+    "http",
+    "https",
+    "typescript",
+    "hook-fetch",
+    "hook-fetch-plugin",
+    "hook-fetch-plugin-retry",
+    "hook-fetch-plugin-timeout",
+    "hook-fetch-plugin-error",
+    "hook-fetch-plugin-response",
+    "hook-fetch-plugin-request",
+    "hook-fetch-plugin-response-transform",
+    "hook-fetch-plugin-request-transform"
+  ],
+  "version": "0.0.2",
   "type": "module",
   "files": [
     "dist",
@@ -16,13 +33,18 @@
   "types": "./types/index.d.ts",
   "exports": {
     ".": {
-      "require": "./cjs/index.js",
-      "import": "./es/index.js",
-      "types": "./es/index.d.ts"
+      "require": "./dist/cjs/index.js",
+      "import": "./dist/es/index.js",
+      "types": "./types/index.d.ts"
     },
     "./plugins": {
-      "require": "./cjs/plugins/index.js",
-      "import": "./es/plugins/index.js",
+      "require": "./dist/cjs/plugins/index.js",
+      "import": "./dist/es/plugins/index.js",
+      "types": "./types/plugins/index.d.ts"
+    },
+    "./src": {
+      "require": "./src/index.ts",
+      "import": "./src/index.ts",
       "types": "./types/plugins/index.d.ts"
     }
   },
@@ -39,20 +61,32 @@
     "dev": "vite",
     "build": "tsc && vite build",
     "ci:publish": "pnpm changeset publish -r",
-    "test": "vitest"
+    "test": "vitest",
+    "lint-staged": "lint-staged"
   },
   "devDependencies": {
+    "@commitlint/cli": "^19.5.0",
+    "@commitlint/config-conventional": "^19.5.0",
+    "husky": "^9.1.7",
+    "cz-git": "^1.11.1",
+    "lint-staged": "^13.2.0",
     "@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",
+    "oxlint": "^0.16.3",
     "vite-plugin-dts": "^4.5.3",
     "vitest": "^3.0.8"
   },
   "dependencies": {
     "qs": "^6.14.0",
     "radash": "^12.1.0"
+  },
+  "config": {
+    "commitizen": {
+      "path": "node_modules/cz-git"
+    }
   }
 }

package/types/index.d.ts

@@ -1,23 +1,41 @@
 import { AnyObject } from 'typescript-api-pro';
 import { BaseOptions, HookFetchPlugin, RequestUseOptions } from './types';
 import { HookFetch } from './utils';
-declare class Base {
+type Generic<R extends AnyObject, K extends keyof R, T> = R & {
+    [P in K]: T;
+};
+declare class Base<R extends AnyObject = AnyObject, E = AnyObject, K extends keyof R = string> {
     #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>;
+    request<T = AnyObject, P = AnyObject, D = AnyObject>(url: string, { timeout, headers, method, params, data, qsArrayFormat, withCredentials, extra }?: RequestUseOptions<P, D, E>): HookFetch<Generic<R, K, T>, E>;
+    get<T = AnyObject, P = AnyObject>(url: string, params?: P, options?: Omit<RequestUseOptions<P, never, E>, 'params' | 'method'>): HookFetch<Generic<R, K, T>, E>;
+    head<T = AnyObject, P = AnyObject>(url: string, params?: P, options?: Omit<RequestUseOptions<P, never, E>, 'params' | 'method'>): HookFetch<Generic<R, K, T>, E>;
+    options<T = AnyObject, P = AnyObject>(url: string, params?: P, options?: Omit<RequestUseOptions<P, never, E>, 'params' | 'method'>): HookFetch<Generic<R, K, T>, E>;
+    delete<T = AnyObject, P = AnyObject>(url: string, options?: Omit<RequestUseOptions<P, never, E>, 'method'>): HookFetch<Generic<R, K, T>, E>;
+    post<T = AnyObject, D = AnyObject, P = AnyObject>(url: string, data?: D, options?: Omit<RequestUseOptions<P, D, E>, 'data' | 'method'>): HookFetch<Generic<R, K, T>, E>;
+    put<T = AnyObject, D = AnyObject, P = AnyObject>(url: string, data?: D, options?: Omit<RequestUseOptions<P, D, E>, 'data' | 'method'>): HookFetch<Generic<R, K, T>, E>;
+    patch<T = AnyObject, D = AnyObject, P = AnyObject>(url: string, data?: D, options?: Omit<RequestUseOptions<P, D, E>, 'data' | 'method'>): HookFetch<Generic<R, K, T>, E>;
     abortAll(): void;
 }
 declare const useRequest: <R = AnyObject, P = AnyObject, D = AnyObject, E = AnyObject>(url: string, options?: RequestUseOptions<P, D, E>) => HookFetch<R, E>;
+export declare const request: <R = AnyObject, P = AnyObject, D = AnyObject, E = AnyObject>(url: string, options?: RequestUseOptions<P, D, E>) => HookFetch<R, E>;
+export declare const get: <R = AnyObject, P = AnyObject, E = AnyObject>(url: string, params?: P, options?: Omit<RequestUseOptions<P, never, E>, "params" | "method">) => HookFetch<R, E>;
+export declare const head: <R = AnyObject, P = AnyObject, E = AnyObject>(url: string, params?: P, options?: Omit<RequestUseOptions<P, never, E>, "params" | "method">) => HookFetch<R, E>;
+export declare const options: <R = AnyObject, P = AnyObject, E = AnyObject>(url: string, params?: P, options?: Omit<RequestUseOptions<P, never, E>, "params" | "method">) => HookFetch<R, E>;
+export declare const del: <R = AnyObject, P = AnyObject, E = AnyObject>(url: string, options?: Omit<RequestUseOptions<P, never, E>, "method">) => HookFetch<R, E>;
+export declare const post: <R = AnyObject, D = AnyObject, P = AnyObject, E = AnyObject>(url: string, data?: D, options?: Omit<RequestUseOptions<P, D, E>, "data" | "method">) => HookFetch<R, E>;
+export declare const put: <R = AnyObject, D = AnyObject, P = AnyObject, E = AnyObject>(url: string, data?: D, options?: Omit<RequestUseOptions<P, D, E>, "data" | "method">) => HookFetch<R, E>;
+export declare const patch: <R = AnyObject, D = AnyObject, P = AnyObject, E = AnyObject>(url: string, data?: D, options?: Omit<RequestUseOptions<P, D, E>, "data" | "method">) => HookFetch<R, E>;
 type ExportDefault = typeof useRequest & {
-    create: (options: BaseOptions) => Base;
+    create: <R extends AnyObject = AnyObject, E = AnyObject, K extends keyof R = string>(options: BaseOptions) => (Base<R, E, K>['request'] & Base<R, E, K>);
+    get: typeof get;
+    head: typeof head;
+    options: typeof options;
+    delete: typeof del;
+    post: typeof post;
+    put: typeof put;
+    patch: typeof patch;
 };
-declare const _default: ExportDefault;
-export default _default;
+declare const defaultFn: ExportDefault;
+export default defaultFn;

package/types/types.d.ts

@@ -11,9 +11,11 @@ export interface RequestConfig<P, D, E = AnyObject> extends Omit<RequestInit, 'b
     method: RequestMethod;
     qsArrayFormat?: QueryString.IStringifyOptions['arrayFormat'];
 }
+export type FetchResponseType = 'json' | 'text' | 'blob' | 'arrayBuffer' | 'formData' | 'bytes';
 export interface FetchPluginContext<T = unknown, E = unknown, P = unknown, D = unknown> {
     config: RequestConfig<P, D, E>;
     response: Response;
+    responseType: FetchResponseType;
     result?: T;
     controller: AbortController;
 }

package/types/utils.d.ts

@@ -1,6 +1,6 @@
 import { default as QueryString } from 'qs';
 import { AnyObject } from 'typescript-api-pro';
-import { HookFetchPlugin, BaseRequestOptions, OnFinallyHandler, RequestConfig, RequestMethod, ResponseErrorOptions, StreamContext } from './types';
+import { HookFetchPlugin, BaseRequestOptions, FetchPluginContext, 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 {
@@ -15,9 +15,9 @@ export declare class ResponseError<E = unknown> extends Error {
 }
 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>>)[];
+    afterResponsePlugins: ((context: FetchPluginContext<unknown, unknown, unknown, unknown>) => Promise<FetchPluginContext<any>>)[];
     errorPlugins: ((error: Error) => Promise<void | Error | ResponseError<unknown>>)[];
-    finallyPlugins: OnFinallyHandler<unknown, unknown, unknown>[];
+    finallyPlugins: import('./types').OnFinallyHandler<unknown, unknown, unknown>[];
     transformStreamChunkPlugins: ((chunk: StreamContext<any>) => Promise<StreamContext>)[];
 };
 export declare const buildUrl: (url: string, params?: AnyObject, qsArrayFormat?: QueryString.IStringifyOptions["arrayFormat"]) => string;
@@ -26,14 +26,17 @@ export declare const getBody: (body: AnyObject, method: RequestMethod, headers?:
 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>;
+    lazyFinally(onfinally?: (() => void) | null | undefined): Promise<T> | null;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null | undefined): Promise<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>>;
+    blob(): Promise<any>;
+    text(): Promise<any>;
+    arrayBuffer(): Promise<any>;
+    formData(): Promise<any>;
+    bytes(): Promise<any>;
     stream<T>(): AsyncGenerator<StreamContext<T> | StreamContext<null>, void, unknown>;
+    retry(): HookFetch<unknown, E>;
+    get response(): Promise<Response>;
 }