@vueuse/integrations 6.3.2 → 6.5.3

package/index.mjs

@@ -1,337 +1,402 @@
-import { shallowRef, ref, unref, watch, computed, isRef, watchEffect } from 'vue-demi';
+import { shallowRef, ref, watch, computed, isRef, watchEffect } from 'vue-demi';
 import axios from 'axios';
 import { tryOnScopeDispose, isNumber, isClient } from '@vueuse/shared';
 import Cookie from 'universal-cookie';
+import { createDrauu } from 'drauu';
+import { createEventHook, unrefElement, tryOnScopeDispose as tryOnScopeDispose$1 } from '@vueuse/core';
 import { createFocusTrap } from 'focus-trap';
 import jwt_decode from 'jwt-decode';
 import nprogress from 'nprogress';
 import QRCode from 'qrcode';
 
-/**
- * Wrapper for axios.
- *
- * @see https://vueuse.org/useAxios
- * @param url
- * @param config
- */
-function useAxios(url, ...args) {
-    let config = {};
-    let instance = axios;
-    if (args.length > 0) {
-        /**
-         * Unable to use `instanceof` here becuase of (https://github.com/axios/axios/issues/737)
-         * so instead we are checking if there is a `requset` on the object to see if it is an
-         * axios instance
-         */
-        if ('request' in args[0])
-            instance = args[0];
-        else
-            config = args[0];
-    }
-    if (args.length > 1) {
-        if ('request' in args[1])
-            instance = args[1];
-    }
-    const response = shallowRef();
-    const data = shallowRef();
-    const isFinished = ref(false);
-    const isLoading = ref(true);
-    const aborted = ref(false);
-    const error = shallowRef();
-    const cancelToken = axios.CancelToken.source();
-    const abort = (message) => {
-        if (isFinished.value || !isLoading.value)
-            return;
-        cancelToken.cancel(message);
-        aborted.value = true;
-        isLoading.value = false;
-        isFinished.value = false;
-    };
-    instance(url, Object.assign(Object.assign({}, config), { cancelToken: cancelToken.token }))
-        .then((r) => {
-        response.value = r;
-        data.value = r.data;
-    })
-        .catch((e) => {
-        error.value = e;
-    })
-        .finally(() => {
-        isLoading.value = false;
-        isFinished.value = true;
-    });
-    return {
-        response,
-        data,
-        error,
-        finished: isFinished,
-        loading: isLoading,
-        isFinished,
-        isLoading,
-        cancel: abort,
-        canceled: aborted,
-        aborted,
-        abort,
-    };
+var __defProp$3 = Object.defineProperty;
+var __defProps$1 = Object.defineProperties;
+var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
+var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
+var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$3 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$3.call(b, prop))
+      __defNormalProp$3(a, prop, b[prop]);
+  if (__getOwnPropSymbols$3)
+    for (var prop of __getOwnPropSymbols$3(b)) {
+      if (__propIsEnum$3.call(b, prop))
+        __defNormalProp$3(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
+function useAxios(url, ...args) {
+  let config = {};
+  let instance = axios;
+  if (args.length > 0) {
+    if ("request" in args[0])
+      instance = args[0];
+    else
+      config = args[0];
+  }
+  if (args.length > 1) {
+    if ("request" in args[1])
+      instance = args[1];
+  }
+  const response = shallowRef();
+  const data = shallowRef();
+  const isFinished = ref(false);
+  const isLoading = ref(true);
+  const aborted = ref(false);
+  const error = shallowRef();
+  const cancelToken = axios.CancelToken.source();
+  const abort = (message) => {
+    if (isFinished.value || !isLoading.value)
+      return;
+    cancelToken.cancel(message);
+    aborted.value = true;
+    isLoading.value = false;
+    isFinished.value = false;
+  };
+  instance(url, __spreadProps$1(__spreadValues$3({}, config), { cancelToken: cancelToken.token })).then((r) => {
+    response.value = r;
+    data.value = r.data;
+  }).catch((e) => {
+    error.value = e;
+  }).finally(() => {
+    isLoading.value = false;
+    isFinished.value = true;
+  });
+  return {
+    response,
+    data,
+    error,
+    finished: isFinished,
+    loading: isLoading,
+    isFinished,
+    isLoading,
+    cancel: abort,
+    canceled: aborted,
+    aborted,
+    abort
+  };
 }
 
-/**
- * Creates a new {@link useCookies} function
- * @param {Object} 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
- */
-function createCookies(req) {
-    const universalCookie = new Cookie(req ? req.headers.cookie : null);
-    return (dependencies, { doNotParse = false, autoUpdateDependencies = false } = {}) => useCookies(dependencies, { doNotParse, autoUpdateDependencies }, universalCookie);
-}
-/**
- * Reactive methods to work with cookies (use {@link createCookies} method instead if you are using SSR)
- * @param {string[]|null|undefined} dependencies - array of watching cookie's names. Pass empty array if don't want to watch cookies changes.
- * @param {Object} options
- * @param {boolean} options.doNotParse - don't try parse value as JSON
- * @param {boolean} options.autoUpdateDependencies - automatically update watching dependencies
- * @param {Object} cookies - universal-cookie instance
- */
-function useCookies(dependencies, { doNotParse = false, autoUpdateDependencies = false } = {}, cookies = new Cookie()) {
-    const watchingDependencies = autoUpdateDependencies ? [...dependencies || []] : dependencies;
-    let previousCookies = cookies.getAll({ doNotParse: true });
-    /**
-     * Adds reactivity to get/getAll methods
-     */
-    const touches = ref(0);
-    const onChange = () => {
-        const newCookies = cookies.getAll({ doNotParse: true });
-        if (shouldUpdate(watchingDependencies || null, newCookies, previousCookies))
-            touches.value++;
-        previousCookies = newCookies;
-    };
-    cookies.addChangeListener(onChange);
-    tryOnScopeDispose(() => {
-        cookies.removeChangeListener(onChange);
-    });
-    return {
-        /**
-         * Reactive get cookie by name. If **autoUpdateDependencies = true** then it will update watching dependencies
-         */
-        get: (...args) => {
-            /**
-             * Auto update watching dependencies if needed
-             */
-            if (autoUpdateDependencies && watchingDependencies && !watchingDependencies.includes(args[0]))
-                watchingDependencies.push(args[0]);
-            // eslint-disable-next-line no-unused-expressions
-            touches.value; // adds reactivity to method
-            return cookies.get(args[0], Object.assign({ doNotParse }, args[1]));
-        },
-        /**
-         * Reactive get all cookies
-         */
-        getAll: (...args) => {
-            // eslint-disable-next-line no-unused-expressions
-            touches.value; // adds reactivity to method
-            return cookies.getAll(Object.assign({ doNotParse }, args[0]));
-        },
-        set: (...args) => cookies.set(...args),
-        remove: (...args) => cookies.remove(...args),
-        addChangeListener: (...args) => cookies.addChangeListener(...args),
-        removeChangeListener: (...args) => cookies.removeChangeListener(...args),
-    };
-}
-function shouldUpdate(dependencies, newCookies, oldCookies) {
-    if (!dependencies)
-        return true;
-    for (const dependency of dependencies) {
-        if (newCookies[dependency] !== oldCookies[dependency])
-            return true;
-    }
-    return false;
+var __defProp$2 = Object.defineProperty;
+var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
+var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
+var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$2.call(b, prop))
+      __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(b)) {
+      if (__propIsEnum$2.call(b, prop))
+        __defNormalProp$2(a, prop, b[prop]);
+    }
+  return a;
+};
+function createCookies(req) {
+  const universalCookie = new Cookie(req ? req.headers.cookie : null);
+  return (dependencies, { doNotParse = false, autoUpdateDependencies = false } = {}) => useCookies(dependencies, { doNotParse, autoUpdateDependencies }, universalCookie);
 }
