hook-fetch 2.0.5 → 2.1.0

package/package.json

@@ -18,7 +18,18 @@
     "hook-fetch-plugin-response-transform",
     "hook-fetch-plugin-request-transform"
   ],
-  "version": "2.0.5",
+  "version": "2.1.0",
+  "scripts": {
+    "dev": "vite",
+    "build:rolldown": "rolldown -c ./rolldown.config.ts",
+    "build:umd": "vite build -c ./vite.config.umd.ts",
+    "build:base": "rimraf types && vite build",
+    "build": "rimraf types && rimraf dist && pnpm build:rolldown",
+    "publish:release": "npm publish",
+    "publish:beta": "npm publish --tag beta",
+    "test": "vitest",
+    "lint-staged": "lint-staged"
+  },
   "type": "module",
   "files": [
     "dist",
@@ -31,7 +42,9 @@
   "main": "./dist/cjs/index.cjs",
   "module": "./dist/es/index.mjs",
   "types": "./types/index.d.ts",
+  "browser": "./dist/umd/index.js",
   "unpkg": "./dist/umd/index.js",
+  "jsdelivr": "./dist/umd/index.js",
   "exports": {
     ".": {
       "require": "./dist/cjs/index.cjs",
@@ -82,12 +95,14 @@
     "oxlint": "^0.16.3",
     "react": "^19.1.0",
     "rimraf": "^6.0.1",
-    "rolldown": "1.0.0-beta.8",
+    "rolldown": "1.0.0-beta.28",
+    "rolldown-plugin-dts": "^0.13.6",
     "typescript": "^5.7.3",
     "vite": "npm:rolldown-vite@latest",
     "vite-plugin-dts": "^4.5.3",
     "vitest": "^3.0.8",
-    "vue": "^3.5.16"
+    "vue": "^3.5.16",
+    "@jsonlee/tsconfig": "workspace:^"
   },
   "peerDependencies": {
     "react": "^19.1.0",
@@ -105,15 +120,5 @@
     "commitizen": {
       "path": "node_modules/cz-git"
     }
-  },
-  "scripts": {
-    "dev": "vite",
-    "build:umd": "vite build -c ./vite.config.umd.ts",
-    "build:base": "rimraf types && vite build",
-    "build": "rimraf types && pnpm build:base && pnpm build:umd",
-    "ci:publish": "pnpm changeset publish -r",
-    "ci:beta": "pnpm changeset publish --tag beta -r",
-    "test": "vitest",
-    "lint-staged": "lint-staged"
   }
-}
+}

package/types/index-n7kSnbyZ.d.ts

