@reactive-vscode/vueuse 0.2.8 → 0.2.10

package/dist/index.d.ts

@@ -1,10 +1,13 @@
 import { ComputedGetter } from '@reactive-vscode/reactivity';
 import { ComputedRef } from '@reactive-vscode/reactivity';
+import { MaybeRef } from '@reactive-vscode/reactivity';
+import { MaybeRefOrGetter } 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';
 import { ToRef } from '@reactive-vscode/reactivity';
 import { ToRefs } from '@reactive-vscode/reactivity';
+import { toValue as toValue_2 } from '@reactive-vscode/reactivity';
 import { UnwrapNestedRefs } from '@reactive-vscode/reactivity';
 import { UnwrapRef } from '@reactive-vscode/reactivity';
 import * as vue from '@reactive-vscode/reactivity';
@@ -18,6 +21,8 @@ import { WritableComputedRef } from '@reactive-vscode/reactivity';
 export declare interface AfterFetchContext<T = any> {
     response: Response;
     data: T | null;
+    context: BeforeFetchContext;
+    execute: (throwOnFailed?: boolean) => Promise<any>;
 }
 
 /**
@@ -347,6 +352,7 @@ export declare interface EventHook<T = any> {
     on: EventHookOn<T>;
     off: EventHookOff<T>;
     trigger: EventHookTrigger<T>;
+    clear: () => void;
 }
 
 export declare type EventHookOff<T = any> = (fn: Callback<T>) => void;
@@ -516,16 +522,6 @@ export declare type MapSources<T> = {
     [K in keyof T]: T[K] extends WatchSource<infer V> ? V : never;
 };
 
-/**
- * Maybe it's a ref, or a plain value.
- */
-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.
- */
-declare type MaybeRefOrGetter<T = any> = MaybeRef<T> | ComputedRef<T> | (() => T);
-
 export declare type MultiWatchSources = (WatchSource<unknown> | object)[];
 
 export declare type Mutable<T> = {
@@ -564,6 +560,9 @@ declare type OnCleanup = (cleanupFn: () => void) => void;
 export declare interface OnFetchErrorContext<T = any, E = any> {
     error: E;
     data: T | null;
+    response: Response | null;
+    context: BeforeFetchContext;
+    execute: (throwOnFailed?: boolean) => Promise<any>;
 }
 
 export declare interface Pausable {
@@ -739,7 +738,7 @@ export declare const resolveRef: typeof toRef;
 /**
  * @deprecated use `toValue` instead
  */
-export declare const resolveUnref: typeof toValue;
+export declare const resolveUnref: typeof toValue_2;
 
 export declare interface Serializer<T> {
     read: (raw: string) => T;
@@ -879,7 +878,7 @@ export declare interface ThrottleFilterOptions {
     rejectOnCancel?: boolean;
 }
 
-export declare interface ToDataURLOptions {
+export declare interface ToDataURLOptions extends UseBase64Options {
     /**
      * MIME type
      */
@@ -932,8 +931,10 @@ export declare interface ToRefsOptions {
 
 /**
  * Get the value of value/ref/getter.
+ *
+ * @deprecated use `toValue` from `vue` instead
  */
-export declare function toValue<T>(r: MaybeRefOrGetter<T>): T;
+export declare const toValue: typeof toValue_2;
 
 declare interface Transform<L, R> {
     ltr: (left: L) => R;
@@ -1020,9 +1021,19 @@ export declare interface UntilValueInstance<T, Not extends boolean = false> exte
 
 export declare type UrlParams = Record<string, string[] | string>;
 
-export declare function useArrayDifference<T>(list: MaybeRefOrGetter<T[]>, values: MaybeRefOrGetter<T[]>, key?: keyof T): ComputedRef<T[]>;
+export declare function useArrayDifference<T>(list: MaybeRefOrGetter<T[]>, values: MaybeRefOrGetter<T[]>, key?: keyof T, options?: UseArrayDifferenceOptions): ComputedRef<T[]>;
 
-export declare function useArrayDifference<T>(list: MaybeRefOrGetter<T[]>, values: MaybeRefOrGetter<T[]>, compareFn?: (value: T, othVal: T) => boolean): ComputedRef<T[]>;
+export declare function useArrayDifference<T>(list: MaybeRefOrGetter<T[]>, values: MaybeRefOrGetter<T[]>, compareFn?: (value: T, othVal: T) => boolean, options?: UseArrayDifferenceOptions): ComputedRef<T[]>;
+
+declare interface UseArrayDifferenceOptions {
+    /**
+     * Returns asymmetric difference
+     *
+     * @see https://en.wikipedia.org/wiki/Symmetric_difference
+     * @default false
+     */
+    symmetric?: boolean;
+}
 
 /**
  * Reactive `Array.every`
@@ -1223,7 +1234,7 @@ export declare type UseAsyncQueueTask<T> = (...args: any[]) => T | Promise<T>;
  * @param initialState    The initial state, used until the first evaluation finishes
  * @param options
  */
-export declare function useAsyncState<Data, Params extends any[] = [], Shallow extends boolean = true>(promise: Promise<Data> | ((...args: Params) => Promise<Data>), initialState: Data, options?: UseAsyncStateOptions<Shallow, Data>): UseAsyncStateReturn<Data, Params, Shallow>;
+export declare function useAsyncState<Data, Params extends any[] = any[], Shallow extends boolean = true>(promise: Promise<Data> | ((...args: Params) => Promise<Data>), initialState: Data, options?: UseAsyncStateOptions<Shallow, Data>): UseAsyncStateReturn<Data, Params, Shallow>;
 
 export declare interface UseAsyncStateOptions<Shallow extends boolean, D = any> {
     /**
@@ -1285,11 +1296,11 @@ export declare interface UseAsyncStateReturnBase<Data, Params extends any[], Sha
     execute: (delay?: number, ...args: Params) => Promise<Data>;
 }
 
-export declare function useBase64(target: MaybeRefOrGetter<string>): UseBase64Return;
+export declare function useBase64(target: MaybeRefOrGetter<string>, options?: UseBase64Options): UseBase64Return;
 
-export declare function useBase64(target: MaybeRefOrGetter<Blob>): UseBase64Return;
+export declare function useBase64(target: MaybeRefOrGetter<Blob>, options?: UseBase64Options): UseBase64Return;
 
-export declare function useBase64(target: MaybeRefOrGetter<ArrayBuffer>): UseBase64Return;
+export declare function useBase64(target: MaybeRefOrGetter<ArrayBuffer>, options?: UseBase64Options): UseBase64Return;
 
 export declare function useBase64(target: MaybeRefOrGetter<HTMLCanvasElement>, options?: ToDataURLOptions): UseBase64Return;
 
@@ -1303,8 +1314,17 @@ export declare function useBase64<T extends Set<unknown>>(target: MaybeRefOrGett
 
 export declare function useBase64<T>(target: MaybeRefOrGetter<T[]>, options?: UseBase64ObjectOptions<T[]>): UseBase64Return;
 
-export declare interface UseBase64ObjectOptions<T> {
-    serializer: (v: T) => string;
+export declare interface UseBase64ObjectOptions<T> extends UseBase64Options {
+    serializer?: (v: T) => string;
+}
+
+declare interface UseBase64Options {
+    /**
+     * Output as Data URL format
+     *
+     * @default true
+     */
+    dataUrl?: boolean;
 }
 
 export declare interface UseBase64Return {
@@ -1331,7 +1351,7 @@ export declare interface UseBroadcastChannelOptions extends ConfigurableWindow {
 }
 
 export declare interface UseBroadcastChannelReturn<D, P> {
-    isSupported: Ref<boolean>;
+    isSupported: ComputedRef<boolean>;
     channel: Ref<BroadcastChannel | undefined>;
     data: Ref<D>;
     post: (data: P) => void;
@@ -1399,6 +1419,10 @@ export declare interface UseClonedReturn<T> {
      * Cloned ref
      */
     cloned: Ref<T>;
+    /**
+     * Ref indicates whether the cloned data is modified
+     */
+    isModified: Ref<boolean>;
     /**
      * Sync cloned data with source manually
      */
@@ -1597,11 +1621,7 @@ export declare interface UseFetchOptions {
      * Will run immediately after the fetch request is returned.
      * Runs after any 4xx and 5xx response
      */
-    onFetchError?: (ctx: {
-        data: any;
-        response: Response | null;
-        error: any;
-    }) => Promise<Partial<OnFetchErrorContext>> | Partial<OnFetchErrorContext>;
+    onFetchError?: (ctx: OnFetchErrorContext) => Promise<Partial<OnFetchErrorContext>> | Partial<OnFetchErrorContext>;
 }
 
 export declare interface UseFetchReturn<T> {
@@ -1839,11 +1859,11 @@ export declare interface UseManualRefHistoryReturn<Raw, Serialized> {
     /**
      * A ref representing if undo is possible (non empty undoStack)
      */
-    canUndo: Ref<boolean>;
+    canUndo: ComputedRef<boolean>;
     /**
      * A ref representing if redo is possible (non empty redoStack)
      */
-    canRedo: Ref<boolean>;
+    canRedo: ComputedRef<boolean>;
     /**
      * Undo changes
      */
@@ -2135,7 +2155,7 @@ export declare interface UseStepperReturn<StepName, Steps, Step> {
 }
 
 declare function useTextareaAutosize(options?: UseTextareaAutosizeOptions): {
-    textarea: vue.Ref<HTMLTextAreaElement, HTMLTextAreaElement>;
+    textarea: vue.Ref<HTMLTextAreaElement | undefined, HTMLTextAreaElement | undefined>;
     input: vue.Ref<string, string>;
     triggerResize: () => void;
 };
@@ -2144,7 +2164,7 @@ export declare interface UseTextareaAutosizeOptions {
     /** Textarea element to autosize. */
     element?: MaybeRef<HTMLTextAreaElement | undefined>;
     /** Textarea content. */
-    input?: MaybeRef<string | undefined>;
+    input?: MaybeRef<string>;
     /** Watch sources that should trigger a textarea resize. */
     watch?: WatchSource | Array<WatchSource>;
     /** Function called when the textarea size changes. */
@@ -2283,7 +2303,7 @@ export declare interface UseTimeoutOptions<Controls extends boolean> extends Use
     callback?: Fn;
 }
 
-export declare function useTimeoutPoll(fn: () => Awaitable<void>, interval: MaybeRefOrGetter<number>, timeoutPollOptions?: UseTimeoutFnOptions): Pausable;
+export declare function useTimeoutPoll(fn: () => Awaitable<void>, interval: MaybeRefOrGetter<number>, options?: UseTimeoutFnOptions): Pausable;
 
 /**
  * Reactive current timestamp.
@@ -2348,9 +2368,11 @@ export declare interface UseToNumberOptions {
     /**
      * Method to use to convert the value to a number.
      *
+     * Or a custom function for the conversion.
+     *
      * @default 'parseFloat'
      */
-    method?: 'parseFloat' | 'parseInt';
+    method?: 'parseFloat' | 'parseInt' | ((value: string | number) => number);
     /**
      * The base in mathematical numeral systems passed to `parseInt`.
      * Only works with `method: 'parseInt'`
@@ -2399,6 +2421,13 @@ export declare interface UseUrlSearchParamsOptions<T> extends ConfigurableWindow
      * @default true
      */
     write?: boolean;
+    /**
+     * Write mode for `window.history` when `write` is enabled
+     * - `replace`: replace the current history entry
+     * - `push`: push a new history entry
+     * @default 'replace'
+     */
+    writeMode?: 'replace' | 'push';
 }
 
 /**
@@ -2425,11 +2454,11 @@ export declare interface UseWebSocketOptions {
          *
          * @default 'ping'
          */
-        message?: string | ArrayBuffer | Blob;
+        message?: MaybeRefOrGetter<WebSocketHeartbeatMessage>;
         /**
          * Response message for the heartbeat, if undefined the message will be used
          */
-        responseMessage?: string | ArrayBuffer | Blob;
+        responseMessage?: MaybeRefOrGetter<WebSocketHeartbeatMessage>;
         /**
          * Interval, in milliseconds
          *
@@ -2469,11 +2498,17 @@ export declare interface UseWebSocketOptions {
         onFailed?: Fn;
     };
     /**
-     * Automatically open a connection
+     * Immediately open the connection when calling this composable
      *
      * @default true
      */
     immediate?: boolean;
+    /**
+     * Automatically connect to the websocket when URL changes
+     *
+     * @default true
+     */
+    autoConnect?: boolean;
     /**
      * Automatically close a connection
      *
@@ -2672,6 +2707,8 @@ export declare function watchWithFilter<T extends object, Immediate extends Read
 declare interface WatchWithFilterOptions<Immediate> extends WatchOptions<Immediate>, ConfigurableEventFilter {
 }
 
+declare type WebSocketHeartbeatMessage = string | ArrayBuffer | Blob;
+
 export declare type WebSocketStatus = 'OPEN' | 'CONNECTING' | 'CLOSED';
 
 export declare type WebWorkerStatus = 'PENDING' | 'SUCCESS' | 'RUNNING' | 'ERROR' | 'TIMEOUT_EXPIRED';