-
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __rest(s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
+function useCookies(dependencies, { doNotParse = false, autoUpdateDependencies = false } = {}, cookies = new Cookie()) {
+  const watchingDependencies = autoUpdateDependencies ? [...dependencies || []] : dependencies;
+  let previousCookies = cookies.getAll({ doNotParse: true });
+  const touches = ref(0);
+  const onChange = () => {
+    const newCookies = cookies.getAll({ doNotParse: true });
+    if (shouldUpdate(watchingDependencies || null, newCookies, previousCookies))
+      touches.value++;
+    previousCookies = newCookies;
+  };
+  cookies.addChangeListener(onChange);
+  tryOnScopeDispose(() => {
+    cookies.removeChangeListener(onChange);
+  });
+  return {
+    get: (...args) => {
+      if (autoUpdateDependencies && watchingDependencies && !watchingDependencies.includes(args[0]))
+        watchingDependencies.push(args[0]);
+      touches.value;
+      return cookies.get(args[0], __spreadValues$2({ doNotParse }, args[1]));
+    },
+    getAll: (...args) => {
+      touches.value;
+      return cookies.getAll(__spreadValues$2({ doNotParse }, args[0]));
+    },
+    set: (...args) => cookies.set(...args),
+    remove: (...args) => cookies.remove(...args),
+    addChangeListener: (...args) => cookies.addChangeListener(...args),
+    removeChangeListener: (...args) => cookies.removeChangeListener(...args)
+  };
 }
-
-/**
- * Get the dom element of a ref of element or Vue component instance
- *
- * @param elRef
- */
-function unrefElement(elRef) {
-    var _a, _b;
-    const plain = unref(elRef);
-    return (_b = (_a = plain) === null || _a === void 0 ? void 0 : _a.$el) !== null && _b !== void 0 ? _b : plain;
+function shouldUpdate(dependencies, newCookies, oldCookies) {
+  if (!dependencies)
+    return true;
+  for (const dependency of dependencies) {
+    if (newCookies[dependency] !== oldCookies[dependency])
+      return true;
+  }
+  return false;
 }
 
-var SwipeDirection;
-(function (SwipeDirection) {
-    SwipeDirection["UP"] = "UP";
-    SwipeDirection["RIGHT"] = "RIGHT";
-    SwipeDirection["DOWN"] = "DOWN";
-    SwipeDirection["LEFT"] = "LEFT";
-    SwipeDirection["NONE"] = "NONE";
-})(SwipeDirection || (SwipeDirection = {}));
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+function useDrauu(target, options) {
+  const drauuInstance = ref();
+  let disposables = [];
+  const onChangedHook = createEventHook();
+  const onCanceledHook = createEventHook();
+  const onCommittedHook = createEventHook();
+  const onStartHook = createEventHook();
+  const onEndHook = createEventHook();
+  const canUndo = ref(false);
+  const canRedo = ref(false);
+  const altPressed = ref(false);
+  const shiftPressed = ref(false);
+  const brush = ref({
+    color: "black",
+    size: 3,
+    arrowEnd: false,
+    cornerRadius: 0,
+    dasharray: void 0,
+    fill: "transparent",
+    mode: "draw"
+  });
+  watch(brush, () => {
+    const instance = drauuInstance.value;
+    if (instance)
+      instance.brush = brush.value;
+  }, { 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;
+    }
+  };
+  watch(() => unrefElement(target), (el) => {
+    if (!el || !(el instanceof SVGSVGElement))
+      return;
+    if (drauuInstance.value)
+      cleanup();
+    drauuInstance.value = createDrauu(__spreadValues$1({ el }, options));
+    syncStatus();
+    disposables = [
+      drauuInstance.value.on("canceled", () => onCanceledHook.trigger()),
+      drauuInstance.value.on("committed", () => onCommittedHook.trigger()),
+      drauuInstance.value.on("start", () => onStartHook.trigger()),
+      drauuInstance.value.on("end", () => onEndHook.trigger()),
+      drauuInstance.value.on("changed", () => {
+        syncStatus();
+        onChangedHook.trigger();
+      })
+    ];
+  }, { flush: "post" });
+  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
+  };
+}
 
-/**
- * Reactive focus-trap
- *
- * @see https://vueuse.org/useFocusTrap
- * @param target The target element to trap focus within
- * @param options Focus trap options
- * @param autoFocus Focus trap automatically when mounted
- */
-function useFocusTrap(target, options = {}) {
-    let trap;
-    const { immediate } = options, focusTrapOptions = __rest(options, ["immediate"]);
-    const hasFocus = ref(false);
-    const isPaused = ref(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;
-        }
-    };
-    watch(() => unrefElement(target), (el) => {
-        if (!el)
-            return;
-        trap = createFocusTrap(el, Object.assign(Object.assign({}, focusTrapOptions), { onActivate() {
-                hasFocus.value = true;
-                // Apply if user provided onActivate option
-                if (options.onActivate)
-                    options.onActivate();
-            },
-            onDeactivate() {
-                hasFocus.value = false;
-                // Apply if user provided onDeactivate option
-                if (options.onDeactivate)
-                    options.onDeactivate();
-            } }));
-        // Focus if immediate is set to true
-        if (immediate)
-            activate();
-    }, { flush: 'post' });
-    // Cleanup on unmount
-    tryOnScopeDispose(() => deactivate());
-    return {
-        hasFocus,
-        isPaused,
-        activate,
-        deactivate,
-        pause,
-        unpause,
-    };
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function useFocusTrap(target, options = {}) {
+  let trap;
+  const _a = options, { immediate } = _a, focusTrapOptions = __objRest(_a, ["immediate"]);
+  const hasFocus = ref(false);
+  const isPaused = ref(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;
+    }
+  };
+  watch(() => unrefElement(target), (el) => {
+    if (!el)
+      return;
+    trap = createFocusTrap(el, __spreadProps(__spreadValues({}, focusTrapOptions), {
+      onActivate() {
+        hasFocus.value = true;
+        if (options.onActivate)
+          options.onActivate();
+      },
+      onDeactivate() {
+        hasFocus.value = false;
+        if (options.onDeactivate)
+          options.onDeactivate();
+      }
+    }));
+    if (immediate)
+      activate();
+  }, { flush: "post" });
+  tryOnScopeDispose$1(() => deactivate());
+  return {
+    hasFocus,
+    isPaused,
+    activate,
+    deactivate,
+    pause,
+    unpause
+  };
 }
 
