@cloudcome/utils-vue 1.13.1 → 1.13.3

package/dist/request.mjs

@@ -1,78 +1,75 @@
+import { useAsync } from "./async.mjs";
+import { computed, ref } from "vue";
+import { isFunction, isObject } from "@cloudcome/utils-core/type";
 import { MemoryCache } from "@cloudcome/utils-core/cache";
 import { tryFlatten } from "@cloudcome/utils-core/try";
-import { isObject, isFunction } from "@cloudcome/utils-core/type";
-import { ref, computed } from "vue";
-import { useAsync } from "./async.mjs";
-const defaultCacheStorage = new MemoryCache();
-const defaultShareStorage = new MemoryCache();
+//#region src/request.ts
+var defaultCacheStorage = new MemoryCache();
+var defaultShareStorage = new MemoryCache();
 function useRequest(fn, options) {
-  const { id, cache, share, onCacheHit, onSuccess } = options || {};
-  const shareStorage = defaultShareStorage;
-  const shareAble = isObject(share) ? !share.disabled : share;
-  const shareOptions = isObject(share) ? share : {};
-  const hitShare = ref(false);
-  const _cached = defaultCacheStorage;
-  const cacheStorage = isObject(cache) ? cache.storage || _cached : _cached;
-  const cacheAble = isObject(cache) ? !cache.disabled : cache;
-  const cacheOptions = isObject(cache) ? cache : {};
-  const hitCache = ref(false);
-  const cacheableFn = async (...inputs) => {
-    const requestId = isFunction(id) ? id() : id;
-    hitShare.value = false;
-    hitCache.value = false;
-    if (requestId && shareAble) {
-      const shared = shareStorage.get(requestId);
-      if (shared) {
-        hitShare.value = true;
-        const [err2, data2] = await tryFlatten(shared.data);
-        if (err2) {
-          shareStorage.del(requestId);
-          throw err2;
-        }
-        return data2;
-      }
-    }
-    const { promise, resolve, reject } = Promise.withResolvers();
-    if (requestId && shareAble) {
-      shareStorage.set(requestId, promise, shareOptions);
-    }
-    if (requestId && cacheAble) {
-      const cached = await cacheStorage.get(requestId);
-      if (cached) {
-        const data2 = cached.data;
-        resolve(data2);
-        hitCache.value = true;
-        await onCacheHit?.(cached);
-        return promise;
-      }
-    }
-    const [err, data] = await tryFlatten(fn(...inputs));
-    if (err) {
-      reject(err);
-      return promise;
-    }
-    if (requestId && cacheAble) {
-      cacheStorage.set(requestId, data, cacheOptions);
-    }
-    resolve(data);
-    return promise;
-  };
-  const { state: asyncState, run: send, runAsync: sendAsync, ...async } = useAsync(cacheableFn, options);
-  const state = computed(() => ({
-    ...asyncState.value,
-    hitShare: hitShare.value,
-    hitCache: hitCache.value
-  }));
-  return {
-    ...async,
-    state,
-    send,
-    sendAsync,
-    hitShare,
-    hitCache
-  };
+	const { id, cache, share, onCacheHit } = options || {};
+	const shareStorage = defaultShareStorage;
+	const shareAble = isObject(share) ? !share.disabled : share;
+	const shareOptions = isObject(share) ? share : {};
+	const hitShare = ref(false);
+	const _cached = defaultCacheStorage;
+	const cacheStorage = isObject(cache) ? cache.storage || _cached : _cached;
+	const cacheAble = isObject(cache) ? !cache.disabled : cache;
+	const cacheOptions = isObject(cache) ? cache : {};
+	const hitCache = ref(false);
+	const cacheableFn = async (...inputs) => {
+		const requestId = isFunction(id) ? id() : id;
+		hitShare.value = false;
+		hitCache.value = false;
+		if (requestId && shareAble) {
+			const shared = shareStorage.get(requestId);
+			if (shared) {
+				hitShare.value = true;
+				const [err, data] = await tryFlatten(shared.data);
+				if (err) {
+					shareStorage.del(requestId);
+					throw err;
+				}
+				return data;
+			}
+		}
+		const { promise, resolve, reject } = Promise.withResolvers();
+		if (requestId && shareAble) shareStorage.set(requestId, promise, shareOptions);
+		if (requestId && cacheAble) {
+			const cached = await cacheStorage.get(requestId);
+			if (cached) {
+				const data = cached.data;
+				resolve(data);
+				hitCache.value = true;
+				await onCacheHit?.(cached);
+				return promise;
+			}
+		}
+		const [err, data] = await tryFlatten(fn(...inputs));
+		if (err) {
+			reject(err);
+			return promise;
+		}
+		if (requestId && cacheAble) cacheStorage.set(requestId, data, cacheOptions);
+		resolve(data);
+		return promise;
+	};
+	const { state: asyncState, run: send, runAsync: sendAsync, ...async } = useAsync(cacheableFn, options);
+	const state = computed(() => ({
+		...asyncState.value,
+		hitShare: hitShare.value,
+		hitCache: hitCache.value
+	}));
+	return {
+		...async,
+		state,
+		send,
+		sendAsync,
+		hitShare,
+		hitCache
+	};
 }
