@reactive-vscode/vueuse 0.4.1 → 1.0.0-beta.1

package/dist/index.js

@@ -1,8 +1,19 @@
-import { customRef, toValue, watch, effectScope, unref, computed, ref, shallowReadonly, isRef, readonly, toRefs as toRefs$1, reactive, toRef as toRef$1, getCurrentScope, onScopeDispose, shallowRef, nextTick, isReactive, watchEffect, isReadonly, markRaw } from "@reactive-vscode/reactivity";
-import { toRef, toValue as toValue2, toValue as toValue3 } from "@reactive-vscode/reactivity";
+import { customRef, toValue, shallowRef, watchEffect, readonly, watch, effectScope, unref, computed, ref, shallowReadonly, isRef, getCurrentScope, hasInjectionContext, inject, provide, toRefs as toRefs$1, reactive, toRef as toRef$1, onBeforeMount, nextTick, onBeforeUnmount, onScopeDispose, onUnmounted, isReactive, isReadonly, markRaw } from "@reactive-vscode/reactivity";
 function getCurrentInstance() {
   return null;
 }
+function computedEager(fn, options) {
+  var _options$flush;
+  const result = shallowRef();
+  watchEffect(() => {
+    result.value = fn();
+  }, {
+    ...options,
+    flush: (_options$flush = options === null || options === void 0 ? void 0 : options.flush) !== null && _options$flush !== void 0 ? _options$flush : "sync"
+  });
+  return readonly(result);
+}
+const eagerComputed = computedEager;
 function computedWithControl(source, fn, options = {}) {
   let v = void 0;
   let track;
@@ -38,6 +49,7 @@ function computedWithControl(source, fn, options = {}) {
   result.trigger = update;
   return result;
 }
+const controlledComputed = computedWithControl;
 function tryOnScopeDispose(fn, failSilently) {
   if (getCurrentScope()) {
     onScopeDispose(fn, failSilently);
@@ -83,6 +95,38 @@ function createGlobalState(stateFactory) {
     return state;
   });
 }
+const localProvidedStateMap = /* @__PURE__ */ new WeakMap();
+const injectLocal = /* @__NO_SIDE_EFFECTS__ */ (...args) => {
+  var _getCurrentInstance;
+  const key = args[0];
+  const instance = (_getCurrentInstance = getCurrentInstance()) === null || _getCurrentInstance === void 0 ? void 0 : _getCurrentInstance.proxy;
+  const owner = instance !== null && instance !== void 0 ? instance : getCurrentScope();
+  if (owner == null && !hasInjectionContext()) throw new Error("injectLocal must be called in setup");
+  if (owner && localProvidedStateMap.has(owner) && key in localProvidedStateMap.get(owner)) return localProvidedStateMap.get(owner)[key];
+  return inject(...args);
+};
+function provideLocal(key, value) {
+  var _getCurrentInstance;
+  const instance = (_getCurrentInstance = getCurrentInstance()) === null || _getCurrentInstance === void 0 ? void 0 : _getCurrentInstance.proxy;
+  const owner = instance !== null && instance !== void 0 ? instance : getCurrentScope();
+  if (owner == null) throw new Error("provideLocal must be called in setup");
+  if (!localProvidedStateMap.has(owner)) localProvidedStateMap.set(owner, /* @__PURE__ */ Object.create(null));
+  const localProvidedState = localProvidedStateMap.get(owner);
+  localProvidedState[key] = value;
+  return provide(key, value);
+}
+// @__NO_SIDE_EFFECTS__
+function createInjectionState(composable, options) {
+  const key = (options === null || options === void 0 ? void 0 : options.injectionKey) || Symbol(composable.name || "InjectionState");
+  const defaultValue = options === null || options === void 0 ? void 0 : options.defaultValue;
+  const useProvidingState = (...args) => {
+    const state = composable(...args);
+    provideLocal(key, state);
+    return state;
+  };
+  const useInjectedState = () => /* @__PURE__ */ injectLocal(key, defaultValue);
+  return [useProvidingState, useInjectedState];
+}
 // @__NO_SIDE_EFFECTS__
 function createRef(value, deep) {
   if (deep === true) return ref(value);
@@ -108,7 +152,7 @@ const rand = (min, max) => {
   return Math.floor(Math.random() * (max - min + 1)) + min;
 };
 const hasOwn = (val, key) => Object.prototype.hasOwnProperty.call(val, key);
-function toRef2(...args) {
+function toRef(...args) {
   if (args.length !== 1) return toRef$1(...args);
   const r = args[0];
   return typeof r === "function" ? readonly(customRef(() => ({
@@ -220,7 +264,7 @@ function throttleFilter(...args) {
 }
 function pausableFilter(extendFilter = bypassFilter, options = {}) {
   const { initialState = "active" } = options;
-  const isActive = toRef2(initialState === "active");
+  const isActive = toRef(initialState === "active");
   function pause() {
     isActive.value = false;
   }
@@ -274,6 +318,9 @@ function increaseWithUnit(target, delta) {
   if (Number.isNaN(result)) return target;
   return result + unit;
 }
+function pxValue(px) {
+  return px.endsWith("rem") ? Number.parseFloat(px) * 16 : Number.parseFloat(px);
+}
 function objectPick(obj, keys, omitUndefined = false) {
   return keys.reduce((n, k) => {
     if (k in obj) {
@@ -382,6 +429,7 @@ function reactify(fn, options) {
     return computed(() => fn.apply(this, args.map((i) => unrefFn(i))));
   };
 }
+const createReactiveFn = reactify;
 // @__NO_SIDE_EFFECTS__
 function reactifyObject(obj, optionsOrKeys = {}) {
   let keys = [];
@@ -437,7 +485,7 @@ function reactiveOmit(obj, ...keys) {
 function reactivePick(obj, ...keys) {
   const flatKeys = keys.flat();
   const predicate = flatKeys[0];
-  return reactiveComputed(() => typeof predicate === "function" ? Object.fromEntries(Object.entries(toRefs$1(obj)).filter(([k, v]) => predicate(toValue(v), k))) : Object.fromEntries(flatKeys.map((k) => [k, toRef2(obj, k)])));
+  return reactiveComputed(() => typeof predicate === "function" ? Object.fromEntries(Object.entries(toRefs$1(obj)).filter(([k, v]) => predicate(toValue(v), k))) : Object.fromEntries(flatKeys.map((k) => [k, toRef(obj, k)])));
 }
 function refAutoReset(defaultValue, afterMs = 1e4) {
   return customRef((track, trigger) => {
@@ -464,6 +512,7 @@ function refAutoReset(defaultValue, afterMs = 1e4) {
     };
   });
 }
+const autoResetRef = refAutoReset;
 // @__NO_SIDE_EFFECTS__
 function useDebounceFn(fn, ms = 200, options = {}) {
   return createFilterWrapper(debounceFilter(ms, options), fn);
@@ -476,6 +525,8 @@ function refDebounced(value, ms = 200, options = {}) {
   watch(value, () => updater());
   return shallowReadonly(debounced);
 }
+const debouncedRef = refDebounced;
+const useDebounce = refDebounced;
 // @__NO_SIDE_EFFECTS__
 function refDefault(source, defaultValue) {
   return computed({
@@ -488,6 +539,29 @@ function refDefault(source, defaultValue) {
     }
   });
 }
+function refManualReset(defaultValue) {
+  let value = toValue(defaultValue);
+  let trigger;
+  const reset = () => {
+    value = toValue(defaultValue);
+    trigger();
+  };
+  const refValue = customRef((track, _trigger) => {
+    trigger = _trigger;
+    return {
+      get() {
+        track();
+        return value;
+      },
+      set(newValue) {
+        value = newValue;
+        trigger();
+      }
+    };
+  });
+  refValue.reset = reset;
+  return refValue;
+}
 // @__NO_SIDE_EFFECTS__
 function useThrottleFn(fn, ms = 200, trailing = false, leading = true, rejectOnCancel = false) {
   return createFilterWrapper(throttleFilter(ms, trailing, leading, rejectOnCancel), fn);
@@ -501,6 +575,8 @@ function refThrottled(value, delay = 200, trailing = true, leading = true) {
   watch(value, () => updater());
   return throttled;
 }
+const throttledRef = refThrottled;
+const useThrottle = refThrottled;
 // @__NO_SIDE_EFFECTS__
 function refWithControl(initial, options = {}) {
   let source = initial;
@@ -636,11 +712,22 @@ function toRefs(objectRef, options = {}) {
   }));
   return result;
 }
+function tryOnBeforeMount(fn, sync = true, target) {
+  if (getLifeCycleTarget(target)) onBeforeMount(fn, target);
+  else if (sync) fn();
+  else nextTick(fn);
+}
+function tryOnBeforeUnmount(fn, target) {
+  if (getLifeCycleTarget(target)) onBeforeUnmount(fn, target);
+}
 function tryOnMounted(fn, sync = true, target) {
   if (getLifeCycleTarget(target)) ;
   else if (sync) fn();
   else nextTick(fn);
 }
+function tryOnUnmounted(fn, target) {
+  if (getLifeCycleTarget(target)) onUnmounted(fn, target);
+}
 function createUntil(r, isNot = false) {
   function toMatch(condition, { flush = "sync", deep = false, timeout, throwOnTimeout } = {}) {
     let stop = null;
@@ -1129,6 +1216,7 @@ function watchDebounced(source, cb, options = {}) {
     eventFilter: debounceFilter(debounce, { maxWait })
   });
 }
+const debouncedWatch = watchDebounced;
 function watchDeep(source, cb, options) {
   return watch(source, cb, {
     ...options,
@@ -1188,6 +1276,7 @@ function watchIgnorable(source, cb, options = {}) {
     ignorePrevAsyncUpdates
   };
 }
+const ignorableWatch = watchIgnorable;
 function watchImmediate(source, cb, options) {
   return watch(source, cb, {
     ...options,
@@ -1207,6 +1296,7 @@ function watchThrottled(source, cb, options = {}) {
     eventFilter: throttleFilter(throttle, trailing, leading)
   });
 }
+const throttledWatch = watchThrottled;
 function watchTriggerable(source, cb, options = {}) {
   let cleanupFn;
   function onEffect() {
@@ -1294,6 +1384,7 @@ function computedAsync(evaluationCallback, initialState, optionsOrRef) {
   });
   else return current;
 }
+const asyncComputed = computedAsync;
 // @__NO_SIDE_EFFECTS__
 function createUnrefFn(fn) {
   return function(...args) {
@@ -1307,11 +1398,6 @@ function unrefElement(elRef) {
   return (_$el = plain === null || plain === void 0 ? void 0 : plain.$el) !== null && _$el !== void 0 ? _$el : plain;
 }
 function useEventListener(...args) {
-  const cleanups = [];
-  const cleanup = () => {
-    cleanups.forEach((fn) => fn());
-    cleanups.length = 0;
-  };
   const register = (el, event, listener, options) => {
     el.addEventListener(event, listener, options);
     return () => el.removeEventListener(event, listener, options);
@@ -1320,7 +1406,7 @@ function useEventListener(...args) {
     const test = toArray(toValue(args[0])).filter((e) => e != null);
     return test.every((e) => typeof e !== "string") ? test : void 0;
   });
-  const stopWatch = watchImmediate(() => {
+  return watchImmediate(() => {
     var _firstParamTargets$va, _firstParamTargets$va2;
     return [
       (_firstParamTargets$va = (_firstParamTargets$va2 = firstParamTargets.value) === null || _firstParamTargets$va2 === void 0 ? void 0 : _firstParamTargets$va2.map((e) => unrefElement(e))) !== null && _firstParamTargets$va !== void 0 ? _firstParamTargets$va : [defaultWindow].filter((e) => e != null),
@@ -1328,18 +1414,14 @@ function useEventListener(...args) {
       toArray(unref(firstParamTargets.value ? args[2] : args[1])),
       toValue(firstParamTargets.value ? args[3] : args[2])
     ];
-  }, ([raw_targets, raw_events, raw_listeners, raw_options]) => {
-    cleanup();
+  }, ([raw_targets, raw_events, raw_listeners, raw_options], _, onCleanup) => {
     if (!(raw_targets === null || raw_targets === void 0 ? void 0 : raw_targets.length) || !(raw_events === null || raw_events === void 0 ? void 0 : raw_events.length) || !(raw_listeners === null || raw_listeners === void 0 ? void 0 : raw_listeners.length)) return;
     const optionsClone = isObject(raw_options) ? { ...raw_options } : raw_options;
-    cleanups.push(...raw_targets.flatMap((el) => raw_events.flatMap((event) => raw_listeners.map((listener) => register(el, event, listener, optionsClone)))));
+    const cleanups = raw_targets.flatMap((el) => raw_events.flatMap((event) => raw_listeners.map((listener) => register(el, event, listener, optionsClone))));
+    onCleanup(() => {
+      cleanups.forEach((fn) => fn());
+    });
   }, { flush: "post" });
-  const stop = () => {
-    stopWatch();
-    cleanup();
-  };
-  tryOnScopeDispose(cleanup);
-  return stop;
 }
 // @__NO_SIDE_EFFECTS__
 function useMounted() {
@@ -1454,6 +1536,7 @@ function useAsyncQueue(tasks, options) {
       }
       updateResult(promiseState.rejected, e);
       onError();
+      if (activeIndex.value === tasks.length - 1) onFinished();
       return e;
     });
   }, Promise.resolve());
@@ -1687,7 +1770,7 @@ function useCloned(source, options = {}) {
 }
 function useCycleList(list, options) {
   const state = shallowRef(getInitialValue());
-  const listRef = toRef2(list);
+  const listRef = toRef(list);
   const index = computed({
     get() {
       var _options$fallbackInde;
@@ -2115,8 +2198,8 @@ function useFetch(url, ...args) {
       finallyEvent.trigger(null);
     });
   };
-  const refetch = toRef2(options.refetch);
-  watch([refetch, toRef2(url)], ([refetch$1]) => refetch$1 && execute(), { deep: true });
+  const refetch = toRef(options.refetch);
+  watch([refetch, toRef(url)], ([refetch$1]) => refetch$1 && execute(), { deep: true });
   const shell = {
     isFinished: readonly(isFinished),
     isFetching: readonly(isFetching),
@@ -2150,7 +2233,7 @@ function useFetch(url, ...args) {
         config.method = method;
         config.payload = payload;
         config.payloadType = payloadType;
-        if (isRef(config.payload)) watch([refetch, toRef2(config.payload)], ([refetch$1]) => refetch$1 && execute(), { deep: true });
+        if (isRef(config.payload)) watch([refetch, toRef(config.payload)], ([refetch$1]) => refetch$1 && execute(), { deep: true });
         return {
           ...shell,
           then(onFulfilled, onRejected) {
@@ -2322,7 +2405,7 @@ function useOffsetPagination(options) {
 }
 function usePrevious(value, initialValue) {
   const previous = shallowRef(initialValue);
-  watch(toRef2(value), (_, oldValue) => {
+  watch(toRef(value), (_, oldValue) => {
     previous.value = oldValue;
   }, { flush: "sync" });
   return readonly(previous);
@@ -2646,7 +2729,7 @@ function useWebSocket(url, options = {}) {
   const data = ref(null);
   const status = shallowRef("CLOSED");
   const wsRef = ref();
-  const urlRef = toRef2(url);
+  const urlRef = toRef(url);
   let heartbeatPause;
   let heartbeatResume;
   let explicitlyClosed = false;
@@ -2709,7 +2792,8 @@ function useWebSocket(url, options = {}) {
         const { retries = -1, delay = 1e3, onFailed } = resolveNestedOptions(options.autoReconnect);
         if ((typeof retries === "function" ? retries : () => typeof retries === "number" && (retries < 0 || retried < retries))(retried)) {
           retried += 1;
-          retryTimeout = setTimeout(_init, delay);
+          const delayTime = typeof delay === "function" ? delay(retried) : delay;
+          retryTimeout = setTimeout(_init, delayTime);
         } else onFailed === null || onFailed === void 0 || onFailed();
       }
     };
@@ -2863,28 +2947,32 @@ function useWebWorkerFn(fn, options = {}) {
 }
 export {
   assert,
-  computedAsync as asyncComputed,
-  refAutoReset as autoResetRef,
+  asyncComputed,
+  autoResetRef,
   bypassFilter,
   camelize,
   clamp,
   cloneFnJSON,
   computedAsync,
+  computedEager,
   computedWithControl,
   containsProp,
-  computedWithControl as controlledComputed,
+  controlledComputed,
   controlledRef,
   createEventHook,
   createFetch,
   createFilterWrapper,
   createGlobalState,
-  reactify as createReactiveFn,
+  createInjectionState,
+  createReactiveFn,
+  createRef,
   createSharedComposable,
   createSingletonPromise,
   createUnrefFn,
   debounceFilter,
-  refDebounced as debouncedRef,
-  watchDebounced as debouncedWatch,
+  debouncedRef,
+  debouncedWatch,
+  eagerComputed,
   extendRef,
   formatDate,
   formatTimeAgo,
@@ -2893,8 +2981,9 @@ export {
   hasOwn,
   hyphenate,
   identity,
-  watchIgnorable as ignorableWatch,
+  ignorableWatch,
   increaseWithUnit,
+  injectLocal,
   invoke,
   isDef,
   isDefined,
@@ -2908,8 +2997,10 @@ export {
   objectOmit,
   objectPick,
   pausableFilter,
-  watchPausable as pausableWatch,
+  pausableWatch,
   promiseTimeout,
+  provideLocal,
+  pxValue,
   rand,
   reactify,
   reactifyObject,
@@ -2919,21 +3010,25 @@ export {
   refAutoReset,
   refDebounced,
   refDefault,
+  refManualReset,
   refThrottled,
   refWithControl,
-  toRef as resolveRef,
-  toValue2 as resolveUnref,
   set,
   syncRef,
   syncRefs,
   throttleFilter,
-  refThrottled as throttledRef,
-  watchThrottled as throttledWatch,
+  throttledRef,
+  throttledWatch,
+  timestamp,
+  toArray,
   toReactive,
-  toRef2 as toRef,
+  toRef,
   toRefs,
-  toValue3 as toValue,
+  tryOnBeforeMount,
+  tryOnBeforeUnmount,
+  tryOnMounted,
   tryOnScopeDispose,
+  tryOnUnmounted,
   until,
   useArrayDifference,
   useArrayEvery,
@@ -2956,7 +3051,7 @@ export {
   useCounter,
   useCycleList,
   useDateFormat,
-  refDebounced as useDebounce,
+  useDebounce,
   useDebounceFn,
   useDebouncedRefHistory,
   useEventBus,
@@ -2973,7 +3068,7 @@ export {
   useRefHistory,
   useSorted,
   useStepper,
-  refThrottled as useThrottle,
+  useThrottle,
   useThrottleFn,
   useThrottledRefHistory,
   useTimeAgo,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@reactive-vscode/vueuse",
   "type": "module",
-  "version": "0.4.1",
+  "version": "1.0.0-beta.1",
   "description": "Useful VueUse utilities for VSCode extension development",
   "author": "_Kerman <kermanx@qq.com>",
   "license": "MIT",
@@ -33,13 +33,13 @@
     "tsconfig.json"
   ],
   "dependencies": {
-    "@reactive-vscode/reactivity": "0.4.1"
+    "@reactive-vscode/reactivity": "1.0.0-beta.1"
   },
   "devDependencies": {
-    "@types/node": "^24.9.2",
-    "@vueuse/core": "^14.0.0",
+    "@types/node": "^25.0.3",
+    "@vueuse/core": "^14.1.0",
     "typescript": "^5.9.3",
-    "vite": "^7.1.12",
+    "vite": "^7.3.0",
     "vite-plugin-dts": "^4.5.4"
   },
   "scripts": {