@vueuse/integrations 12.8.1 → 13.0.0-beta.1

package/useCookies.d.ts

@@ -1,54 +0,0 @@
-import * as universal_cookie from 'universal-cookie';
-import universal_cookie__default from 'universal-cookie';
-import { IncomingMessage } from 'node:http';
-
-/**
- * Creates a new {@link useCookies} function
- * @param req - incoming http request (for SSR)
- * @see https://github.com/reactivestack/cookies/tree/master/packages/universal-cookie universal-cookie
- * @description Creates universal-cookie instance using request (default is window.document.cookie) and returns {@link useCookies} function with provided universal-cookie instance
- */
-declare function createCookies(req?: IncomingMessage): (dependencies?: string[] | null, { doNotParse, autoUpdateDependencies }?: {
-    doNotParse?: boolean | undefined;
-    autoUpdateDependencies?: boolean | undefined;
-}) => {
-    /**
-     * Reactive get cookie by name. If **autoUpdateDependencies = true** then it will update watching dependencies
-     */
-    get: <T = any>(name: string, options?: universal_cookie.CookieGetOptions | undefined) => T;
-    /**
-     * Reactive get all cookies
-     */
-    getAll: <T = any>(options?: universal_cookie.CookieGetOptions | undefined) => T;
-    set: (name: string, value: any, options?: universal_cookie.CookieSetOptions | undefined) => void;
-    remove: (name: string, options?: universal_cookie.CookieSetOptions | undefined) => void;
-    addChangeListener: (callback: universal_cookie.CookieChangeListener) => void;
-    removeChangeListener: (callback: universal_cookie.CookieChangeListener) => void;
-};
-/**
- * Reactive methods to work with cookies (use {@link createCookies} method instead if you are using SSR)
- * @param dependencies - array of watching cookie's names. Pass empty array if don't want to watch cookies changes.
- * @param options
- * @param options.doNotParse - don't try parse value as JSON
- * @param options.autoUpdateDependencies - automatically update watching dependencies
- * @param cookies - universal-cookie instance
- */
-declare function useCookies(dependencies?: string[] | null, { doNotParse, autoUpdateDependencies }?: {
-    doNotParse?: boolean | undefined;
-    autoUpdateDependencies?: boolean | undefined;
-}, cookies?: universal_cookie__default): {
-    /**
-     * Reactive get cookie by name. If **autoUpdateDependencies = true** then it will update watching dependencies
-     */
-    get: <T = any>(name: string, options?: universal_cookie.CookieGetOptions | undefined) => T;
-    /**
-     * Reactive get all cookies
-     */
-    getAll: <T = any>(options?: universal_cookie.CookieGetOptions | undefined) => T;
-    set: (name: string, value: any, options?: universal_cookie.CookieSetOptions | undefined) => void;
-    remove: (name: string, options?: universal_cookie.CookieSetOptions | undefined) => void;
-    addChangeListener: (callback: universal_cookie.CookieChangeListener) => void;
-    removeChangeListener: (callback: universal_cookie.CookieChangeListener) => void;
-};
-
-export { createCookies, useCookies };

package/useDrauu.cjs