-export {
-  useRequest
-};
-//# sourceMappingURL=request.mjs.map
+//#endregion
+export { useRequest };
+
+//# sourceMappingURL=request.mjs.map

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 { tryFlatten } from '@cloudcome/utils-core/try';\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 {\n  type UseAsyncOptions,\n  type UseAsyncOutput,\n  type UseAsyncOutputFilled,\n  type UseAsyncState,\n  type UseAsyncStateFilled,\n  useAsync,\n} 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};\n\nexport type UseRequestStateFilled<O> = UseAsyncStateFilled<O> & {\n  /**\n   * 是否命中共享数据\n   */\n  hitShare: boolean;\n\n  /**\n   * 是否命中缓存\n   */\n  hitCache: boolean;\n};\n\nexport type UseRequestOutput<I extends AnyArray, O> = Omit<UseAsyncOutput<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\nexport type UseRequestOutputFilled<I extends AnyArray, O> = Omit<\n  UseAsyncOutputFilled<I, O>,\n  'run' | 'runAsync' | 'state'\n> & {\n  state: ComputedRef<UseRequestStateFilled<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: Omit<UseRequestOptions<I, O>, 'placeholder'> & { placeholder: () => O },\n): UseRequestOutputFilled<I, O>;\nexport function useRequest<I extends AnyArray, O>(\n  fn: (...inputs: I) => Promise<O>,\n  options?: UseRequestOptions<I, O>,\n): UseRequestOutput<I, O>;\nexport function useRequest<I extends AnyArray, O>(\n  fn: (...inputs: I) => Promise<O>,\n  options?: UseRequestOptions<I, O>,\n): UseRequestOutput<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    hitShare.value = false;\n    hitCache.value = false;\n\n    if (requestId && shareAble) {\n      const shared = shareStorage.get(requestId);\n      if (shared) {\n        hitShare.value = true;\n        const [err, data] = await tryFlatten(shared.data);\n        if (err) {\n          shareStorage.del(requestId);\n          throw err;\n        }\n\n        return data;\n      }\n    }\n\n    // 这里不能先执行，因为如果要缓存的话，必须用缓存结果\n    const { promise, resolve, reject } = Promise.withResolvers<O>();\n\n    if (requestId && shareAble) {\n      shareStorage.set(requestId, promise, shareOptions);\n    }\n\n    if (requestId && cacheAble) {\n      const cached = await cacheStorage.get(requestId);\n\n      if (cached) {\n        const data = cached.data;\n        resolve(data);\n        hitCache.value = true;\n        await onCacheHit?.(cached);\n        return promise;\n      }\n    }\n\n    const [err, data] = await tryFlatten(fn(...inputs));\n\n    if (err) {\n      reject(err);\n      return promise;\n    }\n\n    if (requestId && cacheAble) {\n      cacheStorage.set(requestId, data, cacheOptions);\n    }\n\n    resolve(data);\n    return promise;\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":["err","data"],"mappings":";;;;;AAiJA,MAAM,sBAAsB,IAAI,YAAY;AAC5C,MAAM,sBAAsB,IAAI,YAAY;AAuB5B,SAAA,WACd,IACA,SACwB;AAClB,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,aAAS,QAAQ;AACjB,aAAS,QAAQ;AAEjB,QAAI,aAAa,WAAW;AACpB,YAAA,SAAS,aAAa,IAAI,SAAS;AACzC,UAAI,QAAQ;AACV,iBAAS,QAAQ;AACjB,cAAM,CAACA,MAAKC,KAAI,IAAI,MAAM,WAAW,OAAO,IAAI;AAChD,YAAID,MAAK;AACP,uBAAa,IAAI,SAAS;AACpBA,gBAAAA;AAAAA,QAAA;AAGDC,eAAAA;AAAAA,MAAA;AAAA,IACT;AAIF,UAAM,EAAE,SAAS,SAAS,OAAO,IAAI,QAAQ,cAAiB;AAE9D,QAAI,aAAa,WAAW;AACb,mBAAA,IAAI,WAAW,SAAS,YAAY;AAAA,IAAA;AAGnD,QAAI,aAAa,WAAW;AAC1B,YAAM,SAAS,MAAM,aAAa,IAAI,SAAS;AAE/C,UAAI,QAAQ;AACV,cAAMA,QAAO,OAAO;AACpB,gBAAQA,KAAI;AACZ,iBAAS,QAAQ;AACjB,cAAM,aAAa,MAAM;AAClB,eAAA;AAAA,MAAA;AAAA,IACT;AAGI,UAAA,CAAC,KAAK,IAAI,IAAI,MAAM,WAAW,GAAG,GAAG,MAAM,CAAC;AAElD,QAAI,KAAK;AACP,aAAO,GAAG;AACH,aAAA;AAAA,IAAA;AAGT,QAAI,aAAa,WAAW;AACb,mBAAA,IAAI,WAAW,MAAM,YAAY;AAAA,IAAA;AAGhD,YAAQ,IAAI;AACL,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","names":[],"sources":["../src/request.ts"],"sourcesContent":["import {\n  type Cache,\n  type Cached,\n  type CacheOptions,\n  MemoryCache,\n} from '@cloudcome/utils-core/cache';\nimport type { DateValue } from '@cloudcome/utils-core/date';\nimport { tryFlatten } from '@cloudcome/utils-core/try';\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 {\n  type UseAsyncOptions,\n  type UseAsyncOutput,\n  type UseAsyncOutputFilled,\n  type UseAsyncState,\n  type UseAsyncStateFilled,\n  useAsync,\n} 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};\n\nexport type UseRequestStateFilled<O> = UseAsyncStateFilled<O> & {\n  /**\n   * 是否命中共享数据\n   */\n  hitShare: boolean;\n\n  /**\n   * 是否命中缓存\n   */\n  hitCache: boolean;\n};\n\nexport type UseRequestOutput<I extends AnyArray, O> = Omit<\n  UseAsyncOutput<I, O>,\n  'run' | 'runAsync' | 'state'\n> & {\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\nexport type UseRequestOutputFilled<I extends AnyArray, O> = Omit<\n  UseAsyncOutputFilled<I, O>,\n  'run' | 'runAsync' | 'state'\n> & {\n  state: ComputedRef<UseRequestStateFilled<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: Omit<UseRequestOptions<I, O>, 'placeholder'> & {\n    placeholder: () => O;\n  },\n): UseRequestOutputFilled<I, O>;\nexport function useRequest<I extends AnyArray, O>(\n  fn: (...inputs: I) => Promise<O>,\n  options?: UseRequestOptions<I, O>,\n): UseRequestOutput<I, O>;\nexport function useRequest<I extends AnyArray, O>(\n  fn: (...inputs: I) => Promise<O>,\n  options?: UseRequestOptions<I, O>,\n): UseRequestOutput<I, O> {\n  const { id, cache, share, onCacheHit } = 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    hitShare.value = false;\n    hitCache.value = false;\n\n    if (requestId && shareAble) {\n      const shared = shareStorage.get(requestId);\n      if (shared) {\n        hitShare.value = true;\n        const [err, data] = await tryFlatten(shared.data);\n        if (err) {\n          shareStorage.del(requestId);\n          throw err;\n        }\n\n        return data;\n      }\n    }\n\n    // 这里不能先执行，因为如果要缓存的话，必须用缓存结果\n    const { promise, resolve, reject } = Promise.withResolvers<O>();\n\n    if (requestId && shareAble) {\n      shareStorage.set(requestId, promise, shareOptions);\n    }\n\n    if (requestId && cacheAble) {\n      const cached = await cacheStorage.get(requestId);\n\n      if (cached) {\n        const data = cached.data;\n        resolve(data);\n        hitCache.value = true;\n        await onCacheHit?.(cached);\n        return promise;\n      }\n    }\n\n    const [err, data] = await tryFlatten(fn(...inputs));\n\n    if (err) {\n      reject(err);\n      return promise;\n    }\n\n    if (requestId && cacheAble) {\n      cacheStorage.set(requestId, data, cacheOptions);\n    }\n\n    resolve(data);\n    return promise;\n  };\n  const {\n    state: asyncState,\n    run: send,\n    runAsync: sendAsync,\n    ...async\n  } = 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"],"mappings":";;;;;;AAyJA,IAAM,sBAAsB,IAAI,aAAa;AAC7C,IAAM,sBAAsB,IAAI,aAAa;AAyB7C,SAAgB,WACd,IACA,SACwB;CACxB,MAAM,EAAE,IAAI,OAAO,OAAO,eAAe,WAAW,EAAE;CAEtD,MAAM,eAAe;CACrB,MAAM,YAAY,SAAS,MAAM,GAAG,CAAC,MAAM,WAAW;CACtD,MAAM,eAAe,SAAS,MAAM,GAAG,QAAQ,EAAE;CACjD,MAAM,WAAW,IAAI,MAAM;CAE3B,MAAM,UAAU;CAChB,MAAM,eAAe,SAAS,MAAM,GAAG,MAAM,WAAW,UAAU;CAClE,MAAM,YAAY,SAAS,MAAM,GAAG,CAAC,MAAM,WAAW;CACtD,MAAM,eAAe,SAAS,MAAM,GAAG,QAAQ,EAAE;CACjD,MAAM,WAAW,IAAI,MAAM;CAE3B,MAAM,cAAc,OAAO,GAAG,WAAc;EAC1C,MAAM,YAAY,WAAW,GAAG,GAAG,IAAI,GAAG;EAE1C,SAAS,QAAQ;EACjB,SAAS,QAAQ;EAEjB,IAAI,aAAa,WAAW;GAC1B,MAAM,SAAS,aAAa,IAAI,UAAU;GAC1C,IAAI,QAAQ;IACV,SAAS,QAAQ;IACjB,MAAM,CAAC,KAAK,QAAQ,MAAM,WAAW,OAAO,KAAK;IACjD,IAAI,KAAK;KACP,aAAa,IAAI,UAAU;KAC3B,MAAM;;IAGR,OAAO;;;EAKX,MAAM,EAAE,SAAS,SAAS,WAAW,QAAQ,eAAkB;EAE/D,IAAI,aAAa,WACf,aAAa,IAAI,WAAW,SAAS,aAAa;EAGpD,IAAI,aAAa,WAAW;GAC1B,MAAM,SAAS,MAAM,aAAa,IAAI,UAAU;GAEhD,IAAI,QAAQ;IACV,MAAM,OAAO,OAAO;IACpB,QAAQ,KAAK;IACb,SAAS,QAAQ;IACjB,MAAM,aAAa,OAAO;IAC1B,OAAO;;;EAIX,MAAM,CAAC,KAAK,QAAQ,MAAM,WAAW,GAAG,GAAG,OAAO,CAAC;EAEnD,IAAI,KAAK;GACP,OAAO,IAAI;GACX,OAAO;;EAGT,IAAI,aAAa,WACf,aAAa,IAAI,WAAW,MAAM,aAAa;EAGjD,QAAQ,KAAK;EACb,OAAO;;CAET,MAAM,EACJ,OAAO,YACP,KAAK,MACL,UAAU,WACV,GAAG,UACD,SAAS,aAAa,QAAQ;CAElC,MAAM,QAAQ,gBAAgB;EAC5B,GAAG,WAAW;EACd,UAAU,SAAS;EACnB,UAAU,SAAS;EACpB,EAAE;CAEH,OAAO;EACL,GAAG;EACH;EACA;EACA;EACA;EACA;EACD"}

