@cloudcome/utils-vue 1.7.1 → 1.7.2

package/dist/async.cjs

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("@cloudcome/utils-core/type");
 const vue = require("vue");
 function useAsync(fn, options) {
   const times = vue.ref(0);

package/dist/async.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"async.cjs","sources":["../src/async.ts"],"sourcesContent":["import { isFunction, isNullish } from '@cloudcome/utils-core/type';\nimport type { AnyArray, MaybeCallable } from '@cloudcome/utils-core/types';\nimport { type ComputedGetter, type ComputedRef, type Ref, computed, nextTick } from 'vue';\nimport { onMounted, ref } from 'vue';\n\n/**\n * 异步操作的配置选项\n * @template T 异步操作返回的数据类型\n * @template P 异步操作的参数类型\n */\nexport type UseAsyncOptions<I extends AnyArray, O> = {\n  /**\n   * 异步操作开始前的回调函数。\n   * 可用于执行初始化逻辑或显示加载状态。\n   */\n  onBefore?: (...inputs: I) => unknown;\n\n  /**\n   * 异步操作成功后的回调函数。\n   * @param data 异步操作返回的数据。\n   * 可用于处理成功后的数据更新或通知。\n   */\n  onSuccess?: (data: O, ...inputs: I) => unknown;\n\n  /**\n   * 异步操作失败后的回调函数。\n   * @param err 异步操作抛出的错误。\n   * 可用于记录错误日志或显示错误提示。\n   */\n  onError?: (err: unknown, ...inputs: I) => unknown;\n\n  /**\n   * 异步操作结束后的回调函数（无论成功或失败）。\n   * 可用于清理操作或触发后续逻辑。\n   */\n  onAfter?: (...inputs: I) => unknown;\n};\n\nexport type UseAsyncState<O> = {\n  times: number;\n  loading: boolean;\n  error: unknown;\n  data: O | null;\n};\n\nexport type UseAsyncReturns<I extends AnyArray, O> = {\n  state: ComputedRef<UseAsyncState<O>>;\n  loading: Ref<boolean>;\n  data: Ref<O | null>;\n  error: Ref<unknown>;\n  run: (...inputs: I) => void;\n  runAsync: (...inputs: I) => Promise<O>;\n};\n\n/**\n * 用于处理异步操作的组合式函数。\n * 提供加载状态、数据、错误信息以及执行方法。\n * @template O 异步函数返回的数据类型\n * @template I 异步函数的入参类型\n * @param fn 异步函数，接收参数并返回 Promise。\n * @param options 异步操作的配置选项。\n * @returns 包含状态和操作方法的对象：\n * - loading: 是否正在加载。\n * - data: 异步操作返回的数据。\n * - error: 异步操作抛出的错误。\n * - runAsync: 执行异步操作并返回 Promise。\n * - run: 执行异步操作但不返回 Promise。\n * @example\n * const { loading, data, error, runAsync, run } = useAsync(async (id: number) => {\n *   const response = await fetch(`/api/user/${id}`);\n *   return response.json();\n * }, {\n *   onBefore: () => console.log('Fetching user data...'),\n *   onSuccess: (data) => console.log('User data fetched:', data),\n *   onError: (err) => console.error('Failed to fetch user data:', err),\n *   onFinally: () => console.log('Fetch operation completed.'),\n * });\n */\nexport function useAsync<I extends AnyArray, O>(\n  fn: (...inputs: I) => Promise<O>,\n  options?: UseAsyncOptions<I, O>,\n): UseAsyncReturns<I, O> {\n  const times = ref(0);\n  const loading = ref(false);\n  const data = ref<O | null>(null) as Ref<O | null>;\n  const error = ref<unknown>(null);\n  const state = computed(() => ({\n    times: times.value,\n    loading: loading.value,\n    data: data.value,\n    error: error.value,\n  }));\n\n  const runAsync = async (...inputs: I): Promise<O> => {\n    loading.value = true;\n    error.value = null;\n\n    try {\n      times.value++;\n      options?.onBefore?.(...inputs);\n      data.value = await fn(...inputs);\n      options?.onSuccess?.(data.value, ...inputs);\n      return data.value;\n    } catch (err) {\n      error.value = err;\n      options?.onError?.(err, ...inputs);\n      throw err;\n    } finally {\n      loading.value = false;\n      options?.onAfter?.(...inputs);\n    }\n  };\n\n  const run = (...inputs: I) => {\n    runAsync(...inputs).then();\n  };\n\n  return {\n    state,\n    /**\n     * 是否正在加载。\n     */\n    loading,\n\n    /**\n     * 异步操作返回的数据。\n     */\n    data,\n\n    /**\n     * 异步操作抛出的错误。\n     */\n    error,\n\n    /**\n     * 执行异步操作并返回 Promise。\n     * @param inputs 异步函数的参数。\n     * @returns 异步操作的结果。\n     */\n    runAsync,\n\n    /**\n     * 执行异步操作但不返回 Promise。\n     * @param inputs 异步函数的参数。\n     */\n    run,\n  };\n}\n\n// const { run: run1 } = useAsync(() => Promise.resolve(1));\n// run1();\n\n// const { run: run2 } = useAsync((a: number) => Promise.resolve(1));\n// run2(2);\n\n// const { run: run3 } = useAsync((a: number, b: string) => Promise.resolve(1));\n// run3(2, '2');\n"],"names":["ref","computed"],"mappings":";;;;AA8EgB,SAAA,SACd,IACA,SACuB;AACjB,QAAA,QAAQA,QAAI,CAAC;AACb,QAAA,UAAUA,QAAI,KAAK;AACnB,QAAA,OAAOA,QAAc,IAAI;AACzB,QAAA,QAAQA,QAAa,IAAI;AACzB,QAAA,QAAQC,IAAAA,SAAS,OAAO;AAAA,IAC5B,OAAO,MAAM;AAAA,IACb,SAAS,QAAQ;AAAA,IACjB,MAAM,KAAK;AAAA,IACX,OAAO,MAAM;AAAA,EAAA,EACb;AAEI,QAAA,WAAW,UAAU,WAA0B;;AACnD,YAAQ,QAAQ;AAChB,UAAM,QAAQ;AAEV,QAAA;AACI,YAAA;AACG,+CAAA,aAAA,iCAAW,GAAG;AACvB,WAAK,QAAQ,MAAM,GAAG,GAAG,MAAM;AAC/B,+CAAS,cAAT,iCAAqB,KAAK,OAAO,GAAG;AACpC,aAAO,KAAK;AAAA,aACL,KAAK;AACZ,YAAM,QAAQ;AACL,+CAAA,YAAA,iCAAU,KAAK,GAAG;AACrB,YAAA;AAAA,IAAA,UACN;AACA,cAAQ,QAAQ;AACP,+CAAA,YAAA,iCAAU,GAAG;AAAA,IAAM;AAAA,EAEhC;AAEM,QAAA,MAAM,IAAI,WAAc;AACnB,aAAA,GAAG,MAAM,EAAE,KAAK;AAAA,EAC3B;AAEO,SAAA;AAAA,IACL;AAAA;AAAA;AAAA;AAAA,IAIA;AAAA;AAAA;AAAA;AAAA,IAKA;AAAA;AAAA;AAAA;AAAA,IAKA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOA;AAAA;AAAA;AAAA;AAAA;AAAA,IAMA;AAAA,EACF;AACF;;"}
+{"version":3,"file":"async.cjs","sources":["../src/async.ts"],"sourcesContent":["import type { AnyArray } from '@cloudcome/utils-core/types';\nimport { type ComputedRef, type Ref, computed, ref } from 'vue';\n\n/**\n * 异步操作的配置选项\n * @template T 异步操作返回的数据类型\n * @template P 异步操作的参数类型\n */\nexport type UseAsyncOptions<I extends AnyArray, O> = {\n  /**\n   * 异步操作开始前的回调函数。\n   * 可用于执行初始化逻辑或显示加载状态。\n   */\n  onBefore?: (...inputs: I) => unknown;\n\n  /**\n   * 异步操作成功后的回调函数。\n   * @param data 异步操作返回的数据。\n   * 可用于处理成功后的数据更新或通知。\n   */\n  onSuccess?: (data: O, ...inputs: I) => unknown;\n\n  /**\n   * 异步操作失败后的回调函数。\n   * @param err 异步操作抛出的错误。\n   * 可用于记录错误日志或显示错误提示。\n   */\n  onError?: (err: unknown, ...inputs: I) => unknown;\n\n  /**\n   * 异步操作结束后的回调函数（无论成功或失败）。\n   * 可用于清理操作或触发后续逻辑。\n   */\n  onAfter?: (...inputs: I) => unknown;\n};\n\nexport type UseAsyncState<O> = {\n  times: number;\n  loading: boolean;\n  error: unknown;\n  data: O | null;\n};\n\nexport type UseAsyncReturns<I extends AnyArray, O> = {\n  state: ComputedRef<UseAsyncState<O>>;\n  loading: Ref<boolean>;\n  data: Ref<O | null>;\n  error: Ref<unknown>;\n  run: (...inputs: I) => void;\n  runAsync: (...inputs: I) => Promise<O>;\n};\n\n/**\n * 用于处理异步操作的组合式函数。\n * 提供加载状态、数据、错误信息以及执行方法。\n * @template O 异步函数返回的数据类型\n * @template I 异步函数的入参类型\n * @param fn 异步函数，接收参数并返回 Promise。\n * @param options 异步操作的配置选项。\n * @returns 包含状态和操作方法的对象：\n * - loading: 是否正在加载。\n * - data: 异步操作返回的数据。\n * - error: 异步操作抛出的错误。\n * - runAsync: 执行异步操作并返回 Promise。\n * - run: 执行异步操作但不返回 Promise。\n * @example\n * const { loading, data, error, runAsync, run } = useAsync(async (id: number) => {\n *   const response = await fetch(`/api/user/${id}`);\n *   return response.json();\n * }, {\n *   onBefore: () => console.log('Fetching user data...'),\n *   onSuccess: (data) => console.log('User data fetched:', data),\n *   onError: (err) => console.error('Failed to fetch user data:', err),\n *   onFinally: () => console.log('Fetch operation completed.'),\n * });\n */\nexport function useAsync<I extends AnyArray, O>(\n  fn: (...inputs: I) => Promise<O>,\n  options?: UseAsyncOptions<I, O>,\n): UseAsyncReturns<I, O> {\n  const times = ref(0);\n  const loading = ref(false);\n  const data = ref<O | null>(null) as Ref<O | null>;\n  const error = ref<unknown>(null);\n  const state = computed(() => ({\n    times: times.value,\n    loading: loading.value,\n    data: data.value,\n    error: error.value,\n  }));\n\n  const runAsync = async (...inputs: I): Promise<O> => {\n    loading.value = true;\n    error.value = null;\n\n    try {\n      times.value++;\n      options?.onBefore?.(...inputs);\n      data.value = await fn(...inputs);\n      options?.onSuccess?.(data.value, ...inputs);\n      return data.value;\n    } catch (err) {\n      error.value = err;\n      options?.onError?.(err, ...inputs);\n      throw err;\n    } finally {\n      loading.value = false;\n      options?.onAfter?.(...inputs);\n    }\n  };\n\n  const run = (...inputs: I) => {\n    runAsync(...inputs).then();\n  };\n\n  return {\n    state,\n    /**\n     * 是否正在加载。\n     */\n    loading,\n\n    /**\n     * 异步操作返回的数据。\n     */\n    data,\n\n    /**\n     * 异步操作抛出的错误。\n     */\n    error,\n\n    /**\n     * 执行异步操作并返回 Promise。\n     * @param inputs 异步函数的参数。\n     * @returns 异步操作的结果。\n     */\n    runAsync,\n\n    /**\n     * 执行异步操作但不返回 Promise。\n     * @param inputs 异步函数的参数。\n     */\n    run,\n  };\n}\n\n// const { run: run1 } = useAsync(() => Promise.resolve(1));\n// run1();\n\n// const { run: run2 } = useAsync((a: number) => Promise.resolve(1));\n// run2(2);\n\n// const { run: run3 } = useAsync((a: number, b: string) => Promise.resolve(1));\n// run3(2, '2');\n"],"names":["ref","computed"],"mappings":";;;AA4EgB,SAAA,SACd,IACA,SACuB;AACjB,QAAA,QAAQA,QAAI,CAAC;AACb,QAAA,UAAUA,QAAI,KAAK;AACnB,QAAA,OAAOA,QAAc,IAAI;AACzB,QAAA,QAAQA,QAAa,IAAI;AACzB,QAAA,QAAQC,IAAAA,SAAS,OAAO;AAAA,IAC5B,OAAO,MAAM;AAAA,IACb,SAAS,QAAQ;AAAA,IACjB,MAAM,KAAK;AAAA,IACX,OAAO,MAAM;AAAA,EAAA,EACb;AAEI,QAAA,WAAW,UAAU,WAA0B;;AACnD,YAAQ,QAAQ;AAChB,UAAM,QAAQ;AAEV,QAAA;AACI,YAAA;AACG,+CAAA,aAAA,iCAAW,GAAG;AACvB,WAAK,QAAQ,MAAM,GAAG,GAAG,MAAM;AAC/B,+CAAS,cAAT,iCAAqB,KAAK,OAAO,GAAG;AACpC,aAAO,KAAK;AAAA,aACL,KAAK;AACZ,YAAM,QAAQ;AACL,+CAAA,YAAA,iCAAU,KAAK,GAAG;AACrB,YAAA;AAAA,IAAA,UACN;AACA,cAAQ,QAAQ;AACP,+CAAA,YAAA,iCAAU,GAAG;AAAA,IAAM;AAAA,EAEhC;AAEM,QAAA,MAAM,IAAI,WAAc;AACnB,aAAA,GAAG,MAAM,EAAE,KAAK;AAAA,EAC3B;AAEO,SAAA;AAAA,IACL;AAAA;AAAA;AAAA;AAAA,IAIA;AAAA;AAAA;AAAA;AAAA,IAKA;AAAA;AAAA;AAAA;AAAA,IAKA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOA;AAAA;AAAA;AAAA;AAAA;AAAA,IAMA;AAAA,EACF;AACF;;"}

