@reactive-vscode/vueuse 0.2.4 → 0.2.5

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 import { ComputedGetter } from '@reactive-vscode/reactivity';
 import { ComputedRef } from '@reactive-vscode/reactivity';
-import { MaybeRef as MaybeRef_2 } from '@reactive-vscode/reactivity';
 import { Ref } from '@reactive-vscode/reactivity';
 import { ShallowRef } from '@reactive-vscode/reactivity';
 import { ShallowUnwrapRef as ShallowUnwrapRef_2 } from '@reactive-vscode/reactivity';
@@ -8,7 +7,7 @@ import { ToRef } from '@reactive-vscode/reactivity';
 import { ToRefs } from '@reactive-vscode/reactivity';
 import { UnwrapNestedRefs } from '@reactive-vscode/reactivity';
 import { UnwrapRef } from '@reactive-vscode/reactivity';
-import * as vue_demi from '@reactive-vscode/reactivity';
+import * as vue from '@reactive-vscode/reactivity';
 import { WatchCallback } from '@reactive-vscode/reactivity';
 import { WatchOptions } from '@reactive-vscode/reactivity';
 import { WatchSource } from '@reactive-vscode/reactivity';
@@ -87,6 +86,21 @@ export declare interface BeforeFetchContext {
     cancel: Fn;
 }
 
+declare interface BrowserLocationState {
+    readonly trigger: string;
+    readonly state?: any;
+    readonly length?: number;
+    readonly origin?: string;
+    hash?: string;
+    host?: string;
+    hostname?: string;
+    href?: string;
+    pathname?: string;
+    port?: string;
+    protocol?: string;
+    search?: string;
+}
+
 export declare const bypassFilter: EventFilter;
 
 /**
@@ -94,9 +108,9 @@ export declare const bypassFilter: EventFilter;
  * https://github.com/vuejs/vue-apollo/blob/v4/packages/vue-apollo-composable/src/util/useEventHook.ts
  */
 
-declare type Callback<T> = IsAny<T> extends true ? (param: any) => void : ([
+declare type Callback<T> = IsAny<T> extends true ? (...param: any) => void : ([
 T
-] extends [void] ? () => void : (param: T) => void);
+] extends [void] ? (...param: unknown[]) => void : (...param: [T, ...unknown[]]) => void);
 
 export declare const camelize: (str: string) => string;
 
@@ -116,7 +130,9 @@ declare type Combination = 'overwrite' | 'chain';
  * @param initialState           The initial state, used until the first evaluation finishes
  * @param optionsOrRef           Additional options or a ref passed to receive the updates of the async evaluation
  */
-declare function computedAsync<T>(evaluationCallback: (onCancel: AsyncComputedOnCancel) => T | Promise<T>, initialState?: T, optionsOrRef?: Ref<boolean> | AsyncComputedOptions): Ref<T>;
+declare function computedAsync<T>(evaluationCallback: (onCancel: AsyncComputedOnCancel) => T | Promise<T>, initialState: T, optionsOrRef?: Ref<boolean> | AsyncComputedOptions): Ref<T>;
+
+declare function computedAsync<T>(evaluationCallback: (onCancel: AsyncComputedOnCancel) => T | Promise<T>, initialState?: undefined, optionsOrRef?: Ref<boolean> | AsyncComputedOptions): Ref<T | undefined>;
 export { computedAsync as asyncComputed }
 export { computedAsync }
 
@@ -339,7 +355,7 @@ export declare type EventHookOn<T = any> = (fn: Callback<T>) => {
     off: () => void;
 };
 