package/dist/shared.cjs

@@ -1,33 +1,94 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const type = require("@cloudcome/utils-core/type");
-const vue = require("vue");
+let vue = require("vue");
+let _cloudcome_utils_core_type = require("@cloudcome/utils-core/type");
+//#region src/shared.ts
+/**
+* 运行生命周期钩子函数的工具函数
+*
+* @protected 内部方法
+* @template T - 泛型参数（未在函数中使用）
+* @param enterHook - 进入时执行的钩子函数，接收一个回调函数作为参数
+* @param leaveHook - 离开时执行的钩子函数，接收一个回调函数作为参数
+* @param onEnter - 进入时的监听器，可以返回一个清理函数
+*
+* @example
+* _runLifeHook(
+*   (hook) => onMounted(hook),     // 在组件挂载时执行进入逻辑
+*   (hook) => onUnmounted(hook),   // 在组件卸载时执行离开逻辑
+*   () => {
+*     // 执行进入时的逻辑
+*     console.log('组件已挂载');
+*
+*     // 返回一个清理函数，在离开时执行
+*     return () => {
+*       console.log('组件将要卸载');
+*     };
+*   }
+* );
+*/
 function _runLifeHook(enterHook, leaveHook, onEnter) {
-  let onLeave;
-  enterHook(async () => {
-    const enterResult = await onEnter();
-    if (type.isFunction(enterResult)) {
-      onLeave = enterResult;
-    }
-  });
-  leaveHook(() => {
-    onLeave?.();
-  });
+	let onLeave;
+	enterHook(async () => {
+		const enterResult = await onEnter();
+		if ((0, _cloudcome_utils_core_type.isFunction)(enterResult)) onLeave = enterResult;
+	});
+	leaveHook(() => {
+		onLeave?.();
+	});
 }
+/**
+* 运行作用域钩子函数的工具函数
+*
+* 该函数创建一个独立的响应式作用域，在该作用域内执行传入的回调函数，
+* 并在适当的时机自动清理资源。这确保了响应式副作用的隔离和自动回收。
+*
+* @protected 内部方法
+* @param runner - 需要在作用域内执行的回调函数，可以返回一个清理函数
+*
+* @example
+* // 基本用法
+* _runScope(() => {
+*   // 在这里创建的响应式副作用会被限制在当前作用域内
+*   const stop = watch(someRef, (val) => {
+*     console.log(val);
+*   });
+*
+*   // 返回一个清理函数，在作用域销毁时执行
+*   return () => {
+*     stop();
+*   };
+* });
+*
+* @example
+* // 异步用法
+* _runScope(async () => {
+*   const data = await fetchData();
+*
+*   // 根据获取的数据创建响应式监听
+*   const stop = watch(() => data.value, (val) => {
+*     console.log(val);
+*   });
+*
+*   // 返回清理函数
+*   return () => {
+*     stop();
+*   };
+* });
+*/
 function _runScope(runner) {
-  const scope = vue.effectScope();
-  let dispose;
-  scope.run(async () => {
-    const result = await runner();
-    if (type.isFunction(result)) {
-      dispose = result;
-    }
-  });
-  vue.onScopeDispose(() => {
-    dispose?.();
-    scope.stop();
-  });
+	const scope = (0, vue.effectScope)();
+	let dispose;
+	scope.run(async () => {
+		const result = await runner();
+		if ((0, _cloudcome_utils_core_type.isFunction)(result)) dispose = result;
+	});
+	(0, vue.onScopeDispose)(() => {
+		dispose?.();
+		scope.stop();
+	});
 }