@@ -0,0 +1,108 @@
+import { BaseOptions, BaseRequestOptions, DeleteOptions, GetOptions, HeadOptions, HookFetchPlugin, OptionsOptions, PatchOptions, PostOptions, PutOptions, RequestOptions, ResponseError, StreamContext } from "./types-CAGBd7wv.js";
+import { AnyObject, Generic } from "typescript-api-pro";
+import QueryString from "qs";
+
+//#region src/utils.d.ts
+
+declare class HookFetchRequest<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): Promise<TResult1 | TResult2>;
+  catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null | undefined): Promise<T | TResult>;
+  finally(onfinally?: (() => void) | null | undefined): void;
+  abort(): void;
+  json(): Promise<T>;
+  blob(): Promise<Blob>;
+  text(): Promise<string>;
+  arrayBuffer(): Promise<ArrayBuffer>;
+  formData(): Promise<FormData>;
+  bytes(): Promise<Uint8Array<ArrayBufferLike>>;
+  stream<T>(): AsyncGenerator<StreamContext<T> | StreamContext<null>, ResponseError<unknown> | undefined, unknown>;
+  retry(): HookFetchRequest<unknown, E>;
+  get response(): Promise<Response>;
+}
+//#endregion
+//#region src/base.d.ts
+type GenericWithNull<T, R extends AnyObject | null, K extends keyof R> = R extends null ? T : Generic<Exclude<R, null>, K, T>;
+declare class HookFetch<R extends AnyObject | null = null, K extends keyof R = never, E = AnyObject> {
+  #private;
+  constructor({
+    timeout,
+    baseURL,
+    headers,
+    plugins,
+    withCredentials
+  }: BaseOptions);
+  use(plugin: HookFetchPlugin<any, any, any, any>): this;
+  request<T = AnyObject, P = AnyObject, D = AnyObject>(url: string, {
+    timeout,
+    headers,
+    method,
+    params,
+    data,
+    qsArrayFormat,
+    withCredentials,
+    extra
+  }?: RequestOptions<P, D, E>): HookFetchRequest<GenericWithNull<T, R, K>, E>;
+  get<T = AnyObject, P = AnyObject>(url: string, params?: P, options?: GetOptions<P, E>): HookFetchRequest<GenericWithNull<T, R, K>, E>;
+  head<T = AnyObject, P = AnyObject>(url: string, params?: P, options?: HeadOptions<P, E>): HookFetchRequest<GenericWithNull<T, R, K>, E>;
+  options<T = AnyObject, P = AnyObject, D = AnyObject>(url: string, params?: P, options?: OptionsOptions<P, D, E>): HookFetchRequest<GenericWithNull<T, R, K>, E>;
+  delete<T = AnyObject, D = AnyObject, P = AnyObject>(url: string, options?: DeleteOptions<P, D, E>): HookFetchRequest<GenericWithNull<T, R, K>, E>;
+  post<T = AnyObject, D = AnyObject, P = AnyObject>(url: string, data?: D, options?: PostOptions<D, P, E>): HookFetchRequest<GenericWithNull<T, R, K>, E>;
+  upload<T = AnyObject, D = AnyObject, P = AnyObject>(url: string, data?: D, options?: PostOptions<D, P, E>): HookFetchRequest<GenericWithNull<T, R, K>, E>;
+  put<T = AnyObject, D = AnyObject, P = AnyObject>(url: string, data?: D, options?: PutOptions<D, P, E>): HookFetchRequest<GenericWithNull<T, R, K>, E>;
+  patch<T = AnyObject, D = AnyObject, P = AnyObject>(url: string, data?: D, options?: PatchOptions<D, P, E>): HookFetchRequest<GenericWithNull<T, R, K>, E>;
+  abortAll(): void;
+}
+declare const useRequest: <R = AnyObject, P = AnyObject, D = AnyObject, E = AnyObject>(url: string, options?: RequestOptions<P, D, E>) => HookFetchRequest<R, E>;
+declare const request: <R = AnyObject, P = AnyObject, D = AnyObject, E = AnyObject>(url: string, options?: RequestOptions<P, D, E>) => HookFetchRequest<R, E>;
+declare const get: <R = AnyObject, P = AnyObject, E = AnyObject>(url: string, params?: P, options?: GetOptions<P, E>) => HookFetchRequest<R, E>;
+declare const head: <R = AnyObject, P = AnyObject, E = AnyObject>(url: string, params?: P, options?: HeadOptions<P, E>) => HookFetchRequest<R, E>;
+declare const options: <R = AnyObject, P = AnyObject, D = AnyObject, E = AnyObject>(url: string, params?: P, options?: OptionsOptions<P, D, E>) => HookFetchRequest<R, E>;
+declare const del: <R = AnyObject, D = AnyObject, P = AnyObject, E = AnyObject>(url: string, options?: DeleteOptions<P, D, E>) => HookFetchRequest<R, E>;
+declare const post: <R = AnyObject, D = AnyObject, P = AnyObject, E = AnyObject>(url: string, data?: D, options?: PostOptions<D, P, E>) => HookFetchRequest<R, E>;
+declare const upload: <R = AnyObject, D = AnyObject, P = AnyObject, E = AnyObject>(url: string, data?: D, options?: PostOptions<D, P, E>) => HookFetchRequest<R, E>;
+declare const put: <R = AnyObject, D = AnyObject, P = AnyObject, E = AnyObject>(url: string, data?: D, options?: PutOptions<D, P, E>) => HookFetchRequest<R, E>;
+declare const patch: <R = AnyObject, D = AnyObject, P = AnyObject, E = AnyObject>(url: string, data?: D, options?: PatchOptions<D, P, E>) => HookFetchRequest<R, E>;
+type ExportDefault = typeof useRequest & {
+  create: <R extends AnyObject | null = null, K extends keyof R = never, E = AnyObject>(options: BaseOptions) => (HookFetch<R, K, E>['request'] & HookFetch<R, K, E>);
+  get: typeof get;
+  head: typeof head;
+  options: typeof options;
+  delete: typeof del;
+  post: typeof post;
+  put: typeof put;
+  patch: typeof patch;
+  upload: typeof upload;
+};
+declare const hookFetch: ExportDefault;
+//#endregion
+//#region src/enum.d.ts
+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",
+}
+declare enum StatusCode {
+  TIME_OUT = 408,
+  ABORTED = 499,
+  NETWORK_ERROR = 599,
+  BODY_NULL = 502,
+  UNKNOWN = 601,
+}
+declare enum Method {
+  GET = "GET",
+  POST = "POST",
+  PUT = "PUT",
+  DELETE = "DELETE",
+  PATCH = "PATCH",
+  HEAD = "HEAD",
+  OPTIONS = "OPTIONS",
+}
+//#endregion
+export { ContentType, HookFetchRequest, Method, StatusCode, del, get, head, hookFetch, options, patch, post, put, request, upload };

