@cloudcome/utils-vue 1.10.1 → 1.11.0

package/dist/component/life.d.ts

@@ -0,0 +1,54 @@
+import { MaybePromise } from '@cloudcome/utils-core/types';
+export type HookListener = () => MaybePromise<unknown>;
+export type HookListenerWithDispose = () => MaybePromise<undefined | HookListener>;
+/**
+ * 页面挂载前生命周期钩子
+ *
+ * @param beforeMount - 在组件挂载前执行的回调函数，可以返回一个清理函数
+ *
+ * @example
+ * ```ts
+ * useMount(() => {
+ *   console.log('组件即将挂载');
+ *   // 可以返回一个清理函数，在组件卸载前执行
+ *   return () => {
+ *     console.log('组件即将卸载');
+ *   };
+ * });
+ * ```
+ */
+export declare function useMount(beforeMount: HookListenerWithDispose): void;
+/**
+ * 页面挂载后生命周期钩子
+ *
+ * @param mounted - 在组件挂载后执行的回调函数，可以返回一个清理函数
+ *
+ * @example
+ * ```ts
+ * useMounted(() => {
+ *   console.log('组件已挂载');
+ *   // 可以返回一个清理函数，在组件卸载前执行
+ *   return () => {
+ *     console.log('组件即将卸载');
+ *   };
+ * });
+ * ```
+ */
+export declare function useMounted(mounted: HookListenerWithDispose): void;
+/**
+ * 页面激活时生命周期钩子
+ *
+ * @param activated - 在组件被激活时执行的回调函数，可以返回一个清理函数
+ *
+ * @example
+ * ```ts
+ * useActivated(() => {
+ *   console.log('组件已激活');
+ *   // 可以返回一个清理函数，在组件失活前执行
+ *   return () => {
+ *     console.log('组件即将失活');
+ *   };
+ * });
+ * ```
+ */
+export declare function useActivated(activated: HookListenerWithDispose): void;

package/dist/component/self.d.ts

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

package/dist/component.cjs

@@ -1,6 +1,7 @@
 "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);
 }
@@ -10,6 +11,9 @@ function useEmit(Comp, event, listener) {
 function useMethod(Comp, name, method) {
   return method;
 }
+exports.useActivated = life.useActivated;
+exports.useMount = life.useMount;
+exports.useMounted = life.useMounted;
 exports.useEmit = useEmit;
 exports.useExpose = useExpose;
 exports.useMethod = useMethod;

package/dist/component.cjs.map

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

package/dist/component.d.ts

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

package/dist/component.mjs

@@ -1,4 +1,5 @@
 import { ref } from "vue";
+import { b, u, a } from "./life.mjs";
 function useExpose(Comp) {
   return ref(null);
 }
@@ -9,8 +10,11 @@ function useMethod(Comp, name, method) {
   return method;
 }
 export {
+  b as useActivated,
   useEmit,
   useExpose,
-  useMethod
+  useMethod,
+  u as useMount,
+  a as useMounted
 };
 //# sourceMappingURL=component.mjs.map

package/dist/component.mjs.map

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

package/dist/index.cjs

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

package/dist/index.mjs

@@ -1,4 +1,4 @@
-const VERSION = "1.10.0";
+const VERSION = "1.10.1";
 export {
   VERSION
 };

package/dist/life.cjs

@@ -0,0 +1,16 @@
+"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

@@ -0,0 +1 @@
+{"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;;;;"}

package/dist/life.mjs

@@ -0,0 +1,17 @@
+import { _runLifeHook } from "./shared.mjs";
+import { onBeforeUnmount, onBeforeMount, onUnmounted, onMounted, onDeactivated, onActivated } from "vue";
+function useMount(beforeMount) {
+  _runLifeHook(onBeforeMount, onBeforeUnmount, beforeMount);
+}
+function useMounted(mounted) {
+  _runLifeHook(onMounted, onUnmounted, mounted);
+}
+function useActivated(activated) {
+  _runLifeHook(onActivated, onDeactivated, activated);
+}
+export {
+  useMounted as a,
+  useActivated as b,
+  useMount as u
+};
+//# sourceMappingURL=life.mjs.map

package/dist/life.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"life.mjs","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":[],"mappings":";;AAuBO,SAAS,SAAS,aAAsC;AAChD,eAAA,eAAe,iBAAiB,WAAW;AAC1D;AAkBO,SAAS,WAAW,SAAkC;AAC9C,eAAA,WAAW,aAAa,OAAO;AAC9C;AAkBO,SAAS,aAAa,WAAoC;AAClD,eAAA,aAAa,eAAe,SAAS;AACpD;"}