+//#endregion
 exports._runLifeHook = _runLifeHook;
 exports._runScope = _runScope;
-//# sourceMappingURL=shared.cjs.map
+
+//# sourceMappingURL=shared.cjs.map

package/dist/shared.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"shared.cjs","sources":["../src/shared.ts"],"sourcesContent":["import { isFunction } from '@cloudcome/utils-core/type';\nimport type { AnyFunction, MaybePromise } from '@cloudcome/utils-core/types';\nimport { effectScope, onScopeDispose } from 'vue';\n\nexport type HookListener = () => MaybePromise<unknown>;\nexport type HookListenerWithDispose = () => MaybePromise<unknown | HookListener>;\n\n/**\n * 运行生命周期钩子函数的工具函数\n *\n * @protected 内部方法\n * @template T - 泛型参数（未在函数中使用）\n * @param enterHook - 进入时执行的钩子函数，接收一个回调函数作为参数\n * @param leaveHook - 离开时执行的钩子函数，接收一个回调函数作为参数\n * @param onEnter - 进入时的监听器，可以返回一个清理函数\n *\n * @example\n * _runLifeHook(\n *   (hook) => onMounted(hook),     // 在组件挂载时执行进入逻辑\n *   (hook) => onUnmounted(hook),   // 在组件卸载时执行离开逻辑\n *   () => {\n *     // 执行进入时的逻辑\n *     console.log('组件已挂载');\n *\n *     // 返回一个清理函数，在离开时执行\n *     return () => {\n *       console.log('组件将要卸载');\n *     };\n *   }\n * );\n */\nexport function _runLifeHook<T>(\n  enterHook: (hook: AnyFunction) => unknown,\n  leaveHook: (hook: AnyFunction) => unknown,\n  onEnter: HookListenerWithDispose,\n) {\n  // 存储离开时需要执行的清理函数\n  let onLeave: HookListener | undefined;\n\n  // 注册进入钩子，在 enterHook 触发时执行\n  enterHook(async () => {\n    // 执行进入时的监听器逻辑\n    const enterResult = await onEnter();\n\n    // 如果返回结果是一个函数，则将其作为离开时的清理函数保存\n    if (isFunction(enterResult)) {\n      onLeave = enterResult;\n    }\n  });\n\n  // 注册离开钩子，在 leaveHook 触发时执行\n  leaveHook(() => {\n    // 如果存在清理函数，则执行它\n    onLeave?.();\n  });\n}\n\n/**\n * 运行作用域钩子函数的工具函数\n *\n * 该函数创建一个独立的响应式作用域，在该作用域内执行传入的回调函数，\n * 并在适当的时机自动清理资源。这确保了响应式副作用的隔离和自动回收。\n *\n * @protected 内部方法\n * @param runner - 需要在作用域内执行的回调函数，可以返回一个清理函数\n *\n * @example\n * // 基本用法\n * _runScope(() => {\n *   // 在这里创建的响应式副作用会被限制在当前作用域内\n *   const stop = watch(someRef, (val) => {\n *     console.log(val);\n *   });\n *\n *   // 返回一个清理函数，在作用域销毁时执行\n *   return () => {\n *     stop();\n *   };\n * });\n *\n * @example\n * // 异步用法\n * _runScope(async () => {\n *   const data = await fetchData();\n *\n *   // 根据获取的数据创建响应式监听\n *   const stop = watch(() => data.value, (val) => {\n *     console.log(val);\n *   });\n *\n *   // 返回清理函数\n *   return () => {\n *     stop();\n *   };\n * });\n */\nexport function _runScope(runner: HookListenerWithDispose) {\n  // 创建一个独立的响应式作用域，用于收集和管理响应式副作用\n  const scope = effectScope();\n  // 存储用户提供的清理函数\n  let dispose: HookListener | undefined;\n\n  // 在创建的作用域内执行回调函数\n  scope.run(async () => {\n    // 执行传入的回调函数并等待其完成（支持异步操作）\n    const result = await runner();\n\n    // 如果回调函数返回了一个函数，则将其作为清理函数保存\n    if (isFunction(result)) {\n      dispose = result;\n    }\n  });\n\n  // 注册作用域销毁时的回调函数\n  onScopeDispose(() => {\n    // 如果存在用户提供的清理函数，则执行它\n    dispose?.();\n    // 停止并清理整个作用域内的所有响应式副作用\n    scope.stop();\n  });\n}\n"],"names":["isFunction","effectScope","onScopeDispose"],"mappings":";;;;AA+BgB,SAAA,aACd,WACA,WACA,SACA;AAEI,MAAA;AAGJ,YAAU,YAAY;AAEd,UAAA,cAAc,MAAM,QAAQ;AAG9B,QAAAA,KAAAA,WAAW,WAAW,GAAG;AACjB,gBAAA;AAAA,IAAA;AAAA,EACZ,CACD;AAGD,YAAU,MAAM;AAEJ,cAAA;AAAA,EAAA,CACX;AACH;AAyCO,SAAS,UAAU,QAAiC;AAEzD,QAAM,QAAQC,IAAAA,YAAY;AAEtB,MAAA;AAGJ,QAAM,IAAI,YAAY;AAEd,UAAA,SAAS,MAAM,OAAO;AAGxB,QAAAD,KAAAA,WAAW,MAAM,GAAG;AACZ,gBAAA;AAAA,IAAA;AAAA,EACZ,CACD;AAGDE,MAAAA,eAAe,MAAM;AAET,cAAA;AAEV,UAAM,KAAK;AAAA,EAAA,CACZ;AACH;;;"}
+{"version":3,"file":"shared.cjs","names":[],"sources":["../src/shared.ts"],"sourcesContent":["import { isFunction } from '@cloudcome/utils-core/type';\nimport type { AnyFunction, MaybePromise } from '@cloudcome/utils-core/types';\nimport { effectScope, onScopeDispose } from 'vue';\n\nexport type HookListener = () => MaybePromise<unknown>;\nexport type HookListenerWithDispose = () => MaybePromise<\n  unknown | HookListener\n>;\n\n/**\n * 运行生命周期钩子函数的工具函数\n *\n * @protected 内部方法\n * @template T - 泛型参数（未在函数中使用）\n * @param enterHook - 进入时执行的钩子函数，接收一个回调函数作为参数\n * @param leaveHook - 离开时执行的钩子函数，接收一个回调函数作为参数\n * @param onEnter - 进入时的监听器，可以返回一个清理函数\n *\n * @example\n * _runLifeHook(\n *   (hook) => onMounted(hook),     // 在组件挂载时执行进入逻辑\n *   (hook) => onUnmounted(hook),   // 在组件卸载时执行离开逻辑\n *   () => {\n *     // 执行进入时的逻辑\n *     console.log('组件已挂载');\n *\n *     // 返回一个清理函数，在离开时执行\n *     return () => {\n *       console.log('组件将要卸载');\n *     };\n *   }\n * );\n */\nexport function _runLifeHook<_T>(\n  enterHook: (hook: AnyFunction) => unknown,\n  leaveHook: (hook: AnyFunction) => unknown,\n  onEnter: HookListenerWithDispose,\n) {\n  // 存储离开时需要执行的清理函数\n  let onLeave: HookListener | undefined;\n\n  // 注册进入钩子，在 enterHook 触发时执行\n  enterHook(async () => {\n    // 执行进入时的监听器逻辑\n    const enterResult = await onEnter();\n\n    // 如果返回结果是一个函数，则将其作为离开时的清理函数保存\n    if (isFunction(enterResult)) {\n      onLeave = enterResult;\n    }\n  });\n\n  // 注册离开钩子，在 leaveHook 触发时执行\n  leaveHook(() => {\n    // 如果存在清理函数，则执行它\n    onLeave?.();\n  });\n}\n\n/**\n * 运行作用域钩子函数的工具函数\n *\n * 该函数创建一个独立的响应式作用域，在该作用域内执行传入的回调函数，\n * 并在适当的时机自动清理资源。这确保了响应式副作用的隔离和自动回收。\n *\n * @protected 内部方法\n * @param runner - 需要在作用域内执行的回调函数，可以返回一个清理函数\n *\n * @example\n * // 基本用法\n * _runScope(() => {\n *   // 在这里创建的响应式副作用会被限制在当前作用域内\n *   const stop = watch(someRef, (val) => {\n *     console.log(val);\n *   });\n *\n *   // 返回一个清理函数，在作用域销毁时执行\n *   return () => {\n *     stop();\n *   };\n * });\n *\n * @example\n * // 异步用法\n * _runScope(async () => {\n *   const data = await fetchData();\n *\n *   // 根据获取的数据创建响应式监听\n *   const stop = watch(() => data.value, (val) => {\n *     console.log(val);\n *   });\n *\n *   // 返回清理函数\n *   return () => {\n *     stop();\n *   };\n * });\n */\nexport function _runScope(runner: HookListenerWithDispose) {\n  // 创建一个独立的响应式作用域，用于收集和管理响应式副作用\n  const scope = effectScope();\n  // 存储用户提供的清理函数\n  let dispose: HookListener | undefined;\n\n  // 在创建的作用域内执行回调函数\n  scope.run(async () => {\n    // 执行传入的回调函数并等待其完成（支持异步操作）\n    const result = await runner();\n\n    // 如果回调函数返回了一个函数，则将其作为清理函数保存\n    if (isFunction(result)) {\n      dispose = result;\n    }\n  });\n\n  // 注册作用域销毁时的回调函数\n  onScopeDispose(() => {\n    // 如果存在用户提供的清理函数，则执行它\n    dispose?.();\n    // 停止并清理整个作用域内的所有响应式副作用\n    scope.stop();\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,SAAgB,aACd,WACA,WACA,SACA;CAEA,IAAI;CAGJ,UAAU,YAAY;EAEpB,MAAM,cAAc,MAAM,SAAS;EAGnC,KAAA,GAAA,2BAAA,YAAe,YAAY,EACzB,UAAU;GAEZ;CAGF,gBAAgB;EAEd,WAAW;GACX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CJ,SAAgB,UAAU,QAAiC;CAEzD,MAAM,SAAA,GAAA,IAAA,cAAqB;CAE3B,IAAI;CAGJ,MAAM,IAAI,YAAY;EAEpB,MAAM,SAAS,MAAM,QAAQ;EAG7B,KAAA,GAAA,2BAAA,YAAe,OAAO,EACpB,UAAU;GAEZ;CAGF,CAAA,GAAA,IAAA,sBAAqB;EAEnB,WAAW;EAEX,MAAM,MAAM;GACZ"}

package/dist/shared.d.ts

@@ -25,7 +25,7 @@ export type HookListenerWithDispose = () => MaybePromise<unknown | HookListener>
  *   }
  * );
  */
