@cloudcome/utils-vue 1.13.2 → 1.13.3

package/README.md

@@ -117,7 +117,7 @@ UniApp 工具库，依赖 `@cloudcome/utils-core`、`@cloudcome/utils-vue`：
 
 ## 开发
 
-详见 [DEVELOPMENT.md](./DEVELOPMENT.md)。
+详见 [CONTRIBUTING.md](./CONTRIBUTING.md)。
 
 ## 许可
 

package/dist/async.cjs

@@ -1,69 +1,69 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("@cloudcome/utils-core/try");
-const vue = require("vue");
+let vue = require("vue");
+//#region src/async.ts
 function useAsync(fn, options) {
-  const times = vue.ref(0);
-  const loading = vue.ref(false);
-  const placeholder = options?.placeholder;
-  const data = vue.ref(placeholder ? placeholder() : null);
-  const error = vue.ref(null);
-  const state = vue.computed(() => ({
-    times: times.value,
-    loading: loading.value,
-    data: data.value,
-    error: error.value
-  }));
-  const runAsync = async (...inputs) => {
-    loading.value = true;
-    error.value = null;
-    try {
-      await options?.onBefore?.(...inputs);
-      times.value++;
-      data.value = await fn(...inputs);
-      await options?.onSuccess?.(data.value, ...inputs);
-      return data.value;
-    } catch (err) {
-      error.value = err;
-      try {
-        options?.onError?.(err, ...inputs);
-      } catch (err2) {
-      }
-      throw err;
-    } finally {
-      loading.value = false;
-      await options?.onAfter?.(...inputs);
-    }
-  };
-  const run = (...inputs) => {
-    runAsync(...inputs).then();
-  };
-  return {
-    state,
-    /**
-     * 是否正在加载。
-     */
-    loading,
-    /**
-     * 异步操作返回的数据。
-     */
-    data,
-    /**
-     * 异步操作抛出的错误。
-     */
-    error,
-    /**
-     * 执行异步操作并返回 Promise。
-     * @param inputs 异步函数的参数。
-     * @returns 异步操作的结果。
-     */
-    runAsync,
-    /**
-     * 执行异步操作但不返回 Promise。
-     * @param inputs 异步函数的参数。
-     */
-    run
-  };
+	const times = (0, vue.ref)(0);
+	const loading = (0, vue.ref)(false);
+	const placeholder = options?.placeholder;
+	const data = (0, vue.ref)(placeholder ? placeholder() : null);
+	const error = (0, vue.ref)(null);
+	const state = (0, vue.computed)(() => ({
+		times: times.value,
+		loading: loading.value,
+		data: data.value,
+		error: error.value
+	}));
+	const runAsync = async (...inputs) => {
+		loading.value = true;
+		error.value = null;
+		try {
+			await options?.onBefore?.(...inputs);
+			times.value++;
+			data.value = await fn(...inputs);
+			await options?.onSuccess?.(data.value, ...inputs);
+			return data.value;
+		} catch (err) {
+			error.value = err;
+			try {
+				options?.onError?.(err, ...inputs);
+			} catch (_err) {}
+			throw err;
+		} finally {
+			loading.value = false;
+			await options?.onAfter?.(...inputs);
+		}
+	};
+	const run = (...inputs) => {
+		runAsync(...inputs).then();
+	};
+	return {
+		state,
+		/**
+		* 是否正在加载。
+		*/
+		loading,
+		/**
+		* 异步操作返回的数据。
+		*/
+		data,
+		/**
+		* 异步操作抛出的错误。
+		*/
+		error,
+		/**
+		* 执行异步操作并返回 Promise。
+		* @param inputs 异步函数的参数。
+		* @returns 异步操作的结果。
+		*/
+		runAsync,
+		/**
+		* 执行异步操作但不返回 Promise。
+		* @param inputs 异步函数的参数。
+		*/
+		run
+	};
 }
+//#endregion
 exports.useAsync = useAsync;
-//# sourceMappingURL=async.cjs.map
+
+//# sourceMappingURL=async.cjs.map