-export declare type EventHookTrigger<T = any> = (param?: T) => Promise<unknown[]>;
+export declare type EventHookTrigger<T = any> = (...param: IsAny<T> extends true ? unknown[] : [T, ...unknown[]]) => Promise<unknown[]>;
 
 /**
  * Overload 1: Unwrap set to false
@@ -478,15 +494,15 @@ export declare type IsAny<T> = IfAny<T, true, false>;
 
 export declare const isDef: <T = any>(val?: T) => val is T;
 
-export declare function isDefined<T>(v: Ref<T>): v is Ref<Exclude<T, null | undefined>>;
-
 export declare function isDefined<T>(v: ComputedRef<T>): v is ComputedRef<Exclude<T, null | undefined>>;
 
+export declare function isDefined<T>(v: Ref<T>): v is Ref<Exclude<T, null | undefined>>;
+
 export declare function isDefined<T>(v: T): v is Exclude<T, null | undefined>;
 
 export declare const isObject: (val: any) => val is object;
 
-export declare function makeDestructurable<T extends Record<string, unknown>, const A extends readonly any[]>(obj: T, arr: A): T & A;
+export declare function makeDestructurable<T extends Record<string, unknown>, A extends readonly any[]>(obj: T, arr: A): T & A;
 
 export declare type MapOldSources<T, Immediate> = {
     [K in keyof T]: T[K] extends WatchSource<infer V> ? Immediate extends true ? V | undefined : V : never;
@@ -501,22 +517,14 @@ export declare type MapSources<T> = {
 };
 
 /**
- * Maybe it's a ref, or a plain value
- *
- * ```ts
- * type MaybeRef<T> = T | Ref<T>
- * ```
+ * Maybe it's a ref, or a plain value.
  */
-declare type MaybeRef<T> = T | Ref<T>;
+declare type MaybeRef<T = any> = T | Ref<T> | ShallowRef<T> | WritableComputedRef<T>;
 
 /**
- * Maybe it's a ref, or a plain value, or a getter function
- *
- * ```ts
- * type MaybeRefOrGetter<T> = (() => T) | T | Ref<T> | ComputedRef<T>
- * ```
+ * Maybe it's a ref, or a plain value, or a getter function.
  */
-declare type MaybeRefOrGetter<T> = MaybeRef<T> | (() => T);
+declare type MaybeRefOrGetter<T = any> = MaybeRef<T> | ComputedRef<T> | (() => T);
 
 export declare type MultiWatchSources = (WatchSource<unknown> | object)[];
 
@@ -539,7 +547,7 @@ export declare const notNullish: <T = any>(val?: T | null | undefined) => val is
 
 export declare const now: () => number;
 
-export declare function objectEntries<T extends object>(obj: T): [keyof T, T[keyof T]][];
+export declare function objectEntries<T extends object>(obj: T): Array<[keyof T, T[keyof T]]>;
 
 /**
  * Create a new subset object by omit giving keys
@@ -698,7 +706,7 @@ export declare function refDefault<T>(source: Ref<T | undefined | null>, default
  * @param [trailing] if true, update the value again after the delay time is up
  * @param [leading] if true, update the value on the leading edge of the ms timeout
  */
-declare function refThrottled<T>(value: Ref<T>, delay?: number, trailing?: boolean, leading?: boolean): Ref<T>;
+declare function refThrottled<T>(value: Ref<T>, delay?: number, trailing?: boolean, leading?: boolean): Ref<T, T>;
 export { refThrottled }
 export { refThrottled as throttledRef }
 export { refThrottled as useThrottle }
@@ -706,14 +714,14 @@ export { refThrottled as useThrottle }
 /**
  * Fine-grained controls over ref and its reactivity.
  */
-export declare function refWithControl<T>(initial: T, options?: ControlledRefOptions<T>): vue_demi.ShallowUnwrapRef<{
+export declare function refWithControl<T>(initial: T, options?: ControlledRefOptions<T>): vue.ShallowUnwrapRef<{
     get: (tracking?: boolean) => T;
     set: (value: T, triggering?: boolean) => void;
     untrackedGet: () => T;
     silentSet: (v: T) => void;
     peek: () => T;
     lay: (v: T) => void;
-}> & vue_demi.Ref<T>;
+}> & vue.Ref<T, T>;
 
 /**
  * A ref that allow to set null or undefined
@@ -823,7 +831,7 @@ export declare type SyncRefOptions<L, R, D extends Direction> = ConfigurableFlus
  * @param source source ref
  * @param targets
  */