@@ -1,116 +0,0 @@
-'use strict';
-
-var core = require('@vueuse/core');
-var shared = require('@vueuse/shared');
-var drauu = require('drauu');
-var vue = require('vue');
-
-function useDrauu(target, options) {
-  const drauuInstance = vue.ref();
-  let disposables = [];
-  const onChangedHook = core.createEventHook();
-  const onCanceledHook = core.createEventHook();
-  const onCommittedHook = core.createEventHook();
-  const onStartHook = core.createEventHook();
-  const onEndHook = core.createEventHook();
-  const canUndo = vue.shallowRef(false);
-  const canRedo = vue.shallowRef(false);
-  const altPressed = vue.shallowRef(false);
-  const shiftPressed = vue.shallowRef(false);
-  const brush = vue.ref({
-    color: "black",
-    size: 3,
-    arrowEnd: false,
-    cornerRadius: 0,
-    dasharray: void 0,
-    fill: "transparent",
-    mode: "draw",
-    ...options == null ? void 0 : options.brush
-  });
-  vue.watch(brush, () => {
-    const instance = drauuInstance.value;
-    if (instance) {
-      instance.brush = brush.value;
-      instance.mode = brush.value.mode;
-    }
-  }, { deep: true });
-  const undo = () => {
-    var _a;
-    return (_a = drauuInstance.value) == null ? void 0 : _a.undo();
-  };
-  const redo = () => {
-    var _a;
-    return (_a = drauuInstance.value) == null ? void 0 : _a.redo();
-  };
-  const clear = () => {
-    var _a;
-    return (_a = drauuInstance.value) == null ? void 0 : _a.clear();
-  };
-  const cancel = () => {
-    var _a;
-    return (_a = drauuInstance.value) == null ? void 0 : _a.cancel();
-  };
-  const load = (svg) => {
-    var _a;
-    return (_a = drauuInstance.value) == null ? void 0 : _a.load(svg);
-  };
-  const dump = () => {
-    var _a;
-    return (_a = drauuInstance.value) == null ? void 0 : _a.dump();
-  };
-  const cleanup = () => {
-    var _a;
-    disposables.forEach((dispose) => dispose());
-    (_a = drauuInstance.value) == null ? void 0 : _a.unmount();
-  };
-  const syncStatus = () => {
-    if (drauuInstance.value) {
-      canUndo.value = drauuInstance.value.canUndo();
-      canRedo.value = drauuInstance.value.canRedo();
-      altPressed.value = drauuInstance.value.altPressed;
-      shiftPressed.value = drauuInstance.value.shiftPressed;
-    }
-  };
-  vue.watch(
-    () => core.unrefElement(target),
-    (el) => {
-      if (!el || typeof SVGSVGElement === "undefined" || !(el instanceof SVGSVGElement))
-        return;
-      if (drauuInstance.value)
-        cleanup();
-      drauuInstance.value = drauu.createDrauu({ el, ...options });
-      syncStatus();
-      disposables = [
-        drauuInstance.value.on("canceled", () => onCanceledHook.trigger()),
-        drauuInstance.value.on("committed", (node) => onCommittedHook.trigger(node)),
-        drauuInstance.value.on("start", () => onStartHook.trigger()),
-        drauuInstance.value.on("end", () => onEndHook.trigger()),
-        drauuInstance.value.on("changed", () => {
-          syncStatus();
-          onChangedHook.trigger();
-        })
-      ];
-    },
-    { flush: "post" }
-  );
-  shared.tryOnScopeDispose(() => cleanup());
-  return {
-    drauuInstance,
-    load,
-    dump,
-    clear,
-    cancel,
-    undo,
-    redo,
-    canUndo,
-    canRedo,
-    brush,
-    onChanged: onChangedHook.on,
-    onCommitted: onCommittedHook.on,
-    onStart: onStartHook.on,
-    onEnd: onEndHook.on,
-    onCanceled: onCanceledHook.on
-  };
-}
-
-exports.useDrauu = useDrauu;

package/useDrauu.d.cts

@@ -1,32 +0,0 @@
-import { EventHookOn, MaybeComputedElementRef } from '@vueuse/core';
-import { Options, Drauu, Brush } from 'drauu';
-import { Ref, ShallowRef } from 'vue';
-
-type UseDrauuOptions = Omit<Options, 'el'>;
-interface UseDrauuReturn {
-    drauuInstance: Ref<Drauu | undefined>;
-    load: (svg: string) => void;
-    dump: () => string | undefined;
-    clear: () => void;
-    cancel: () => void;
-    undo: () => boolean | undefined;
-    redo: () => boolean | undefined;
-    canUndo: ShallowRef<boolean>;
-    canRedo: ShallowRef<boolean>;
-    brush: Ref<Brush>;
-    onChanged: EventHookOn;
-    onCommitted: EventHookOn;
-    onStart: EventHookOn;
-    onEnd: EventHookOn;
-    onCanceled: EventHookOn;
-}
-/**
- * Reactive drauu
- *
- * @see https://vueuse.org/useDrauu
- * @param target The target svg element
- * @param options Drauu Options
- */
-declare function useDrauu(target: MaybeComputedElementRef, options?: UseDrauuOptions): UseDrauuReturn;
-
-export { type UseDrauuOptions, type UseDrauuReturn, useDrauu };