package/dist/async.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"async.cjs","sources":["../src/async.ts"],"sourcesContent":["import { tryFlatten } from '@cloudcome/utils-core/try';\nimport 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  placeholder?: () => O;\n\n  /**\n   * 异步操作开始前的回调函数，可用于执行初始化逻辑或显示加载状态，抛出错误则中断操作\n   */\n  onBefore?: (...inputs: I) => unknown;\n\n  /**\n   * 异步操作成功后的回调函数，可用于处理成功后的数据更新或通知。\n   * @param data 异步操作返回的数据。\n   */\n  onSuccess?: (data: O, ...inputs: I) => unknown;\n\n  /**\n   * 异步操作失败后的回调函数，可用于记录错误日志或显示错误提示。\n   * @param err 异步操作抛出的错误。\n   */\n  onError?: (err: unknown, ...inputs: I) => unknown;\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 UseAsyncStateFilled<O> = {\n  times: number;\n  loading: boolean;\n  error: unknown;\n  data: O;\n};\n\nexport type UseAsyncOutput<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\nexport type UseAsyncOutputFilled<I extends AnyArray, O> = {\n  state: ComputedRef<UseAsyncStateFilled<O>>;\n  loading: Ref<boolean>;\n  data: Ref<O>;\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: Omit<UseAsyncOptions<I, O>, 'placeholder'> & { placeholder: () => O },\n): UseAsyncOutputFilled<I, O>;\nexport function useAsync<I extends AnyArray, O>(\n  fn: (...inputs: I) => Promise<O>,\n  options?: UseAsyncOptions<I, O>,\n): UseAsyncOutput<I, O>;\nexport function useAsync<I extends AnyArray, O>(\n  fn: (...inputs: I) => Promise<O>,\n  options?: UseAsyncOptions<I, O>,\n): UseAsyncOutput<I, O> {\n  const times = ref(0);\n  const loading = ref(false);\n  const placeholder = options?.placeholder;\n  const data = ref(placeholder ? placeholder() : 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      await options?.onBefore?.(...inputs);\n      times.value++;\n      data.value = await fn(...inputs);\n      await options?.onSuccess?.(data.value, ...inputs);\n      return data.value;\n    } catch (err) {\n      error.value = err;\n      try {\n        options?.onError?.(err, ...inputs);\n      } catch (err) {\n        //\n      }\n      throw err;\n    } finally {\n      loading.value = false;\n      await 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","err"],"mappings":";;;;AAmGgB,SAAA,SACd,IACA,SACsB;AAChB,QAAA,QAAQA,QAAI,CAAC;AACb,QAAA,UAAUA,QAAI,KAAK;AACzB,QAAM,cAAc,SAAS;AAC7B,QAAM,OAAOA,IAAA,IAAI,cAAc,YAAA,IAAgB,IAAI;AAC7C,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,SAAS,WAAW,GAAG,MAAM;AAC7B,YAAA;AACN,WAAK,QAAQ,MAAM,GAAG,GAAG,MAAM;AAC/B,YAAM,SAAS,YAAY,KAAK,OAAO,GAAG,MAAM;AAChD,aAAO,KAAK;AAAA,aACL,KAAK;AACZ,YAAM,QAAQ;AACV,UAAA;AACO,iBAAA,UAAU,KAAK,GAAG,MAAM;AAAA,eAC1BC,MAAK;AAAA,MAAA;AAGR,YAAA;AAAA,IAAA,UACN;AACA,cAAQ,QAAQ;AACV,YAAA,SAAS,UAAU,GAAG,MAAM;AAAA,IAAA;AAAA,EAEtC;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","names":[],"sources":["../src/async.ts"],"sourcesContent":["import type { AnyArray } from '@cloudcome/utils-core/types';\nimport { type ComputedRef, computed, type Ref, ref } from 'vue';\n\n/**\n * 异步操作的配置选项\n * @template T 异步操作返回的数据类型\n * @template P 异步操作的参数类型\n */\nexport type UseAsyncOptions<I extends AnyArray, O> = {\n  placeholder?: () => O;\n\n  /**\n   * 异步操作开始前的回调函数，可用于执行初始化逻辑或显示加载状态，抛出错误则中断操作\n   */\n  onBefore?: (...inputs: I) => unknown;\n\n  /**\n   * 异步操作成功后的回调函数，可用于处理成功后的数据更新或通知。\n   * @param data 异步操作返回的数据。\n   */\n  onSuccess?: (data: O, ...inputs: I) => unknown;\n\n  /**\n   * 异步操作失败后的回调函数，可用于记录错误日志或显示错误提示。\n   * @param err 异步操作抛出的错误。\n   */\n  onError?: (err: unknown, ...inputs: I) => unknown;\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 UseAsyncStateFilled<O> = {\n  times: number;\n  loading: boolean;\n  error: unknown;\n  data: O;\n};\n\nexport type UseAsyncOutput<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\nexport type UseAsyncOutputFilled<I extends AnyArray, O> = {\n  state: ComputedRef<UseAsyncStateFilled<O>>;\n  loading: Ref<boolean>;\n  data: Ref<O>;\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: Omit<UseAsyncOptions<I, O>, 'placeholder'> & {\n    placeholder: () => O;\n  },\n): UseAsyncOutputFilled<I, O>;\nexport function useAsync<I extends AnyArray, O>(\n  fn: (...inputs: I) => Promise<O>,\n  options?: UseAsyncOptions<I, O>,\n): UseAsyncOutput<I, O>;\nexport function useAsync<I extends AnyArray, O>(\n  fn: (...inputs: I) => Promise<O>,\n  options?: UseAsyncOptions<I, O>,\n): UseAsyncOutput<I, O> {\n  const times = ref(0);\n  const loading = ref(false);\n  const placeholder = options?.placeholder;\n  const data = ref(placeholder ? placeholder() : 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      await options?.onBefore?.(...inputs);\n      times.value++;\n      data.value = await fn(...inputs);\n      await options?.onSuccess?.(data.value, ...inputs);\n      return data.value;\n    } catch (err) {\n      error.value = err;\n      try {\n        options?.onError?.(err, ...inputs);\n      } catch (_err) {\n        //\n      }\n      throw err;\n    } finally {\n      loading.value = false;\n      await 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"],"mappings":";;;AAoGA,SAAgB,SACd,IACA,SACsB;CACtB,MAAM,SAAA,GAAA,IAAA,KAAY,EAAE;CACpB,MAAM,WAAA,GAAA,IAAA,KAAc,MAAM;CAC1B,MAAM,cAAc,SAAS;CAC7B,MAAM,QAAA,GAAA,IAAA,KAAW,cAAc,aAAa,GAAG,KAAK;CACpD,MAAM,SAAA,GAAA,IAAA,KAAqB,KAAK;CAChC,MAAM,SAAA,GAAA,IAAA,iBAAwB;EAC5B,OAAO,MAAM;EACb,SAAS,QAAQ;EACjB,MAAM,KAAK;EACX,OAAO,MAAM;EACd,EAAE;CAEH,MAAM,WAAW,OAAO,GAAG,WAA0B;EACnD,QAAQ,QAAQ;EAChB,MAAM,QAAQ;EAEd,IAAI;GACF,MAAM,SAAS,WAAW,GAAG,OAAO;GACpC,MAAM;GACN,KAAK,QAAQ,MAAM,GAAG,GAAG,OAAO;GAChC,MAAM,SAAS,YAAY,KAAK,OAAO,GAAG,OAAO;GACjD,OAAO,KAAK;WACL,KAAK;GACZ,MAAM,QAAQ;GACd,IAAI;IACF,SAAS,UAAU,KAAK,GAAG,OAAO;YAC3B,MAAM;GAGf,MAAM;YACE;GACR,QAAQ,QAAQ;GAChB,MAAM,SAAS,UAAU,GAAG,OAAO;;;CAIvC,MAAM,OAAO,GAAG,WAAc;EAC5B,SAAS,GAAG,OAAO,CAAC,MAAM;;CAG5B,OAAO;EACL;;;;EAIA;;;;EAKA;;;;EAKA;;;;;;EAOA;;;;;EAMA;EACD"}

