@cloudcome/utils-vue 1.13.2 → 1.14.0

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<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"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,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

package/dist/state.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"state.mjs","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":[],"mappings":";AAYgB,SAAA,aAAgB,OAAU,SAAkC;AAC1E,MAAI,YAAY;AACV,QAAA,UAAU,IAAI,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,OAAO,SAAS,MAAM;AAEhB,UAAA,CAAC,QAAQ,OAAO;AACX,eAAA;AAAA,MAAA;AAGF,aAAA;AAAA,IACR,CAAA;AAAA,EACH;AACF;"}
+{"version":3,"file":"state.mjs","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,UAAU,IAAI,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,OAAO,eAAe;GAEpB,IAAI,CAAC,QAAQ,OACX,OAAO;GAGT,OAAO;IACP;EACH"}

package/dist/time.cjs

@@ -1,42 +1,52 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const vue = require("vue");
-const life = require("./life.cjs");
-const shared = require("./shared.cjs");
+const require_shared = require("./shared.cjs");
+const require_component = require("./component.cjs");
+let vue = require("vue");
+//#region src/time.ts
+/**
+* 创建一个延迟更新的响应式值
+*
+* 该函数创建一个基于原始响应式值的延迟更新值，当原始值发生变化时，
+* 延迟值会在指定的延迟时间后更新。如果在延迟期间原始值再次变化，
+* 则会重新计算延迟时间。
+*
+* @param initialValue 原始响应式值，类型为Ref<T>
+* @param delay 延迟时间，可以是数字或响应式数字，默认为100毫秒
+* @returns 返回一个计算属性，其值会在延迟后更新为原始值
+*/
 function useLazyValue(initialValue, delay) {
-  const lazyValue = vue.ref(initialValue.value);
-  let changedAt = 0;
-  shared._runScope(() => {
-    let t;
-    vue.watch(initialValue, (value) => {
-      const delayValue = vue.toValue(delay) || 100;
-      clearTimeout(t);
-      if (changedAt > 0 && Date.now() - changedAt > delayValue) {
-        lazyValue.value = value;
-      } else {
-        t = setTimeout(() => {
-          lazyValue.value = value;
-        }, delayValue);
-      }
-      changedAt = Date.now();
-    });
-    return () => {
-      clearTimeout(t);
-    };
-  });
-  return vue.computed(() => {
-    return lazyValue.value;
-  });
+	const lazyValue = (0, vue.ref)(initialValue.value);
+	let changedAt = 0;
+	require_shared._runScope(() => {
+		let t;
+		(0, vue.watch)(initialValue, (value) => {
+			const delayValue = (0, vue.toValue)(delay) || 100;
+			clearTimeout(t);
+			if (changedAt > 0 && Date.now() - changedAt > delayValue) lazyValue.value = value;
+			else t = setTimeout(() => {
+				lazyValue.value = value;
+			}, delayValue);
+			changedAt = Date.now();
+		});
+		return () => {
+			clearTimeout(t);
+		};
+	});
+	return (0, vue.computed)(() => {
+		return lazyValue.value;
+	});
 }
 function useInterval(callback, delay) {
-  life.useMount(() => {
-    const delayValue = vue.toValue(delay) || 100;
-    const t = setInterval(callback, delayValue);
-    return () => {
-      clearInterval(t);
-    };
-  });
+	require_component.useMount(() => {
+		const delayValue = (0, vue.toValue)(delay) || 100;
+		const t = setInterval(callback, delayValue);
+		return () => {
+			clearInterval(t);
+		};
+	});
 }
+//#endregion
 exports.useInterval = useInterval;
 exports.useLazyValue = useLazyValue;
-//# sourceMappingURL=time.cjs.map
+
+//# sourceMappingURL=time.cjs.map