-/**
- * Reactive decoded jwt token.
- *
- * @see https://vueuse.org/useJwt
- * @param jwt
- */
-function useJwt(encodedJwt, options = {}) {
-    const encodedJwtRef = ref(encodedJwt);
-    const { onError, fallbackValue = null, } = options;
-    const decodeWithFallback = (encodedJwt, options) => {
-        try {
-            return jwt_decode(encodedJwt, options);
-        }
-        catch (err) {
-            onError === null || onError === void 0 ? void 0 : onError(err);
-            return fallbackValue;
-        }
-    };
-    const header = computed(() => decodeWithFallback(encodedJwtRef.value, { header: true }));
-    const payload = computed(() => decodeWithFallback(encodedJwtRef.value));
-    return {
-        header,
-        payload,
-    };
+function useJwt(encodedJwt, options = {}) {
+  const encodedJwtRef = ref(encodedJwt);
+  const {
+    onError,
+    fallbackValue = null
+  } = options;
+  const decodeWithFallback = (encodedJwt2, options2) => {
+    try {
+      return jwt_decode(encodedJwt2, options2);
+    } catch (err) {
+      onError == null ? void 0 : onError(err);
+      return fallbackValue;
+    }
+  };
+  const header = computed(() => decodeWithFallback(encodedJwtRef.value, { header: true }));
+  const payload = computed(() => decodeWithFallback(encodedJwtRef.value));
+  return {
+    header,
+    payload
+  };
 }
 
-/**
- * Reactive progress bar.
- *
- * @see https://vueuse.org/useNProgress
- * @param currentProgress
- * @param options
- */
-function useNProgress(currentProgress = null, options) {
-    const progress = isRef(currentProgress)
-        ? currentProgress
-        : ref(currentProgress);
-    const isLoading = computed({
-        set: load => load ? nprogress.start() : nprogress.done(),
-        get: () => isNumber(progress.value) && progress.value < 1,
-    });
-    if (options)
-        nprogress.configure(options);
-    const setProgress = nprogress.set;
-    nprogress.set = (n) => {
-        progress.value = n;
-        return setProgress.call(nprogress, n);
-    };
-    watchEffect(() => {
-        if (isNumber(progress.value))
-            setProgress.call(nprogress, progress.value);
-    });
-    tryOnScopeDispose(nprogress.remove);
-    return {
-        isLoading,
-        progress,
-        start: nprogress.start,
-        done: nprogress.done,
-        remove: () => {
-            progress.value = null;
-            nprogress.remove();
-        },
-    };
+function useNProgress(currentProgress = null, options) {
+  const progress = isRef(currentProgress) ? currentProgress : ref(currentProgress);
+  const isLoading = computed({
+    set: (load) => load ? nprogress.start() : nprogress.done(),
+    get: () => isNumber(progress.value) && progress.value < 1
+  });
+  if (options)
+    nprogress.configure(options);
+  const setProgress = nprogress.set;
+  nprogress.set = (n) => {
+    progress.value = n;
+    return setProgress.call(nprogress, n);
+  };
+  watchEffect(() => {
+    if (isNumber(progress.value))
+      setProgress.call(nprogress, progress.value);
+  });
+  tryOnScopeDispose(nprogress.remove);
+  return {
+    isLoading,
+    progress,
+    start: nprogress.start,
+    done: nprogress.done,
+    remove: () => {
+      progress.value = null;
+      nprogress.remove();
+    }
+  };
 }
 
-/**
- * Wrapper for qrcode.
- *
- * @see https://vueuse.org/useQRCode
- * @param text
- * @param options
- */
-function useQRCode(text, options) {
-    const src = ref(text);
-    const result = ref('');
-    watch(src, async (value) => {
-        if (src.value && isClient)
-            result.value = await QRCode.toDataURL(value, options);
-    }, { immediate: true });
-    return result;
+function useQRCode(text, options) {
+  const src = ref(text);
+  const result = ref("");
+  watch(src, async (value) => {
+    if (src.value && isClient)
+      result.value = await QRCode.toDataURL(value, options);
+  }, { immediate: true });
+  return result;
 }
 
-export { createCookies, useAxios, useCookies, useFocusTrap, useJwt, useNProgress, useQRCode };
+export { createCookies, useAxios, useCookies, useDrauu, useFocusTrap, useJwt, useNProgress, useQRCode };