-export declare function syncRefs<T>(source: WatchSource<T>, targets: Ref<T> | Ref<T>[], options?: SyncRefsOptions): vue_demi.WatchStopHandle;
+export declare function syncRefs<T>(source: WatchSource<T>, targets: Ref<T> | Ref<T>[], options?: SyncRefsOptions): vue.WatchHandle;
 
 export declare interface SyncRefsOptions extends ConfigurableFlushSync {
     /**
@@ -1036,7 +1044,9 @@ export declare function useArrayEvery<T>(list: MaybeRefOrGetter<MaybeRefOrGetter
  *
  * @returns a shallow copy of a portion of the given array, filtered down to just the elements from the given array that pass the test implemented by the provided function. If no elements pass the test, an empty array will be returned.
  */
-export declare function useArrayFilter<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: T[]) => boolean): ComputedRef<T[]>;
+export declare function useArrayFilter<T, S extends T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: T[]) => element is S): ComputedRef<S[]>;
+
+export declare function useArrayFilter<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: T[]) => unknown): ComputedRef<T[]>;
 
 /**
  * Reactive `Array.find`
@@ -1348,6 +1358,19 @@ declare function useBrowserLocation(options?: ConfigurableWindow): Ref<{
     port?: string | undefined;
     protocol?: string | undefined;
     search?: string | undefined;
+}, BrowserLocationState | {
+    readonly trigger: string;
+    readonly state?: any;
+    readonly length?: number | undefined;
+    readonly origin?: string | undefined;
+    hash?: string | undefined;
+    host?: string | undefined;
+    hostname?: string | undefined;
+    href?: string | undefined;
+    pathname?: string | undefined;
+    port?: string | undefined;
+    protocol?: string | undefined;
+    search?: string | undefined;
 }>;
 
 export declare type UseBrowserLocationReturn = ReturnType<typeof useBrowserLocation>;
@@ -1389,8 +1412,8 @@ export declare interface UseClonedReturn<T> {
  * @param [initialValue]
  * @param options
  */