package/dist/async.mjs

@@ -1,4 +1,3 @@
-import "@cloudcome/utils-core/type";
 import { ref, computed } from "vue";
 function useAsync(fn, options) {
   const times = ref(0);

package/dist/async.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"async.mjs","sources":["../src/async.ts"],"sourcesContent":["import { isFunction, isNullish } from '@cloudcome/utils-core/type';\nimport type { AnyArray, MaybeCallable } from '@cloudcome/utils-core/types';\nimport { type ComputedGetter, type ComputedRef, type Ref, computed, nextTick } from 'vue';\nimport { onMounted, ref } from 'vue';\n\n/**\n * 异步操作的配置选项\n * @template T 异步操作返回的数据类型\n * @template P 异步操作的参数类型\n */\nexport type UseAsyncOptions<I extends AnyArray, O> = {\n  /**\n   * 异步操作开始前的回调函数。\n   * 可用于执行初始化逻辑或显示加载状态。\n   */\n  onBefore?: (...inputs: I) => unknown;\n\n  /**\n   * 异步操作成功后的回调函数。\n   * @param data 异步操作返回的数据。\n   * 可用于处理成功后的数据更新或通知。\n   */\n  onSuccess?: (data: O, ...inputs: I) => unknown;\n\n  /**\n   * 异步操作失败后的回调函数。\n   * @param err 异步操作抛出的错误。\n   * 可用于记录错误日志或显示错误提示。\n   */\n  onError?: (err: unknown, ...inputs: I) => unknown;\n\n  /**\n   * 异步操作结束后的回调函数（无论成功或失败）。\n   * 可用于清理操作或触发后续逻辑。\n   */\n  onAfter?: (...inputs: I) => unknown;\n};\n\nexport type UseAsyncState<O> = {\n  times: number;\n  loading: boolean;\n  error: unknown;\n  data: O | null;\n};\n\nexport type UseAsyncReturns<I extends AnyArray, O> = {\n  state: ComputedRef<UseAsyncState<O>>;\n  loading: Ref<boolean>;\n  data: Ref<O | null>;\n  error: Ref<unknown>;\n  run: (...inputs: I) => void;\n  runAsync: (...inputs: I) => Promise<O>;\n};\n\n/**\n * 用于处理异步操作的组合式函数。\n * 提供加载状态、数据、错误信息以及执行方法。\n * @template O 异步函数返回的数据类型\n * @template I 异步函数的入参类型\n * @param fn 异步函数，接收参数并返回 Promise。\n * @param options 异步操作的配置选项。\n * @returns 包含状态和操作方法的对象：\n * - loading: 是否正在加载。\n * - data: 异步操作返回的数据。\n * - error: 异步操作抛出的错误。\n * - runAsync: 执行异步操作并返回 Promise。\n * - run: 执行异步操作但不返回 Promise。\n * @example\n * const { loading, data, error, runAsync, run } = useAsync(async (id: number) => {\n *   const response = await fetch(`/api/user/${id}`);\n *   return response.json();\n * }, {\n *   onBefore: () => console.log('Fetching user data...'),\n *   onSuccess: (data) => console.log('User data fetched:', data),\n *   onError: (err) => console.error('Failed to fetch user data:', err),\n *   onFinally: () => console.log('Fetch operation completed.'),\n * });\n */\nexport function useAsync<I extends AnyArray, O>(\n  fn: (...inputs: I) => Promise<O>,\n  options?: UseAsyncOptions<I, O>,\n): UseAsyncReturns<I, O> {\n  const times = ref(0);\n  const loading = ref(false);\n  const data = ref<O | null>(null) as Ref<O | null>;\n  const error = ref<unknown>(null);\n  const state = computed(() => ({\n    times: times.value,\n    loading: loading.value,\n    data: data.value,\n    error: error.value,\n  }));\n\n  const runAsync = async (...inputs: I): Promise<O> => {\n    loading.value = true;\n    error.value = null;\n\n    try {\n      times.value++;\n      options?.onBefore?.(...inputs);\n      data.value = await fn(...inputs);\n      options?.onSuccess?.(data.value, ...inputs);\n      return data.value;\n    } catch (err) {\n      error.value = err;\n      options?.onError?.(err, ...inputs);\n      throw err;\n    } finally {\n      loading.value = false;\n      options?.onAfter?.(...inputs);\n    }\n  };\n\n  const run = (...inputs: I) => {\n    runAsync(...inputs).then();\n  };\n\n  return {\n    state,\n    /**\n     * 是否正在加载。\n     */\n    loading,\n\n    /**\n     * 异步操作返回的数据。\n     */\n    data,\n\n    /**\n     * 异步操作抛出的错误。\n     */\n    error,\n\n    /**\n     * 执行异步操作并返回 Promise。\n     * @param inputs 异步函数的参数。\n     * @returns 异步操作的结果。\n     */\n    runAsync,\n\n    /**\n     * 执行异步操作但不返回 Promise。\n     * @param inputs 异步函数的参数。\n     */\n    run,\n  };\n}\n\n// const { run: run1 } = useAsync(() => Promise.resolve(1));\n// run1();\n\n// const { run: run2 } = useAsync((a: number) => Promise.resolve(1));\n// run2(2);\n\n// const { run: run3 } = useAsync((a: number, b: string) => Promise.resolve(1));\n// run3(2, '2');\n"],"names":[],"mappings":";;AA8EgB,SAAA,SACd,IACA,SACuB;AACjB,QAAA,QAAQ,IAAI,CAAC;AACb,QAAA,UAAU,IAAI,KAAK;AACnB,QAAA,OAAO,IAAc,IAAI;AACzB,QAAA,QAAQ,IAAa,IAAI;AACzB,QAAA,QAAQ,SAAS,OAAO;AAAA,IAC5B,OAAO,MAAM;AAAA,IACb,SAAS,QAAQ;AAAA,IACjB,MAAM,KAAK;AAAA,IACX,OAAO,MAAM;AAAA,EAAA,EACb;AAEI,QAAA,WAAW,UAAU,WAA0B;;AACnD,YAAQ,QAAQ;AAChB,UAAM,QAAQ;AAEV,QAAA;AACI,YAAA;AACG,+CAAA,aAAA,iCAAW,GAAG;AACvB,WAAK,QAAQ,MAAM,GAAG,GAAG,MAAM;AAC/B,+CAAS,cAAT,iCAAqB,KAAK,OAAO,GAAG;AACpC,aAAO,KAAK;AAAA,aACL,KAAK;AACZ,YAAM,QAAQ;AACL,+CAAA,YAAA,iCAAU,KAAK,GAAG;AACrB,YAAA;AAAA,IAAA,UACN;AACA,cAAQ,QAAQ;AACP,+CAAA,YAAA,iCAAU,GAAG;AAAA,IAAM;AAAA,EAEhC;AAEM,QAAA,MAAM,IAAI,WAAc;AACnB,aAAA,GAAG,MAAM,EAAE,KAAK;AAAA,EAC3B;AAEO,SAAA;AAAA,IACL;AAAA;AAAA;AAAA;AAAA,IAIA;AAAA;AAAA;AAAA;AAAA,IAKA;AAAA;AAAA;AAAA;AAAA,IAKA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOA;AAAA;AAAA;AAAA;AAAA;AAAA,IAMA;AAAA,EACF;AACF;"}
+{"version":3,"file":"async.mjs","sources":["../src/async.ts"],"sourcesContent":["import type { AnyArray } from '@cloudcome/utils-core/types';\nimport { type ComputedRef, type Ref, computed, ref } from 'vue';\n\n/**\n * 异步操作的配置选项\n * @template T 异步操作返回的数据类型\n * @template P 异步操作的参数类型\n */\nexport type UseAsyncOptions<I extends AnyArray, O> = {\n  /**\n   * 异步操作开始前的回调函数。\n   * 可用于执行初始化逻辑或显示加载状态。\n   */\n  onBefore?: (...inputs: I) => unknown;\n\n  /**\n   * 异步操作成功后的回调函数。\n   * @param data 异步操作返回的数据。\n   * 可用于处理成功后的数据更新或通知。\n   */\n  onSuccess?: (data: O, ...inputs: I) => unknown;\n\n  /**\n   * 异步操作失败后的回调函数。\n   * @param err 异步操作抛出的错误。\n   * 可用于记录错误日志或显示错误提示。\n   */\n  onError?: (err: unknown, ...inputs: I) => unknown;\n\n  /**\n   * 异步操作结束后的回调函数（无论成功或失败）。\n   * 可用于清理操作或触发后续逻辑。\n   */\n  onAfter?: (...inputs: I) => unknown;\n};\n\nexport type UseAsyncState<O> = {\n  times: number;\n  loading: boolean;\n  error: unknown;\n  data: O | null;\n};\n\nexport type UseAsyncReturns<I extends AnyArray, O> = {\n  state: ComputedRef<UseAsyncState<O>>;\n  loading: Ref<boolean>;\n  data: Ref<O | null>;\n  error: Ref<unknown>;\n  run: (...inputs: I) => void;\n  runAsync: (...inputs: I) => Promise<O>;\n};\n\n/**\n * 用于处理异步操作的组合式函数。\n * 提供加载状态、数据、错误信息以及执行方法。\n * @template O 异步函数返回的数据类型\n * @template I 异步函数的入参类型\n * @param fn 异步函数，接收参数并返回 Promise。\n * @param options 异步操作的配置选项。\n * @returns 包含状态和操作方法的对象：\n * - loading: 是否正在加载。\n * - data: 异步操作返回的数据。\n * - error: 异步操作抛出的错误。\n * - runAsync: 执行异步操作并返回 Promise。\n * - run: 执行异步操作但不返回 Promise。\n * @example\n * const { loading, data, error, runAsync, run } = useAsync(async (id: number) => {\n *   const response = await fetch(`/api/user/${id}`);\n *   return response.json();\n * }, {\n *   onBefore: () => console.log('Fetching user data...'),\n *   onSuccess: (data) => console.log('User data fetched:', data),\n *   onError: (err) => console.error('Failed to fetch user data:', err),\n *   onFinally: () => console.log('Fetch operation completed.'),\n * });\n */\nexport function useAsync<I extends AnyArray, O>(\n  fn: (...inputs: I) => Promise<O>,\n  options?: UseAsyncOptions<I, O>,\n): UseAsyncReturns<I, O> {\n  const times = ref(0);\n  const loading = ref(false);\n  const data = ref<O | null>(null) as Ref<O | null>;\n  const error = ref<unknown>(null);\n  const state = computed(() => ({\n    times: times.value,\n    loading: loading.value,\n    data: data.value,\n    error: error.value,\n  }));\n\n  const runAsync = async (...inputs: I): Promise<O> => {\n    loading.value = true;\n    error.value = null;\n\n    try {\n      times.value++;\n      options?.onBefore?.(...inputs);\n      data.value = await fn(...inputs);\n      options?.onSuccess?.(data.value, ...inputs);\n      return data.value;\n    } catch (err) {\n      error.value = err;\n      options?.onError?.(err, ...inputs);\n      throw err;\n    } finally {\n      loading.value = false;\n      options?.onAfter?.(...inputs);\n    }\n  };\n\n  const run = (...inputs: I) => {\n    runAsync(...inputs).then();\n  };\n\n  return {\n    state,\n    /**\n     * 是否正在加载。\n     */\n    loading,\n\n    /**\n     * 异步操作返回的数据。\n     */\n    data,\n\n    /**\n     * 异步操作抛出的错误。\n     */\n    error,\n\n    /**\n     * 执行异步操作并返回 Promise。\n     * @param inputs 异步函数的参数。\n     * @returns 异步操作的结果。\n     */\n    runAsync,\n\n    /**\n     * 执行异步操作但不返回 Promise。\n     * @param inputs 异步函数的参数。\n     */\n    run,\n  };\n}\n\n// const { run: run1 } = useAsync(() => Promise.resolve(1));\n// run1();\n\n// const { run: run2 } = useAsync((a: number) => Promise.resolve(1));\n// run2(2);\n\n// const { run: run3 } = useAsync((a: number, b: string) => Promise.resolve(1));\n// run3(2, '2');\n"],"names":[],"mappings":";AA4EgB,SAAA,SACd,IACA,SACuB;AACjB,QAAA,QAAQ,IAAI,CAAC;AACb,QAAA,UAAU,IAAI,KAAK;AACnB,QAAA,OAAO,IAAc,IAAI;AACzB,QAAA,QAAQ,IAAa,IAAI;AACzB,QAAA,QAAQ,SAAS,OAAO;AAAA,IAC5B,OAAO,MAAM;AAAA,IACb,SAAS,QAAQ;AAAA,IACjB,MAAM,KAAK;AAAA,IACX,OAAO,MAAM;AAAA,EAAA,EACb;AAEI,QAAA,WAAW,UAAU,WAA0B;;AACnD,YAAQ,QAAQ;AAChB,UAAM,QAAQ;AAEV,QAAA;AACI,YAAA;AACG,+CAAA,aAAA,iCAAW,GAAG;AACvB,WAAK,QAAQ,MAAM,GAAG,GAAG,MAAM;AAC/B,+CAAS,cAAT,iCAAqB,KAAK,OAAO,GAAG;AACpC,aAAO,KAAK;AAAA,aACL,KAAK;AACZ,YAAM,QAAQ;AACL,+CAAA,YAAA,iCAAU,KAAK,GAAG;AACrB,YAAA;AAAA,IAAA,UACN;AACA,cAAQ,QAAQ;AACP,+CAAA,YAAA,iCAAU,GAAG;AAAA,IAAM;AAAA,EAEhC;AAEM,QAAA,MAAM,IAAI,WAAc;AACnB,aAAA,GAAG,MAAM,EAAE,KAAK;AAAA,EAC3B;AAEO,SAAA;AAAA,IACL;AAAA;AAAA;AAAA;AAAA,IAIA;AAAA;AAAA;AAAA;AAAA,IAKA;AAAA;AAAA;AAAA;AAAA,IAKA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOA;AAAA;AAAA;AAAA;AAAA;AAAA,IAMA;AAAA,EACF;AACF;"}

