@varlet/axle 0.2.6 → 0.2.7-alpha.1701536208987

package/es/index.js

@@ -1,2 +1,214 @@
-export * from './instance.js';
-export * from './interceptors';
+import {
+  __spreadValues
+} from "./chunk-KLNSLHAC.js";
+
+// src/instance.ts
+import axios from "axios";
+import qs from "qs";
+import { inBrowser } from "@varlet/shared";
+function createFetchRunner(service, method, responseType) {
+  return function(url, params, config) {
+    return service[method](url, __spreadValues({
+      params,
+      responseType
+    }, config));
+  };
+}
+function createModifyRunner(service, method, contentType) {
+  return function(url, params, config) {
+    if (contentType === "application/x-www-form-urlencoded") {
+      params = qs.stringify(params);
+    }
+    if (contentType === "multipart/form-data") {
+      const formData = new FormData();
+      Object.keys(params).forEach((key) => formData.append(key, params[key]));
+      params = formData;
+    }
+    return service[method](url, params, __spreadValues({
+      headers: {
+        "Content-Type": contentType
+      }
+    }, config));
+  };
+}
+function download(url, filename) {
+  if (!inBrowser()) {
+    return;
+  }
+  const a = document.createElement("a");
+  a.download = filename;
+  a.style.display = "none";
+  a.href = typeof url === "string" ? url : URL.createObjectURL(url);
+  document.body.appendChild(a);
+  a.click();
+  URL.revokeObjectURL(a.href);
+  document.body.removeChild(a);
+}
+function createAxle(config = {}) {
+  const service = axios.create(config);
+  function getHeaders() {
+    return service.defaults.headers.common;
+  }
+  function setHeader(key, value) {
+    ;
+    service.defaults.headers.common[key] = value;
+  }
+  function removeHeader(key) {
+    if (typeof key === "string") {
+      Reflect.deleteProperty(service.defaults.headers.common, key);
+      return;
+    }
+    key.forEach((k) => Reflect.deleteProperty(service.defaults.headers.common, k));
+  }
+  function useRequestInterceptor(...interceptors) {
+    interceptors.forEach((interceptor) => {
+      service.interceptors.request.use(interceptor.onFulfilled, interceptor.onRejected, interceptor.options);
+    });
+  }
+  function useResponseInterceptor(...interceptors) {
+    interceptors.forEach((interceptor) => {
+      service.interceptors.response.use(interceptor.onFulfilled, interceptor.onRejected, interceptor.options);
+    });
+  }
+  return {
+    get: createFetchRunner(service, "get", "json"),
+    getBlob: createFetchRunner(service, "get", "blob"),
+    getDocument: createFetchRunner(service, "get", "document"),
+    getArrayBuffer: createFetchRunner(service, "get", "arraybuffer"),
+    getText: createFetchRunner(service, "get", "text"),
+    getStream: createFetchRunner(service, "get", "stream"),
+    head: createFetchRunner(service, "head", "json"),
+    headBlob: createFetchRunner(service, "head", "blob"),
+    headDocument: createFetchRunner(service, "head", "document"),
+    headArrayBuffer: createFetchRunner(service, "head", "arraybuffer"),
+    headText: createFetchRunner(service, "head", "text"),
+    headStream: createFetchRunner(service, "head", "stream"),
+    options: createFetchRunner(service, "options", "json"),
+    optionsBlob: createFetchRunner(service, "options", "blob"),
+    optionsDocument: createFetchRunner(service, "options", "document"),
+    optionsArrayBuffer: createFetchRunner(service, "options", "arraybuffer"),
+    optionsText: createFetchRunner(service, "options", "text"),
+    optionsStream: createFetchRunner(service, "options", "stream"),
+    delete: createFetchRunner(service, "delete", "json"),
+    deleteBlob: createFetchRunner(service, "delete", "blob"),
+    deleteDocument: createFetchRunner(service, "delete", "document"),
+    deleteArrayBuffer: createFetchRunner(service, "delete", "arraybuffer"),
+    deleteText: createFetchRunner(service, "delete", "text"),
+    deleteStream: createFetchRunner(service, "delete", "stream"),
+    post: createModifyRunner(service, "post", "application/json"),
+    postUrlEncode: createModifyRunner(service, "post", "application/x-www-form-urlencoded"),
+    postMultipart: createModifyRunner(service, "post", "multipart/form-data"),
+    put: createModifyRunner(service, "put", "application/json"),
+    putUrlEncode: createModifyRunner(service, "put", "application/x-www-form-urlencoded"),
+    putMultipart: createModifyRunner(service, "put", "multipart/form-data"),
+    patch: createModifyRunner(service, "patch", "application/json"),
+    patchUrlEncode: createModifyRunner(service, "patch", "application/x-www-form-urlencoded"),
+    patchMultipart: createModifyRunner(service, "patch", "multipart/form-data"),
+    getHeaders,
+    setHeader,
+    removeHeader,
+    useRequestInterceptor,
+    useResponseInterceptor,
+    axios: service
+  };
+}
+
+// src/interceptors/requestHeadersInterceptor.ts
+import { isFunction } from "@varlet/shared";
+
+// src/matcher.ts
+import { minimatch } from "minimatch";
+function matchPattern(pattern, method, url) {
+  return pattern.startsWith("method:") ? pattern.replace("method:", "").trim() === method : minimatch(url != null ? url : "", pattern);
+}
+function createMatcher(include, exclude) {
+  function matcher(method, url) {
+    if (!include && !exclude) {
+      return true;
+    }
+    const isExclude = (exclude != null ? exclude : []).some((pattern) => matchPattern(pattern, method, url));
+    if (isExclude) {
+      return false;
+    }
+    if (!include) {
+      return true;
+    }
+    const isInclude = (include != null ? include : []).some((pattern) => matchPattern(pattern, method, url));
+    return isInclude;
+  }
+  return matcher;
+}
+
+// src/interceptors/requestHeadersInterceptor.ts
+function requestHeadersInterceptor(options = {}) {
+  const { headers: headersOrGetter } = options;
+  return {
+    onFulfilled(config) {
+      var _a, _b, _c;
+      const matcher = createMatcher(options.include, options.exclude);
+      if (!matcher((_a = config.method) != null ? _a : "", (_b = config.url) != null ? _b : "")) {
+        return config;
+      }
+      const headers = (_c = isFunction(headersOrGetter) ? headersOrGetter() : headersOrGetter) != null ? _c : {};
+      Object.entries(headers).forEach(([key, value]) => {
+        config.headers[key] = value;
+      });
+      return config;
+    },
+    onRejected(error) {
+      return Promise.reject(error);
+    },
+    options: options.axiosInterceptorOptions
+  };
+}
+
+// src/interceptors/responseBlobInterceptor.ts
+function responseBlobInterceptor(options = {}) {
+  return {
+    onFulfilled(response) {
+      var _a, _b, _c, _d;
+      const matcher = createMatcher(options.include, options.exclude);
+      if (!matcher((_a = response.config.method) != null ? _a : "", (_b = response.config.url) != null ? _b : "")) {
+        return response;
+      }
+      if (response.request.responseType === "blob") {
+        return (_d = (_c = options.onResponse) == null ? void 0 : _c.call(options, response)) != null ? _d : response;
+      }
+      return response;
+    },
+    onRejected(error) {
+      return Promise.reject(error);
+    },
+    options: options.axiosInterceptorOptions
+  };
+}
+
+// src/interceptors/responseTimeoutInterceptor.ts
+function responseTimeoutInterceptor(options = {}) {
+  return {
+    onFulfilled(response) {
+      return response;
+    },
+    onRejected(error) {
+      var _a, _b, _c;
+      const matcher = createMatcher(options.include, options.exclude);
+      if (!matcher((_a = error.config.method) != null ? _a : "", (_b = error.config.url) != null ? _b : "")) {
+        return Promise.reject(error);
+      }
+      if (error.code === "ECONNABORTED" && error.message.includes("timeout") || error.code === "ETIMEDOUT") {
+        error.code = (_c = options == null ? void 0 : options.normalizeErrorCode) != null ? _c : "TIMEOUT";
+      }
+      return Promise.reject(error);
+    },
+    options: options.axiosInterceptorOptions
+  };
+}
+export {
+  createAxle,
+  createFetchRunner,
+  createModifyRunner,
+  download,
+  requestHeadersInterceptor,
+  responseBlobInterceptor,
+  responseTimeoutInterceptor
+};