package/dist/time.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"time.cjs","sources":["../src/time.ts"],"sourcesContent":["import { type Ref, computed, effectScope, onScopeDispose, ref, toValue, watch } from 'vue';\nimport { useMount } from './component';\nimport { _runLifeHook, _runScope } from './shared';\n\n/**\n * 创建一个延迟更新的响应式值\n *\n * 该函数创建一个基于原始响应式值的延迟更新值，当原始值发生变化时，\n * 延迟值会在指定的延迟时间后更新。如果在延迟期间原始值再次变化，\n * 则会重新计算延迟时间。\n *\n * @param initialValue 原始响应式值，类型为Ref<T>\n * @param delay 延迟时间，可以是数字或响应式数字，默认为100毫秒\n * @returns 返回一个计算属性，其值会在延迟后更新为原始值\n */\nexport function useLazyValue<T>(initialValue: Ref<T>, delay?: number | Ref<number>) {\n  const lazyValue = ref(initialValue.value);\n  let changedAt = 0;\n\n  _runScope(() => {\n    // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n    let t: any;\n\n    watch(initialValue, (value) => {\n      const delayValue = toValue(delay) || 100;\n      clearTimeout(t);\n\n      if (changedAt > 0 && Date.now() - changedAt > delayValue) {\n        lazyValue.value = value;\n      } else {\n        t = setTimeout(() => {\n          lazyValue.value = value;\n        }, delayValue);\n      }\n\n      changedAt = Date.now();\n    });\n\n    return () => {\n      clearTimeout(t);\n    };\n  });\n\n  return computed<T>(() => {\n    return lazyValue.value;\n  });\n}\n\nexport function useInterval(callback: () => void, delay?: number | Ref<number>) {\n  useMount(() => {\n    const delayValue = toValue(delay) || 100;\n    const t = setInterval(callback, delayValue);\n\n    return () => {\n      clearInterval(t);\n    };\n  });\n}\n"],"names":["ref","_runScope","watch","toValue","computed","useMount"],"mappings":";;;;;AAegB,SAAA,aAAgB,cAAsB,OAA8B;AAC5E,QAAA,YAAYA,IAAAA,IAAI,aAAa,KAAK;AACxC,MAAI,YAAY;AAEhBC,SAAAA,UAAU,MAAM;AAEV,QAAA;AAEEC,cAAA,cAAc,CAAC,UAAU;AACvB,YAAA,aAAaC,IAAAA,QAAQ,KAAK,KAAK;AACrC,mBAAa,CAAC;AAEd,UAAI,YAAY,KAAK,KAAK,IAAI,IAAI,YAAY,YAAY;AACxD,kBAAU,QAAQ;AAAA,MAAA,OACb;AACL,YAAI,WAAW,MAAM;AACnB,oBAAU,QAAQ;AAAA,WACjB,UAAU;AAAA,MAAA;AAGf,kBAAY,KAAK,IAAI;AAAA,IAAA,CACtB;AAED,WAAO,MAAM;AACX,mBAAa,CAAC;AAAA,IAChB;AAAA,EAAA,CACD;AAED,SAAOC,aAAY,MAAM;AACvB,WAAO,UAAU;AAAA,EAAA,CAClB;AACH;AAEgB,SAAA,YAAY,UAAsB,OAA8B;AAC9EC,OAAAA,SAAS,MAAM;AACP,UAAA,aAAaF,IAAAA,QAAQ,KAAK,KAAK;AAC/B,UAAA,IAAI,YAAY,UAAU,UAAU;AAE1C,WAAO,MAAM;AACX,oBAAc,CAAC;AAAA,IACjB;AAAA,EAAA,CACD;AACH;;;"}
+{"version":3,"file":"time.cjs","names":[],"sources":["../src/time.ts"],"sourcesContent":["import { computed, type Ref, ref, toValue, watch } from 'vue';\nimport { useMount } from './component';\nimport { _runScope } from './shared';\n\n/**\n * 创建一个延迟更新的响应式值\n *\n * 该函数创建一个基于原始响应式值的延迟更新值，当原始值发生变化时，\n * 延迟值会在指定的延迟时间后更新。如果在延迟期间原始值再次变化，\n * 则会重新计算延迟时间。\n *\n * @param initialValue 原始响应式值，类型为Ref<T>\n * @param delay 延迟时间，可以是数字或响应式数字，默认为100毫秒\n * @returns 返回一个计算属性，其值会在延迟后更新为原始值\n */\nexport function useLazyValue<T>(initialValue: Ref<T>, delay?: number | Ref<number>) {\n  const lazyValue = ref(initialValue.value);\n  let changedAt = 0;\n\n  _runScope(() => {\n    // biome-ignore lint/suspicious/noExplicitAny: 内部使用 any\n    let t: any;\n\n    watch(initialValue, (value) => {\n      const delayValue = toValue(delay) || 100;\n      clearTimeout(t);\n\n      if (changedAt > 0 && Date.now() - changedAt > delayValue) {\n        lazyValue.value = value;\n      } else {\n        t = setTimeout(() => {\n          lazyValue.value = value;\n        }, delayValue);\n      }\n\n      changedAt = Date.now();\n    });\n\n    return () => {\n      clearTimeout(t);\n    };\n  });\n\n  return computed<T>(() => {\n    return lazyValue.value;\n  });\n}\n\nexport function useInterval(callback: () => void, delay?: number | Ref<number>) {\n  useMount(() => {\n    const delayValue = toValue(delay) || 100;\n    const t = setInterval(callback, delayValue);\n\n    return () => {\n      clearInterval(t);\n    };\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAeA,SAAgB,aAAgB,cAAsB,OAA8B;CAClF,MAAM,aAAA,GAAA,IAAA,KAAgB,aAAa,MAAM;CACzC,IAAI,YAAY;CAEhB,eAAA,gBAAgB;EAEd,IAAI;EAEJ,CAAA,GAAA,IAAA,OAAM,eAAe,UAAU;GAC7B,MAAM,cAAA,GAAA,IAAA,SAAqB,MAAM,IAAI;GACrC,aAAa,EAAE;GAEf,IAAI,YAAY,KAAK,KAAK,KAAK,GAAG,YAAY,YAC5C,UAAU,QAAQ;QAElB,IAAI,iBAAiB;IACnB,UAAU,QAAQ;MACjB,WAAW;GAGhB,YAAY,KAAK,KAAK;IACtB;EAEF,aAAa;GACX,aAAa,EAAE;;GAEjB;CAEF,QAAA,GAAA,IAAA,gBAAyB;EACvB,OAAO,UAAU;GACjB;;AAGJ,SAAgB,YAAY,UAAsB,OAA8B;CAC9E,kBAAA,eAAe;EACb,MAAM,cAAA,GAAA,IAAA,SAAqB,MAAM,IAAI;EACrC,MAAM,IAAI,YAAY,UAAU,WAAW;EAE3C,aAAa;GACX,cAAc,EAAE;;GAElB"}

package/dist/time.mjs

@@ -1,42 +1,50 @@
-import { ref, watch, toValue, computed } from "vue";
-import { u as useMount } from "./life.mjs";
 import { _runScope } from "./shared.mjs";
+import { useMount } from "./component.mjs";
+import { computed, ref, toValue, watch } from "vue";
+//#region src/time.ts
+/**
+* 创建一个延迟更新的响应式值
+*
+* 该函数创建一个基于原始响应式值的延迟更新值，当原始值发生变化时，
+* 延迟值会在指定的延迟时间后更新。如果在延迟期间原始值再次变化，
+* 则会重新计算延迟时间。
+*
+* @param initialValue 原始响应式值，类型为Ref<T>
+* @param delay 延迟时间，可以是数字或响应式数字，默认为100毫秒
+* @returns 返回一个计算属性，其值会在延迟后更新为原始值
+*/
 function useLazyValue(initialValue, delay) {
-  const lazyValue = ref(initialValue.value);
-  let changedAt = 0;
-  _runScope(() => {
-    let t;
-    watch(initialValue, (value) => {
-      const delayValue = toValue(delay) || 100;
-      clearTimeout(t);
-      if (changedAt > 0 && Date.now() - changedAt > delayValue) {
-        lazyValue.value = value;
-      } else {
-        t = setTimeout(() => {
-          lazyValue.value = value;
-        }, delayValue);
-      }
-      changedAt = Date.now();
-    });
-    return () => {
-      clearTimeout(t);
-    };
-  });
-  return computed(() => {
-    return lazyValue.value;
-  });
+	const lazyValue = ref(initialValue.value);
+	let changedAt = 0;
+	_runScope(() => {
+		let t;
+		watch(initialValue, (value) => {
+			const delayValue = toValue(delay) || 100;
+			clearTimeout(t);
+			if (changedAt > 0 && Date.now() - changedAt > delayValue) lazyValue.value = value;
+			else t = setTimeout(() => {
+				lazyValue.value = value;
+			}, delayValue);
+			changedAt = Date.now();
+		});
+		return () => {
+			clearTimeout(t);
+		};
+	});
+	return computed(() => {
+		return lazyValue.value;
+	});
 }
 function useInterval(callback, delay) {
-  useMount(() => {
-    const delayValue = toValue(delay) || 100;
-    const t = setInterval(callback, delayValue);
-    return () => {
-      clearInterval(t);
-    };
-  });
+	useMount(() => {
+		const delayValue = toValue(delay) || 100;
+		const t = setInterval(callback, delayValue);
+		return () => {
+			clearInterval(t);
+		};
+	});
 }
-export {
-  useInterval,
-  useLazyValue
-};
-//# sourceMappingURL=time.mjs.map
+//#endregion
+export { useInterval, useLazyValue };
+
+//# sourceMappingURL=time.mjs.map

package/dist/time.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"time.mjs","sources":["../src/time.ts"],"sourcesContent":["import { type Ref, computed, effectScope, onScopeDispose, ref, toValue, watch } from 'vue';\nimport { useMount } from './component';\nimport { _runLifeHook, _runScope } from './shared';\n\n/**\n * 创建一个延迟更新的响应式值\n *\n * 该函数创建一个基于原始响应式值的延迟更新值，当原始值发生变化时，\n * 延迟值会在指定的延迟时间后更新。如果在延迟期间原始值再次变化，\n * 则会重新计算延迟时间。\n *\n * @param initialValue 原始响应式值，类型为Ref<T>\n * @param delay 延迟时间，可以是数字或响应式数字，默认为100毫秒\n * @returns 返回一个计算属性，其值会在延迟后更新为原始值\n */\nexport function useLazyValue<T>(initialValue: Ref<T>, delay?: number | Ref<number>) {\n  const lazyValue = ref(initialValue.value);\n  let changedAt = 0;\n\n  _runScope(() => {\n    // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n    let t: any;\n\n    watch(initialValue, (value) => {\n      const delayValue = toValue(delay) || 100;\n      clearTimeout(t);\n\n      if (changedAt > 0 && Date.now() - changedAt > delayValue) {\n        lazyValue.value = value;\n      } else {\n        t = setTimeout(() => {\n          lazyValue.value = value;\n        }, delayValue);\n      }\n\n      changedAt = Date.now();\n    });\n\n    return () => {\n      clearTimeout(t);\n    };\n  });\n\n  return computed<T>(() => {\n    return lazyValue.value;\n  });\n}\n\nexport function useInterval(callback: () => void, delay?: number | Ref<number>) {\n  useMount(() => {\n    const delayValue = toValue(delay) || 100;\n    const t = setInterval(callback, delayValue);\n\n    return () => {\n      clearInterval(t);\n    };\n  });\n}\n"],"names":[],"mappings":";;;AAegB,SAAA,aAAgB,cAAsB,OAA8B;AAC5E,QAAA,YAAY,IAAI,aAAa,KAAK;AACxC,MAAI,YAAY;AAEhB,YAAU,MAAM;AAEV,QAAA;AAEE,UAAA,cAAc,CAAC,UAAU;AACvB,YAAA,aAAa,QAAQ,KAAK,KAAK;AACrC,mBAAa,CAAC;AAEd,UAAI,YAAY,KAAK,KAAK,IAAI,IAAI,YAAY,YAAY;AACxD,kBAAU,QAAQ;AAAA,MAAA,OACb;AACL,YAAI,WAAW,MAAM;AACnB,oBAAU,QAAQ;AAAA,WACjB,UAAU;AAAA,MAAA;AAGf,kBAAY,KAAK,IAAI;AAAA,IAAA,CACtB;AAED,WAAO,MAAM;AACX,mBAAa,CAAC;AAAA,IAChB;AAAA,EAAA,CACD;AAED,SAAO,SAAY,MAAM;AACvB,WAAO,UAAU;AAAA,EAAA,CAClB;AACH;AAEgB,SAAA,YAAY,UAAsB,OAA8B;AAC9E,WAAS,MAAM;AACP,UAAA,aAAa,QAAQ,KAAK,KAAK;AAC/B,UAAA,IAAI,YAAY,UAAU,UAAU;AAE1C,WAAO,MAAM;AACX,oBAAc,CAAC;AAAA,IACjB;AAAA,EAAA,CACD;AACH;"}
+{"version":3,"file":"time.mjs","names":[],"sources":["../src/time.ts"],"sourcesContent":["import { computed, type Ref, ref, toValue, watch } from 'vue';\nimport { useMount } from './component';\nimport { _runScope } from './shared';\n\n/**\n * 创建一个延迟更新的响应式值\n *\n * 该函数创建一个基于原始响应式值的延迟更新值，当原始值发生变化时，\n * 延迟值会在指定的延迟时间后更新。如果在延迟期间原始值再次变化，\n * 则会重新计算延迟时间。\n *\n * @param initialValue 原始响应式值，类型为Ref<T>\n * @param delay 延迟时间，可以是数字或响应式数字，默认为100毫秒\n * @returns 返回一个计算属性，其值会在延迟后更新为原始值\n */\nexport function useLazyValue<T>(initialValue: Ref<T>, delay?: number | Ref<number>) {\n  const lazyValue = ref(initialValue.value);\n  let changedAt = 0;\n\n  _runScope(() => {\n    // biome-ignore lint/suspicious/noExplicitAny: 内部使用 any\n    let t: any;\n\n    watch(initialValue, (value) => {\n      const delayValue = toValue(delay) || 100;\n      clearTimeout(t);\n\n      if (changedAt > 0 && Date.now() - changedAt > delayValue) {\n        lazyValue.value = value;\n      } else {\n        t = setTimeout(() => {\n          lazyValue.value = value;\n        }, delayValue);\n      }\n\n      changedAt = Date.now();\n    });\n\n    return () => {\n      clearTimeout(t);\n    };\n  });\n\n  return computed<T>(() => {\n    return lazyValue.value;\n  });\n}\n\nexport function useInterval(callback: () => void, delay?: number | Ref<number>) {\n  useMount(() => {\n    const delayValue = toValue(delay) || 100;\n    const t = setInterval(callback, delayValue);\n\n    return () => {\n      clearInterval(t);\n    };\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;AAeA,SAAgB,aAAgB,cAAsB,OAA8B;CAClF,MAAM,YAAY,IAAI,aAAa,MAAM;CACzC,IAAI,YAAY;CAEhB,gBAAgB;EAEd,IAAI;EAEJ,MAAM,eAAe,UAAU;GAC7B,MAAM,aAAa,QAAQ,MAAM,IAAI;GACrC,aAAa,EAAE;GAEf,IAAI,YAAY,KAAK,KAAK,KAAK,GAAG,YAAY,YAC5C,UAAU,QAAQ;QAElB,IAAI,iBAAiB;IACnB,UAAU,QAAQ;MACjB,WAAW;GAGhB,YAAY,KAAK,KAAK;IACtB;EAEF,aAAa;GACX,aAAa,EAAE;;GAEjB;CAEF,OAAO,eAAkB;EACvB,OAAO,UAAU;GACjB;;AAGJ,SAAgB,YAAY,UAAsB,OAA8B;CAC9E,eAAe;EACb,MAAM,aAAa,QAAQ,MAAM,IAAI;EACrC,MAAM,IAAI,YAAY,UAAU,WAAW;EAE3C,aAAa;GACX,cAAc,EAAE;;GAElB"}

package/dist/types.cjs

@@ -1,2 +0,0 @@
-"use strict";
-//# sourceMappingURL=types.cjs.map

package/dist/types.mjs

@@ -1,2 +0,0 @@
-
-//# sourceMappingURL=types.mjs.map

package/package.json

@@ -1,11 +1,38 @@
 {
   "name": "@cloudcome/utils-vue",
-  "version": "1.13.2",
+  "version": "1.14.0",
   "description": "cloudcome utils for vue",
-  "engines": {
-    "node": ">=22"
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "async": [
+        "./dist/async.d.ts"
+      ],
+      "component": [
+        "./dist/component.d.ts"
+      ],
+      "event": [
+        "./dist/event.d.ts"
+      ],
+      "request": [
+        "./dist/request.d.ts"
+      ],
+      "shared": [
+        "./dist/shared.d.ts"
+      ],
+      "state": [
+        "./dist/state.d.ts"
+      ],
+      "time": [
+        "./dist/time.d.ts"
+      ],
+      "types": [
+        "./dist/types.d.ts"
+      ]
+    }
   },
-  "engineStrict": true,
   "sideEffects": false,
   "exports": {
     ".": {
@@ -55,60 +82,32 @@
       "require": "./dist/types.cjs"
     }
   },
-  "typesVersions": {
-    "*": {
-      "async": [
-        "./dist/async.d.ts"
-      ],
-      "component": [
-        "./dist/component.d.ts"
-      ],
-      "event": [
-        "./dist/event.d.ts"
-      ],
-      "request": [
-        "./dist/request.d.ts"
-      ],
-      "shared": [
-        "./dist/shared.d.ts"
-      ],
-      "state": [
-        "./dist/state.d.ts"
-      ],
-      "time": [
-        "./dist/time.d.ts"
-      ],
-      "types": [
-        "./dist/types.d.ts"
-      ]
-    }
-  },
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
   "files": [
     "dist"
   ],
-  "dependencies": {
-    "@cloudcome/utils-core": "~1.19.1",
-    "vue": "^3.5.13",
-    "vue-component-type-helpers": "^2.2.10"
+  "engines": {
+    "node": ">=22"
   },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/cloudcome/utils.git"
+  "dependencies": {
+    "@cloudcome/utils-core": "~1.20.1",
+    "vue": "^3.5.34",
+    "vue-component-type-helpers": "^3.2.8"
   },
   "keywords": [
-    "utils",
     "cloudcome",
+    "utils",
+    "utils-browser",
     "utils-core",
-    "utils-vue",
+    "utils-node",
     "utils-react",
     "utils-uni",
-    "utils-node",
-    "utils-browser"
+    "utils-vue"
   ],
-  "homepage": "https://github.com/cloudcome/utils",
+  "homepage": "https://cloudcome.github.io/utils/",
   "license": "MIT",
-  "author": "云淡然 <hi@ydr.me> (https://ydr.me/)"
+  "author": "云淡然 <hi@ydr.me> (https://ydr.me/)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cloudcome/utils.git"
+  }
 }