package/dist/component.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"component.cjs","sources":["../src/component.ts"],"sourcesContent":["import { ref } from 'vue';\nimport type { ComponentEmit, ComponentExposed, ComponentProps } from 'vue-component-type-helpers';\n\n/**\n * 创建一个响应式引用，用于暴露组件实例\n * @template T 组件类型\n * @param {T} Comp 组件定义\n * @returns {Ref<ComponentExposed<T> | null>} 返回一个可响应式访问的组件实例引用\n * @example\n * const compRef = useExpose(MyComponent)\n */\nexport function useExpose<T>(Comp: T) {\n  return ref<ComponentExposed<T> | null>(null);\n}\n\n/**\n * 将字符串的首字母转换为小写\n * @template S 字符串类型\n * @typedef {S extends `${infer First}${infer Rest}` ? `${Lowercase<First>}${Rest}` : S} LowercaseFirst\n */\ntype LowercaseFirst<S extends string> = S extends `${infer First}${infer Rest}` ? `${Lowercase<First>}${Rest}` : S;\n\n/**\n * 从组件props中提取事件类型\n * @template T 组件props类型\n * @typedef {Object} PickEmits\n * @property {Object} [K in keyof T as K extends `on${infer Rest}`...] 转换后的emit事件名\n *   - @property {Function} [...args: P] 事件回调函数\n */\ntype PickEmits<T> = {\n  [K in keyof T as K extends `on${infer Rest}`\n    ? // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n      T[K] extends (...args: any[]) => any\n      ? LowercaseFirst<Rest>\n      : never\n    : // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n      never]: T[K] extends (...args: infer P) => any ? (...args: P) => unknown : never;\n};\n\n/**\n * 创建一个组件emit事件监听器\n * @template T 组件类型\n * @template E 从组件props中提取的事件类型\n * @template K 事件名\n * @param {T} Comp 组件定义\n * @param {K} event 事件名称\n * @param {E[K]} listener 事件监听函数\n * @returns {E[K]} 返回传入的事件监听函数\n * @example\n * const handleClick = useEmit(MyComponent, 'click', (payload) => {\n *   console.log('click event', payload)\n * })\n */\nexport function useEmit<T, E extends PickEmits<Required<ComponentProps<T>>>, K extends keyof E>(\n  Comp: T,\n  event: K,\n  listener: E[K],\n) {\n  return listener;\n}\n\ntype PickMethods<T> = {\n  // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n  [K in keyof T]: T[K] extends (...args: infer P) => any ? T[K] : never;\n};\n\n/**\n * 从组件props中提取方法并返回指定方法\n * @template T 组件类型\n * @template M 从组件props中提取的方法类型\n * @template K 方法名类型\n * @param {T} Comp 组件定义\n * @param {K} name 方法名称\n * @param {M[K]} method 要返回的方法\n * @returns {M[K]} 返回传入的方法\n * @example\n * const handleUpdate = useMethod(MyComponent, 'update', (value) => {\n *   console.log('update value', value)\n * })\n */\nexport function useMethod<T, M extends PickMethods<Required<ComponentProps<T>>>, K extends keyof M>(\n  Comp: T,\n  name: K,\n  method: M[K],\n) {\n  return method;\n}\n"],"names":["ref"],"mappings":";;;AAWO,SAAS,UAAa,MAAS;AACpC,SAAOA,IAAAA,IAAgC,IAAI;AAC7C;AAwCgB,SAAA,QACd,MACA,OACA,UACA;AACO,SAAA;AACT;AAqBgB,SAAA,UACd,MACA,MACA,QACA;AACO,SAAA;AACT;;;;"}
+{"version":3,"file":"component.cjs","sources":["../src/component.ts"],"sourcesContent":["import { type Ref, ref } from 'vue';\nimport type { ComponentExposed, ComponentProps } from 'vue-component-type-helpers';\n\n/**\n * 创建一个响应式引用，用于暴露组件实例\n * @template T 组件类型\n * @param {T} Comp 组件定义\n * @returns 返回一个可响应式访问的组件实例引用\n * @example\n * const compRef = useExpose(MyComponent)\n */\nexport function useExpose<T>(Comp: T) {\n  // 这里必须类型断言，否则构建会失败\n  return ref<ComponentExposed<T> | null>(null) as Ref<ComponentExposed<T> | null>;\n}\n\n/**\n * 将字符串的首字母转换为小写\n * @template S 字符串类型\n * @typedef {S extends `${infer First}${infer Rest}` ? `${Lowercase<First>}${Rest}` : S} LowercaseFirst\n */\ntype LowercaseFirst<S extends string> = S extends `${infer First}${infer Rest}` ? `${Lowercase<First>}${Rest}` : S;\n\n/**\n * 从组件props中提取事件类型\n * @template T 组件props类型\n * @typedef {Object} PickEmits\n * @property {Object} [K in keyof T as K extends `on${infer Rest}`...] 转换后的emit事件名\n *   - @property {Function} [...args: P] 事件回调函数\n */\ntype PickEmits<T> = {\n  [K in keyof T as K extends `on${infer Rest}`\n    ? // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n      T[K] extends (...args: any[]) => any\n      ? LowercaseFirst<Rest>\n      : never\n    : // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n      never]: T[K] extends (...args: infer P) => any ? (...args: P) => unknown : never;\n};\n\n/**\n * 创建一个组件emit事件监听器\n * @template T 组件类型\n * @template E 从组件props中提取的事件类型\n * @template K 事件名\n * @param {T} Comp 组件定义\n * @param {K} event 事件名称\n * @param {E[K]} listener 事件监听函数\n * @returns {E[K]} 返回传入的事件监听函数\n * @example\n * const handleClick = useEmit(MyComponent, 'click', (payload) => {\n *   console.log('click event', payload)\n * })\n */\nexport function useEmit<T, E extends PickEmits<Required<ComponentProps<T>>>, K extends keyof E>(\n  Comp: T,\n  event: K,\n  listener: E[K],\n) {\n  return listener;\n}\n\ntype PickMethods<T> = {\n  // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n  [K in keyof T]: T[K] extends (...args: infer P) => any ? T[K] : never;\n};\n\n/**\n * 从组件props中提取方法并返回指定方法\n * @template T 组件类型\n * @template M 从组件props中提取的方法类型\n * @template K 方法名类型\n * @param {T} Comp 组件定义\n * @param {K} name 方法名称\n * @param {M[K]} method 要返回的方法\n * @returns {M[K]} 返回传入的方法\n * @example\n * const handleUpdate = useMethod(MyComponent, 'update', (value) => {\n *   console.log('update value', value)\n * })\n */\nexport function useMethod<T, M extends PickMethods<Required<ComponentProps<T>>>, K extends keyof M>(\n  Comp: T,\n  name: K,\n  method: M[K],\n) {\n  return method;\n}\n"],"names":["ref"],"mappings":";;;AAWO,SAAS,UAAa,MAAS;AAEpC,SAAOA,IAAAA,IAAgC,IAAI;AAC7C;AAwCgB,SAAA,QACd,MACA,OACA,UACA;AACO,SAAA;AACT;AAqBgB,SAAA,UACd,MACA,MACA,QACA;AACO,SAAA;AACT;;;;"}