package/useDrauu.d.ts

@@ -1,32 +0,0 @@
-import { EventHookOn, MaybeComputedElementRef } from '@vueuse/core';
-import { Options, Drauu, Brush } from 'drauu';
-import { Ref, ShallowRef } from 'vue';
-
-type UseDrauuOptions = Omit<Options, 'el'>;
-interface UseDrauuReturn {
-    drauuInstance: Ref<Drauu | undefined>;
-    load: (svg: string) => void;
-    dump: () => string | undefined;
-    clear: () => void;
-    cancel: () => void;
-    undo: () => boolean | undefined;
-    redo: () => boolean | undefined;
-    canUndo: ShallowRef<boolean>;
-    canRedo: ShallowRef<boolean>;
-    brush: Ref<Brush>;
-    onChanged: EventHookOn;
-    onCommitted: EventHookOn;
-    onStart: EventHookOn;
-    onEnd: EventHookOn;
-    onCanceled: EventHookOn;
-}
-/**
- * Reactive drauu
- *
- * @see https://vueuse.org/useDrauu
- * @param target The target svg element
- * @param options Drauu Options
- */
-declare function useDrauu(target: MaybeComputedElementRef, options?: UseDrauuOptions): UseDrauuReturn;
-
-export { type UseDrauuOptions, type UseDrauuReturn, useDrauu };

package/useFocusTrap/component.cjs

@@ -1,33 +0,0 @@
-'use strict';
-
-var core = require('@vueuse/core');
-var focusTrap = require('focus-trap');
-var vue = require('vue');
-
-const UseFocusTrap = /* @__PURE__ */ /*@__PURE__*/ vue.defineComponent({
-  name: "UseFocusTrap",
-  props: ["as", "options"],
-  setup(props, { slots }) {
-    let trap;
-    const target = vue.ref();
-    const activate = () => trap && trap.activate();
-    const deactivate = () => trap && trap.deactivate();
-    vue.watch(
-      () => core.unrefElement(target),
-      (el) => {
-        if (!el)
-          return;
-        trap = focusTrap.createFocusTrap(el, props.options || {});
-        activate();
-      },
-      { flush: "post" }
-    );
-    vue.onScopeDispose(() => deactivate());
-    return () => {
-      if (slots.default)
-        return vue.h(props.as || "div", { ref: target }, slots.default());
-    };
-  }
-});
-
-exports.UseFocusTrap = UseFocusTrap;

package/useFocusTrap/component.d.cts

@@ -1,17 +0,0 @@
-import * as vue from 'vue';
-import { RenderableComponent } from '@vueuse/core';
-import { Options } from 'focus-trap';
-
-interface UseFocusTrapOptions extends Options {
-    /**
-     * Immediately activate the trap
-     */
-    immediate?: boolean;
-}
-
-interface ComponentUseFocusTrapOptions extends RenderableComponent {
-    options?: UseFocusTrapOptions;
-}
-declare const UseFocusTrap: vue.DefineComponent<ComponentUseFocusTrapOptions, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<ComponentUseFocusTrapOptions> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
-
-export { type ComponentUseFocusTrapOptions, UseFocusTrap };

package/useFocusTrap/component.d.ts

@@ -1,17 +0,0 @@
-import * as vue from 'vue';
-import { RenderableComponent } from '@vueuse/core';
-import { Options } from 'focus-trap';
-
-interface UseFocusTrapOptions extends Options {
-    /**
-     * Immediately activate the trap
-     */
-    immediate?: boolean;
-}
-
-interface ComponentUseFocusTrapOptions extends RenderableComponent {
-    options?: UseFocusTrapOptions;
-}
-declare const UseFocusTrap: vue.DefineComponent<ComponentUseFocusTrapOptions, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<ComponentUseFocusTrapOptions> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
-
-export { type ComponentUseFocusTrapOptions, UseFocusTrap };

package/useFocusTrap.cjs