package/dist/shared.cjs

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const type = require("@cloudcome/utils-core/type");
+const vue = require("vue");
+function _runLifeHook(enterHook, leaveHook, onEnter) {
+  let onLeave;
+  enterHook(async () => {
+    const enterResult = await onEnter();
+    if (type.isFunction(enterResult)) {
+      onLeave = enterResult;
+    }
+  });
+  leaveHook(() => {
+    onLeave?.();
+  });
+}
+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();
+  });
+}
+exports._runLifeHook = _runLifeHook;
+exports._runScope = _runScope;
+//# sourceMappingURL=shared.cjs.map

package/dist/shared.cjs.map

@@ -0,0 +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;;;"}

package/dist/shared.d.ts

@@ -0,0 +1,68 @@
+import { AnyFunction, MaybePromise } from '@cloudcome/utils-core/types';
+export type HookListener = () => MaybePromise<unknown>;
+export type HookListenerWithDispose = () => MaybePromise<unknown | HookListener>;
+/**
+ * 运行生命周期钩子函数的工具函数
+ *
+ * @protected 内部方法
+ * @template T - 泛型参数（未在函数中使用）
+ * @param enterHook - 进入时执行的钩子函数，接收一个回调函数作为参数
+ * @param leaveHook - 离开时执行的钩子函数，接收一个回调函数作为参数
+ * @param onEnter - 进入时的监听器，可以返回一个清理函数
+ *
+ * @example
+ * _runLifeHook(
+ *   (hook) => onMounted(hook),     // 在组件挂载时执行进入逻辑
+ *   (hook) => onUnmounted(hook),   // 在组件卸载时执行离开逻辑
+ *   () => {
+ *     // 执行进入时的逻辑
+ *     console.log('组件已挂载');
+ *
+ *     // 返回一个清理函数，在离开时执行
+ *     return () => {
+ *       console.log('组件将要卸载');
+ *     };
+ *   }
+ * );
+ */
+export declare function _runLifeHook<T>(enterHook: (hook: AnyFunction) => unknown, leaveHook: (hook: AnyFunction) => unknown, onEnter: HookListenerWithDispose): void;
+/**
+ * 运行作用域钩子函数的工具函数
+ *
+ * 该函数创建一个独立的响应式作用域，在该作用域内执行传入的回调函数，
+ * 并在适当的时机自动清理资源。这确保了响应式副作用的隔离和自动回收。
+ *
+ * @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();
+ *   };
+ * });
+ */
+export declare function _runScope(runner: HookListenerWithDispose): void;

package/dist/shared.mjs

@@ -0,0 +1,33 @@
+import { isFunction } from "@cloudcome/utils-core/type";
+import { effectScope, onScopeDispose } from "vue";
+function _runLifeHook(enterHook, leaveHook, onEnter) {
+  let onLeave;
+  enterHook(async () => {
+    const enterResult = await onEnter();
+    if (isFunction(enterResult)) {
+      onLeave = enterResult;
+    }
+  });
+  leaveHook(() => {
+    onLeave?.();
+  });
+}
+function _runScope(runner) {
+  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

package/dist/shared.mjs.map

@@ -0,0 +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;"}

package/dist/time.cjs

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const vue = require("vue");
+const life = require("./life.cjs");
+const shared = require("./shared.cjs");
+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;
+  });
+}
+function useInterval(callback, delay) {
+  life.useMount(() => {
+    const delayValue = vue.toValue(delay) || 100;
+    const t = setInterval(callback, delayValue);
+    return () => {
+      clearInterval(t);
+    };
+  });
+}
+exports.useInterval = useInterval;
+exports.useLazyValue = useLazyValue;
+//# sourceMappingURL=time.cjs.map

package/dist/time.cjs.map

@@ -0,0 +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;;;"}