package/dist/component.d.ts

@@ -0,0 +1,61 @@
+import { Ref } from 'vue';
+import { ComponentExposed, ComponentProps } from 'vue-component-type-helpers';
+/**
+ * 创建一个响应式引用，用于暴露组件实例
+ * @template T 组件类型
+ * @param {T} Comp 组件定义
+ * @returns 返回一个可响应式访问的组件实例引用
+ * @example
+ * const compRef = useExpose(MyComponent)
+ */
+export declare function useExpose<T>(Comp: T): Ref<ComponentExposed<T> | null>;
+/**
+ * 将字符串的首字母转换为小写
+ * @template S 字符串类型
+ * @typedef {S extends `${infer First}${infer Rest}` ? `${Lowercase<First>}${Rest}` : S} LowercaseFirst
+ */
+type LowercaseFirst<S extends string> = S extends `${infer First}${infer Rest}` ? `${Lowercase<First>}${Rest}` : S;
+/**
+ * 从组件props中提取事件类型
+ * @template T 组件props类型
+ * @typedef {Object} PickEmits
+ * @property {Object} [K in keyof T as K extends `on${infer Rest}`...] 转换后的emit事件名
+ *   - @property {Function} [...args: P] 事件回调函数
+ */
+type PickEmits<T> = {
+    [K in keyof T as K extends `on${infer Rest}` ? T[K] extends (...args: any[]) => any ? LowercaseFirst<Rest> : never : never]: T[K] extends (...args: infer P) => any ? (...args: P) => unknown : never;
+};
+/**
+ * 创建一个组件emit事件监听器
+ * @template T 组件类型
+ * @template E 从组件props中提取的事件类型
+ * @template K 事件名
+ * @param {T} Comp 组件定义
+ * @param {K} event 事件名称
+ * @param {E[K]} listener 事件监听函数
+ * @returns {E[K]} 返回传入的事件监听函数
+ * @example
+ * const handleClick = useEmit(MyComponent, 'click', (payload) => {
+ *   console.log('click event', payload)
+ * })
+ */
+export declare function useEmit<T, E extends PickEmits<Required<ComponentProps<T>>>, K extends keyof E>(Comp: T, event: K, listener: E[K]): E[K];
+type PickMethods<T> = {
+    [K in keyof T]: T[K] extends (...args: infer P) => any ? T[K] : never;
+};
+/**
+ * 从组件props中提取方法并返回指定方法
+ * @template T 组件类型
+ * @template M 从组件props中提取的方法类型
+ * @template K 方法名类型
+ * @param {T} Comp 组件定义
+ * @param {K} name 方法名称
+ * @param {M[K]} method 要返回的方法
+ * @returns {M[K]} 返回传入的方法
+ * @example
+ * const handleUpdate = useMethod(MyComponent, 'update', (value) => {
+ *   console.log('update value', value)
+ * })
+ */
+export declare function useMethod<T, M extends PickMethods<Required<ComponentProps<T>>>, K extends keyof M>(Comp: T, name: K, method: M[K]): M[K];
+export {};

package/dist/component.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"component.mjs","sources":["../src/component.ts"],"sourcesContent":["import { ref } from 'vue';\nimport type { ComponentEmit, ComponentExposed, ComponentProps } from 'vue-component-type-helpers';\n\n/**\n * 创建一个响应式引用，用于暴露组件实例\n * @template T 组件类型\n * @param {T} Comp 组件定义\n * @returns {Ref<ComponentExposed<T> | null>} 返回一个可响应式访问的组件实例引用\n * @example\n * const compRef = useExpose(MyComponent)\n */\nexport function useExpose<T>(Comp: T) {\n  return ref<ComponentExposed<T> | null>(null);\n}\n\n/**\n * 将字符串的首字母转换为小写\n * @template S 字符串类型\n * @typedef {S extends `${infer First}${infer Rest}` ? `${Lowercase<First>}${Rest}` : S} LowercaseFirst\n */\ntype LowercaseFirst<S extends string> = S extends `${infer First}${infer Rest}` ? `${Lowercase<First>}${Rest}` : S;\n\n/**\n * 从组件props中提取事件类型\n * @template T 组件props类型\n * @typedef {Object} PickEmits\n * @property {Object} [K in keyof T as K extends `on${infer Rest}`...] 转换后的emit事件名\n *   - @property {Function} [...args: P] 事件回调函数\n */\ntype PickEmits<T> = {\n  [K in keyof T as K extends `on${infer Rest}`\n    ? // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n      T[K] extends (...args: any[]) => any\n      ? LowercaseFirst<Rest>\n      : never\n    : // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n      never]: T[K] extends (...args: infer P) => any ? (...args: P) => unknown : never;\n};\n\n/**\n * 创建一个组件emit事件监听器\n * @template T 组件类型\n * @template E 从组件props中提取的事件类型\n * @template K 事件名\n * @param {T} Comp 组件定义\n * @param {K} event 事件名称\n * @param {E[K]} listener 事件监听函数\n * @returns {E[K]} 返回传入的事件监听函数\n * @example\n * const handleClick = useEmit(MyComponent, 'click', (payload) => {\n *   console.log('click event', payload)\n * })\n */\nexport function useEmit<T, E extends PickEmits<Required<ComponentProps<T>>>, K extends keyof E>(\n  Comp: T,\n  event: K,\n  listener: E[K],\n) {\n  return listener;\n}\n\ntype PickMethods<T> = {\n  // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n  [K in keyof T]: T[K] extends (...args: infer P) => any ? T[K] : never;\n};\n\n/**\n * 从组件props中提取方法并返回指定方法\n * @template T 组件类型\n * @template M 从组件props中提取的方法类型\n * @template K 方法名类型\n * @param {T} Comp 组件定义\n * @param {K} name 方法名称\n * @param {M[K]} method 要返回的方法\n * @returns {M[K]} 返回传入的方法\n * @example\n * const handleUpdate = useMethod(MyComponent, 'update', (value) => {\n *   console.log('update value', value)\n * })\n */\nexport function useMethod<T, M extends PickMethods<Required<ComponentProps<T>>>, K extends keyof M>(\n  Comp: T,\n  name: K,\n  method: M[K],\n) {\n  return method;\n}\n"],"names":[],"mappings":";AAWO,SAAS,UAAa,MAAS;AACpC,SAAO,IAAgC,IAAI;AAC7C;AAwCgB,SAAA,QACd,MACA,OACA,UACA;AACO,SAAA;AACT;AAqBgB,SAAA,UACd,MACA,MACA,QACA;AACO,SAAA;AACT;"}
+{"version":3,"file":"component.mjs","sources":["../src/component.ts"],"sourcesContent":["import { type Ref, ref } from 'vue';\nimport type { ComponentExposed, ComponentProps } from 'vue-component-type-helpers';\n\n/**\n * 创建一个响应式引用，用于暴露组件实例\n * @template T 组件类型\n * @param {T} Comp 组件定义\n * @returns 返回一个可响应式访问的组件实例引用\n * @example\n * const compRef = useExpose(MyComponent)\n */\nexport function useExpose<T>(Comp: T) {\n  // 这里必须类型断言，否则构建会失败\n  return ref<ComponentExposed<T> | null>(null) as Ref<ComponentExposed<T> | null>;\n}\n\n/**\n * 将字符串的首字母转换为小写\n * @template S 字符串类型\n * @typedef {S extends `${infer First}${infer Rest}` ? `${Lowercase<First>}${Rest}` : S} LowercaseFirst\n */\ntype LowercaseFirst<S extends string> = S extends `${infer First}${infer Rest}` ? `${Lowercase<First>}${Rest}` : S;\n\n/**\n * 从组件props中提取事件类型\n * @template T 组件props类型\n * @typedef {Object} PickEmits\n * @property {Object} [K in keyof T as K extends `on${infer Rest}`...] 转换后的emit事件名\n *   - @property {Function} [...args: P] 事件回调函数\n */\ntype PickEmits<T> = {\n  [K in keyof T as K extends `on${infer Rest}`\n    ? // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n      T[K] extends (...args: any[]) => any\n      ? LowercaseFirst<Rest>\n      : never\n    : // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n      never]: T[K] extends (...args: infer P) => any ? (...args: P) => unknown : never;\n};\n\n/**\n * 创建一个组件emit事件监听器\n * @template T 组件类型\n * @template E 从组件props中提取的事件类型\n * @template K 事件名\n * @param {T} Comp 组件定义\n * @param {K} event 事件名称\n * @param {E[K]} listener 事件监听函数\n * @returns {E[K]} 返回传入的事件监听函数\n * @example\n * const handleClick = useEmit(MyComponent, 'click', (payload) => {\n *   console.log('click event', payload)\n * })\n */\nexport function useEmit<T, E extends PickEmits<Required<ComponentProps<T>>>, K extends keyof E>(\n  Comp: T,\n  event: K,\n  listener: E[K],\n) {\n  return listener;\n}\n\ntype PickMethods<T> = {\n  // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n  [K in keyof T]: T[K] extends (...args: infer P) => any ? T[K] : never;\n};\n\n/**\n * 从组件props中提取方法并返回指定方法\n * @template T 组件类型\n * @template M 从组件props中提取的方法类型\n * @template K 方法名类型\n * @param {T} Comp 组件定义\n * @param {K} name 方法名称\n * @param {M[K]} method 要返回的方法\n * @returns {M[K]} 返回传入的方法\n * @example\n * const handleUpdate = useMethod(MyComponent, 'update', (value) => {\n *   console.log('update value', value)\n * })\n */\nexport function useMethod<T, M extends PickMethods<Required<ComponentProps<T>>>, K extends keyof M>(\n  Comp: T,\n  name: K,\n  method: M[K],\n) {\n  return method;\n}\n"],"names":[],"mappings":";AAWO,SAAS,UAAa,MAAS;AAEpC,SAAO,IAAgC,IAAI;AAC7C;AAwCgB,SAAA,QACd,MACA,OACA,UACA;AACO,SAAA;AACT;AAqBgB,SAAA,UACd,MACA,MACA,QACA;AACO,SAAA;AACT;"}