package/dist/async.mjs

@@ -1,69 +1,68 @@
-import "@cloudcome/utils-core/try";
-import { ref, computed } from "vue";
+import { computed, ref } from "vue";
+//#region src/async.ts
 function useAsync(fn, options) {
-  const times = ref(0);
-  const loading = ref(false);
-  const placeholder = options?.placeholder;
-  const data = ref(placeholder ? placeholder() : null);
-  const error = ref(null);
-  const state = computed(() => ({
-    times: times.value,
-    loading: loading.value,
-    data: data.value,
-    error: error.value
-  }));
-  const runAsync = async (...inputs) => {
-    loading.value = true;
-    error.value = null;
-    try {
-      await options?.onBefore?.(...inputs);
-      times.value++;
-      data.value = await fn(...inputs);
-      await options?.onSuccess?.(data.value, ...inputs);
-      return data.value;
-    } catch (err) {
-      error.value = err;
-      try {
-        options?.onError?.(err, ...inputs);
-      } catch (err2) {
-      }
-      throw err;
-    } finally {
-      loading.value = false;
-      await options?.onAfter?.(...inputs);
-    }
-  };
-  const run = (...inputs) => {
-    runAsync(...inputs).then();
-  };
-  return {
-    state,
-    /**
-     * 是否正在加载。
-     */
-    loading,
-    /**
-     * 异步操作返回的数据。
-     */
-    data,
-    /**
-     * 异步操作抛出的错误。
-     */
-    error,
-    /**
-     * 执行异步操作并返回 Promise。
-     * @param inputs 异步函数的参数。
-     * @returns 异步操作的结果。
-     */
-    runAsync,
-    /**
-     * 执行异步操作但不返回 Promise。
-     * @param inputs 异步函数的参数。
-     */
-    run
-  };
+	const times = ref(0);
+	const loading = ref(false);
+	const placeholder = options?.placeholder;
+	const data = ref(placeholder ? placeholder() : null);
+	const error = ref(null);
+	const state = computed(() => ({
+		times: times.value,
+		loading: loading.value,
+		data: data.value,
+		error: error.value
+	}));
+	const runAsync = async (...inputs) => {
+		loading.value = true;
+		error.value = null;
+		try {
+			await options?.onBefore?.(...inputs);
+			times.value++;
+			data.value = await fn(...inputs);
+			await options?.onSuccess?.(data.value, ...inputs);
+			return data.value;
+		} catch (err) {
+			error.value = err;
+			try {
+				options?.onError?.(err, ...inputs);
+			} catch (_err) {}
+			throw err;
+		} finally {
+			loading.value = false;
+			await options?.onAfter?.(...inputs);
+		}
+	};
+	const run = (...inputs) => {
+		runAsync(...inputs).then();
+	};
+	return {
+		state,
+		/**
+		* 是否正在加载。
+		*/
+		loading,
+		/**
+		* 异步操作返回的数据。
+		*/
+		data,
+		/**
+		* 异步操作抛出的错误。
+		*/
+		error,
+		/**
+		* 执行异步操作并返回 Promise。
+		* @param inputs 异步函数的参数。
+		* @returns 异步操作的结果。
+		*/
+		runAsync,
+		/**
+		* 执行异步操作但不返回 Promise。
+		* @param inputs 异步函数的参数。
+		*/
+		run
+	};
 }