package/dist/{lazy.d.ts → time.d.ts}

@@ -6,8 +6,9 @@ import { Ref } from 'vue';
  * 延迟值会在指定的延迟时间后更新。如果在延迟期间原始值再次变化，
  * 则会重新计算延迟时间。
  *
- * @param boolean 原始响应式值，类型为Ref<T>
+ * @param initialValue 原始响应式值，类型为Ref<T>
  * @param delay 延迟时间，可以是数字或响应式数字，默认为100毫秒
  * @returns 返回一个计算属性，其值会在延迟后更新为原始值
  */
-export declare function useLazyValue<T>(boolean: Ref<T>, delay?: number | Ref<number>): import('vue').ComputedRef<T>;
+export declare function useLazyValue<T>(initialValue: Ref<T>, delay?: number | Ref<number>): import('vue').ComputedRef<T>;
+export declare function useInterval(callback: () => void, delay?: number | Ref<number>): void;

package/dist/time.mjs

@@ -0,0 +1,42 @@
+import { ref, watch, toValue, computed } from "vue";
+import { u as useMount } from "./life.mjs";
+import { _runScope } from "./shared.mjs";
+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;
+  });
+}
+function useInterval(callback, delay) {
+  useMount(() => {
+    const delayValue = toValue(delay) || 100;
+    const t = setInterval(callback, delayValue);
+    return () => {
+      clearInterval(t);
+    };
+  });
+}
+export {
+  useInterval,
+  useLazyValue
+};
+//# sourceMappingURL=time.mjs.map

package/dist/time.mjs.map

@@ -0,0 +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;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudcome/utils-vue",
-  "version": "1.10.1",
+  "version": "1.11.0",
   "description": "cloudcome utils for vue",
   "engines": {
     "node": ">=22"
@@ -29,21 +29,21 @@
       "import": "./dist/event.mjs",
       "require": "./dist/event.cjs"
     },
-    "./lazy": {
-      "types": "./dist/lazy.d.ts",
-      "import": "./dist/lazy.mjs",
-      "require": "./dist/lazy.cjs"
-    },
-    "./page": {
-      "types": "./dist/page.d.ts",
-      "import": "./dist/page.mjs",
-      "require": "./dist/page.cjs"
-    },
     "./request": {
       "types": "./dist/request.d.ts",
       "import": "./dist/request.mjs",
       "require": "./dist/request.cjs"
     },