-export declare function _runLifeHook<T>(enterHook: (hook: AnyFunction) => unknown, leaveHook: (hook: AnyFunction) => unknown, onEnter: HookListenerWithDispose): void;
+export declare function _runLifeHook<_T>(enterHook: (hook: AnyFunction) => unknown, leaveHook: (hook: AnyFunction) => unknown, onEnter: HookListenerWithDispose): void;
 /**
  * 运行作用域钩子函数的工具函数
  *

package/dist/shared.mjs

@@ -1,33 +1,92 @@
-import { isFunction } from "@cloudcome/utils-core/type";
 import { effectScope, onScopeDispose } from "vue";
+import { isFunction } from "@cloudcome/utils-core/type";
+//#region src/shared.ts
+/**
+* 运行生命周期钩子函数的工具函数
+*
+* @protected 内部方法
+* @template T - 泛型参数（未在函数中使用）
+* @param enterHook - 进入时执行的钩子函数，接收一个回调函数作为参数
+* @param leaveHook - 离开时执行的钩子函数，接收一个回调函数作为参数
+* @param onEnter - 进入时的监听器，可以返回一个清理函数
+*
+* @example
+* _runLifeHook(
+*   (hook) => onMounted(hook),     // 在组件挂载时执行进入逻辑
+*   (hook) => onUnmounted(hook),   // 在组件卸载时执行离开逻辑
+*   () => {
+*     // 执行进入时的逻辑
+*     console.log('组件已挂载');
+*
+*     // 返回一个清理函数，在离开时执行
+*     return () => {
+*       console.log('组件将要卸载');
+*     };
+*   }
+* );
+*/
 function _runLifeHook(enterHook, leaveHook, onEnter) {
-  let onLeave;
-  enterHook(async () => {
-    const enterResult = await onEnter();
-    if (isFunction(enterResult)) {
-      onLeave = enterResult;
-    }
-  });
-  leaveHook(() => {
-    onLeave?.();
-  });
+	let onLeave;
+	enterHook(async () => {
+		const enterResult = await onEnter();
+		if (isFunction(enterResult)) onLeave = enterResult;
+	});
+	leaveHook(() => {
+		onLeave?.();
+	});
 }