package/types/index.d.ts

@@ -1,6 +1,3 @@
-import { default as hookFetch } from './base';
-export * from './base';
-export * from './enum';
-export * from './types';
-export * from './error';
-export default hookFetch;
+import { AfterResponseHandler, BaseOptions, BaseRequestOptions, BeforeRequestHandler, BeforeStreamHandler, DeleteOptions, FetchPluginContext, FetchResponseType, GetOptions, HeadOptions, HookFetchPlugin, OnErrorHandler, OnFinallyHandler, OptionProps, OptionsOptions, PatchOptions, PostOptions, PutOptions, RequestConfig, RequestMethod, RequestMethodWithBody, RequestMethodWithParams, RequestOptions, RequestUseOptions, RequestWithBodyFnOptions, RequestWithBodyOptions, RequestWithParamsFnOptions, RequestWithParamsOptions, ResponseError, ResponseErrorOptions, StreamContext, TransformStreamChunkHandler } from "./types-CAGBd7wv.js";
+import { ContentType, Method, StatusCode, del, get, head, hookFetch, options, patch, post, put, request, upload } from "./index-n7kSnbyZ.js";
+export { AfterResponseHandler, BaseOptions, BaseRequestOptions, BeforeRequestHandler, BeforeStreamHandler, ContentType, DeleteOptions, FetchPluginContext, FetchResponseType, GetOptions, HeadOptions, HookFetchPlugin, Method, OnErrorHandler, OnFinallyHandler, OptionProps, OptionsOptions, PatchOptions, PostOptions, PutOptions, RequestConfig, RequestMethod, RequestMethodWithBody, RequestMethodWithParams, RequestOptions, RequestUseOptions, RequestWithBodyFnOptions, RequestWithBodyOptions, RequestWithParamsFnOptions, RequestWithParamsOptions, ResponseError, ResponseErrorOptions, StatusCode, StreamContext, TransformStreamChunkHandler, hookFetch as default, del, get, head, options, patch, post, put, request, upload };

package/types/plugins/index.d.ts

@@ -1 +1,3 @@
-export * from './sse';
+import "../types-CAGBd7wv.js";
+import { SSETextDecoderPluginOptions, sseTextDecoderPlugin } from "../sse-DPRkQwhR.js";
+export { SSETextDecoderPluginOptions, sseTextDecoderPlugin };

package/types/plugins/sse.d.ts