package/es/instance-8e68a761.d.ts

@@ -0,0 +1,64 @@
+import { AxiosRequestConfig, AxiosResponse, AxiosInterceptorOptions, InternalAxiosRequestConfig, HeadersDefaults, AxiosInstance, ResponseType } from 'axios';
+
+type AxleRequestConfig = AxiosRequestConfig & {
+    exceptionMessage?: any;
+};
+type FetchRunner = <T = any, R = AxiosResponse<T>>(url: string, params?: any, config?: AxleRequestConfig) => Promise<R>;
+type ModifyRunner = <T = any, R = AxiosResponse<T>>(url: string, params?: any, config?: AxleRequestConfig) => Promise<R>;
+type FetchMethod = 'get' | 'delete' | 'options' | 'head';
+type ModifyMethod = 'post' | 'put' | 'patch';
+type RunnerMethod = keyof Omit<AxleInstance, 'axios' | 'getHeaders' | 'setHeader' | 'removeHeader' | 'useRequestInterceptor' | 'useResponseInterceptor'>;
+interface Interceptor<V> {
+    onFulfilled?: ((value: V) => any) | null;
+    onRejected?: ((error: any) => any) | null;
+    options?: AxiosInterceptorOptions;
+}
+type RequestInterceptor = Interceptor<InternalAxiosRequestConfig>;
+type ResponseInterceptor<V = AxiosResponse<any, any>> = Interceptor<V>;
+type AxleInstance = {
+    get: FetchRunner;
+    getBlob: FetchRunner;
+    getDocument: FetchRunner;
+    getText: FetchRunner;
+    getArrayBuffer: FetchRunner;
+    getStream: FetchRunner;
+    head: FetchRunner;
+    headBlob: FetchRunner;
+    headDocument: FetchRunner;
+    headText: FetchRunner;
+    headArrayBuffer: FetchRunner;
+    headStream: FetchRunner;
+    options: FetchRunner;
+    optionsBlob: FetchRunner;
+    optionsDocument: FetchRunner;
+    optionsText: FetchRunner;
+    optionsArrayBuffer: FetchRunner;
+    optionsStream: FetchRunner;
+    delete: FetchRunner;
+    deleteBlob: FetchRunner;
+    deleteDocument: FetchRunner;
+    deleteText: FetchRunner;
+    deleteArrayBuffer: FetchRunner;
+    deleteStream: FetchRunner;
+    post: ModifyRunner;
+    postUrlEncode: ModifyRunner;
+    postMultipart: ModifyRunner;
+    put: ModifyRunner;
+    putUrlEncode: ModifyRunner;
+    putMultipart: ModifyRunner;
+    patch: ModifyRunner;
+    patchUrlEncode: ModifyRunner;
+    patchMultipart: ModifyRunner;
+    getHeaders(): HeadersDefaults['common'];
+    setHeader(key: string, value: string): void;
+    removeHeader(key: string | string[]): void;
+    useRequestInterceptor(...interceptors: RequestInterceptor[]): void;
+    useResponseInterceptor(...interceptors: ResponseInterceptor[]): void;
+    axios: AxiosInstance;
+};
+declare function createFetchRunner(service: AxiosInstance, method: FetchMethod, responseType: ResponseType): <T, R = AxiosResponse<T, any>>(url: string, params?: any, config?: AxleRequestConfig) => Promise<R>;
+declare function createModifyRunner(service: AxiosInstance, method: ModifyMethod, contentType: 'application/json' | 'multipart/form-data' | 'application/x-www-form-urlencoded'): <T, R = AxiosResponse<T, any>>(url: string, params?: any, config?: AxleRequestConfig) => Promise<R>;
+declare function download(url: string | Blob, filename: string): void;
+declare function createAxle(config?: AxiosRequestConfig): AxleInstance;
+
+export { AxleRequestConfig as A, FetchRunner as F, Interceptor as I, ModifyRunner as M, RequestInterceptor as R, ResponseInterceptor as a, FetchMethod as b, ModifyMethod as c, RunnerMethod as d, AxleInstance as e, createFetchRunner as f, createModifyRunner as g, download as h, createAxle as i };