-export {
-  useAsync
-};
-//# sourceMappingURL=async.mjs.map
+//#endregion
+export { useAsync };
+
+//# sourceMappingURL=async.mjs.map

package/dist/async.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"async.mjs","sources":["../src/async.ts"],"sourcesContent":["import { tryFlatten } from '@cloudcome/utils-core/try';\nimport 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  placeholder?: () => O;\n\n  /**\n   * 异步操作开始前的回调函数，可用于执行初始化逻辑或显示加载状态，抛出错误则中断操作\n   */\n  onBefore?: (...inputs: I) => unknown;\n\n  /**\n   * 异步操作成功后的回调函数，可用于处理成功后的数据更新或通知。\n   * @param data 异步操作返回的数据。\n   */\n  onSuccess?: (data: O, ...inputs: I) => unknown;\n\n  /**\n   * 异步操作失败后的回调函数，可用于记录错误日志或显示错误提示。\n   * @param err 异步操作抛出的错误。\n   */\n  onError?: (err: unknown, ...inputs: I) => unknown;\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 UseAsyncStateFilled<O> = {\n  times: number;\n  loading: boolean;\n  error: unknown;\n  data: O;\n};\n\nexport type UseAsyncOutput<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\nexport type UseAsyncOutputFilled<I extends AnyArray, O> = {\n  state: ComputedRef<UseAsyncStateFilled<O>>;\n  loading: Ref<boolean>;\n  data: Ref<O>;\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: Omit<UseAsyncOptions<I, O>, 'placeholder'> & { placeholder: () => O },\n): UseAsyncOutputFilled<I, O>;\nexport function useAsync<I extends AnyArray, O>(\n  fn: (...inputs: I) => Promise<O>,\n  options?: UseAsyncOptions<I, O>,\n): UseAsyncOutput<I, O>;\nexport function useAsync<I extends AnyArray, O>(\n  fn: (...inputs: I) => Promise<O>,\n  options?: UseAsyncOptions<I, O>,\n): UseAsyncOutput<I, O> {\n  const times = ref(0);\n  const loading = ref(false);\n  const placeholder = options?.placeholder;\n  const data = ref(placeholder ? placeholder() : 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      await options?.onBefore?.(...inputs);\n      times.value++;\n      data.value = await fn(...inputs);\n      await options?.onSuccess?.(data.value, ...inputs);\n      return data.value;\n    } catch (err) {\n      error.value = err;\n      try {\n        options?.onError?.(err, ...inputs);\n      } catch (err) {\n        //\n      }\n      throw err;\n    } finally {\n      loading.value = false;\n      await 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":["err"],"mappings":";;AAmGgB,SAAA,SACd,IACA,SACsB;AAChB,QAAA,QAAQ,IAAI,CAAC;AACb,QAAA,UAAU,IAAI,KAAK;AACzB,QAAM,cAAc,SAAS;AAC7B,QAAM,OAAO,IAAI,cAAc,YAAA,IAAgB,IAAI;AAC7C,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,SAAS,WAAW,GAAG,MAAM;AAC7B,YAAA;AACN,WAAK,QAAQ,MAAM,GAAG,GAAG,MAAM;AAC/B,YAAM,SAAS,YAAY,KAAK,OAAO,GAAG,MAAM;AAChD,aAAO,KAAK;AAAA,aACL,KAAK;AACZ,YAAM,QAAQ;AACV,UAAA;AACO,iBAAA,UAAU,KAAK,GAAG,MAAM;AAAA,eAC1BA,MAAK;AAAA,MAAA;AAGR,YAAA;AAAA,IAAA,UACN;AACA,cAAQ,QAAQ;AACV,YAAA,SAAS,UAAU,GAAG,MAAM;AAAA,IAAA;AAAA,EAEtC;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","names":[],"sources":["../src/async.ts"],"sourcesContent":["import type { AnyArray } from '@cloudcome/utils-core/types';\nimport { type ComputedRef, computed, type Ref, ref } from 'vue';\n\n/**\n * 异步操作的配置选项\n * @template T 异步操作返回的数据类型\n * @template P 异步操作的参数类型\n */\nexport type UseAsyncOptions<I extends AnyArray, O> = {\n  placeholder?: () => O;\n\n  /**\n   * 异步操作开始前的回调函数，可用于执行初始化逻辑或显示加载状态，抛出错误则中断操作\n   */\n  onBefore?: (...inputs: I) => unknown;\n\n  /**\n   * 异步操作成功后的回调函数，可用于处理成功后的数据更新或通知。\n   * @param data 异步操作返回的数据。\n   */\n  onSuccess?: (data: O, ...inputs: I) => unknown;\n\n  /**\n   * 异步操作失败后的回调函数，可用于记录错误日志或显示错误提示。\n   * @param err 异步操作抛出的错误。\n   */\n  onError?: (err: unknown, ...inputs: I) => unknown;\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 UseAsyncStateFilled<O> = {\n  times: number;\n  loading: boolean;\n  error: unknown;\n  data: O;\n};\n\nexport type UseAsyncOutput<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\nexport type UseAsyncOutputFilled<I extends AnyArray, O> = {\n  state: ComputedRef<UseAsyncStateFilled<O>>;\n  loading: Ref<boolean>;\n  data: Ref<O>;\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: Omit<UseAsyncOptions<I, O>, 'placeholder'> & {\n    placeholder: () => O;\n  },\n): UseAsyncOutputFilled<I, O>;\nexport function useAsync<I extends AnyArray, O>(\n  fn: (...inputs: I) => Promise<O>,\n  options?: UseAsyncOptions<I, O>,\n): UseAsyncOutput<I, O>;\nexport function useAsync<I extends AnyArray, O>(\n  fn: (...inputs: I) => Promise<O>,\n  options?: UseAsyncOptions<I, O>,\n): UseAsyncOutput<I, O> {\n  const times = ref(0);\n  const loading = ref(false);\n  const placeholder = options?.placeholder;\n  const data = ref(placeholder ? placeholder() : 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      await options?.onBefore?.(...inputs);\n      times.value++;\n      data.value = await fn(...inputs);\n      await options?.onSuccess?.(data.value, ...inputs);\n      return data.value;\n    } catch (err) {\n      error.value = err;\n      try {\n        options?.onError?.(err, ...inputs);\n      } catch (_err) {\n        //\n      }\n      throw err;\n    } finally {\n      loading.value = false;\n      await 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"],"mappings":";;AAoGA,SAAgB,SACd,IACA,SACsB;CACtB,MAAM,QAAQ,IAAI,EAAE;CACpB,MAAM,UAAU,IAAI,MAAM;CAC1B,MAAM,cAAc,SAAS;CAC7B,MAAM,OAAO,IAAI,cAAc,aAAa,GAAG,KAAK;CACpD,MAAM,QAAQ,IAAa,KAAK;CAChC,MAAM,QAAQ,gBAAgB;EAC5B,OAAO,MAAM;EACb,SAAS,QAAQ;EACjB,MAAM,KAAK;EACX,OAAO,MAAM;EACd,EAAE;CAEH,MAAM,WAAW,OAAO,GAAG,WAA0B;EACnD,QAAQ,QAAQ;EAChB,MAAM,QAAQ;EAEd,IAAI;GACF,MAAM,SAAS,WAAW,GAAG,OAAO;GACpC,MAAM;GACN,KAAK,QAAQ,MAAM,GAAG,GAAG,OAAO;GAChC,MAAM,SAAS,YAAY,KAAK,OAAO,GAAG,OAAO;GACjD,OAAO,KAAK;WACL,KAAK;GACZ,MAAM,QAAQ;GACd,IAAI;IACF,SAAS,UAAU,KAAK,GAAG,OAAO;YAC3B,MAAM;GAGf,MAAM;YACE;GACR,QAAQ,QAAQ;GAChB,MAAM,SAAS,UAAU,GAAG,OAAO;;;CAIvC,MAAM,OAAO,GAAG,WAAc;EAC5B,SAAS,GAAG,OAAO,CAAC,MAAM;;CAG5B,OAAO;EACL;;;;EAIA;;;;EAKA;;;;EAKA;;;;;;EAOA;;;;;EAMA;EACD"}