@@ -1,45 +1,3 @@
-import { HookFetchPlugin } from '../types';
-export interface SSETextDecoderPluginOptions {
-    splitSeparator: string;
-    lineSeparator: string | undefined;
-    trim: boolean;
-    json: boolean;
-    prefix: string;
-    doneSymbol: string;
-}
-/**
- * SSE 文本解码插件 | A SSE (Server-Sent Events) response text decoder plugin.
- *
- * 用于处理服务端推送事件(SSE)的响应流,提供以下功能:
- * - 将二进制Buffer解码为文本
- * - 按指定分隔符拆分事件块
- * - 去除首尾空白字符
- * - 自动JSON解析
- * - 移除特定前缀
- *
- * Processes Server-Sent Events (SSE) response streams with the following features:
- * - Decodes binary buffer to text
- * - Splits event chunks by specified separator
- * - Trims whitespace
- * - Automatic JSON parsing
- * - Removes specified prefix
- *
- * @param {Object} [options] 配置选项 | Plugin options
- * @param {string} [options.splitSeparator='\n\n'] 分割符,用于拆分事件块(默认 '\n\n') | Separator for splitting events (default '\n\n')
- * @param {string} [options.lineSeparator] 行分割符,用于拆分每行(可选) | Line separator for splitting each line (optional)
- * @param {boolean} [options.trim=true] 是否去除首尾空白(默认 true) | Whether to trim whitespace (default true)
- * @param {boolean} [options.json=false] 是否解析JSON(默认 false) | Whether to parse JSON (default false)
- * @param {string} [options.prefix=''] 要移除的前缀,如 "data: "(默认为空) | Prefix to remove, e.g. "data: " (default '')
- * @param {string} [options.doneSymbol] 结束标记,收到此标记时结束流(可选) | Symbol indicating stream end (optional)
- * @returns {HookFetchPlugin} 返回 HookFetch 插件实例 | Returns a HookFetch plugin instance
- * @example
- * request.use(sseTextDecoderPlugin({
- *   json: true,
- *   prefix: 'data:',
- *   splitSeparator: '\n\n',
- *   doneSymbol: '[DONE]'
- * }));
- */
-export declare const sseTextDecoderPlugin: ({ splitSeparator, lineSeparator, trim, json, prefix, doneSymbol }?: Partial<SSETextDecoderPluginOptions>) => HookFetchPlugin<unknown, {
-    sseAble: boolean;
-}>;
+import "../types-CAGBd7wv.js";
+import { SSETextDecoderPluginOptions, sseTextDecoderPlugin } from "../sse-DPRkQwhR.js";
+export { SSETextDecoderPluginOptions, sseTextDecoderPlugin };

package/types/react/index.d.ts

@@ -1,34 +1,26 @@
-import { HookFetchRequest } from '../utils';
+import { ResponseError, StreamContext } from "../types-CAGBd7wv.js";
+import { HookFetchRequest } from "../index-n7kSnbyZ.js";
+import * as react0 from "react";
+
+//#region src/react/index.d.ts
 interface UseHookFetchOptions<Q extends (...args: any[]) => any> {
-    request: Q;
-    onError?: (e: Error) => any;
+  request: Q;
+  onError?: (e: Error) => any;
 }