+/**
+* 运行作用域钩子函数的工具函数
+*
+* 该函数创建一个独立的响应式作用域，在该作用域内执行传入的回调函数，
+* 并在适当的时机自动清理资源。这确保了响应式副作用的隔离和自动回收。
+*
+* @protected 内部方法
+* @param runner - 需要在作用域内执行的回调函数，可以返回一个清理函数
+*
+* @example
+* // 基本用法
+* _runScope(() => {
+*   // 在这里创建的响应式副作用会被限制在当前作用域内
+*   const stop = watch(someRef, (val) => {
+*     console.log(val);
+*   });
+*
+*   // 返回一个清理函数，在作用域销毁时执行
+*   return () => {
+*     stop();
+*   };
+* });
+*
+* @example
+* // 异步用法
+* _runScope(async () => {
+*   const data = await fetchData();
+*
+*   // 根据获取的数据创建响应式监听
+*   const stop = watch(() => data.value, (val) => {
+*     console.log(val);
+*   });
+*
+*   // 返回清理函数
+*   return () => {
+*     stop();
+*   };
+* });
+*/
 function _runScope(runner) {
-  const scope = effectScope();
-  let dispose;
-  scope.run(async () => {
-    const result = await runner();
-    if (isFunction(result)) {
-      dispose = result;
-    }
-  });
-  onScopeDispose(() => {
-    dispose?.();
-    scope.stop();
-  });
+	const scope = effectScope();
+	let dispose;
+	scope.run(async () => {
+		const result = await runner();
+		if (isFunction(result)) dispose = result;
+	});
+	onScopeDispose(() => {
+		dispose?.();
+		scope.stop();
+	});
 }
-export {
-  _runLifeHook,
-  _runScope
-};
-//# sourceMappingURL=shared.mjs.map
+//#endregion
+export { _runLifeHook, _runScope };
+
+//# sourceMappingURL=shared.mjs.map