package/dist/component/self.d.ts

@@ -8,7 +8,7 @@ import { ComponentExposed, ComponentProps } from 'vue-component-type-helpers';
  * @example
  * const compRef = useExpose(MyComponent)
  */
-export declare function useExpose<T>(Comp: T): Ref<ComponentExposed<T> | null>;
+export declare function useExpose<T>(_Comp: T): Ref<ComponentExposed<T> | null>;
 /**
  * 将字符串的首字母转换为小写
  * @template S 字符串类型
@@ -39,9 +39,9 @@ type PickEmits<T> = {
  *   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];
+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;
+    [K in keyof T]: T[K] extends (...args: unknown[]) => any ? T[K] : never;
 };
 /**
  * 从组件props中提取方法并返回指定方法
@@ -57,5 +57,5 @@ type PickMethods<T> = {
  *   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 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.cjs

@@ -1,20 +1,117 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const vue = require("vue");
-const life = require("./life.cjs");
-function useExpose(Comp) {
-  return vue.ref(null);
+const require_shared = require("./shared.cjs");
+let vue = require("vue");
+//#region src/component/life.ts
+/**
+* 页面挂载前生命周期钩子
+*
+* @param beforeMount - 在组件挂载前执行的回调函数，可以返回一个清理函数
+*
+* @example
+* ```ts
+* useMount(() => {
+*   console.log('组件即将挂载');
+*   // 可以返回一个清理函数，在组件卸载前执行
+*   return () => {
+*     console.log('组件即将卸载');
+*   };
+* });
+* ```
+*/
+function useMount(beforeMount) {
+	require_shared._runLifeHook(vue.onBeforeMount, vue.onBeforeUnmount, beforeMount);
 }
