@vueuse/integrations 10.2.1 → 10.3.0

package/useFuse.d.mts

@@ -0,0 +1,25 @@
+import * as vue_demi from 'vue-demi';
+import { ComputedRef } from 'vue-demi';
+import Fuse from 'fuse.js';
+import { MaybeRefOrGetter } from '@vueuse/shared';
+
+type FuseOptions<T> = Fuse.IFuseOptions<T>;
+interface UseFuseOptions<T> {
+    fuseOptions?: FuseOptions<T>;
+    resultLimit?: number;
+    matchAllWhenSearchEmpty?: boolean;
+}
+declare function useFuse<DataItem>(search: MaybeRefOrGetter<string>, data: MaybeRefOrGetter<DataItem[]>, options?: MaybeRefOrGetter<UseFuseOptions<DataItem>>): {
+    fuse: vue_demi.Ref<{
+        search: <R = DataItem>(pattern: string | Fuse.Expression, options?: Fuse.FuseSearchOptions | undefined) => Fuse.FuseResult<R>[];
+        setCollection: (docs: readonly DataItem[], index?: Fuse.FuseIndex<DataItem> | undefined) => void;
+        add: (doc: DataItem) => void;
+        remove: (predicate: (doc: DataItem, idx: number) => boolean) => DataItem[];
+        removeAt: (idx: number) => void;
+        getIndex: () => Fuse.FuseIndex<DataItem>;
+    }>;
+    results: ComputedRef<Fuse.FuseResult<DataItem>[]>;
+};
+type UseFuseReturn = ReturnType<typeof useFuse>;
+
+export { FuseOptions, UseFuseOptions, UseFuseReturn, useFuse };

package/useIDBKeyval.d.cts

@@ -0,0 +1,41 @@
+import { ConfigurableFlush, MaybeRefOrGetter, RemovableRef } from '@vueuse/shared';
+import { Ref } from 'vue-demi';
+
+interface UseIDBOptions extends ConfigurableFlush {
+    /**
+     * Watch for deep changes
+     *
+     * @default true
+     */
+    deep?: boolean;
+    /**
+     * On error callback
+     *
+     * Default log error to `console.error`
+     */
+    onError?: (error: unknown) => void;
+    /**
+     * Use shallow ref as reference
+     *
+     * @default false
+     */
+    shallow?: boolean;
+    /**
+     * Write the default value to the storage when it does not exist
+     *
+     * @default true
+     */
+    writeDefaults?: boolean;
+}
+/**
+ *
+ * @param key
+ * @param initialValue
+ * @param options
+ */
+declare function useIDBKeyval<T>(key: IDBValidKey, initialValue: MaybeRefOrGetter<T>, options?: UseIDBOptions): {
+    data: RemovableRef<T>;
+    isFinished: Ref<boolean>;
+};
+
+export { UseIDBOptions, useIDBKeyval };

package/useIDBKeyval.d.mts

@@ -0,0 +1,41 @@
+import { ConfigurableFlush, MaybeRefOrGetter, RemovableRef } from '@vueuse/shared';
+import { Ref } from 'vue-demi';
+
+interface UseIDBOptions extends ConfigurableFlush {
+    /**
+     * Watch for deep changes
+     *
+     * @default true
+     */
+    deep?: boolean;
+    /**
+     * On error callback
+     *
+     * Default log error to `console.error`
+     */
+    onError?: (error: unknown) => void;
+    /**
+     * Use shallow ref as reference
+     *
+     * @default false
+     */
+    shallow?: boolean;
+    /**
+     * Write the default value to the storage when it does not exist
+     *
+     * @default true
+     */
+    writeDefaults?: boolean;
+}
+/**
+ *
+ * @param key
+ * @param initialValue
+ * @param options
+ */
+declare function useIDBKeyval<T>(key: IDBValidKey, initialValue: MaybeRefOrGetter<T>, options?: UseIDBOptions): {
+    data: RemovableRef<T>;
+    isFinished: Ref<boolean>;
+};
+
+export { UseIDBOptions, useIDBKeyval };

package/useJwt.d.cts

@@ -0,0 +1,29 @@
+import { ComputedRef } from 'vue-demi';
+import { MaybeRefOrGetter } from '@vueuse/shared';
+import { JwtPayload, JwtHeader } from 'jwt-decode';
+
+interface UseJwtOptions<Fallback> {
+    /**
+     * Value returned when encounter error on decoding
+     *
+     * @default null
+     */
+    fallbackValue?: Fallback;
+    /**
+     * Error callback for decoding
+     */
+    onError?: (error: unknown) => void;
+}
+interface UseJwtReturn<Payload, Header, Fallback> {
+    header: ComputedRef<Header | Fallback>;
+    payload: ComputedRef<Payload | Fallback>;
+}
+/**
+ * Reactive decoded jwt token.
+ *
+ * @see https://vueuse.org/useJwt
+ * @param jwt
+ */
+declare function useJwt<Payload extends object = JwtPayload, Header extends object = JwtHeader, Fallback = null>(encodedJwt: MaybeRefOrGetter<string>, options?: UseJwtOptions<Fallback>): UseJwtReturn<Payload, Header, Fallback>;
+
+export { UseJwtOptions, UseJwtReturn, useJwt };