-export declare function useCounter(initialValue?: MaybeRef_2<number>, options?: UseCounterOptions): {
-    count: vue_demi.Ref<number>;
+export declare function useCounter(initialValue?: MaybeRef<number>, options?: UseCounterOptions): {
+    count: vue.Ref<number, MaybeRef<number>>;
     inc: (delta?: number) => number;
     dec: (delta?: number) => number;
     get: () => number;
@@ -1445,7 +1468,7 @@ export declare interface UseCycleListReturn<T> {
  * @param formatStr - The combination of tokens to format the date
  * @param options - UseDateFormatOptions
  */
-export declare function useDateFormat(date: MaybeRefOrGetter<DateLike>, formatStr?: MaybeRefOrGetter<string>, options?: UseDateFormatOptions): vue_demi.ComputedRef<string>;
+export declare function useDateFormat(date: MaybeRefOrGetter<DateLike>, formatStr?: MaybeRefOrGetter<string>, options?: UseDateFormatOptions): vue.ComputedRef<string>;
 
 export declare interface UseDateFormatOptions {
     /**
@@ -1453,7 +1476,7 @@ export declare interface UseDateFormatOptions {
      *
      * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#locales_argument).
      */
-    locales?: Intl.LocalesArgument;
+    locales?: MaybeRefOrGetter<Intl.LocalesArgument>;
     /**
      * A custom function to re-modify the way to display meridiem
      *
@@ -1878,7 +1901,7 @@ export declare type UseNowReturn = ReturnType<typeof useNow>;
  * @see https://vueuse.org/useObjectUrl
  * @param object
  */
-export declare function useObjectUrl(object: MaybeRefOrGetter<Blob | MediaSource | null | undefined>): Readonly<vue_demi.Ref<string | undefined>>;
+export declare function useObjectUrl(object: MaybeRefOrGetter<Blob | MediaSource | null | undefined>): Readonly<vue.Ref<string | undefined, string | undefined>>;
 
 export declare function useOffsetPagination(options: Omit<UseOffsetPaginationOptions, 'total'>): UseOffsetPaginationInfinityPageReturn;
 
@@ -2022,7 +2045,7 @@ export declare interface UseRefHistoryReturn<Raw, Serialized> extends UseManualR
  * @param options
  */
 declare function useShare(shareOptions?: MaybeRefOrGetter<UseShareOptions>, options?: ConfigurableNavigator): {
-    isSupported: vue_demi.ComputedRef<boolean>;
+    isSupported: vue.ComputedRef<boolean>;
     share: (overrideOptions?: MaybeRefOrGetter<UseShareOptions>) => Promise<void>;
 };
 
@@ -2112,8 +2135,8 @@ export declare interface UseStepperReturn<StepName, Steps, Step> {
 }
 
 declare function useTextareaAutosize(options?: UseTextareaAutosizeOptions): {
-    textarea: vue_demi.Ref<HTMLTextAreaElement>;
-    input: vue_demi.Ref<string>;
+    textarea: vue.Ref<HTMLTextAreaElement, HTMLTextAreaElement>;
+    input: vue.Ref<string, string>;
     triggerResize: () => void;
 };
 
@@ -2127,7 +2150,7 @@ export declare interface UseTextareaAutosizeOptions {
     /** Function called when the textarea size changes. */
     onResize?: () => void;
     /** Specify style target to apply the height based on textarea content. If not provided it will use textarea it self.  */
-    styleTarget?: MaybeRef<HTMLElement>;
+    styleTarget?: MaybeRef<HTMLElement | undefined>;
     /** Specify the style property that will be used to manipulate height. Can be `height | minHeight`. Default value is `height`. */
     styleProp?: 'height' | 'minHeight';
 }
@@ -2403,6 +2426,10 @@ export declare interface UseWebSocketOptions {
          * @default 'ping'
          */
         message?: string | ArrayBuffer | Blob;
+        /**
+         * Response message for the heartbeat, if undefined the message will be used
+         */
+        responseMessage?: string | ArrayBuffer | Blob;
         /**
          * Interval, in milliseconds
          *
@@ -2503,7 +2530,7 @@ export declare interface UseWebSocketReturn<T> {
  */
 export declare function useWebWorkerFn<T extends (...fnArgs: any[]) => any>(fn: T, options?: UseWebWorkerOptions): {
     workerFn: (...fnArgs: Parameters<T>) => Promise<ReturnType<T>>;
-    workerStatus: vue_demi.Ref<WebWorkerStatus>;
+    workerStatus: vue.Ref<WebWorkerStatus, WebWorkerStatus>;
     workerTerminate: (status?: WebWorkerStatus) => void;
 };
 
@@ -2538,7 +2565,7 @@ export declare interface UseWebWorkerReturn<Data = any> {
  *
  * @see https://vueuse.org/watchArray
  */
-export declare function watchArray<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T[]> | T[], cb: WatchArrayCallback<T[], Immediate extends true ? T[] | undefined : T[]>, options?: WatchOptions<Immediate>): vue_demi.WatchStopHandle;
+export declare function watchArray<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T[]> | T[], cb: WatchArrayCallback<T[], Immediate extends true ? T[] | undefined : T[]>, options?: WatchOptions<Immediate>): vue.WatchHandle;
 
 export declare type WatchArrayCallback<V = any, OV = any> = (value: V, oldValue: OV, added: V, removed: OV, onCleanup: (cleanupFn: () => void) => void) => any;
 
@@ -2567,7 +2594,7 @@ export declare interface WatchDebouncedOptions<Immediate> extends WatchOptions<I
     debounce?: MaybeRefOrGetter<number>;
 }
 
-export declare function watchDeep<T extends Readonly<MultiWatchSources>, Immediate extends Readonly<boolean> = false>(source: T, cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: Omit<WatchOptions<Immediate>, 'deep'>): WatchStopHandle;
+export declare function watchDeep<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(source: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: Omit<WatchOptions<Immediate>, 'deep'>): WatchStopHandle;
 
 export declare function watchDeep<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: Omit<WatchOptions<Immediate>, 'deep'>): WatchStopHandle;
 
@@ -2587,7 +2614,7 @@ export declare interface WatchIgnorableReturn {
     stop: WatchStopHandle;
 }
 
-export declare function watchImmediate<T extends Readonly<MultiWatchSources>>(source: T, cb: WatchCallback<MapSources<T>, MapOldSources<T, true>>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchStopHandle;
+export declare function watchImmediate<T extends Readonly<WatchSource<unknown>[]>>(source: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, true>>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchStopHandle;
 
 export declare function watchImmediate<T>(source: WatchSource<T>, cb: WatchCallback<T, T | undefined>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchStopHandle;
 
@@ -2654,7 +2681,7 @@ export declare type WebWorkerStatus = 'PENDING' | 'SUCCESS' | 'RUNNING' | 'ERROR
  *
  * @see https://vueuse.org/whenever
  */
-export declare function whenever<T>(source: WatchSource<T | false | null | undefined>, cb: WatchCallback<T>, options?: WheneverOptions): vue_demi.WatchStopHandle;
+export declare function whenever<T>(source: WatchSource<T | false | null | undefined>, cb: WatchCallback<T>, options?: WheneverOptions): vue.WatchHandle;
 
 export declare interface WheneverOptions extends WatchOptions {
     /**

package/dist/index.js

@@ -17,7 +17,7 @@ function computedWithControl(source, fn) {
     return {
       get() {
         if (dirty.value) {
-          v = get2();
+          v = get2(v);
           dirty.value = false;
         }
         track();
@@ -87,7 +87,7 @@ function createSharedComposable(composable) {
   };
   return (...args) => {
     subscribers += 1;
-    if (!state) {
+    if (!scope) {
       scope = effectScope(true);
       state = scope.run(() => composable(...args));
     }
@@ -699,7 +699,10 @@ function createUntil(r, isNot = false) {
         r,
         (v) => {
           if (condition(v) !== isNot) {
-            stop == null ? void 0 : stop();
+            if (stop)
+              stop();
+            else
+              nextTick(() => stop == null ? void 0 : stop());
             resolve(v);
           }
         },
@@ -728,7 +731,10 @@ function createUntil(r, isNot = false) {
         [r, value],
         ([v1, v2]) => {
           if (isNot !== (v1 === v2)) {
-            stop == null ? void 0 : stop();
+            if (stop)
+              stop();
+            else
+              nextTick(() => stop == null ? void 0 : stop());
             resolve(v1);
           }
         },
@@ -955,8 +961,8 @@ function formatDate(date, formatStr, options = {}) {
     M: () => month + 1,
     Mo: () => formatOrdinal(month + 1),
     MM: () => `${month + 1}`.padStart(2, "0"),
-    MMM: () => date.toLocaleDateString(options.locales, { month: "short" }),
-    MMMM: () => date.toLocaleDateString(options.locales, { month: "long" }),
+    MMM: () => date.toLocaleDateString(toValue(options.locales), { month: "short" }),
+    MMMM: () => date.toLocaleDateString(toValue(options.locales), { month: "long" }),
     D: () => String(days),
     Do: () => formatOrdinal(days),
     DD: () => `${days}`.padStart(2, "0"),
@@ -974,9 +980,9 @@ function formatDate(date, formatStr, options = {}) {
     ss: () => `${seconds}`.padStart(2, "0"),
     SSS: () => `${milliseconds}`.padStart(3, "0"),
     d: () => day,
-    dd: () => date.toLocaleDateString(options.locales, { weekday: "narrow" }),
-    ddd: () => date.toLocaleDateString(options.locales, { weekday: "short" }),
-    dddd: () => date.toLocaleDateString(options.locales, { weekday: "long" }),
+    dd: () => date.toLocaleDateString(toValue(options.locales), { weekday: "narrow" }),
+    ddd: () => date.toLocaleDateString(toValue(options.locales), { weekday: "short" }),
+    dddd: () => date.toLocaleDateString(toValue(options.locales), { weekday: "long" }),
     A: () => meridiem(hours, minutes),
     AA: () => meridiem(hours, minutes, false, true),
     a: () => meridiem(hours, minutes, true),
@@ -1473,12 +1479,12 @@ function createUnrefFn(fn) {
     return fn.apply(this, args.map((i) => toValue(i)));
   };
 }
+const defaultWindow = isClient ? window : void 0;
 function unrefElement(elRef) {
   var _a;
   const plain = toValue(elRef);
   return (_a = plain == null ? void 0 : plain.$el) != null ? _a : plain;
 }
-const defaultWindow = isClient ? window : void 0;
 function useEventListener(...args) {
   let target;
   let events2;
@@ -1626,7 +1632,8 @@ function useAsyncQueue(tasks, options) {
       }
       const done = curr(prevRes).then((currentRes) => {
         updateResult(promiseState.fulfilled, currentRes);
-        activeIndex.value === tasks.length - 1 && onFinished();
+        if (activeIndex.value === tasks.length - 1)
+          onFinished();
         return currentRes;
       });
       if (!signal)
@@ -3014,6 +3021,7 @@ function useWebSocket(url, options = {}) {
     status.value = "CONNECTING";
     ws.onopen = () => {
       status.value = "OPEN";
+      retried = 0;
       onConnected == null ? void 0 : onConnected(ws);
       heartbeatResume == null ? void 0 : heartbeatResume();
       _sendBuffer();
@@ -3021,19 +3029,20 @@ function useWebSocket(url, options = {}) {
     ws.onclose = (ev) => {
       status.value = "CLOSED";
       onDisconnected == null ? void 0 : onDisconnected(ws, ev);
-      if (!explicitlyClosed && options.autoReconnect) {
+      if (!explicitlyClosed && options.autoReconnect && ws === wsRef.value) {
         const {
           retries = -1,
           delay = 1e3,
           onFailed
         } = resolveNestedOptions(options.autoReconnect);
-        retried += 1;
-        if (typeof retries === "number" && (retries < 0 || retried < retries))
+        if (typeof retries === "number" && (retries < 0 || retried < retries)) {
+          retried += 1;
           setTimeout(_init, delay);
-        else if (typeof retries === "function" && retries())
+        } else if (typeof retries === "function" && retries()) {
           setTimeout(_init, delay);
-        else
+        } else {
           onFailed == null ? void 0 : onFailed();
+        }
       }
     };
     ws.onerror = (e) => {
@@ -3043,9 +3052,10 @@ function useWebSocket(url, options = {}) {
       if (options.heartbeat) {
         resetHeartbeat();
         const {
-          message = DEFAULT_PING_MESSAGE
+          message = DEFAULT_PING_MESSAGE,
+          responseMessage = message
         } = resolveNestedOptions(options.heartbeat);
-        if (e.data === message)
+        if (e.data === responseMessage)
           return;
       }
       data.value = e.data;
@@ -3099,16 +3109,6 @@ function useWebSocket(url, options = {}) {
     ws: wsRef
   };
 }
-function jobRunner(userFunc) {
-  return (e) => {
-    const userFuncArgs = e.data[0];
-    return Promise.resolve(userFunc.apply(void 0, userFuncArgs)).then((result) => {
-      postMessage(["SUCCESS", result]);
-    }).catch((error) => {
-      postMessage(["ERROR", error]);
-    });
-  };
-}
 function depsParser(deps, localDeps) {
   if (deps.length === 0 && localDeps.length === 0)
     return "";
@@ -3125,6 +3125,16 @@ function depsParser(deps, localDeps) {
   const importString = `importScripts(${depsString});`;
   return `${depsString.trim() === "" ? "" : importString} ${depsFunctionString}`;
 }
+function jobRunner(userFunc) {
+  return (e) => {
+    const userFuncArgs = e.data[0];
+    return Promise.resolve(userFunc.apply(void 0, userFuncArgs)).then((result) => {
+      postMessage(["SUCCESS", result]);
+    }).catch((error) => {
+      postMessage(["ERROR", error]);
+    });
+  };
+}
 function createWorkerBlobUrl(fn, deps, localDeps) {
   const blobCode = `${depsParser(deps, localDeps)}; onmessage=(${jobRunner})(${fn})`;
   const blob = new Blob([blobCode], { type: "text/javascript" });
@@ -3190,11 +3200,12 @@ function useWebWorkerFn(fn, options = {}) {
     return newWorker;
   };
   const callWorker = (...fnArgs) => new Promise((resolve, reject) => {
+    var _a;
     promise.value = {
       resolve,
       reject
     };
-    worker.value && worker.value.postMessage([[...fnArgs]]);
+    (_a = worker.value) == null ? void 0 : _a.postMessage([[...fnArgs]]);
     workerStatus.value = "RUNNING";
   });
   const workerFn = (...fnArgs) => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@reactive-vscode/vueuse",
   "type": "module",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "description": "Useful VueUse utilities for VSCode extension development",
   "author": "_Kerman <kermanx@qq.com>",
   "license": "MIT",
@@ -32,14 +32,14 @@
     "tsconfig.json"
   ],
   "dependencies": {
-    "@reactive-vscode/reactivity": "0.2.4"
+    "@reactive-vscode/reactivity": "0.2.5"
   },
   "devDependencies": {
-    "@types/node": "^20.14.2",
-    "@vueuse/core": "^10.10.0",
-    "typescript": "^5.4.5",
-    "vite": "^5.2.12",
-    "vite-plugin-dts": "^3.9.1"
+    "@types/node": "^20.16.10",
+    "@vueuse/core": "^11.1.0",
+    "typescript": "^5.6.2",
+    "vite": "^5.4.8",
+    "vite-plugin-dts": "^4.2.1"
   },
   "scripts": {
     "typecheck": "tsc --noEmit",