package/es/use.d.ts

@@ -1,21 +1,29 @@
-import { type Ref } from 'vue';
-import { type AxleRequestConfig, type RunnerMethod, type AxleInstance } from './instance.js';
-export interface RunOptions<P> {
+import { Ref, WritableComputedRef } from 'vue';
+import { A as AxleRequestConfig, d as RunnerMethod, e as AxleInstance } from './instance-8e68a761.js';
+import 'axios';
+
+declare function useValues<T extends Ref<any>[]>(...valueCollection: T): WritableComputedRef<T[number]['value'][]>;
+
+declare function useHasLoading(...loadings: Ref<boolean>[]): Ref<boolean>;
+
+declare function useAverageProgress(...progressCollection: Ref<number>[]): Ref<number>;
+
+interface RunOptions<P> {
     url?: string;
     params?: P;
     config?: AxleRequestConfig;
     resetValue?: boolean;
     _retryCount?: number;
 }
-export type Run<R, P> = (options?: RunOptions<P>) => Promise<R>;
-export interface UseAxleRefs<V> {
+type Run<R, P> = (options?: RunOptions<P>) => Promise<R>;
+interface UseAxleRefs<V> {
     value: Ref<V>;
     loading: Ref<boolean>;
     error: Ref<Error | undefined>;
     uploadProgress: Ref<number>;
     downloadProgress: Ref<number>;
 }
-export interface UseAxleOptions<V = any, R = any, P = Record<string, any>> {
+interface UseAxleOptions<V = any, R = any, P = Record<string, any>> {
     url: string;
     method: RunnerMethod;
     value?: V;
@@ -30,7 +38,7 @@ export interface UseAxleOptions<V = any, R = any, P = Record<string, any>> {
     onSuccess?(response: R, refs: UseAxleRefs<V>): void;
     onError?(error: Error, refs: UseAxleRefs<V>): void;
 }
-export type UseAxleInstance<V, R, P> = [
+type UseAxleInstance<V, R, P> = [
     value: Ref<V>,
     run: Run<R, P>,
     extra: {
@@ -41,11 +49,10 @@ export type UseAxleInstance<V, R, P> = [
         abort(): void;
     }
 ];
-export interface CreateUseAxleOptions {
+interface CreateUseAxleOptions {
     axle: AxleInstance;
     onTransform?(response: any, refs: any): any;
 }
-export declare function createUseAxle(options: CreateUseAxleOptions): <V = any, R = any, P = Record<string, any>>(options: UseAxleOptions<V, R, P>) => UseAxleInstance<V, R, P>;
-export * from './useValues.js';
-export * from './useHasLoading.js';
-export * from './useAverageProgress.js';
+declare function createUseAxle(options: CreateUseAxleOptions): <V = any, R = any, P = Record<string, any>>(options: UseAxleOptions<V, R, P>) => UseAxleInstance<V, R, P>;
+
+export { CreateUseAxleOptions, Run, RunOptions, UseAxleInstance, UseAxleOptions, UseAxleRefs, createUseAxle, useAverageProgress, useHasLoading, useValues };

package/es/use.js

@@ -1,92 +1,168 @@
-import { ref } from 'vue';
-import { isFunction } from '@varlet/shared';
-export function createUseAxle(options) {
-    const { axle, onTransform: defaultOnTransform } = options;
-    const useAxle = (options) => {
-        var _a;
-        const { url, method, immediate, value: initialValue, resetValue: initialResetValue, params: initialParamsOrGetter, config: initialConfig, retry = 0, onBefore = () => { }, onAfter = () => { }, onTransform = (_a = defaultOnTransform) !== null && _a !== void 0 ? _a : ((response) => response), onSuccess = () => { }, onError = () => { }, } = options;
-        const initialUrl = url;
-        const value = ref(initialValue);
-        const loading = ref(false);
-        const error = ref();
-        const downloadProgress = ref(0);
-        const uploadProgress = ref(0);
-        const shouldRetry = retry > 0;
-        const refs = {
-            value,
-            loading,
-            error,
-            downloadProgress,
-            uploadProgress,
-        };
-        let controller = new AbortController();
-        const run = async (options = {}) => {
-            var _a, _b, _c;
-            if (controller.signal.aborted) {
-                controller = new AbortController();
-            }
-            const resetValue = (_b = (_a = options.resetValue) !== null && _a !== void 0 ? _a : initialResetValue) !== null && _b !== void 0 ? _b : false;
-            if (resetValue === true) {
-                value.value = initialValue;
-            }
-            uploadProgress.value = 0;
-            downloadProgress.value = 0;
-            const url = (_c = options.url) !== null && _c !== void 0 ? _c : initialUrl;
-            onBefore(refs);
-            loading.value = true;
-            try {
-                const getterParams = isFunction(initialParamsOrGetter) ? initialParamsOrGetter() : {};
-                const response = await axle[method](url, Object.assign(Object.assign({}, getterParams), options.params), Object.assign({ signal: controller.signal, onUploadProgress(event) {
-                        var _a;
-                        uploadProgress.value = (_a = event.progress) !== null && _a !== void 0 ? _a : 0;
-                    },
-                    onDownloadProgress(event) {
-                        var _a;
-                        downloadProgress.value = (_a = event.progress) !== null && _a !== void 0 ? _a : 0;
-                    } }, options.config));
-                value.value = onTransform(response, refs);
-                error.value = undefined;
-                onSuccess(response, refs);
-                loading.value = false;
-                onAfter(refs);
-                return response;
-            }
-            catch (responseError) {
-                const currentRetryCount = options._retryCount == null ? 0 : options._retryCount;
-                if (shouldRetry && currentRetryCount < retry) {
-                    return run(Object.assign(Object.assign({}, options), { _retryCount: currentRetryCount + 1 }));
-                }
-                error.value = responseError;
-                onError(responseError, refs);
-                loading.value = false;
-                onAfter(refs);
-                throw responseError;
+import {
+  __spreadProps,
+  __spreadValues
+} from "./chunk-KLNSLHAC.js";
+
+// src/use.ts
+import { ref as ref3 } from "vue";
+import { isFunction } from "@varlet/shared";
+
+// src/useValues.ts
+import { computed } from "vue";
+function useValues(...valueCollection) {
+  return computed({
+    get: () => valueCollection.map((value) => value.value),
+    set(values) {
+      valueCollection.forEach((value, index) => {
+        value.value = values[index];
+      });
+    }
+  });
+}
+
+// src/useHasLoading.ts
+import { ref, watch } from "vue";
+function useHasLoading(...loadings) {
+  const hasLoading = ref(false);
+  watch(
+    () => loadings.map((loading) => loading.value),
+    (newLoadings) => {
+      hasLoading.value = newLoadings.some(Boolean);
+    },
+    { immediate: true }
+  );
+  return hasLoading;
+}
+
+// src/useAverageProgress.ts
+import { ref as ref2, watch as watch2 } from "vue";
+function useAverageProgress(...progressCollection) {
+  const averageProgress = ref2(0);
+  watch2(
+    () => progressCollection.map((progress) => progress.value),
+    (newProgressCollection) => {
+      const total = newProgressCollection.reduce((total2, progress) => total2 + progress, 0);
+      averageProgress.value = total / progressCollection.length;
+    },
+    { immediate: true }
+  );
+  return averageProgress;
+}
+
+// src/use.ts
+function createUseAxle(options) {
+  const { axle, onTransform: defaultOnTransform } = options;
+  const useAxle = (options2) => {
+    const {
+      url,
+      method,
+      immediate,
+      value: initialValue,
+      resetValue: initialResetValue,
+      params: initialParamsOrGetter,
+      config: initialConfig,
+      retry = 0,
+      onBefore = () => {
+      },
+      onAfter = () => {
+      },
+      onTransform = defaultOnTransform != null ? defaultOnTransform : (response) => response,
+      onSuccess = () => {
+      },
+      onError = () => {
+      }
+    } = options2;
+    const initialUrl = url;
+    const value = ref3(initialValue);
+    const loading = ref3(false);
+    const error = ref3();
+    const downloadProgress = ref3(0);
+    const uploadProgress = ref3(0);
+    const shouldRetry = retry > 0;
+    const refs = {
+      value,
+      loading,
+      error,
+      downloadProgress,
+      uploadProgress
+    };
+    let controller = new AbortController();
+    const run = async (options3 = {}) => {
+      var _a, _b, _c;
+      if (controller.signal.aborted) {
+        controller = new AbortController();
+      }
+      const resetValue = (_b = (_a = options3.resetValue) != null ? _a : initialResetValue) != null ? _b : false;
+      if (resetValue === true) {
+        value.value = initialValue;
+      }
+      uploadProgress.value = 0;
+      downloadProgress.value = 0;
+      const url2 = (_c = options3.url) != null ? _c : initialUrl;
+      onBefore(refs);
+      loading.value = true;
+      try {
+        const getterParams = isFunction(initialParamsOrGetter) ? initialParamsOrGetter() : {};
+        const response = await axle[method](
+          url2,
+          __spreadValues(__spreadValues({}, getterParams), options3.params),
+          __spreadValues({
+            signal: controller.signal,
+            onUploadProgress(event) {
+              var _a2;
+              uploadProgress.value = (_a2 = event.progress) != null ? _a2 : 0;
+            },
+            onDownloadProgress(event) {
+              var _a2;
+              downloadProgress.value = (_a2 = event.progress) != null ? _a2 : 0;
             }
-        };
-        const abort = () => {
-            controller.abort();
-        };
-        if (immediate) {
-            run({
-                url: initialUrl,
-                params: isFunction(initialParamsOrGetter) ? {} : initialParamsOrGetter,
-                config: initialConfig,
-            });
+          }, options3.config)
+        );
+        value.value = onTransform(response, refs);
+        error.value = void 0;
+        onSuccess(response, refs);
+        loading.value = false;
+        onAfter(refs);
+        return response;
+      } catch (responseError) {
+        const currentRetryCount = options3._retryCount == null ? 0 : options3._retryCount;
+        if (shouldRetry && currentRetryCount < retry) {
+          return run(__spreadProps(__spreadValues({}, options3), { _retryCount: currentRetryCount + 1 }));
         }
-        return [
-            value,
-            run,
-            {
-                loading,
-                error,
-                uploadProgress,
-                downloadProgress,
-                abort,
-            },
-        ];
+        error.value = responseError;
+        onError(responseError, refs);
+        loading.value = false;
+        onAfter(refs);
+        throw responseError;
+      }
+    };
+    const abort = () => {
+      controller.abort();
     };
-    return useAxle;
+    if (immediate) {
+      run({
+        url: initialUrl,
+        params: isFunction(initialParamsOrGetter) ? {} : initialParamsOrGetter,
+        config: initialConfig
+      });
+    }
+    return [
+      value,
+      run,
+      {
+        loading,
+        error,
+        uploadProgress,
+        downloadProgress,
+        abort
+      }
+    ];
+  };
+  return useAxle;
 }
-export * from './useValues.js';
-export * from './useHasLoading.js';
-export * from './useAverageProgress.js';
+export {
+  createUseAxle,
+  useAverageProgress,
+  useHasLoading,
+  useValues
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@varlet/axle",
-  "version": "0.2.6",
+  "version": "0.2.7-alpha.1701536208987",
   "description": "Progressive request tool based on axios",
   "type": "module",
   "main": "es/index.js",
@@ -24,21 +24,45 @@
   "keywords": [
     "axle",
     "axios",
-    "helpers"
+    "helpers",
+    "vue3",
+    "composition api"
   ],
   "author": "haoziqaq <357229046@qq.com>",
   "license": "MIT",
+  "simple-git-hooks": {
+    "pre-commit": "pnpm exec nano-staged --allow-empty --concurrent false",
+    "commit-msg": "pnpm exec commitlint -e $1"
+  },
+  "nano-staged": {
+    "*.{vue,ts,tsx,js,jsx,less,css}": "pnpm format",
+    "*.{vue,ts,tsx,js,jsx}": "pnpm lint"
+  },
   "dependencies": {
     "@varlet/shared": "^2.19.2",
     "axios": "^1.4.0",
+    "micromatch": "^4.0.5",
+    "minimatch": "^9.0.3",
     "qs": "^6.11.0"
   },
+  "peerDependencies": {
+    "vue": "^3.2.0"
+  },
   "devDependencies": {
-    "@types/qs": "^6.9.7",
-    "@varlet/release": "0.0.3",
+    "tsup": "7.2.0",
+    "nano-staged": "0.8.0",
     "rimraf": "^5.0.1",
+    "simple-git-hooks": "^2.8.1",
     "typescript": "^5.1.5",
-    "vue": "3.3.4"
+    "vue": "3.3.4",
+    "eslint": "^8.43.0",
+    "prettier": "^2.8.8",
+    "@varlet/release": "0.0.3",
+    "@varlet/eslint-config": "^2.19.2",
+    "@commitlint/cli": "^17.6.5",
+    "@commitlint/config-conventional": "^17.6.5",
+    "@types/minimatch": "^5.1.2",
+    "@types/qs": "^6.9.7"
   },
   "repository": {
     "type": "git",
@@ -52,9 +76,14 @@
     "pnpm": ">=8.0"
   },
   "scripts": {
+    "preinstall": "npx only-allow pnpm",
+    "postinstall": "simple-git-hooks",
     "bootstrap": "pnpm i && pnpm build && pnpm --filter ./playground i",
-    "dev": "tsc -w",
-    "build": "rimraf ./es && tsc",
+    "dev": "tsup src/index.ts src/use.ts --format esm --out-dir=es --watch --dts",
+    "build": "tsup src/index.ts src/use.ts --format esm --out-dir=es --dts --clean",
+    "dev:play": "pnpm --dir ./playground dev",
+    "lint": "eslint . --fix",
+    "format": "prettier --write .",
     "release": "pnpm build && vr release"
   }
 }