+    "./shared": {
+      "types": "./dist/shared.d.ts",
+      "import": "./dist/shared.mjs",
+      "require": "./dist/shared.cjs"
+    },
+    "./time": {
+      "types": "./dist/time.d.ts",
+      "import": "./dist/time.mjs",
+      "require": "./dist/time.cjs"
+    },
     "./types": {
       "types": "./dist/types.d.ts",
       "import": "./dist/types.mjs",
@@ -61,15 +61,15 @@
       "event": [
         "./dist/event.d.ts"
       ],
-      "lazy": [
-        "./dist/lazy.d.ts"
-      ],
-      "page": [
-        "./dist/page.d.ts"
-      ],
       "request": [
         "./dist/request.d.ts"
       ],
+      "shared": [
+        "./dist/shared.d.ts"
+      ],
+      "time": [
+        "./dist/time.d.ts"
+      ],
       "types": [
         "./dist/types.d.ts"
       ]

package/dist/lazy.cjs

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const vue = require("vue");
-function useLazyValue(boolean, delay) {
-  const scope = vue.effectScope();
-  const lazyBoolean = vue.ref(boolean.value);
-  let changedAt = 0;
-  let t;
-  scope.run(() => {
-    vue.watch(boolean, (value) => {
-      const delayValue = vue.toValue(delay) || 100;
-      clearTimeout(t);
-      if (changedAt > 0 && Date.now() - changedAt > delayValue) {
-        lazyBoolean.value = value;
-      } else {
-        t = setTimeout(() => {
-          lazyBoolean.value = value;
-        }, delayValue);
-      }
-      changedAt = Date.now();
-    });
-  });
-  vue.onScopeDispose(() => {
-    clearTimeout(t);
-    scope.stop();
-  });
-  return vue.computed(() => {
-    return lazyBoolean.value;
-  });
-}
-exports.useLazyValue = useLazyValue;
-//# sourceMappingURL=lazy.cjs.map

package/dist/lazy.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"lazy.cjs","sources":["../src/lazy.ts"],"sourcesContent":["import { type Ref, computed, effectScope, onScopeDispose, ref, toValue, watch } from 'vue';\n\n/**\n * 创建一个延迟更新的响应式值\n *\n * 该函数创建一个基于原始响应式值的延迟更新值，当原始值发生变化时，\n * 延迟值会在指定的延迟时间后更新。如果在延迟期间原始值再次变化，\n * 则会重新计算延迟时间。\n *\n * @param boolean 原始响应式值，类型为Ref<T>\n * @param delay 延迟时间，可以是数字或响应式数字，默认为100毫秒\n * @returns 返回一个计算属性，其值会在延迟后更新为原始值\n */\nexport function useLazyValue<T>(boolean: Ref<T>, delay?: number | Ref<number>) {\n  const scope = effectScope();\n  const lazyBoolean = ref(boolean.value);\n  let changedAt = 0;\n  // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n  let t: any;\n\n  scope.run(() => {\n    watch(boolean, (value) => {\n      const delayValue = toValue(delay) || 100;\n      clearTimeout(t);\n\n      if (changedAt > 0 && Date.now() - changedAt > delayValue) {\n        lazyBoolean.value = value;\n      } else {\n        t = setTimeout(() => {\n          lazyBoolean.value = value;\n        }, delayValue);\n      }\n\n      changedAt = Date.now();\n    });\n  });\n\n  onScopeDispose(() => {\n    clearTimeout(t);\n    scope.stop();\n  });\n\n  return computed<T>(() => {\n    return lazyBoolean.value;\n  });\n}\n"],"names":["effectScope","ref","watch","toValue","onScopeDispose","computed"],"mappings":";;;AAagB,SAAA,aAAgB,SAAiB,OAA8B;AAC7E,QAAM,QAAQA,IAAAA,YAAY;AACpB,QAAA,cAAcC,IAAAA,IAAI,QAAQ,KAAK;AACrC,MAAI,YAAY;AAEZ,MAAA;AAEJ,QAAM,IAAI,MAAM;AACRC,cAAA,SAAS,CAAC,UAAU;AAClB,YAAA,aAAaC,IAAAA,QAAQ,KAAK,KAAK;AACrC,mBAAa,CAAC;AAEd,UAAI,YAAY,KAAK,KAAK,IAAI,IAAI,YAAY,YAAY;AACxD,oBAAY,QAAQ;AAAA,MAAA,OACf;AACL,YAAI,WAAW,MAAM;AACnB,sBAAY,QAAQ;AAAA,WACnB,UAAU;AAAA,MAAA;AAGf,kBAAY,KAAK,IAAI;AAAA,IAAA,CACtB;AAAA,EAAA,CACF;AAEDC,MAAAA,eAAe,MAAM;AACnB,iBAAa,CAAC;AACd,UAAM,KAAK;AAAA,EAAA,CACZ;AAED,SAAOC,aAAY,MAAM;AACvB,WAAO,YAAY;AAAA,EAAA,CACpB;AACH;;"}

package/dist/lazy.mjs

@@ -1,32 +0,0 @@
-import { effectScope, ref, watch, toValue, onScopeDispose, computed } from "vue";
-function useLazyValue(boolean, delay) {
-  const scope = effectScope();
-  const lazyBoolean = ref(boolean.value);
-  let changedAt = 0;
-  let t;
-  scope.run(() => {
-    watch(boolean, (value) => {
-      const delayValue = toValue(delay) || 100;
-      clearTimeout(t);
-      if (changedAt > 0 && Date.now() - changedAt > delayValue) {
-        lazyBoolean.value = value;
-      } else {
-        t = setTimeout(() => {
-          lazyBoolean.value = value;
-        }, delayValue);
-      }
-      changedAt = Date.now();
-    });
-  });
-  onScopeDispose(() => {
-    clearTimeout(t);
-    scope.stop();
-  });
-  return computed(() => {
-    return lazyBoolean.value;
-  });
-}
-export {
-  useLazyValue
-};
-//# sourceMappingURL=lazy.mjs.map