package/dist/index.cjs

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const VERSION = "1.7.0";
+const VERSION = "1.7.1";
 exports.VERSION = VERSION;
 //# sourceMappingURL=index.cjs.map

package/dist/index.mjs

@@ -1,4 +1,4 @@
-const VERSION = "1.7.0";
+const VERSION = "1.7.1";
 export {
   VERSION
 };

package/dist/request.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"request.cjs","sources":["../src/request.ts"],"sourcesContent":["import { type Cache, type CacheOptions, type Cached, MemoryCache } from '@cloudcome/utils-core/cache';\nimport type { DateValue } from '@cloudcome/utils-core/date';\nimport { isFunction, isObject } from '@cloudcome/utils-core/type';\nimport type { AnyArray, MaybeCallable, MaybePromise } from '@cloudcome/utils-core/types';\nimport type { ComputedRef, Ref } from 'vue';\nimport { computed, ref } from 'vue';\nimport { type UseAsyncOptions, type UseAsyncReturns, type UseAsyncState, useAsync } from './async';\n\n/**\n * 请求缓存配置选项。\n * @template T 缓存数据的类型。\n */\nexport type RequestCacheOptions<T> = CacheOptions & {\n  /**\n   * 是否禁用缓存，默认为 false。\n   * 如果设置为 true，则不会使用缓存。\n   */\n  disabled?: boolean;\n\n  /**\n   * 自定义缓存存储实现。\n   * 可以传入自定义的缓存类来替代默认的内存缓存。\n   */\n  storage?: Cache<T>;\n};\n\nexport type RequestShareOptions = {\n  /**\n   * 是否禁用共享请求，默认为 false。\n   * 如果设置为 true，则不会共享请求结果。\n   */\n  disabled?: boolean;\n\n  /**\n   * 共享的最大时长（毫秒），为 0 时表示永久共享。\n   * 超过该时长后，共享的请求结果将被清除。\n   */\n  maxAge?: number;\n\n  /**\n   * 共享的过期时间（时间戳、日期字符串、日期对象等）。\n   * 优先级比 maxAge 更高，指定具体的过期时间。\n   */\n  expiredAt?: DateValue;\n};\n\nexport type RetryOptions = {\n  /**\n   * 是否禁用共享请求，默认为 false。\n   * 如果设置为 true，则不会重试。\n   */\n  disabled?: boolean;\n};\n\n/**\n * 请求选项，扩展了异步操作的选项。\n * @template T 请求返回的数据类型。\n * @template I 请求参数的类型。\n */\nexport type UseRequestOptions<I extends AnyArray, O> = UseAsyncOptions<I, O> & {\n  /**\n   * 请求的唯一标识符，可以是字符串或函数返回的字符串。\n   * 用于缓存和共享的键值。\n   */\n  id?: MaybeCallable<string>;\n\n  /**\n   * 缓存配置，可以是布尔值或完整的缓存选项。\n   * 如果为 true，则启用默认缓存；如果为对象，则可以自定义缓存行为。\n   */\n  cache?: boolean | RequestCacheOptions<O>;\n\n  /**\n   * 共享配置，可以是布尔值或完整的共享选项。\n   * 共享时，相同的请求 ID 会复用第一次发出且没有响应完成的请求。\n   *\n   * 例如，10 组件同时或先后发起 10 次请求用于获取用户信息，\n   * 那么这 10 个组件会共同等待第一次发起的请求，直到完成。\n   *\n   * 共享与缓存是不同的概念，共享是进行时，缓存是过去时，即：\n   * - 共享是共享**正在发送**的请求\n   * - 缓存是缓存**已经发送**的请求\n   *\n   * 如果为 true，则启用默认共享；如果为对象，则可以自定义共享行为。\n   */\n  share?: boolean | RequestShareOptions;\n\n  /**\n   * 当命中缓存时的回调函数。\n   * 在缓存命中时触发，接收缓存的数据作为参数。\n   */\n  onCacheHit?: (cached: Cached<O>) => unknown;\n};\n\nexport type UseRequestState<O> = UseAsyncState<O> & {\n  /**\n   * 是否命中共享数据\n   */\n  hitShare: boolean;\n\n  /**\n   * 是否命中缓存\n   */\n  hitCache: boolean;\n};\nexport type UseRequestReturns<I extends AnyArray, O> = Omit<UseAsyncReturns<I, O>, 'run' | 'runAsync' | 'state'> & {\n  state: ComputedRef<UseRequestState<O>>;\n  send: (...inputs: I) => void;\n  sendAsync: (...inputs: I) => Promise<O>;\n  hitShare: Ref<boolean>;\n  hitCache: Ref<boolean>;\n};\n\nconst defaultCacheStorage = new MemoryCache();\nconst defaultShareStorage = new MemoryCache();\n\n/**\n * 使用请求功能的组合式函数。\n * 支持缓存和异步操作的封装。\n *\n * @template O 请求返回的数据类型。\n * @template I 请求参数的类型。\n * @param {() => Promise<O>} fn 实际的请求函数，返回一个 Promise。\n * @param {UseRequestOptions<I, O>} [options] 请求选项，包括缓存和回调配置。\n * @returns 返回一个对象，包含以下内容：\n * - 异步操作的状态（如 loading、error 等）。\n * - 是否命中缓存（hitCache）。\n * - 是否命中共享请求（hitShare）。\n */\nexport function useRequest<I extends AnyArray, O>(\n  fn: (...inputs: I) => Promise<O>,\n  options?: UseRequestOptions<I, O>,\n): UseRequestReturns<I, O> {\n  const { id, cache, share, onCacheHit, onSuccess } = options || {};\n\n  const shareStorage = defaultShareStorage as MemoryCache<Promise<O>>;\n  const shareAble = isObject(share) ? !share.disabled : share;\n  const shareOptions = isObject(share) ? share : {};\n  const hitShare = ref(false);\n\n  const _cached = defaultCacheStorage as Cache<O>;\n  const cacheStorage = isObject(cache) ? cache.storage || _cached : _cached;\n  const cacheAble = isObject(cache) ? !cache.disabled : cache;\n  const cacheOptions = isObject(cache) ? cache : {};\n  const hitCache = ref(false);\n\n  const cacheableFn = async (...inputs: I) => {\n    const requestId = isFunction(id) ? id() : id;\n\n    if (requestId && shareAble) {\n      const shared = shareStorage.get(requestId);\n      if (shared) {\n        hitShare.value = true;\n        return await shared.data;\n      }\n    }\n\n    if (requestId && cacheAble) {\n      const cached = await cacheStorage.get(requestId);\n\n      if (cached) {\n        const data = cached.data;\n        hitCache.value = true;\n        onCacheHit?.(cached);\n        onSuccess?.(data, ...inputs);\n        return data;\n      }\n    }\n\n    const promise = fn(...inputs);\n\n    if (requestId && shareAble) {\n      shareStorage.set(requestId, promise, shareOptions);\n    }\n\n    const data = await promise;\n\n    if (requestId && cacheAble) {\n      cacheStorage.set(requestId, data, cacheOptions);\n    }\n\n    return data;\n  };\n  const { state: asyncState, run: send, runAsync: sendAsync, ...async } = useAsync(cacheableFn, options);\n\n  const state = computed(() => ({\n    ...asyncState.value,\n    hitShare: hitShare.value,\n    hitCache: hitCache.value,\n  }));\n\n  return {\n    ...async,\n    state,\n    send,\n    sendAsync,\n    hitShare,\n    hitCache,\n  };\n}\n"],"names":["MemoryCache","cache","isObject","ref","isFunction","data","async","useAsync","computed"],"mappings":";;;;;;AAiHA,MAAM,sBAAsB,IAAIA,MAAAA,YAAY;AAC5C,MAAM,sBAAsB,IAAIA,MAAAA,YAAY;AAe5B,SAAA,WACd,IACA,SACyB;AACnB,QAAA,EAAE,IAAI,OAAAC,QAAO,OAAO,YAAY,UAAU,IAAI,WAAW,CAAC;AAEhE,QAAM,eAAe;AACrB,QAAM,YAAYC,KAAAA,SAAS,KAAK,IAAI,CAAC,MAAM,WAAW;AACtD,QAAM,eAAeA,KAAA,SAAS,KAAK,IAAI,QAAQ,CAAC;AAC1C,QAAA,WAAWC,QAAI,KAAK;AAE1B,QAAM,UAAU;AAChB,QAAM,eAAeD,KAAAA,SAASD,MAAK,IAAIA,OAAM,WAAW,UAAU;AAClE,QAAM,YAAYC,KAAAA,SAASD,MAAK,IAAI,CAACA,OAAM,WAAWA;AACtD,QAAM,eAAeC,KAAA,SAASD,MAAK,IAAIA,SAAQ,CAAC;AAC1C,QAAA,WAAWE,QAAI,KAAK;AAEpB,QAAA,cAAc,UAAU,WAAc;AAC1C,UAAM,YAAYC,KAAA,WAAW,EAAE,IAAI,GAAO,IAAA;AAE1C,QAAI,aAAa,WAAW;AACpB,YAAA,SAAS,aAAa,IAAI,SAAS;AACzC,UAAI,QAAQ;AACV,iBAAS,QAAQ;AACjB,eAAO,MAAM,OAAO;AAAA,MAAA;AAAA,IACtB;AAGF,QAAI,aAAa,WAAW;AAC1B,YAAM,SAAS,MAAM,aAAa,IAAI,SAAS;AAE/C,UAAI,QAAQ;AACV,cAAMC,QAAO,OAAO;AACpB,iBAAS,QAAQ;AACjB,iDAAa;AACDA,+CAAAA,OAAM,GAAG;AACdA,eAAAA;AAAAA,MAAA;AAAA,IACT;AAGI,UAAA,UAAU,GAAG,GAAG,MAAM;AAE5B,QAAI,aAAa,WAAW;AACb,mBAAA,IAAI,WAAW,SAAS,YAAY;AAAA,IAAA;AAGnD,UAAM,OAAO,MAAM;AAEnB,QAAI,aAAa,WAAW;AACb,mBAAA,IAAI,WAAW,MAAM,YAAY;AAAA,IAAA;AAGzC,WAAA;AAAA,EACT;AACA,QAAM,EAAE,OAAO,YAAY,KAAK,MAAM,UAAU,WAAW,GAAGC,QAAM,IAAIC,eAAS,aAAa,OAAO;AAE/F,QAAA,QAAQC,IAAAA,SAAS,OAAO;AAAA,IAC5B,GAAG,WAAW;AAAA,IACd,UAAU,SAAS;AAAA,IACnB,UAAU,SAAS;AAAA,EAAA,EACnB;AAEK,SAAA;AAAA,IACL,GAAGF;AAAAA,IACH;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;;"}
+{"version":3,"file":"request.cjs","sources":["../src/request.ts"],"sourcesContent":["import { type Cache, type CacheOptions, type Cached, MemoryCache } from '@cloudcome/utils-core/cache';\nimport type { DateValue } from '@cloudcome/utils-core/date';\nimport { isFunction, isObject } from '@cloudcome/utils-core/type';\nimport type { AnyArray, MaybeCallable } from '@cloudcome/utils-core/types';\nimport type { ComputedRef, Ref } from 'vue';\nimport { computed, ref } from 'vue';\nimport { type UseAsyncOptions, type UseAsyncReturns, type UseAsyncState, useAsync } from './async';\n\n/**\n * 请求缓存配置选项。\n * @template T 缓存数据的类型。\n */\nexport type RequestCacheOptions<T> = CacheOptions & {\n  /**\n   * 是否禁用缓存，默认为 false。\n   * 如果设置为 true，则不会使用缓存。\n   */\n  disabled?: boolean;\n\n  /**\n   * 自定义缓存存储实现。\n   * 可以传入自定义的缓存类来替代默认的内存缓存。\n   */\n  storage?: Cache<T>;\n};\n\nexport type RequestShareOptions = {\n  /**\n   * 是否禁用共享请求，默认为 false。\n   * 如果设置为 true，则不会共享请求结果。\n   */\n  disabled?: boolean;\n\n  /**\n   * 共享的最大时长（毫秒），为 0 时表示永久共享。\n   * 超过该时长后，共享的请求结果将被清除。\n   */\n  maxAge?: number;\n\n  /**\n   * 共享的过期时间（时间戳、日期字符串、日期对象等）。\n   * 优先级比 maxAge 更高，指定具体的过期时间。\n   */\n  expiredAt?: DateValue;\n};\n\nexport type RetryOptions = {\n  /**\n   * 是否禁用共享请求，默认为 false。\n   * 如果设置为 true，则不会重试。\n   */\n  disabled?: boolean;\n};\n\n/**\n * 请求选项，扩展了异步操作的选项。\n * @template T 请求返回的数据类型。\n * @template I 请求参数的类型。\n */\nexport type UseRequestOptions<I extends AnyArray, O> = UseAsyncOptions<I, O> & {\n  /**\n   * 请求的唯一标识符，可以是字符串或函数返回的字符串。\n   * 用于缓存和共享的键值。\n   */\n  id?: MaybeCallable<string>;\n\n  /**\n   * 缓存配置，可以是布尔值或完整的缓存选项。\n   * 如果为 true，则启用默认缓存；如果为对象，则可以自定义缓存行为。\n   */\n  cache?: boolean | RequestCacheOptions<O>;\n\n  /**\n   * 共享配置，可以是布尔值或完整的共享选项。\n   * 共享时，相同的请求 ID 会复用第一次发出且没有响应完成的请求。\n   *\n   * 例如，10 组件同时或先后发起 10 次请求用于获取用户信息，\n   * 那么这 10 个组件会共同等待第一次发起的请求，直到完成。\n   *\n   * 共享与缓存是不同的概念，共享是进行时，缓存是过去时，即：\n   * - 共享是共享**正在发送**的请求\n   * - 缓存是缓存**已经发送**的请求\n   *\n   * 如果为 true，则启用默认共享；如果为对象，则可以自定义共享行为。\n   */\n  share?: boolean | RequestShareOptions;\n\n  /**\n   * 当命中缓存时的回调函数。\n   * 在缓存命中时触发，接收缓存的数据作为参数。\n   */\n  onCacheHit?: (cached: Cached<O>) => unknown;\n};\n\nexport type UseRequestState<O> = UseAsyncState<O> & {\n  /**\n   * 是否命中共享数据\n   */\n  hitShare: boolean;\n\n  /**\n   * 是否命中缓存\n   */\n  hitCache: boolean;\n};\nexport type UseRequestReturns<I extends AnyArray, O> = Omit<UseAsyncReturns<I, O>, 'run' | 'runAsync' | 'state'> & {\n  state: ComputedRef<UseRequestState<O>>;\n  send: (...inputs: I) => void;\n  sendAsync: (...inputs: I) => Promise<O>;\n  hitShare: Ref<boolean>;\n  hitCache: Ref<boolean>;\n};\n\nconst defaultCacheStorage = new MemoryCache();\nconst defaultShareStorage = new MemoryCache();\n\n/**\n * 使用请求功能的组合式函数。\n * 支持缓存和异步操作的封装。\n *\n * @template O 请求返回的数据类型。\n * @template I 请求参数的类型。\n * @param {() => Promise<O>} fn 实际的请求函数，返回一个 Promise。\n * @param {UseRequestOptions<I, O>} [options] 请求选项，包括缓存和回调配置。\n * @returns 返回一个对象，包含以下内容：\n * - 异步操作的状态（如 loading、error 等）。\n * - 是否命中缓存（hitCache）。\n * - 是否命中共享请求（hitShare）。\n */\nexport function useRequest<I extends AnyArray, O>(\n  fn: (...inputs: I) => Promise<O>,\n  options?: UseRequestOptions<I, O>,\n): UseRequestReturns<I, O> {\n  const { id, cache, share, onCacheHit, onSuccess } = options || {};\n\n  const shareStorage = defaultShareStorage as MemoryCache<Promise<O>>;\n  const shareAble = isObject(share) ? !share.disabled : share;\n  const shareOptions = isObject(share) ? share : {};\n  const hitShare = ref(false);\n\n  const _cached = defaultCacheStorage as Cache<O>;\n  const cacheStorage = isObject(cache) ? cache.storage || _cached : _cached;\n  const cacheAble = isObject(cache) ? !cache.disabled : cache;\n  const cacheOptions = isObject(cache) ? cache : {};\n  const hitCache = ref(false);\n\n  const cacheableFn = async (...inputs: I) => {\n    const requestId = isFunction(id) ? id() : id;\n\n    if (requestId && shareAble) {\n      const shared = shareStorage.get(requestId);\n      if (shared) {\n        hitShare.value = true;\n        return await shared.data;\n      }\n    }\n\n    if (requestId && cacheAble) {\n      const cached = await cacheStorage.get(requestId);\n\n      if (cached) {\n        const data = cached.data;\n        hitCache.value = true;\n        onCacheHit?.(cached);\n        onSuccess?.(data, ...inputs);\n        return data;\n      }\n    }\n\n    const promise = fn(...inputs);\n\n    if (requestId && shareAble) {\n      shareStorage.set(requestId, promise, shareOptions);\n    }\n\n    const data = await promise;\n\n    if (requestId && cacheAble) {\n      cacheStorage.set(requestId, data, cacheOptions);\n    }\n\n    return data;\n  };\n  const { state: asyncState, run: send, runAsync: sendAsync, ...async } = useAsync(cacheableFn, options);\n\n  const state = computed(() => ({\n    ...asyncState.value,\n    hitShare: hitShare.value,\n    hitCache: hitCache.value,\n  }));\n\n  return {\n    ...async,\n    state,\n    send,\n    sendAsync,\n    hitShare,\n    hitCache,\n  };\n}\n"],"names":["MemoryCache","cache","isObject","ref","isFunction","data","async","useAsync","computed"],"mappings":";;;;;;AAiHA,MAAM,sBAAsB,IAAIA,MAAAA,YAAY;AAC5C,MAAM,sBAAsB,IAAIA,MAAAA,YAAY;AAe5B,SAAA,WACd,IACA,SACyB;AACnB,QAAA,EAAE,IAAI,OAAAC,QAAO,OAAO,YAAY,UAAU,IAAI,WAAW,CAAC;AAEhE,QAAM,eAAe;AACrB,QAAM,YAAYC,KAAAA,SAAS,KAAK,IAAI,CAAC,MAAM,WAAW;AACtD,QAAM,eAAeA,KAAA,SAAS,KAAK,IAAI,QAAQ,CAAC;AAC1C,QAAA,WAAWC,QAAI,KAAK;AAE1B,QAAM,UAAU;AAChB,QAAM,eAAeD,KAAAA,SAASD,MAAK,IAAIA,OAAM,WAAW,UAAU;AAClE,QAAM,YAAYC,KAAAA,SAASD,MAAK,IAAI,CAACA,OAAM,WAAWA;AACtD,QAAM,eAAeC,KAAA,SAASD,MAAK,IAAIA,SAAQ,CAAC;AAC1C,QAAA,WAAWE,QAAI,KAAK;AAEpB,QAAA,cAAc,UAAU,WAAc;AAC1C,UAAM,YAAYC,KAAA,WAAW,EAAE,IAAI,GAAO,IAAA;AAE1C,QAAI,aAAa,WAAW;AACpB,YAAA,SAAS,aAAa,IAAI,SAAS;AACzC,UAAI,QAAQ;AACV,iBAAS,QAAQ;AACjB,eAAO,MAAM,OAAO;AAAA,MAAA;AAAA,IACtB;AAGF,QAAI,aAAa,WAAW;AAC1B,YAAM,SAAS,MAAM,aAAa,IAAI,SAAS;AAE/C,UAAI,QAAQ;AACV,cAAMC,QAAO,OAAO;AACpB,iBAAS,QAAQ;AACjB,iDAAa;AACDA,+CAAAA,OAAM,GAAG;AACdA,eAAAA;AAAAA,MAAA;AAAA,IACT;AAGI,UAAA,UAAU,GAAG,GAAG,MAAM;AAE5B,QAAI,aAAa,WAAW;AACb,mBAAA,IAAI,WAAW,SAAS,YAAY;AAAA,IAAA;AAGnD,UAAM,OAAO,MAAM;AAEnB,QAAI,aAAa,WAAW;AACb,mBAAA,IAAI,WAAW,MAAM,YAAY;AAAA,IAAA;AAGzC,WAAA;AAAA,EACT;AACA,QAAM,EAAE,OAAO,YAAY,KAAK,MAAM,UAAU,WAAW,GAAGC,QAAM,IAAIC,eAAS,aAAa,OAAO;AAE/F,QAAA,QAAQC,IAAAA,SAAS,OAAO;AAAA,IAC5B,GAAG,WAAW;AAAA,IACd,UAAU,SAAS;AAAA,IACnB,UAAU,SAAS;AAAA,EAAA,EACnB;AAEK,SAAA;AAAA,IACL,GAAGF;AAAAA,IACH;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;;"}