-/**
- * Hook fetch composable function | Hook fetch 组合式函数
- * @param options - Hook fetch options | Hook fetch 选项
- * @param options.request - Request function | 请求函数
- * @param options.onError - Error callback function | 错误回调函数
- * @returns {Function} request - Request function | 请求函数
- * @returns {Function} cancel - Cancel request | 取消请求
- * @returns {boolean} loading - Loading state | 加载状态
- * @returns {Function} setLoading - Set Loading State | 修改加载状态
- * @returns {Function} text - Get response as text | 获取文本响应
- * @returns {Function} stream - Get response as stream | 获取流响应 | 获取流响应
- * @returns {Function} blob - Get response as blob | 获取二进制响应
- * @returns {Function} arrayBuffer - Get response as array buffer | 获取二进制缓冲区响应
- * @returns {Function} formDataResult - Get response as form data | 获取表单数据响应
- * @returns {Function} bytesData - Get response as bytes | 获取字节数据响应
- */
-export declare const useHookFetch: <Q extends (...args: any[]) => any>({ request, onError }: UseHookFetchOptions<Q>) => {
-    request: (...args: any[]) => import('react').RefObject<HookFetchRequest<any, any> | null>;
-    stream: (...args: Parameters<Q>) => AsyncGenerator<import('..').StreamContext<unknown> | import('..').StreamContext<null>, import('../utils').ResponseError<unknown> | undefined, unknown>;
-    text: (...args: Parameters<Q>) => Promise<any>;
-    blob: (...args: Parameters<Q>) => Promise<any>;
-    arrayBufferData: (...args: Parameters<Q>) => Promise<any>;
-    formDataResult: (...args: Parameters<Q>) => Promise<any>;
-    bytesData: (...args: Parameters<Q>) => Promise<any>;
-    cancel: () => void;
-    loading: boolean;
-    setLoading: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+declare const useHookFetch: <Q extends (...args: any[]) => any>({
+  request,
+  onError
+}: UseHookFetchOptions<Q>) => {
+  request: (...args: any[]) => react0.RefObject<HookFetchRequest<any, any> | null>;
+  stream: (...args: Parameters<Q>) => AsyncGenerator<StreamContext<unknown> | StreamContext<null>, ResponseError<unknown> | undefined, unknown>;
+  text: (...args: Parameters<Q>) => Promise<string>;
+  blob: (...args: Parameters<Q>) => Promise<Blob>;
+  arrayBufferData: (...args: Parameters<Q>) => Promise<ArrayBuffer>;
+  formDataResult: (...args: Parameters<Q>) => Promise<FormData>;
+  bytesData: (...args: Parameters<Q>) => Promise<Uint8Array<ArrayBufferLike>>;
+  cancel: () => void;
+  loading: boolean;
+  setLoading: react0.Dispatch<react0.SetStateAction<boolean>>;
 };
-export {};
+//#endregion
+export { useHookFetch };

package/types/sse-DPRkQwhR.d.ts

@@ -0,0 +1,23 @@
+import { HookFetchPlugin } from "./types-CAGBd7wv.js";
+
+//#region src/plugins/sse.d.ts
+interface SSETextDecoderPluginOptions {
+  splitSeparator: string;
+  lineSeparator: string | undefined;
+  trim: boolean;
+  json: boolean;
+  prefix: string;
+  doneSymbol: string;
+}
+declare const sseTextDecoderPlugin: ({
+  splitSeparator,
+  lineSeparator,
+  trim,
+  json,
+  prefix,
+  doneSymbol
+}?: Partial<SSETextDecoderPluginOptions>) => HookFetchPlugin<unknown, {
+  sseAble: boolean;
+}>;
+//#endregion
+export { SSETextDecoderPluginOptions, sseTextDecoderPlugin };

package/types/types-CAGBd7wv.d.ts

@@ -0,0 +1,110 @@
+import { AnyObject } from "typescript-api-pro";
+import QueryString from "qs";
+
+//#region src/error.d.ts
+interface ResponseErrorOptions<E = unknown> {
+  name?: string;
+  message: string;
+  status?: number;
+  statusText?: string;
+  response?: Response;
+  config?: RequestConfig<unknown, unknown, E>;
+}
+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;
+}
+//#endregion
+//#region src/types.d.ts
+type FetchResponseType = 'json' | 'text' | 'blob' | 'arrayBuffer' | 'formData' | 'bytes';
+type RequestMethodWithParams = 'GET' | 'HEAD';
+type RequestMethodWithBody = 'PUT' | 'PATCH' | 'POST' | 'DELETE' | 'OPTIONS';
+type RequestMethod = RequestMethodWithParams | RequestMethodWithBody;
+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'];
+}
+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;
+};
+interface FetchPluginContext<T = unknown, E = unknown, P = unknown, D = unknown> {
+  config: RequestConfig<P, D, E>;
+  response: Response;
+  responseType: FetchResponseType;
+  result?: T;
+  controller: AbortController;
+}
+interface StreamContext<T = unknown> {
+  result: T;
+  source: Uint8Array<ArrayBufferLike>;
+  error: unknown | null;
+}
+type BeforeRequestHandler<E = unknown, P = unknown, D = unknown> = (config: RequestConfig<P, D, E>) => RequestConfig<P, D, E> | PromiseLike<RequestConfig<P, D, E>>;
+type AfterResponseHandler<T = unknown, E = unknown, P = unknown, D = unknown> = (context: FetchPluginContext<T>, config: RequestConfig<P, D, E>) => FetchPluginContext<T> | PromiseLike<FetchPluginContext<T>>;
+type BeforeStreamHandler<E = unknown, P = unknown, D = unknown> = (body: ReadableStream<any>, config: RequestConfig<P, D, E>) => ReadableStream<any> | PromiseLike<ReadableStream<any>>;
+type TransformStreamChunkHandler<E = unknown, P = unknown, D = unknown> = (chunk: StreamContext<any>, config: RequestConfig<P, D, E>) => StreamContext | PromiseLike<StreamContext>;
+type OnFinallyHandler<E = unknown, P = unknown, D = unknown> = (res: Pick<FetchPluginContext<unknown, E, P, D>, 'config' | 'response'>) => void | PromiseLike<void>;
+type OnErrorHandler<E = unknown, P = unknown, D = unknown> = (error: ResponseError, config: RequestConfig<P, D, E>) => PromiseLike<Error | void | ResponseError<E>> | Error | void | ResponseError<E>;
+type HookFetchPlugin<T = unknown, E = unknown, P = unknown, D = unknown> = {
+  name: string;
+  priority?: number;
+  beforeRequest?: BeforeRequestHandler<E, P, D>;
+  afterResponse?: AfterResponseHandler<T, E, P, D>;
+  beforeStream?: BeforeStreamHandler<E, P, D>;
+  transformStreamChunk?: TransformStreamChunkHandler<E, P, D>;
+  onError?: OnErrorHandler<E, P, D>;
+  onFinally?: OnFinallyHandler<E, P, D>;
+};
+interface OptionProps {
+  baseURL: string;
+  timeout: number;
+  headers: HeadersInit;
+  plugins: Array<HookFetchPlugin<any, any, any, any>>;
+  withCredentials: boolean;
+}
+type BaseOptions = Partial<OptionProps>;
+type RequestOptions<P = AnyObject, D = AnyObject, E = AnyObject> = Omit<BaseRequestOptions<P, D, E>, 'url' | 'plugins' | 'baseURL' | 'controller'>;
+type RequestUseOptions<P = AnyObject, D = AnyObject, E = AnyObject> = RequestOptions<P, D, E>;
+type RequestWithBodyOptions<D = AnyObject, P = AnyObject, E = AnyObject> = Omit<RequestOptions<P, D, E>, 'data'>;
+type RequestWithParamsOptions<P = AnyObject, E = AnyObject> = Omit<RequestOptions<P, null, E>, 'params' | 'data'>;
+type RequestWithBodyFnOptions<D = AnyObject, P = AnyObject, E = AnyObject> = Omit<RequestOptions<P, D, E>, 'data' | 'method'>;
+type RequestWithParamsFnOptions<P = AnyObject, E = AnyObject> = Omit<RequestOptions<P, null, E>, 'params' | 'data' | 'method'>;
+type PostOptions<D = AnyObject, P = AnyObject, E = AnyObject> = RequestWithBodyFnOptions<D, P, E>;
+type PutOptions<D = AnyObject, P = AnyObject, E = AnyObject> = RequestWithBodyFnOptions<D, P, E>;
+type PatchOptions<D = AnyObject, P = AnyObject, E = AnyObject> = RequestWithBodyFnOptions<D, P, E>;
+type GetOptions<P = AnyObject, E = AnyObject> = RequestWithParamsFnOptions<P, E>;
+type HeadOptions<P = AnyObject, E = AnyObject> = RequestWithParamsFnOptions<P, E>;
+type OptionsOptions<P = AnyObject, D = AnyObject, E = AnyObject> = RequestUseOptions<P, D, E>;
+type DeleteOptions<P = AnyObject, D = AnyObject, E = AnyObject> = RequestUseOptions<P, D, E>;
+//#endregion
+export { AfterResponseHandler, BaseOptions, BaseRequestOptions, BeforeRequestHandler, BeforeStreamHandler, DeleteOptions, FetchPluginContext, FetchResponseType, GetOptions, HeadOptions, HookFetchPlugin, OnErrorHandler, OnFinallyHandler, OptionProps, OptionsOptions, PatchOptions, PostOptions, PutOptions, RequestConfig, RequestMethod, RequestMethodWithBody, RequestMethodWithParams, RequestOptions, RequestUseOptions, RequestWithBodyFnOptions, RequestWithBodyOptions, RequestWithParamsFnOptions, RequestWithParamsOptions, ResponseError, ResponseErrorOptions, StreamContext, TransformStreamChunkHandler };