package/dist/shared.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"shared.mjs","sources":["../src/shared.ts"],"sourcesContent":["import { isFunction } from '@cloudcome/utils-core/type';\nimport type { AnyFunction, MaybePromise } from '@cloudcome/utils-core/types';\nimport { effectScope, onScopeDispose } from 'vue';\n\nexport type HookListener = () => MaybePromise<unknown>;\nexport type HookListenerWithDispose = () => MaybePromise<unknown | HookListener>;\n\n/**\n * 运行生命周期钩子函数的工具函数\n *\n * @protected 内部方法\n * @template T - 泛型参数（未在函数中使用）\n * @param enterHook - 进入时执行的钩子函数，接收一个回调函数作为参数\n * @param leaveHook - 离开时执行的钩子函数，接收一个回调函数作为参数\n * @param onEnter - 进入时的监听器，可以返回一个清理函数\n *\n * @example\n * _runLifeHook(\n *   (hook) => onMounted(hook),     // 在组件挂载时执行进入逻辑\n *   (hook) => onUnmounted(hook),   // 在组件卸载时执行离开逻辑\n *   () => {\n *     // 执行进入时的逻辑\n *     console.log('组件已挂载');\n *\n *     // 返回一个清理函数，在离开时执行\n *     return () => {\n *       console.log('组件将要卸载');\n *     };\n *   }\n * );\n */\nexport function _runLifeHook<T>(\n  enterHook: (hook: AnyFunction) => unknown,\n  leaveHook: (hook: AnyFunction) => unknown,\n  onEnter: HookListenerWithDispose,\n) {\n  // 存储离开时需要执行的清理函数\n  let onLeave: HookListener | undefined;\n\n  // 注册进入钩子，在 enterHook 触发时执行\n  enterHook(async () => {\n    // 执行进入时的监听器逻辑\n    const enterResult = await onEnter();\n\n    // 如果返回结果是一个函数，则将其作为离开时的清理函数保存\n    if (isFunction(enterResult)) {\n      onLeave = enterResult;\n    }\n  });\n\n  // 注册离开钩子，在 leaveHook 触发时执行\n  leaveHook(() => {\n    // 如果存在清理函数，则执行它\n    onLeave?.();\n  });\n}\n\n/**\n * 运行作用域钩子函数的工具函数\n *\n * 该函数创建一个独立的响应式作用域，在该作用域内执行传入的回调函数，\n * 并在适当的时机自动清理资源。这确保了响应式副作用的隔离和自动回收。\n *\n * @protected 内部方法\n * @param runner - 需要在作用域内执行的回调函数，可以返回一个清理函数\n *\n * @example\n * // 基本用法\n * _runScope(() => {\n *   // 在这里创建的响应式副作用会被限制在当前作用域内\n *   const stop = watch(someRef, (val) => {\n *     console.log(val);\n *   });\n *\n *   // 返回一个清理函数，在作用域销毁时执行\n *   return () => {\n *     stop();\n *   };\n * });\n *\n * @example\n * // 异步用法\n * _runScope(async () => {\n *   const data = await fetchData();\n *\n *   // 根据获取的数据创建响应式监听\n *   const stop = watch(() => data.value, (val) => {\n *     console.log(val);\n *   });\n *\n *   // 返回清理函数\n *   return () => {\n *     stop();\n *   };\n * });\n */\nexport function _runScope(runner: HookListenerWithDispose) {\n  // 创建一个独立的响应式作用域，用于收集和管理响应式副作用\n  const scope = effectScope();\n  // 存储用户提供的清理函数\n  let dispose: HookListener | undefined;\n\n  // 在创建的作用域内执行回调函数\n  scope.run(async () => {\n    // 执行传入的回调函数并等待其完成（支持异步操作）\n    const result = await runner();\n\n    // 如果回调函数返回了一个函数，则将其作为清理函数保存\n    if (isFunction(result)) {\n      dispose = result;\n    }\n  });\n\n  // 注册作用域销毁时的回调函数\n  onScopeDispose(() => {\n    // 如果存在用户提供的清理函数，则执行它\n    dispose?.();\n    // 停止并清理整个作用域内的所有响应式副作用\n    scope.stop();\n  });\n}\n"],"names":[],"mappings":";;AA+BgB,SAAA,aACd,WACA,WACA,SACA;AAEI,MAAA;AAGJ,YAAU,YAAY;AAEd,UAAA,cAAc,MAAM,QAAQ;AAG9B,QAAA,WAAW,WAAW,GAAG;AACjB,gBAAA;AAAA,IAAA;AAAA,EACZ,CACD;AAGD,YAAU,MAAM;AAEJ,cAAA;AAAA,EAAA,CACX;AACH;AAyCO,SAAS,UAAU,QAAiC;AAEzD,QAAM,QAAQ,YAAY;AAEtB,MAAA;AAGJ,QAAM,IAAI,YAAY;AAEd,UAAA,SAAS,MAAM,OAAO;AAGxB,QAAA,WAAW,MAAM,GAAG;AACZ,gBAAA;AAAA,IAAA;AAAA,EACZ,CACD;AAGD,iBAAe,MAAM;AAET,cAAA;AAEV,UAAM,KAAK;AAAA,EAAA,CACZ;AACH;"}
+{"version":3,"file":"shared.mjs","names":[],"sources":["../src/shared.ts"],"sourcesContent":["import { isFunction } from '@cloudcome/utils-core/type';\nimport type { AnyFunction, MaybePromise } from '@cloudcome/utils-core/types';\nimport { effectScope, onScopeDispose } from 'vue';\n\nexport type HookListener = () => MaybePromise<unknown>;\nexport type HookListenerWithDispose = () => MaybePromise<\n  unknown | HookListener\n>;\n\n/**\n * 运行生命周期钩子函数的工具函数\n *\n * @protected 内部方法\n * @template T - 泛型参数（未在函数中使用）\n * @param enterHook - 进入时执行的钩子函数，接收一个回调函数作为参数\n * @param leaveHook - 离开时执行的钩子函数，接收一个回调函数作为参数\n * @param onEnter - 进入时的监听器，可以返回一个清理函数\n *\n * @example\n * _runLifeHook(\n *   (hook) => onMounted(hook),     // 在组件挂载时执行进入逻辑\n *   (hook) => onUnmounted(hook),   // 在组件卸载时执行离开逻辑\n *   () => {\n *     // 执行进入时的逻辑\n *     console.log('组件已挂载');\n *\n *     // 返回一个清理函数，在离开时执行\n *     return () => {\n *       console.log('组件将要卸载');\n *     };\n *   }\n * );\n */\nexport function _runLifeHook<_T>(\n  enterHook: (hook: AnyFunction) => unknown,\n  leaveHook: (hook: AnyFunction) => unknown,\n  onEnter: HookListenerWithDispose,\n) {\n  // 存储离开时需要执行的清理函数\n  let onLeave: HookListener | undefined;\n\n  // 注册进入钩子，在 enterHook 触发时执行\n  enterHook(async () => {\n    // 执行进入时的监听器逻辑\n    const enterResult = await onEnter();\n\n    // 如果返回结果是一个函数，则将其作为离开时的清理函数保存\n    if (isFunction(enterResult)) {\n      onLeave = enterResult;\n    }\n  });\n\n  // 注册离开钩子，在 leaveHook 触发时执行\n  leaveHook(() => {\n    // 如果存在清理函数，则执行它\n    onLeave?.();\n  });\n}\n\n/**\n * 运行作用域钩子函数的工具函数\n *\n * 该函数创建一个独立的响应式作用域，在该作用域内执行传入的回调函数，\n * 并在适当的时机自动清理资源。这确保了响应式副作用的隔离和自动回收。\n *\n * @protected 内部方法\n * @param runner - 需要在作用域内执行的回调函数，可以返回一个清理函数\n *\n * @example\n * // 基本用法\n * _runScope(() => {\n *   // 在这里创建的响应式副作用会被限制在当前作用域内\n *   const stop = watch(someRef, (val) => {\n *     console.log(val);\n *   });\n *\n *   // 返回一个清理函数，在作用域销毁时执行\n *   return () => {\n *     stop();\n *   };\n * });\n *\n * @example\n * // 异步用法\n * _runScope(async () => {\n *   const data = await fetchData();\n *\n *   // 根据获取的数据创建响应式监听\n *   const stop = watch(() => data.value, (val) => {\n *     console.log(val);\n *   });\n *\n *   // 返回清理函数\n *   return () => {\n *     stop();\n *   };\n * });\n */\nexport function _runScope(runner: HookListenerWithDispose) {\n  // 创建一个独立的响应式作用域，用于收集和管理响应式副作用\n  const scope = effectScope();\n  // 存储用户提供的清理函数\n  let dispose: HookListener | undefined;\n\n  // 在创建的作用域内执行回调函数\n  scope.run(async () => {\n    // 执行传入的回调函数并等待其完成（支持异步操作）\n    const result = await runner();\n\n    // 如果回调函数返回了一个函数，则将其作为清理函数保存\n    if (isFunction(result)) {\n      dispose = result;\n    }\n  });\n\n  // 注册作用域销毁时的回调函数\n  onScopeDispose(() => {\n    // 如果存在用户提供的清理函数，则执行它\n    dispose?.();\n    // 停止并清理整个作用域内的所有响应式副作用\n    scope.stop();\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,SAAgB,aACd,WACA,WACA,SACA;CAEA,IAAI;CAGJ,UAAU,YAAY;EAEpB,MAAM,cAAc,MAAM,SAAS;EAGnC,IAAI,WAAW,YAAY,EACzB,UAAU;GAEZ;CAGF,gBAAgB;EAEd,WAAW;GACX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CJ,SAAgB,UAAU,QAAiC;CAEzD,MAAM,QAAQ,aAAa;CAE3B,IAAI;CAGJ,MAAM,IAAI,YAAY;EAEpB,MAAM,SAAS,MAAM,QAAQ;EAG7B,IAAI,WAAW,OAAO,EACpB,UAAU;GAEZ;CAGF,qBAAqB;EAEnB,WAAW;EAEX,MAAM,MAAM;GACZ"}

package/dist/state.cjs

@@ -1,29 +1,30 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const vue = require("vue");
+let vue = require("vue");
+//#region src/state.ts
+/**
+* 只改变一次的值
+* @param value 初始值
+* @param options 选项
+* @returns 包含 change 方法和 value 响应式值的对象
+*/
 function useOnceState(value, options) {
-  let lastValue = value;
-  const changed = vue.ref(false);
-  const { equal = Object.is } = options || {};
-  return {
-    change(newValue) {
-      if (equal(newValue, lastValue)) {
-        return;
-      }
-      if (changed.value) {
-        return;
-      }
-      changed.value = true;
-      lastValue = newValue;
-    },
-    // 这里需要使用 computed 确保返回的是原始值，而不是 reactive 包装后的对象
-    state: vue.computed(() => {
-      if (!changed.value) {
-        return value;
-      }
-      return lastValue;
-    })
-  };
+	let lastValue = value;
+	const changed = (0, vue.ref)(false);
+	const { equal = Object.is } = options || {};
+	return {
+		change(newValue) {
+			if (equal(newValue, lastValue)) return;
+			if (changed.value) return;
+			changed.value = true;
+			lastValue = newValue;
+		},
+		state: (0, vue.computed)(() => {
+			if (!changed.value) return value;
+			return lastValue;
+		})
+	};
 }
+//#endregion
 exports.useOnceState = useOnceState;
-//# sourceMappingURL=state.cjs.map
+
+//# sourceMappingURL=state.cjs.map

package/dist/state.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"state.cjs","sources":["../src/state.ts"],"sourcesContent":["import { computed, ref } from 'vue';\n\nexport type UseOnceValueOptions<T> = {\n  equal?: (a: T, b: T) => boolean;\n};\n\n/**\n * 只改变一次的值\n * @param value 初始值\n * @param options 选项\n * @returns 包含 change 方法和 value 响应式值的对象\n */\nexport function useOnceState<T>(value: T, options?: UseOnceValueOptions<T>) {\n  let lastValue = value;\n  const changed = ref(false);\n  const { equal = Object.is } = options || {};\n\n  return {\n    change(newValue: T) {\n      if (equal(newValue, lastValue)) {\n        return;\n      }\n\n      if (changed.value) {\n        return;\n      }\n\n      changed.value = true;\n      lastValue = newValue;\n    },\n    // 这里需要使用 computed 确保返回的是原始值，而不是 reactive 包装后的对象\n    state: computed(() => {\n      // changed 使用响应式是为确保 computed 能够响应式更新\n      if (!changed.value) {\n        return value;\n      }\n\n      return lastValue;\n    }),\n  };\n}\n"],"names":["ref","computed"],"mappings":";;;AAYgB,SAAA,aAAgB,OAAU,SAAkC;AAC1E,MAAI,YAAY;AACV,QAAA,UAAUA,QAAI,KAAK;AACzB,QAAM,EAAE,QAAQ,OAAO,GAAG,IAAI,WAAW,CAAC;AAEnC,SAAA;AAAA,IACL,OAAO,UAAa;AACd,UAAA,MAAM,UAAU,SAAS,GAAG;AAC9B;AAAA,MAAA;AAGF,UAAI,QAAQ,OAAO;AACjB;AAAA,MAAA;AAGF,cAAQ,QAAQ;AACJ,kBAAA;AAAA,IACd;AAAA;AAAA,IAEA,OAAOC,aAAS,MAAM;AAEhB,UAAA,CAAC,QAAQ,OAAO;AACX,eAAA;AAAA,MAAA;AAGF,aAAA;AAAA,IACR,CAAA;AAAA,EACH;AACF;;"}
+{"version":3,"file":"state.cjs","names":[],"sources":["../src/state.ts"],"sourcesContent":["import { computed, ref } from 'vue';\n\nexport type UseOnceValueOptions<T> = {\n  equal?: (a: T, b: T) => boolean;\n};\n\n/**\n * 只改变一次的值\n * @param value 初始值\n * @param options 选项\n * @returns 包含 change 方法和 value 响应式值的对象\n */\nexport function useOnceState<T>(value: T, options?: UseOnceValueOptions<T>) {\n  let lastValue = value;\n  const changed = ref(false);\n  const { equal = Object.is } = options || {};\n\n  return {\n    change(newValue: T) {\n      if (equal(newValue, lastValue)) {\n        return;\n      }\n\n      if (changed.value) {\n        return;\n      }\n\n      changed.value = true;\n      lastValue = newValue;\n    },\n    // 这里需要使用 computed 确保返回的是原始值，而不是 reactive 包装后的对象\n    state: computed(() => {\n      // changed 使用响应式是为确保 computed 能够响应式更新\n      if (!changed.value) {\n        return value;\n      }\n\n      return lastValue;\n    }),\n  };\n}\n"],"mappings":";;;;;;;;;AAYA,SAAgB,aAAgB,OAAU,SAAkC;CAC1E,IAAI,YAAY;CAChB,MAAM,WAAA,GAAA,IAAA,KAAc,MAAM;CAC1B,MAAM,EAAE,QAAQ,OAAO,OAAO,WAAW,EAAE;CAE3C,OAAO;EACL,OAAO,UAAa;GAClB,IAAI,MAAM,UAAU,UAAU,EAC5B;GAGF,IAAI,QAAQ,OACV;GAGF,QAAQ,QAAQ;GAChB,YAAY;;EAGd,QAAA,GAAA,IAAA,gBAAsB;GAEpB,IAAI,CAAC,QAAQ,OACX,OAAO;GAGT,OAAO;IACP;EACH"}