@@ -1,68 +0,0 @@
-'use strict';
-
-var core = require('@vueuse/core');
-var shared = require('@vueuse/shared');
-var focusTrap = require('focus-trap');
-var vue = require('vue');
-
-function useFocusTrap(target, options = {}) {
-  let trap;
-  const { immediate, ...focusTrapOptions } = options;
-  const hasFocus = vue.shallowRef(false);
-  const isPaused = vue.shallowRef(false);
-  const activate = (opts) => trap && trap.activate(opts);
-  const deactivate = (opts) => trap && trap.deactivate(opts);
-  const pause = () => {
-    if (trap) {
-      trap.pause();
-      isPaused.value = true;
-    }
-  };
-  const unpause = () => {
-    if (trap) {
-      trap.unpause();
-      isPaused.value = false;
-    }
-  };
-  const targets = vue.computed(() => {
-    const _targets = vue.toValue(target);
-    return core.toArray(_targets).map((el) => {
-      const _el = vue.toValue(el);
-      return typeof _el === "string" ? _el : core.unrefElement(_el);
-    }).filter(shared.notNullish);
-  });
-  vue.watch(
-    targets,
-    (els) => {
-      if (!els.length)
-        return;
-      trap = focusTrap.createFocusTrap(els, {
-        ...focusTrapOptions,
-        onActivate() {
-          hasFocus.value = true;
-          if (options.onActivate)
-            options.onActivate();
-        },
-        onDeactivate() {
-          hasFocus.value = false;
-          if (options.onDeactivate)
-            options.onDeactivate();
-        }
-      });
-      if (immediate)
-        activate();
-    },
-    { flush: "post" }
-  );
-  core.tryOnScopeDispose(() => deactivate());
-  return {
-    hasFocus,
-    isPaused,
-    activate,
-    deactivate,
-    pause,
-    unpause
-  };
-}
-
-exports.useFocusTrap = useFocusTrap;

package/useFocusTrap.d.cts

@@ -1,54 +0,0 @@
-import { Fn, Arrayable, MaybeComputedElementRef } from '@vueuse/core';
-import { Options, ActivateOptions, DeactivateOptions } from 'focus-trap';
-import { ShallowRef, MaybeRefOrGetter } from 'vue';
-
-interface UseFocusTrapOptions extends Options {
-    /**
-     * Immediately activate the trap
-     */
-    immediate?: boolean;
-}
-interface UseFocusTrapReturn {
-    /**
-     * Indicates if the focus trap is currently active
-     */
-    hasFocus: ShallowRef<boolean>;
-    /**
-     * Indicates if the focus trap is currently paused
-     */
-    isPaused: ShallowRef<boolean>;
-    /**
-     * Activate the focus trap
-     *
-     * @see https://github.com/focus-trap/focus-trap#trapactivateactivateoptions
-     * @param opts Activate focus trap options
-     */
-    activate: (opts?: ActivateOptions) => void;
-    /**
-     * Deactivate the focus trap
-     *
-     * @see https://github.com/focus-trap/focus-trap#trapdeactivatedeactivateoptions
-     * @param opts Deactivate focus trap options
-     */
-    deactivate: (opts?: DeactivateOptions) => void;
-    /**
-     * Pause the focus trap
-     *
-     * @see https://github.com/focus-trap/focus-trap#trappause
-     */
-    pause: Fn;
-    /**
-     * Unpauses the focus trap
-     *
-     * @see https://github.com/focus-trap/focus-trap#trapunpause
-     */
-    unpause: Fn;
-}
-/**
- * Reactive focus-trap
- *
- * @see https://vueuse.org/useFocusTrap
- */
-declare function useFocusTrap(target: Arrayable<MaybeRefOrGetter<string> | MaybeComputedElementRef>, options?: UseFocusTrapOptions): UseFocusTrapReturn;
-
-export { type UseFocusTrapOptions, type UseFocusTrapReturn, useFocusTrap };

package/useFocusTrap.d.ts

