@cloudcome/utils-vue 1.13.1 → 1.13.3

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>(\n  initialValue: Ref<T>,\n  delay?: number | Ref<number>,\n) {\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(\n  callback: () => void,\n  delay?: number | Ref<number>,\n) {\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,aACd,cACA,OACA;CACA,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,YACd,UACA,OACA;CACA,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>(\n  initialValue: Ref<T>,\n  delay?: number | Ref<number>,\n) {\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(\n  callback: () => void,\n  delay?: number | Ref<number>,\n) {\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,aACd,cACA,OACA;CACA,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,YACd,UACA,OACA;CACA,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.1",
+  "version": "1.13.3",
   "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,48 +82,16 @@
       "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.0",
-    "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.0",
+    "vue": "^3.5.34",
+    "vue-component-type-helpers": "^3.2.8"
   },
   "keywords": [
     "utils",
@@ -110,5 +105,9 @@
   ],
   "homepage": "https://github.com/cloudcome/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;;;;"}

package/dist/life.mjs

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

@@ -1 +0,0 @@
-{"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/types.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/types.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}