-function useEmit(Comp, event, listener) {
-  return listener;
+/**
+* 页面挂载后生命周期钩子
+*
+* @param mounted - 在组件挂载后执行的回调函数，可以返回一个清理函数
+*
+* @example
+* ```ts
+* useMounted(() => {
+*   console.log('组件已挂载');
+*   // 可以返回一个清理函数，在组件卸载前执行
+*   return () => {
+*     console.log('组件即将卸载');
+*   };
+* });
+* ```
+*/
+function useMounted(mounted) {
+	require_shared._runLifeHook(vue.onMounted, vue.onUnmounted, mounted);
 }
-function useMethod(Comp, name, method) {
-  return method;
+/**
+* 页面激活时生命周期钩子
+*
+* @param activated - 在组件被激活时执行的回调函数，可以返回一个清理函数
+*
+* @example
+* ```ts
+* useActivated(() => {
+*   console.log('组件已激活');
+*   // 可以返回一个清理函数，在组件失活前执行
+*   return () => {
+*     console.log('组件即将失活');
+*   };
+* });
+* ```
+*/
+function useActivated(activated) {
+	require_shared._runLifeHook(vue.onActivated, vue.onDeactivated, activated);
 }
-exports.useActivated = life.useActivated;
-exports.useMount = life.useMount;
-exports.useMounted = life.useMounted;
+//#endregion
+//#region src/component/self.ts
+/**
+* 创建一个响应式引用，用于暴露组件实例
+* @template T 组件类型
+* @param {T} Comp 组件定义
+* @returns 返回一个可响应式访问的组件实例引用
+* @example
+* const compRef = useExpose(MyComponent)
+*/
+function useExpose(_Comp) {
+	return (0, vue.ref)(null);
+}
+/**
+* 创建一个组件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)
+* })
+*/
+function useEmit(_Comp, _event, listener) {
+	return listener;
+}
+/**
+* 从组件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)
+* })
+*/
+function useMethod(_Comp, _name, method) {
+	return method;
+}
+//#endregion
+exports.useActivated = useActivated;
 exports.useEmit = useEmit;
 exports.useExpose = useExpose;
 exports.useMethod = useMethod;
-//# sourceMappingURL=component.cjs.map
+exports.useMount = useMount;
+exports.useMounted = useMounted;
+
+//# sourceMappingURL=component.cjs.map

package/dist/component.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"component.cjs","sources":["../src/component/self.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;;;;;;;"}
+{"version":3,"file":"component.cjs","names":[],"sources":["../src/component/life.ts","../src/component/self.ts"],"sourcesContent":["import type { MaybePromise } from '@cloudcome/utils-core/types';\nimport {\n  onActivated,\n  onBeforeMount,\n  onBeforeUnmount,\n  onDeactivated,\n  onMounted,\n  onUnmounted,\n} from 'vue';\nimport { _runLifeHook } from '@/shared';\n\nexport type HookListener = () => MaybePromise<unknown>;\nexport type HookListenerWithDispose = () => MaybePromise<\n  undefined | HookListener\n>;\n\n/**\n * 页面挂载前生命周期钩子\n *\n * @param beforeMount - 在组件挂载前执行的回调函数，可以返回一个清理函数\n *\n * @example\n * ```ts\n * useMount(() => {\n *   console.log('组件即将挂载');\n *   // 可以返回一个清理函数，在组件卸载前执行\n *   return () => {\n *     console.log('组件即将卸载');\n *   };\n * });\n * ```\n */\nexport function useMount(beforeMount: HookListenerWithDispose) {\n  _runLifeHook(onBeforeMount, onBeforeUnmount, beforeMount);\n}\n\n/**\n * 页面挂载后生命周期钩子\n *\n * @param mounted - 在组件挂载后执行的回调函数，可以返回一个清理函数\n *\n * @example\n * ```ts\n * useMounted(() => {\n *   console.log('组件已挂载');\n *   // 可以返回一个清理函数，在组件卸载前执行\n *   return () => {\n *     console.log('组件即将卸载');\n *   };\n * });\n * ```\n */\nexport function useMounted(mounted: HookListenerWithDispose) {\n  _runLifeHook(onMounted, onUnmounted, mounted);\n}\n\n/**\n * 页面激活时生命周期钩子\n *\n * @param activated - 在组件被激活时执行的回调函数，可以返回一个清理函数\n *\n * @example\n * ```ts\n * useActivated(() => {\n *   console.log('组件已激活');\n *   // 可以返回一个清理函数，在组件失活前执行\n *   return () => {\n *     console.log('组件即将失活');\n *   };\n * });\n * ```\n */\nexport function useActivated(activated: HookListenerWithDispose) {\n  _runLifeHook(onActivated, onDeactivated, activated);\n}\n","import { type Ref, ref } from 'vue';\nimport type {\n  ComponentExposed,\n  ComponentProps,\n} 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>(\n    null,\n  ) 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}`\n  ? `${Lowercase<First>}${Rest}`\n  : 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: 必须使用 any\n      T[K] extends (...args: any[]) => any\n      ? LowercaseFirst<Rest>\n      : never\n    : // biome-ignore lint/suspicious/noExplicitAny: 必须使用 any\n      never]: T[K] extends (...args: infer P) => any\n    ? (...args: P) => unknown\n    : 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<\n  T,\n  E extends PickEmits<Required<ComponentProps<T>>>,\n  K extends keyof E,\n>(_Comp: T, _event: K, listener: E[K]) {\n  return listener;\n}\n\ntype PickMethods<T> = {\n  // biome-ignore lint/suspicious/noExplicitAny: 必须使用 any\n  [K in keyof T]: T[K] extends (...args: unknown[]) => 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<\n  T,\n  M extends PickMethods<Required<ComponentProps<T>>>,\n  K extends keyof M,\n>(_Comp: T, _name: K, method: M[K]) {\n  return method;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAgCA,SAAgB,SAAS,aAAsC;CAC7D,eAAA,aAAa,IAAA,eAAe,IAAA,iBAAiB,YAAY;;;;;;;;;;;;;;;;;;AAmB3D,SAAgB,WAAW,SAAkC;CAC3D,eAAA,aAAa,IAAA,WAAW,IAAA,aAAa,QAAQ;;;;;;;;;;;;;;;;;;AAmB/C,SAAgB,aAAa,WAAoC;CAC/D,eAAA,aAAa,IAAA,aAAa,IAAA,eAAe,UAAU;;;;;;;;;;;;AC3DrD,SAAgB,UAAa,OAAU;CAErC,QAAA,GAAA,IAAA,KACE,KACD;;;;;;;;;;;;;;;;AA6CH,SAAgB,QAId,OAAU,QAAW,UAAgB;CACrC,OAAO;;;;;;;;;;;;;;;;AAsBT,SAAgB,UAId,OAAU,OAAU,QAAc;CAClC,OAAO"}

package/dist/component.d.ts

@@ -1,2 +1,2 @@
-export * from './component/self';
 export * from './component/life';
+export * from './component/self';