@@ -1,54 +0,0 @@
-import { Fn, Arrayable, MaybeComputedElementRef } from '@vueuse/core';
-import { Options, ActivateOptions, DeactivateOptions } from 'focus-trap';
-import { ShallowRef, MaybeRefOrGetter } from 'vue';
-
-interface UseFocusTrapOptions extends Options {
-    /**
-     * Immediately activate the trap
-     */
-    immediate?: boolean;
-}
-interface UseFocusTrapReturn {
-    /**
-     * Indicates if the focus trap is currently active
-     */
-    hasFocus: ShallowRef<boolean>;
-    /**
-     * Indicates if the focus trap is currently paused
-     */
-    isPaused: ShallowRef<boolean>;
-    /**
-     * Activate the focus trap
-     *
-     * @see https://github.com/focus-trap/focus-trap#trapactivateactivateoptions
-     * @param opts Activate focus trap options
-     */
-    activate: (opts?: ActivateOptions) => void;
-    /**
-     * Deactivate the focus trap
-     *
-     * @see https://github.com/focus-trap/focus-trap#trapdeactivatedeactivateoptions
-     * @param opts Deactivate focus trap options
-     */
-    deactivate: (opts?: DeactivateOptions) => void;
-    /**
-     * Pause the focus trap
-     *
-     * @see https://github.com/focus-trap/focus-trap#trappause
-     */
-    pause: Fn;
-    /**
-     * Unpauses the focus trap
-     *
-     * @see https://github.com/focus-trap/focus-trap#trapunpause
-     */
-    unpause: Fn;
-}
-/**
- * Reactive focus-trap
- *
- * @see https://vueuse.org/useFocusTrap
- */
-declare function useFocusTrap(target: Arrayable<MaybeRefOrGetter<string> | MaybeComputedElementRef>, options?: UseFocusTrapOptions): UseFocusTrapReturn;
-
-export { type UseFocusTrapOptions, type UseFocusTrapReturn, useFocusTrap };

package/useFuse.cjs

@@ -1,45 +0,0 @@
-'use strict';
-
-var Fuse = require('fuse.js');
-var vue = require('vue');
-
-function useFuse(search, data, options) {
-  const createFuse = () => {
-    var _a, _b;
-    return new Fuse(
-      (_a = vue.toValue(data)) != null ? _a : [],
-      (_b = vue.toValue(options)) == null ? void 0 : _b.fuseOptions
-    );
-  };
-  const fuse = vue.ref(createFuse());
-  vue.watch(
-    () => {
-      var _a;
-      return (_a = vue.toValue(options)) == null ? void 0 : _a.fuseOptions;
-    },
-    () => {
-      fuse.value = createFuse();
-    },
-    { deep: true }
-  );
-  vue.watch(
-    () => vue.toValue(data),
-    (newData) => {
-      fuse.value.setCollection(newData);
-    },
-    { deep: true }
-  );
-  const results = vue.computed(() => {
-    const resolved = vue.toValue(options);
-    if ((resolved == null ? void 0 : resolved.matchAllWhenSearchEmpty) && !vue.toValue(search))
-      return vue.toValue(data).map((item, index) => ({ item, refIndex: index }));
-    const limit = resolved == null ? void 0 : resolved.resultLimit;
-    return fuse.value.search(vue.toValue(search), limit ? { limit } : void 0);
-  });
-  return {
-    fuse,
-    results
-  };
-}
-
-exports.useFuse = useFuse;

package/useFuse.d.cts

@@ -1,32 +0,0 @@
-import * as vue from 'vue';
-import { MaybeRefOrGetter, ComputedRef } from 'vue';
-import * as fuse_js from 'fuse.js';
-import fuse_js__default, { IFuseOptions, FuseResult } from 'fuse.js';
-
-type FuseOptions<T> = 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.Ref<{
-        search: <R = DataItem>(pattern: string | fuse_js.Expression, options?: fuse_js.FuseSearchOptions) => FuseResult<R>[];
-        setCollection: (docs: readonly DataItem[], index?: fuse_js.FuseIndex<DataItem> | undefined) => void;
-        add: (doc: DataItem) => void;
-        remove: (predicate: (doc: DataItem, idx: number) => boolean) => DataItem[];
-        removeAt: (idx: number) => void;
-        getIndex: () => fuse_js.FuseIndex<DataItem>;
-    }, fuse_js__default<DataItem> | {
-        search: <R = DataItem>(pattern: string | fuse_js.Expression, options?: fuse_js.FuseSearchOptions) => FuseResult<R>[];
-        setCollection: (docs: readonly DataItem[], index?: fuse_js.FuseIndex<DataItem> | undefined) => void;
-        add: (doc: DataItem) => void;
-        remove: (predicate: (doc: DataItem, idx: number) => boolean) => DataItem[];
-        removeAt: (idx: number) => void;
-        getIndex: () => fuse_js.FuseIndex<DataItem>;
-    }>;
-    results: ComputedRef<FuseResult<DataItem>[]>;
-};
-type UseFuseReturn = ReturnType<typeof useFuse>;
-
-export { type FuseOptions, type UseFuseOptions, type UseFuseReturn, useFuse };