package/useJwt.d.mts

@@ -0,0 +1,29 @@
+import { ComputedRef } from 'vue-demi';
+import { MaybeRefOrGetter } from '@vueuse/shared';
+import { JwtPayload, JwtHeader } from 'jwt-decode';
+
+interface UseJwtOptions<Fallback> {
+    /**
+     * Value returned when encounter error on decoding
+     *
+     * @default null
+     */
+    fallbackValue?: Fallback;
+    /**
+     * Error callback for decoding
+     */
+    onError?: (error: unknown) => void;
+}
+interface UseJwtReturn<Payload, Header, Fallback> {
+    header: ComputedRef<Header | Fallback>;
+    payload: ComputedRef<Payload | Fallback>;
+}
+/**
+ * Reactive decoded jwt token.
+ *
+ * @see https://vueuse.org/useJwt
+ * @param jwt
+ */
+declare function useJwt<Payload extends object = JwtPayload, Header extends object = JwtHeader, Fallback = null>(encodedJwt: MaybeRefOrGetter<string>, options?: UseJwtOptions<Fallback>): UseJwtReturn<Payload, Header, Fallback>;
+
+export { UseJwtOptions, UseJwtReturn, useJwt };

package/useNProgress.d.cts

@@ -0,0 +1,20 @@
+import * as vue_demi from 'vue-demi';
+import nprogress, { NProgressOptions } from 'nprogress';
+import { MaybeRefOrGetter } from '@vueuse/shared';
+
+type UseNProgressOptions = Partial<NProgressOptions>;
+/**
+ * Reactive progress bar.
+ *
+ * @see https://vueuse.org/useNProgress
+ */
+declare function useNProgress(currentProgress?: MaybeRefOrGetter<number | null | undefined>, options?: UseNProgressOptions): {
+    isLoading: vue_demi.WritableComputedRef<boolean>;
+    progress: vue_demi.Ref<number | (() => number | null | undefined) | null | undefined>;
+    start: () => nprogress.NProgress;
+    done: (force?: boolean | undefined) => nprogress.NProgress;
+    remove: () => void;
+};
+type UseNProgressReturn = ReturnType<typeof useNProgress>;
+
+export { UseNProgressOptions, UseNProgressReturn, useNProgress };

package/useNProgress.d.mts

@@ -0,0 +1,20 @@
+import * as vue_demi from 'vue-demi';
+import nprogress, { NProgressOptions } from 'nprogress';
+import { MaybeRefOrGetter } from '@vueuse/shared';
+
+type UseNProgressOptions = Partial<NProgressOptions>;
+/**
+ * Reactive progress bar.
+ *
+ * @see https://vueuse.org/useNProgress
+ */
+declare function useNProgress(currentProgress?: MaybeRefOrGetter<number | null | undefined>, options?: UseNProgressOptions): {
+    isLoading: vue_demi.WritableComputedRef<boolean>;
+    progress: vue_demi.Ref<number | (() => number | null | undefined) | null | undefined>;
+    start: () => nprogress.NProgress;
+    done: (force?: boolean | undefined) => nprogress.NProgress;
+    remove: () => void;
+};
+type UseNProgressReturn = ReturnType<typeof useNProgress>;
+
+export { UseNProgressOptions, UseNProgressReturn, useNProgress };

package/useQRCode.d.cts

@@ -0,0 +1,14 @@
+import * as vue_demi from 'vue-demi';
+import { MaybeRefOrGetter } from '@vueuse/shared';
+import QRCode from 'qrcode';
+
+/**
+ * Wrapper for qrcode.
+ *
+ * @see https://vueuse.org/useQRCode
+ * @param text
+ * @param options
+ */
+declare function useQRCode(text: MaybeRefOrGetter<string>, options?: QRCode.QRCodeToDataURLOptions): vue_demi.Ref<string>;
+
+export { useQRCode };

package/useQRCode.d.mts

@@ -0,0 +1,14 @@
+import * as vue_demi from 'vue-demi';
+import { MaybeRefOrGetter } from '@vueuse/shared';
+import QRCode from 'qrcode';
+
+/**
+ * Wrapper for qrcode.
+ *
+ * @see https://vueuse.org/useQRCode
+ * @param text
+ * @param options
+ */
+declare function useQRCode(text: MaybeRefOrGetter<string>, options?: QRCode.QRCodeToDataURLOptions): vue_demi.Ref<string>;
+
+export { useQRCode };

package/useSortable/component.d.cts