package/dist/request.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"request.mjs","sources":["../src/request.ts"],"sourcesContent":["import { type Cache, type CacheOptions, type Cached, MemoryCache } from '@cloudcome/utils-core/cache';\nimport type { DateValue } from '@cloudcome/utils-core/date';\nimport { isFunction, isObject } from '@cloudcome/utils-core/type';\nimport type { AnyArray, MaybeCallable, MaybePromise } from '@cloudcome/utils-core/types';\nimport type { ComputedRef, Ref } from 'vue';\nimport { computed, ref } from 'vue';\nimport { type UseAsyncOptions, type UseAsyncReturns, type UseAsyncState, useAsync } from './async';\n\n/**\n * 请求缓存配置选项。\n * @template T 缓存数据的类型。\n */\nexport type RequestCacheOptions<T> = CacheOptions & {\n  /**\n   * 是否禁用缓存，默认为 false。\n   * 如果设置为 true，则不会使用缓存。\n   */\n  disabled?: boolean;\n\n  /**\n   * 自定义缓存存储实现。\n   * 可以传入自定义的缓存类来替代默认的内存缓存。\n   */\n  storage?: Cache<T>;\n};\n\nexport type RequestShareOptions = {\n  /**\n   * 是否禁用共享请求，默认为 false。\n   * 如果设置为 true，则不会共享请求结果。\n   */\n  disabled?: boolean;\n\n  /**\n   * 共享的最大时长（毫秒），为 0 时表示永久共享。\n   * 超过该时长后，共享的请求结果将被清除。\n   */\n  maxAge?: number;\n\n  /**\n   * 共享的过期时间（时间戳、日期字符串、日期对象等）。\n   * 优先级比 maxAge 更高，指定具体的过期时间。\n   */\n  expiredAt?: DateValue;\n};\n\nexport type RetryOptions = {\n  /**\n   * 是否禁用共享请求，默认为 false。\n   * 如果设置为 true，则不会重试。\n   */\n  disabled?: boolean;\n};\n\n/**\n * 请求选项，扩展了异步操作的选项。\n * @template T 请求返回的数据类型。\n * @template I 请求参数的类型。\n */\nexport type UseRequestOptions<I extends AnyArray, O> = UseAsyncOptions<I, O> & {\n  /**\n   * 请求的唯一标识符，可以是字符串或函数返回的字符串。\n   * 用于缓存和共享的键值。\n   */\n  id?: MaybeCallable<string>;\n\n  /**\n   * 缓存配置，可以是布尔值或完整的缓存选项。\n   * 如果为 true，则启用默认缓存；如果为对象，则可以自定义缓存行为。\n   */\n  cache?: boolean | RequestCacheOptions<O>;\n\n  /**\n   * 共享配置，可以是布尔值或完整的共享选项。\n   * 共享时，相同的请求 ID 会复用第一次发出且没有响应完成的请求。\n   *\n   * 例如，10 组件同时或先后发起 10 次请求用于获取用户信息，\n   * 那么这 10 个组件会共同等待第一次发起的请求，直到完成。\n   *\n   * 共享与缓存是不同的概念，共享是进行时，缓存是过去时，即：\n   * - 共享是共享**正在发送**的请求\n   * - 缓存是缓存**已经发送**的请求\n   *\n   * 如果为 true，则启用默认共享；如果为对象，则可以自定义共享行为。\n   */\n  share?: boolean | RequestShareOptions;\n\n  /**\n   * 当命中缓存时的回调函数。\n   * 在缓存命中时触发，接收缓存的数据作为参数。\n   */\n  onCacheHit?: (cached: Cached<O>) => unknown;\n};\n\nexport type UseRequestState<O> = UseAsyncState<O> & {\n  /**\n   * 是否命中共享数据\n   */\n  hitShare: boolean;\n\n  /**\n   * 是否命中缓存\n   */\n  hitCache: boolean;\n};\nexport type UseRequestReturns<I extends AnyArray, O> = Omit<UseAsyncReturns<I, O>, 'run' | 'runAsync' | 'state'> & {\n  state: ComputedRef<UseRequestState<O>>;\n  send: (...inputs: I) => void;\n  sendAsync: (...inputs: I) => Promise<O>;\n  hitShare: Ref<boolean>;\n  hitCache: Ref<boolean>;\n};\n\nconst defaultCacheStorage = new MemoryCache();\nconst defaultShareStorage = new MemoryCache();\n\n/**\n * 使用请求功能的组合式函数。\n * 支持缓存和异步操作的封装。\n *\n * @template O 请求返回的数据类型。\n * @template I 请求参数的类型。\n * @param {() => Promise<O>} fn 实际的请求函数，返回一个 Promise。\n * @param {UseRequestOptions<I, O>} [options] 请求选项，包括缓存和回调配置。\n * @returns 返回一个对象，包含以下内容：\n * - 异步操作的状态（如 loading、error 等）。\n * - 是否命中缓存（hitCache）。\n * - 是否命中共享请求（hitShare）。\n */\nexport function useRequest<I extends AnyArray, O>(\n  fn: (...inputs: I) => Promise<O>,\n  options?: UseRequestOptions<I, O>,\n): UseRequestReturns<I, O> {\n  const { id, cache, share, onCacheHit, onSuccess } = options || {};\n\n  const shareStorage = defaultShareStorage as MemoryCache<Promise<O>>;\n  const shareAble = isObject(share) ? !share.disabled : share;\n  const shareOptions = isObject(share) ? share : {};\n  const hitShare = ref(false);\n\n  const _cached = defaultCacheStorage as Cache<O>;\n  const cacheStorage = isObject(cache) ? cache.storage || _cached : _cached;\n  const cacheAble = isObject(cache) ? !cache.disabled : cache;\n  const cacheOptions = isObject(cache) ? cache : {};\n  const hitCache = ref(false);\n\n  const cacheableFn = async (...inputs: I) => {\n    const requestId = isFunction(id) ? id() : id;\n\n    if (requestId && shareAble) {\n      const shared = shareStorage.get(requestId);\n      if (shared) {\n        hitShare.value = true;\n        return await shared.data;\n      }\n    }\n\n    if (requestId && cacheAble) {\n      const cached = await cacheStorage.get(requestId);\n\n      if (cached) {\n        const data = cached.data;\n        hitCache.value = true;\n        onCacheHit?.(cached);\n        onSuccess?.(data, ...inputs);\n        return data;\n      }\n    }\n\n    const promise = fn(...inputs);\n\n    if (requestId && shareAble) {\n      shareStorage.set(requestId, promise, shareOptions);\n    }\n\n    const data = await promise;\n\n    if (requestId && cacheAble) {\n      cacheStorage.set(requestId, data, cacheOptions);\n    }\n\n    return data;\n  };\n  const { state: asyncState, run: send, runAsync: sendAsync, ...async } = useAsync(cacheableFn, options);\n\n  const state = computed(() => ({\n    ...asyncState.value,\n    hitShare: hitShare.value,\n    hitCache: hitCache.value,\n  }));\n\n  return {\n    ...async,\n    state,\n    send,\n    sendAsync,\n    hitShare,\n    hitCache,\n  };\n}\n"],"names":["data"],"mappings":";;;;AAiHA,MAAM,sBAAsB,IAAI,YAAY;AAC5C,MAAM,sBAAsB,IAAI,YAAY;AAe5B,SAAA,WACd,IACA,SACyB;AACnB,QAAA,EAAE,IAAI,OAAO,OAAO,YAAY,UAAU,IAAI,WAAW,CAAC;AAEhE,QAAM,eAAe;AACrB,QAAM,YAAY,SAAS,KAAK,IAAI,CAAC,MAAM,WAAW;AACtD,QAAM,eAAe,SAAS,KAAK,IAAI,QAAQ,CAAC;AAC1C,QAAA,WAAW,IAAI,KAAK;AAE1B,QAAM,UAAU;AAChB,QAAM,eAAe,SAAS,KAAK,IAAI,MAAM,WAAW,UAAU;AAClE,QAAM,YAAY,SAAS,KAAK,IAAI,CAAC,MAAM,WAAW;AACtD,QAAM,eAAe,SAAS,KAAK,IAAI,QAAQ,CAAC;AAC1C,QAAA,WAAW,IAAI,KAAK;AAEpB,QAAA,cAAc,UAAU,WAAc;AAC1C,UAAM,YAAY,WAAW,EAAE,IAAI,GAAO,IAAA;AAE1C,QAAI,aAAa,WAAW;AACpB,YAAA,SAAS,aAAa,IAAI,SAAS;AACzC,UAAI,QAAQ;AACV,iBAAS,QAAQ;AACjB,eAAO,MAAM,OAAO;AAAA,MAAA;AAAA,IACtB;AAGF,QAAI,aAAa,WAAW;AAC1B,YAAM,SAAS,MAAM,aAAa,IAAI,SAAS;AAE/C,UAAI,QAAQ;AACV,cAAMA,QAAO,OAAO;AACpB,iBAAS,QAAQ;AACjB,iDAAa;AACDA,+CAAAA,OAAM,GAAG;AACdA,eAAAA;AAAAA,MAAA;AAAA,IACT;AAGI,UAAA,UAAU,GAAG,GAAG,MAAM;AAE5B,QAAI,aAAa,WAAW;AACb,mBAAA,IAAI,WAAW,SAAS,YAAY;AAAA,IAAA;AAGnD,UAAM,OAAO,MAAM;AAEnB,QAAI,aAAa,WAAW;AACb,mBAAA,IAAI,WAAW,MAAM,YAAY;AAAA,IAAA;AAGzC,WAAA;AAAA,EACT;AACA,QAAM,EAAE,OAAO,YAAY,KAAK,MAAM,UAAU,WAAW,GAAG,MAAM,IAAI,SAAS,aAAa,OAAO;AAE/F,QAAA,QAAQ,SAAS,OAAO;AAAA,IAC5B,GAAG,WAAW;AAAA,IACd,UAAU,SAAS;AAAA,IACnB,UAAU,SAAS;AAAA,EAAA,EACnB;AAEK,SAAA;AAAA,IACL,GAAG;AAAA,IACH;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;"}
+{"version":3,"file":"request.mjs","sources":["../src/request.ts"],"sourcesContent":["import { type Cache, type CacheOptions, type Cached, MemoryCache } from '@cloudcome/utils-core/cache';\nimport type { DateValue } from '@cloudcome/utils-core/date';\nimport { isFunction, isObject } from '@cloudcome/utils-core/type';\nimport type { AnyArray, MaybeCallable } from '@cloudcome/utils-core/types';\nimport type { ComputedRef, Ref } from 'vue';\nimport { computed, ref } from 'vue';\nimport { type UseAsyncOptions, type UseAsyncReturns, type UseAsyncState, useAsync } from './async';\n\n/**\n * 请求缓存配置选项。\n * @template T 缓存数据的类型。\n */\nexport type RequestCacheOptions<T> = CacheOptions & {\n  /**\n   * 是否禁用缓存，默认为 false。\n   * 如果设置为 true，则不会使用缓存。\n   */\n  disabled?: boolean;\n\n  /**\n   * 自定义缓存存储实现。\n   * 可以传入自定义的缓存类来替代默认的内存缓存。\n   */\n  storage?: Cache<T>;\n};\n\nexport type RequestShareOptions = {\n  /**\n   * 是否禁用共享请求，默认为 false。\n   * 如果设置为 true，则不会共享请求结果。\n   */\n  disabled?: boolean;\n\n  /**\n   * 共享的最大时长（毫秒），为 0 时表示永久共享。\n   * 超过该时长后，共享的请求结果将被清除。\n   */\n  maxAge?: number;\n\n  /**\n   * 共享的过期时间（时间戳、日期字符串、日期对象等）。\n   * 优先级比 maxAge 更高，指定具体的过期时间。\n   */\n  expiredAt?: DateValue;\n};\n\nexport type RetryOptions = {\n  /**\n   * 是否禁用共享请求，默认为 false。\n   * 如果设置为 true，则不会重试。\n   */\n  disabled?: boolean;\n};\n\n/**\n * 请求选项，扩展了异步操作的选项。\n * @template T 请求返回的数据类型。\n * @template I 请求参数的类型。\n */\nexport type UseRequestOptions<I extends AnyArray, O> = UseAsyncOptions<I, O> & {\n  /**\n   * 请求的唯一标识符，可以是字符串或函数返回的字符串。\n   * 用于缓存和共享的键值。\n   */\n  id?: MaybeCallable<string>;\n\n  /**\n   * 缓存配置，可以是布尔值或完整的缓存选项。\n   * 如果为 true，则启用默认缓存；如果为对象，则可以自定义缓存行为。\n   */\n  cache?: boolean | RequestCacheOptions<O>;\n\n  /**\n   * 共享配置，可以是布尔值或完整的共享选项。\n   * 共享时，相同的请求 ID 会复用第一次发出且没有响应完成的请求。\n   *\n   * 例如，10 组件同时或先后发起 10 次请求用于获取用户信息，\n   * 那么这 10 个组件会共同等待第一次发起的请求，直到完成。\n   *\n   * 共享与缓存是不同的概念，共享是进行时，缓存是过去时，即：\n   * - 共享是共享**正在发送**的请求\n   * - 缓存是缓存**已经发送**的请求\n   *\n   * 如果为 true，则启用默认共享；如果为对象，则可以自定义共享行为。\n   */\n  share?: boolean | RequestShareOptions;\n\n  /**\n   * 当命中缓存时的回调函数。\n   * 在缓存命中时触发，接收缓存的数据作为参数。\n   */\n  onCacheHit?: (cached: Cached<O>) => unknown;\n};\n\nexport type UseRequestState<O> = UseAsyncState<O> & {\n  /**\n   * 是否命中共享数据\n   */\n  hitShare: boolean;\n\n  /**\n   * 是否命中缓存\n   */\n  hitCache: boolean;\n};\nexport type UseRequestReturns<I extends AnyArray, O> = Omit<UseAsyncReturns<I, O>, 'run' | 'runAsync' | 'state'> & {\n  state: ComputedRef<UseRequestState<O>>;\n  send: (...inputs: I) => void;\n  sendAsync: (...inputs: I) => Promise<O>;\n  hitShare: Ref<boolean>;\n  hitCache: Ref<boolean>;\n};\n\nconst defaultCacheStorage = new MemoryCache();\nconst defaultShareStorage = new MemoryCache();\n\n/**\n * 使用请求功能的组合式函数。\n * 支持缓存和异步操作的封装。\n *\n * @template O 请求返回的数据类型。\n * @template I 请求参数的类型。\n * @param {() => Promise<O>} fn 实际的请求函数，返回一个 Promise。\n * @param {UseRequestOptions<I, O>} [options] 请求选项，包括缓存和回调配置。\n * @returns 返回一个对象，包含以下内容：\n * - 异步操作的状态（如 loading、error 等）。\n * - 是否命中缓存（hitCache）。\n * - 是否命中共享请求（hitShare）。\n */\nexport function useRequest<I extends AnyArray, O>(\n  fn: (...inputs: I) => Promise<O>,\n  options?: UseRequestOptions<I, O>,\n): UseRequestReturns<I, O> {\n  const { id, cache, share, onCacheHit, onSuccess } = options || {};\n\n  const shareStorage = defaultShareStorage as MemoryCache<Promise<O>>;\n  const shareAble = isObject(share) ? !share.disabled : share;\n  const shareOptions = isObject(share) ? share : {};\n  const hitShare = ref(false);\n\n  const _cached = defaultCacheStorage as Cache<O>;\n  const cacheStorage = isObject(cache) ? cache.storage || _cached : _cached;\n  const cacheAble = isObject(cache) ? !cache.disabled : cache;\n  const cacheOptions = isObject(cache) ? cache : {};\n  const hitCache = ref(false);\n\n  const cacheableFn = async (...inputs: I) => {\n    const requestId = isFunction(id) ? id() : id;\n\n    if (requestId && shareAble) {\n      const shared = shareStorage.get(requestId);\n      if (shared) {\n        hitShare.value = true;\n        return await shared.data;\n      }\n    }\n\n    if (requestId && cacheAble) {\n      const cached = await cacheStorage.get(requestId);\n\n      if (cached) {\n        const data = cached.data;\n        hitCache.value = true;\n        onCacheHit?.(cached);\n        onSuccess?.(data, ...inputs);\n        return data;\n      }\n    }\n\n    const promise = fn(...inputs);\n\n    if (requestId && shareAble) {\n      shareStorage.set(requestId, promise, shareOptions);\n    }\n\n    const data = await promise;\n\n    if (requestId && cacheAble) {\n      cacheStorage.set(requestId, data, cacheOptions);\n    }\n\n    return data;\n  };\n  const { state: asyncState, run: send, runAsync: sendAsync, ...async } = useAsync(cacheableFn, options);\n\n  const state = computed(() => ({\n    ...asyncState.value,\n    hitShare: hitShare.value,\n    hitCache: hitCache.value,\n  }));\n\n  return {\n    ...async,\n    state,\n    send,\n    sendAsync,\n    hitShare,\n    hitCache,\n  };\n}\n"],"names":["data"],"mappings":";;;;AAiHA,MAAM,sBAAsB,IAAI,YAAY;AAC5C,MAAM,sBAAsB,IAAI,YAAY;AAe5B,SAAA,WACd,IACA,SACyB;AACnB,QAAA,EAAE,IAAI,OAAO,OAAO,YAAY,UAAU,IAAI,WAAW,CAAC;AAEhE,QAAM,eAAe;AACrB,QAAM,YAAY,SAAS,KAAK,IAAI,CAAC,MAAM,WAAW;AACtD,QAAM,eAAe,SAAS,KAAK,IAAI,QAAQ,CAAC;AAC1C,QAAA,WAAW,IAAI,KAAK;AAE1B,QAAM,UAAU;AAChB,QAAM,eAAe,SAAS,KAAK,IAAI,MAAM,WAAW,UAAU;AAClE,QAAM,YAAY,SAAS,KAAK,IAAI,CAAC,MAAM,WAAW;AACtD,QAAM,eAAe,SAAS,KAAK,IAAI,QAAQ,CAAC;AAC1C,QAAA,WAAW,IAAI,KAAK;AAEpB,QAAA,cAAc,UAAU,WAAc;AAC1C,UAAM,YAAY,WAAW,EAAE,IAAI,GAAO,IAAA;AAE1C,QAAI,aAAa,WAAW;AACpB,YAAA,SAAS,aAAa,IAAI,SAAS;AACzC,UAAI,QAAQ;AACV,iBAAS,QAAQ;AACjB,eAAO,MAAM,OAAO;AAAA,MAAA;AAAA,IACtB;AAGF,QAAI,aAAa,WAAW;AAC1B,YAAM,SAAS,MAAM,aAAa,IAAI,SAAS;AAE/C,UAAI,QAAQ;AACV,cAAMA,QAAO,OAAO;AACpB,iBAAS,QAAQ;AACjB,iDAAa;AACDA,+CAAAA,OAAM,GAAG;AACdA,eAAAA;AAAAA,MAAA;AAAA,IACT;AAGI,UAAA,UAAU,GAAG,GAAG,MAAM;AAE5B,QAAI,aAAa,WAAW;AACb,mBAAA,IAAI,WAAW,SAAS,YAAY;AAAA,IAAA;AAGnD,UAAM,OAAO,MAAM;AAEnB,QAAI,aAAa,WAAW;AACb,mBAAA,IAAI,WAAW,MAAM,YAAY;AAAA,IAAA;AAGzC,WAAA;AAAA,EACT;AACA,QAAM,EAAE,OAAO,YAAY,KAAK,MAAM,UAAU,WAAW,GAAG,MAAM,IAAI,SAAS,aAAa,OAAO;AAE/F,QAAA,QAAQ,SAAS,OAAO;AAAA,IAC5B,GAAG,WAAW;AAAA,IACd,UAAU,SAAS;AAAA,IACnB,UAAU,SAAS;AAAA,EAAA,EACnB;AAEK,SAAA;AAAA,IACL,GAAG;AAAA,IACH;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudcome/utils-vue",
-  "version": "1.7.1",
+  "version": "1.7.2",
   "description": "cloudcome utils for vue",
   "engines": {
     "node": ">=22"
@@ -82,7 +82,7 @@
     "dist"
   ],
   "dependencies": {
-    "@cloudcome/utils-core": "~1.4.0",
+    "@cloudcome/utils-core": "~1.4.1",
     "vue": "^3.5.13",
     "vue-component-type-helpers": "^2.2.10"
   },