package/useFuse.d.ts

@@ -1,32 +0,0 @@
-import * as vue from 'vue';
-import { MaybeRefOrGetter, ComputedRef } from 'vue';
-import * as fuse_js from 'fuse.js';
-import fuse_js__default, { IFuseOptions, FuseResult } from 'fuse.js';
-
-type FuseOptions<T> = 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.Ref<{
-        search: <R = DataItem>(pattern: string | fuse_js.Expression, options?: fuse_js.FuseSearchOptions) => FuseResult<R>[];
-        setCollection: (docs: readonly DataItem[], index?: fuse_js.FuseIndex<DataItem> | undefined) => void;
-        add: (doc: DataItem) => void;
-        remove: (predicate: (doc: DataItem, idx: number) => boolean) => DataItem[];
-        removeAt: (idx: number) => void;
-        getIndex: () => fuse_js.FuseIndex<DataItem>;
-    }, fuse_js__default<DataItem> | {
-        search: <R = DataItem>(pattern: string | fuse_js.Expression, options?: fuse_js.FuseSearchOptions) => FuseResult<R>[];
-        setCollection: (docs: readonly DataItem[], index?: fuse_js.FuseIndex<DataItem> | undefined) => void;
-        add: (doc: DataItem) => void;
-        remove: (predicate: (doc: DataItem, idx: number) => boolean) => DataItem[];
-        removeAt: (idx: number) => void;
-        getIndex: () => fuse_js.FuseIndex<DataItem>;
-    }>;
-    results: ComputedRef<FuseResult<DataItem>[]>;
-};
-type UseFuseReturn = ReturnType<typeof useFuse>;
-
-export { type FuseOptions, type UseFuseOptions, type UseFuseReturn, useFuse };

package/useIDBKeyval.cjs

@@ -1,63 +0,0 @@
-'use strict';
-
-var core = require('@vueuse/core');
-var idbKeyval = require('idb-keyval');
-var vue = require('vue');
-
-function useIDBKeyval(key, initialValue, options = {}) {
-  const {
-    flush = "pre",
-    deep = true,
-    shallow = false,
-    onError = (e) => {
-      console.error(e);
-    },
-    writeDefaults = true
-  } = options;
-  const isFinished = vue.shallowRef(false);
-  const data = (shallow ? vue.shallowRef : vue.ref)(initialValue);
-  const rawInit = vue.toValue(initialValue);
-  async function read() {
-    try {
-      const rawValue = await idbKeyval.get(key);
-      if (rawValue === void 0) {
-        if (rawInit !== void 0 && rawInit !== null && writeDefaults)
-          await idbKeyval.set(key, rawInit);
-      } else {
-        data.value = rawValue;
-      }
-    } catch (e) {
-      onError(e);
-    }
-    isFinished.value = true;
-  }
-  read();
-  async function write() {
-    try {
-      if (data.value == null) {
-        await idbKeyval.del(key);
-      } else {
-        await idbKeyval.update(key, () => vue.toRaw(data.value));
-      }
-    } catch (e) {
-      onError(e);
-    }
-  }
-  const {
-    pause: pauseWatch,
-    resume: resumeWatch
-  } = core.watchPausable(data, () => write(), { flush, deep });
-  async function setData(value) {
-    pauseWatch();
-    data.value = value;
-    await write();
-    resumeWatch();
-  }
-  return {
-    set: setData,
-    isFinished,
-    data
-  };
-}
-
-exports.useIDBKeyval = useIDBKeyval;