package/types/vue/index.d.ts

@@ -1,32 +1,25 @@
-import { HookFetchRequest } from '../utils';
+import { ResponseError, StreamContext } from "../types-CAGBd7wv.js";
+import { HookFetchRequest } from "../index-n7kSnbyZ.js";
+import * as vue0 from "vue";
+
+//#region src/vue/index.d.ts
 interface UseHookFetchOptions<Q extends (...args: any[]) => any> {
-    request: Q;
-    onError?: (e: Error) => any;
+  request: Q;
+  onError?: (e: Error) => any;
 }
-/**
- * Hook fetch composable function | Hook fetch 组合式函数
- * @param options - Hook fetch options | Hook fetch 选项
- * @param options.request - Request function | 请求函数
- * @param options.onError - Error callback function | 错误回调函数
- * @returns {Function} request - Request function | 请求函数
- * @returns {Function} cancel - Cancel request | 取消请求
- * @returns {Ref<boolean>} loading - Loading state | 加载状态
- * @returns {Function} text - Get response as text | 获取文本响应
- * @returns {Function} stream - Get response as stream | 获取流响应 | 获取流响应
- * @returns {Function} blob - Get response as blob | 获取二进制响应
- * @returns {Function} arrayBuffer - Get response as array buffer | 获取二进制缓冲区响应
- * @returns {Function} formDataResult - Get response as form data | 获取表单数据响应
- * @returns {Function} bytesData - Get response as bytes | 获取字节数据响应
- */
-export declare const useHookFetch: <Q extends (...args: any[]) => any>({ request, onError }: UseHookFetchOptions<Q>) => {
-    request: (...args: any[]) => HookFetchRequest<any, any> | null;
-    stream: (...args: Parameters<Q>) => AsyncGenerator<import('..').StreamContext<unknown> | import('..').StreamContext<null>, import('../utils').ResponseError<unknown> | undefined, unknown>;
-    text: (...args: Parameters<Q>) => Promise<any>;
-    blob: (...args: Parameters<Q>) => Promise<any>;
-    arrayBufferData: (...args: Parameters<Q>) => Promise<any>;
-    formDataResult: (...args: Parameters<Q>) => Promise<any>;
-    bytesData: (...args: Parameters<Q>) => Promise<any>;
-    cancel: () => void;
-    loading: import('vue').Ref<boolean, boolean>;
+declare const useHookFetch: <Q extends (...args: any[]) => any>({
+  request,
+  onError
+}: UseHookFetchOptions<Q>) => {
+  request: (...args: any[]) => HookFetchRequest<any, any> | null;
+  stream: (...args: Parameters<Q>) => AsyncGenerator<StreamContext<unknown> | StreamContext<null>, ResponseError<unknown> | undefined, unknown>;
+  text: (...args: Parameters<Q>) => Promise<string>;
+  blob: (...args: Parameters<Q>) => Promise<Blob>;
+  arrayBufferData: (...args: Parameters<Q>) => Promise<ArrayBuffer>;
+  formDataResult: (...args: Parameters<Q>) => Promise<FormData>;
+  bytesData: (...args: Parameters<Q>) => Promise<Uint8Array<ArrayBufferLike>>;
+  cancel: () => void;
+  loading: vue0.Ref<boolean, boolean>;
 };
-export {};
+//#endregion
+export { useHookFetch };

package/types/base.d.ts

@@ -1,41 +0,0 @@
-import { AnyObject, Generic } from 'typescript-api-pro';
-import { BaseOptions, DeleteOptions, GetOptions, HeadOptions, HookFetchPlugin, OptionsOptions, PatchOptions, PostOptions, PutOptions, RequestOptions } from './types';
-import { HookFetchRequest } from './utils';
-declare class HookFetch<R extends AnyObject = AnyObject, K extends keyof R = 'data', E = AnyObject> {
-    #private;
-    constructor({ timeout, baseURL, headers, plugins, withCredentials }: BaseOptions);
-    use(plugin: HookFetchPlugin<any, any, any, any>): this;
-    request<T = AnyObject, P = AnyObject, D = AnyObject>(url: string, { timeout, headers, method, params, data, qsArrayFormat, withCredentials, extra }?: RequestOptions<P, D, E>): HookFetchRequest<Generic<R, K, T>, E>;
-    get<T = AnyObject, P = AnyObject>(url: string, params?: P, options?: GetOptions<P, E>): HookFetchRequest<Generic<R, K, T>, E>;
-    head<T = AnyObject, P = AnyObject>(url: string, params?: P, options?: HeadOptions<P, E>): HookFetchRequest<Generic<R, K, T>, E>;
-    options<T = AnyObject, P = AnyObject, D = AnyObject>(url: string, params?: P, options?: OptionsOptions<P, D, E>): HookFetchRequest<Generic<R, K, T>, E>;
-    delete<T = AnyObject, D = AnyObject, P = AnyObject>(url: string, options?: DeleteOptions<P, D, E>): HookFetchRequest<Generic<R, K, T>, E>;
-    post<T = AnyObject, D = AnyObject, P = AnyObject>(url: string, data?: D, options?: PostOptions<D, P, E>): HookFetchRequest<Generic<R, K, T>, E>;
-    upload<T = AnyObject, D = AnyObject, P = AnyObject>(url: string, data?: D, options?: PostOptions<D, P, E>): HookFetchRequest<Generic<R, K, T>, E>;
-    put<T = AnyObject, D = AnyObject, P = AnyObject>(url: string, data?: D, options?: PutOptions<D, P, E>): HookFetchRequest<Generic<R, K, T>, E>;
-    patch<T = AnyObject, D = AnyObject, P = AnyObject>(url: string, data?: D, options?: PatchOptions<D, P, E>): HookFetchRequest<Generic<R, K, T>, E>;
-    abortAll(): void;
-}
-declare const useRequest: <R = AnyObject, P = AnyObject, D = AnyObject, E = AnyObject>(url: string, options?: RequestOptions<P, D, E>) => HookFetchRequest<R, E>;
-export declare const request: <R = AnyObject, P = AnyObject, D = AnyObject, E = AnyObject>(url: string, options?: RequestOptions<P, D, E>) => HookFetchRequest<R, E>;
-export declare const get: <R = AnyObject, P = AnyObject, E = AnyObject>(url: string, params?: P, options?: GetOptions<P, E>) => HookFetchRequest<R, E>;
-export declare const head: <R = AnyObject, P = AnyObject, E = AnyObject>(url: string, params?: P, options?: HeadOptions<P, E>) => HookFetchRequest<R, E>;
-export declare const options: <R = AnyObject, P = AnyObject, D = AnyObject, E = AnyObject>(url: string, params?: P, options?: OptionsOptions<P, D, E>) => HookFetchRequest<R, E>;
-export declare const del: <R = AnyObject, D = AnyObject, P = AnyObject, E = AnyObject>(url: string, options?: DeleteOptions<P, D, E>) => HookFetchRequest<R, E>;
-export declare const post: <R = AnyObject, D = AnyObject, P = AnyObject, E = AnyObject>(url: string, data?: D, options?: PostOptions<D, P, E>) => HookFetchRequest<R, E>;
-export declare const upload: <R = AnyObject, D = AnyObject, P = AnyObject, E = AnyObject>(url: string, data?: D, options?: PostOptions<D, P, E>) => HookFetchRequest<R, E>;
-export declare const put: <R = AnyObject, D = AnyObject, P = AnyObject, E = AnyObject>(url: string, data?: D, options?: PutOptions<D, P, E>) => HookFetchRequest<R, E>;
-export declare const patch: <R = AnyObject, D = AnyObject, P = AnyObject, E = AnyObject>(url: string, data?: D, options?: PatchOptions<D, P, E>) => HookFetchRequest<R, E>;
-type ExportDefault = typeof useRequest & {
-    create: <R extends AnyObject = AnyObject, K extends keyof R = 'data', E = AnyObject>(options: BaseOptions) => (HookFetch<R, K, E>['request'] & HookFetch<R, K, E>);
-    get: typeof get;
-    head: typeof head;
-    options: typeof options;
-    delete: typeof del;
-    post: typeof post;
-    put: typeof put;
-    patch: typeof patch;
-    upload: typeof upload;
-};
-declare const hookFetch: ExportDefault;
-export default hookFetch;

package/types/enum.d.ts

@@ -1,26 +0,0 @@
-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 declare enum Method {
-    GET = "GET",
-    POST = "POST",
-    PUT = "PUT",
-    DELETE = "DELETE",
-    PATCH = "PATCH",
-    HEAD = "HEAD",
-    OPTIONS = "OPTIONS"
-}

package/types/error.d.ts

@@ -1,19 +0,0 @@
-import { RequestConfig } from './types';
-export interface ResponseErrorOptions<E = unknown> {
-    name?: string;
-    message: string;
-    status?: number;
-    statusText?: string;
-    response?: Response;
-    config?: RequestConfig<unknown, unknown, E>;
-}
-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;
-}