package/dist/lazy.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"lazy.mjs","sources":["../src/lazy.ts"],"sourcesContent":["import { type Ref, computed, effectScope, onScopeDispose, ref, toValue, watch } from 'vue';\n\n/**\n * 创建一个延迟更新的响应式值\n *\n * 该函数创建一个基于原始响应式值的延迟更新值，当原始值发生变化时，\n * 延迟值会在指定的延迟时间后更新。如果在延迟期间原始值再次变化，\n * 则会重新计算延迟时间。\n *\n * @param boolean 原始响应式值，类型为Ref<T>\n * @param delay 延迟时间，可以是数字或响应式数字，默认为100毫秒\n * @returns 返回一个计算属性，其值会在延迟后更新为原始值\n */\nexport function useLazyValue<T>(boolean: Ref<T>, delay?: number | Ref<number>) {\n  const scope = effectScope();\n  const lazyBoolean = ref(boolean.value);\n  let changedAt = 0;\n  // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n  let t: any;\n\n  scope.run(() => {\n    watch(boolean, (value) => {\n      const delayValue = toValue(delay) || 100;\n      clearTimeout(t);\n\n      if (changedAt > 0 && Date.now() - changedAt > delayValue) {\n        lazyBoolean.value = value;\n      } else {\n        t = setTimeout(() => {\n          lazyBoolean.value = value;\n        }, delayValue);\n      }\n\n      changedAt = Date.now();\n    });\n  });\n\n  onScopeDispose(() => {\n    clearTimeout(t);\n    scope.stop();\n  });\n\n  return computed<T>(() => {\n    return lazyBoolean.value;\n  });\n}\n"],"names":[],"mappings":";AAagB,SAAA,aAAgB,SAAiB,OAA8B;AAC7E,QAAM,QAAQ,YAAY;AACpB,QAAA,cAAc,IAAI,QAAQ,KAAK;AACrC,MAAI,YAAY;AAEZ,MAAA;AAEJ,QAAM,IAAI,MAAM;AACR,UAAA,SAAS,CAAC,UAAU;AAClB,YAAA,aAAa,QAAQ,KAAK,KAAK;AACrC,mBAAa,CAAC;AAEd,UAAI,YAAY,KAAK,KAAK,IAAI,IAAI,YAAY,YAAY;AACxD,oBAAY,QAAQ;AAAA,MAAA,OACf;AACL,YAAI,WAAW,MAAM;AACnB,sBAAY,QAAQ;AAAA,WACnB,UAAU;AAAA,MAAA;AAGf,kBAAY,KAAK,IAAI;AAAA,IAAA,CACtB;AAAA,EAAA,CACF;AAED,iBAAe,MAAM;AACnB,iBAAa,CAAC;AACd,UAAM,KAAK;AAAA,EAAA,CACZ;AAED,SAAO,SAAY,MAAM;AACvB,WAAO,YAAY;AAAA,EAAA,CACpB;AACH;"}

package/dist/page.cjs

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const vue = require("vue");
-function usePageMount(onBeforeMount) {
-  let un;
-  vue.onBeforeMount(async () => {
-    un = await onBeforeMount();
-  });
-  vue.onBeforeUnmount(() => {
-    un?.();
-  });
-}
-function usePageMounted(onMounted) {
-  let un;
-  vue.onMounted(async () => {
-    un = await onMounted();
-  });
-  vue.onUnmounted(() => {
-    un?.();
-  });
-}
-exports.usePageMount = usePageMount;
-exports.usePageMounted = usePageMounted;
-//# sourceMappingURL=page.cjs.map