package/dist/life.cjs

@@ -1,16 +0,0 @@
-"use strict";
-const shared = require("./shared.cjs");
-const vue = require("vue");
-function useMount(beforeMount) {
-  shared._runLifeHook(vue.onBeforeMount, vue.onBeforeUnmount, beforeMount);
-}
-function useMounted(mounted) {
-  shared._runLifeHook(vue.onMounted, vue.onUnmounted, mounted);
-}
-function useActivated(activated) {
-  shared._runLifeHook(vue.onActivated, vue.onDeactivated, activated);
-}
-exports.useActivated = useActivated;
-exports.useMount = useMount;
-exports.useMounted = useMounted;
-//# sourceMappingURL=life.cjs.map

package/dist/life.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"life.cjs","sources":["../src/component/life.ts"],"sourcesContent":["import { _runLifeHook } from '@/shared';\nimport type { MaybePromise } from '@cloudcome/utils-core/types';\nimport { onActivated, onBeforeMount, onBeforeUnmount, onDeactivated, onMounted, onUnmounted } from 'vue';\n\nexport type HookListener = () => MaybePromise<unknown>;\nexport type HookListenerWithDispose = () => MaybePromise<undefined | HookListener>;\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"],"names":["_runLifeHook","onBeforeMount","onBeforeUnmount","onMounted","onUnmounted","onActivated","onDeactivated"],"mappings":";;;AAuBO,SAAS,SAAS,aAAsC;AAChDA,sBAAAC,IAAAA,eAAeC,qBAAiB,WAAW;AAC1D;AAkBO,SAAS,WAAW,SAAkC;AAC9CF,sBAAAG,IAAAA,WAAWC,iBAAa,OAAO;AAC9C;AAkBO,SAAS,aAAa,WAAoC;AAClDJ,sBAAAK,IAAAA,aAAaC,mBAAe,SAAS;AACpD;;;;"}