@@ -0,0 +1,40 @@
+import * as vue_demi from 'vue-demi';
+import { PropType } from 'vue-demi';
+import { ConfigurableDocument } from '@vueuse/core';
+import { Options } from 'sortablejs';
+
+type UseSortableOptions = Options & ConfigurableDocument;
+
+declare const UseSortable: vue_demi.DefineComponent<{
+    modelValue: {
+        type: PropType<any[]>;
+        required: true;
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    options: {
+        type: PropType<UseSortableOptions>;
+        required: true;
+    };
+}, () => vue_demi.VNode<vue_demi.RendererNode, vue_demi.RendererElement, {
+    [key: string]: any;
+}> | undefined, unknown, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.VNodeProps & vue_demi.AllowedComponentProps & vue_demi.ComponentCustomProps, Readonly<vue_demi.ExtractPropTypes<{
+    modelValue: {
+        type: PropType<any[]>;
+        required: true;
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    options: {
+        type: PropType<UseSortableOptions>;
+        required: true;
+    };
+}>>, {
+    tag: string;
+}, {}>;
+
+export { UseSortable };

package/useSortable/component.d.mts

@@ -0,0 +1,40 @@
+import * as vue_demi from 'vue-demi';
+import { PropType } from 'vue-demi';
+import { ConfigurableDocument } from '@vueuse/core';
+import { Options } from 'sortablejs';
+
+type UseSortableOptions = Options & ConfigurableDocument;
+
+declare const UseSortable: vue_demi.DefineComponent<{
+    modelValue: {
+        type: PropType<any[]>;
+        required: true;
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    options: {
+        type: PropType<UseSortableOptions>;
+        required: true;
+    };
+}, () => vue_demi.VNode<vue_demi.RendererNode, vue_demi.RendererElement, {
+    [key: string]: any;
+}> | undefined, unknown, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.VNodeProps & vue_demi.AllowedComponentProps & vue_demi.ComponentCustomProps, Readonly<vue_demi.ExtractPropTypes<{
+    modelValue: {
+        type: PropType<any[]>;
+        required: true;
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    options: {
+        type: PropType<UseSortableOptions>;
+        required: true;
+    };
+}>>, {
+    tag: string;
+}, {}>;
+
+export { UseSortable };

package/useSortable.d.cts

@@ -0,0 +1,26 @@
+import { ConfigurableDocument, MaybeRefOrGetter } from '@vueuse/core';
+import Sortable, { Options } from 'sortablejs';
+
+interface UseSortableReturn {
+    /**
+     * start sortable instance
+     */
+    start: () => void;
+    /**
+     * destroy sortable instance
+     */
+    stop: () => void;
+    /**
+     * Options getter/setter
+     * @param name a Sortable.Options property.
+     * @param value a value.
+     */
+    option<K extends keyof Sortable.Options>(name: K, value: Sortable.Options[K]): void;
+    option<K extends keyof Sortable.Options>(name: K): Sortable.Options[K];
+}
+type UseSortableOptions = Options & ConfigurableDocument;
+declare function useSortable<T>(selector: string, list: MaybeRefOrGetter<T[]>, options?: UseSortableOptions): UseSortableReturn;
+declare function useSortable<T>(el: MaybeRefOrGetter<HTMLElement | null | undefined>, list: MaybeRefOrGetter<T[]>, options?: UseSortableOptions): UseSortableReturn;
+declare function moveArrayElement<T>(list: MaybeRefOrGetter<T[]>, from: number, to: number): void;
+
+export { UseSortableOptions, UseSortableReturn, moveArrayElement, useSortable };

package/useSortable.d.mts

@@ -0,0 +1,26 @@
+import { ConfigurableDocument, MaybeRefOrGetter } from '@vueuse/core';
+import Sortable, { Options } from 'sortablejs';
+
+interface UseSortableReturn {
+    /**
+     * start sortable instance
+     */
+    start: () => void;
+    /**
+     * destroy sortable instance
+     */
+    stop: () => void;
+    /**
+     * Options getter/setter
+     * @param name a Sortable.Options property.
+     * @param value a value.
+     */
+    option<K extends keyof Sortable.Options>(name: K, value: Sortable.Options[K]): void;
+    option<K extends keyof Sortable.Options>(name: K): Sortable.Options[K];
+}
+type UseSortableOptions = Options & ConfigurableDocument;
+declare function useSortable<T>(selector: string, list: MaybeRefOrGetter<T[]>, options?: UseSortableOptions): UseSortableReturn;
+declare function useSortable<T>(el: MaybeRefOrGetter<HTMLElement | null | undefined>, list: MaybeRefOrGetter<T[]>, options?: UseSortableOptions): UseSortableReturn;
+declare function moveArrayElement<T>(list: MaybeRefOrGetter<T[]>, from: number, to: number): void;
+
+export { UseSortableOptions, UseSortableReturn, moveArrayElement, useSortable };