package/dist/page.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"page.cjs","sources":["../src/page.ts"],"sourcesContent":["import type { MaybePromise } from '@cloudcome/utils-core/types';\nimport { onBeforeMount as onBeforeMountHook, onBeforeUnmount, onMounted as onMountedHook, onUnmounted } from 'vue';\n\nexport type HookListener = () => MaybePromise<unknown>;\nexport type HookListenerWithDispose = () => MaybePromise<undefined | HookListener>;\n\nexport function usePageMount(onBeforeMount: HookListenerWithDispose) {\n  let un: HookListener | undefined;\n\n  onBeforeMountHook(async () => {\n    un = await onBeforeMount();\n  });\n\n  onBeforeUnmount(() => {\n    un?.();\n  });\n}\n\nexport function usePageMounted(onMounted: HookListenerWithDispose) {\n  let un: HookListener | undefined;\n\n  onMountedHook(async () => {\n    un = await onMounted();\n  });\n\n  onUnmounted(() => {\n    un?.();\n  });\n}\n"],"names":["onBeforeMountHook","onBeforeUnmount","onMountedHook","onUnmounted"],"mappings":";;;AAMO,SAAS,aAAa,eAAwC;AAC/D,MAAA;AAEJA,MAAAA,cAAkB,YAAY;AAC5B,SAAK,MAAM,cAAc;AAAA,EAAA,CAC1B;AAEDC,MAAAA,gBAAgB,MAAM;AACf,SAAA;AAAA,EAAA,CACN;AACH;AAEO,SAAS,eAAe,WAAoC;AAC7D,MAAA;AAEJC,MAAAA,UAAc,YAAY;AACxB,SAAK,MAAM,UAAU;AAAA,EAAA,CACtB;AAEDC,MAAAA,YAAY,MAAM;AACX,SAAA;AAAA,EAAA,CACN;AACH;;;"}

package/dist/page.d.ts

@@ -1,5 +0,0 @@
-import { MaybePromise } from '@cloudcome/utils-core/types';
-export type HookListener = () => MaybePromise<unknown>;
-export type HookListenerWithDispose = () => MaybePromise<undefined | HookListener>;
-export declare function usePageMount(onBeforeMount: HookListenerWithDispose): void;
-export declare function usePageMounted(onMounted: HookListenerWithDispose): void;

package/dist/page.mjs

@@ -1,24 +0,0 @@
-import { onBeforeMount, onBeforeUnmount, onMounted, onUnmounted } from "vue";
-function usePageMount(onBeforeMount$1) {
-  let un;
-  onBeforeMount(async () => {
-    un = await onBeforeMount$1();
-  });
-  onBeforeUnmount(() => {
-    un?.();
-  });
-}
-function usePageMounted(onMounted$1) {
-  let un;
-  onMounted(async () => {
-    un = await onMounted$1();
-  });
-  onUnmounted(() => {
-    un?.();
-  });
-}
-export {
-  usePageMount,
-  usePageMounted
-};
-//# sourceMappingURL=page.mjs.map

package/dist/page.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"page.mjs","sources":["../src/page.ts"],"sourcesContent":["import type { MaybePromise } from '@cloudcome/utils-core/types';\nimport { onBeforeMount as onBeforeMountHook, onBeforeUnmount, onMounted as onMountedHook, onUnmounted } from 'vue';\n\nexport type HookListener = () => MaybePromise<unknown>;\nexport type HookListenerWithDispose = () => MaybePromise<undefined | HookListener>;\n\nexport function usePageMount(onBeforeMount: HookListenerWithDispose) {\n  let un: HookListener | undefined;\n\n  onBeforeMountHook(async () => {\n    un = await onBeforeMount();\n  });\n\n  onBeforeUnmount(() => {\n    un?.();\n  });\n}\n\nexport function usePageMounted(onMounted: HookListenerWithDispose) {\n  let un: HookListener | undefined;\n\n  onMountedHook(async () => {\n    un = await onMounted();\n  });\n\n  onUnmounted(() => {\n    un?.();\n  });\n}\n"],"names":["onBeforeMount","onBeforeMountHook","onMounted","onMountedHook"],"mappings":";AAMO,SAAS,aAAaA,iBAAwC;AAC/D,MAAA;AAEJC,gBAAkB,YAAY;AAC5B,SAAK,MAAMD,gBAAc;AAAA,EAAA,CAC1B;AAED,kBAAgB,MAAM;AACf,SAAA;AAAA,EAAA,CACN;AACH;AAEO,SAAS,eAAeE,aAAoC;AAC7D,MAAA;AAEJC,YAAc,YAAY;AACxB,SAAK,MAAMD,YAAU;AAAA,EAAA,CACtB;AAED,cAAY,MAAM;AACX,SAAA;AAAA,EAAA,CACN;AACH;"}