package/dist/state.mjs

@@ -1,29 +1,29 @@
-import { ref, computed } from "vue";
+import { computed, ref } from "vue";
+//#region src/state.ts
+/**
+* 只改变一次的值
+* @param value 初始值
+* @param options 选项
+* @returns 包含 change 方法和 value 响应式值的对象
+*/
 function useOnceState(value, options) {
-  let lastValue = value;
-  const changed = ref(false);
-  const { equal = Object.is } = options || {};
-  return {
-    change(newValue) {
-      if (equal(newValue, lastValue)) {
-        return;
-      }
-      if (changed.value) {
-        return;
-      }
-      changed.value = true;
-      lastValue = newValue;
-    },
-    // 这里需要使用 computed 确保返回的是原始值，而不是 reactive 包装后的对象
-    state: computed(() => {
-      if (!changed.value) {
-        return value;
-      }
-      return lastValue;
-    })
-  };
+	let lastValue = value;
+	const changed = ref(false);
+	const { equal = Object.is } = options || {};
+	return {
+		change(newValue) {
+			if (equal(newValue, lastValue)) return;
+			if (changed.value) return;
+			changed.value = true;
+			lastValue = newValue;
+		},
+		state: computed(() => {
+			if (!changed.value) return value;
+			return lastValue;
+		})
+	};
 }
-export {
-  useOnceState
-};
-//# sourceMappingURL=state.mjs.map
+//#endregion
+export { useOnceState };
+
+//# sourceMappingURL=state.mjs.map