@vueuse/integrations 12.0.0 → 12.2.0-beta.3

package/README.md

@@ -35,10 +35,10 @@ npm i @vueuse/integrations
 For better tree-shaking result, import functions from submodules, for example:
 
 ```ts
-import { useAxios } from '@vueuse/integrations/useAxios'
-
 // Don't
 import { useAxios } from '@vueuse/integrations'
+
+import { useAxios } from '@vueuse/integrations/useAxios'
 ```
 
 ## License

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@vueuse/integrations",
-  "version": "12.0.0",
+  "type": "module",
+  "version": "12.2.0-beta.3",
   "description": "Integration wrappers for utility libraries",
   "author": "Anthony Fu <https://github.com/antfu>",
   "license": "MIT",
@@ -91,7 +92,16 @@
   "module": "./index.mjs",
   "unpkg": "./index.iife.min.js",
   "jsdelivr": "./index.iife.min.js",
-  "types": "./index.d.cts",
+  "types": "./index.d.ts",
+  "files": [
+    "*.cjs",
+    "*.d.cts",
+    "*.d.mts",
+    "*.d.ts",
+    "*.js",
+    "*.mjs",
+    "index.json"
+  ],
   "peerDependencies": {
     "async-validator": "^4",
     "axios": "^1",
@@ -145,8 +155,28 @@
     }
   },
   "dependencies": {
-    "@vueuse/core": "12.0.0",
-    "@vueuse/shared": "12.0.0",
-    "vue": "^3.5.13"
+    "vue": "^3.5.13",
+    "@vueuse/core": "12.2.0-beta.3",
+    "@vueuse/shared": "12.2.0-beta.3"
+  },
+  "devDependencies": {
+    "@types/nprogress": "^0.2.3",
+    "@types/qrcode": "^1.5.5",
+    "@types/sortablejs": "^1.15.8",
+    "async-validator": "^4.2.5",
+    "axios": "^1.7.9",
+    "change-case": "^5.4.4",
+    "drauu": "^0.4.2",
+    "focus-trap": "^7.6.2",
+    "fuse.js": "^7.0.0",
+    "idb-keyval": "^6.2.1",
+    "jwt-decode": "^4.0.0",
+    "nprogress": "^0.2.0",
+    "qrcode": "^1.5.4",
+    "sortablejs": "^1.15.6",
+    "universal-cookie": "^7.2.2"
+  },
+  "scripts": {
+    "build": "rollup --config=rollup.config.ts --configPlugin=rollup-plugin-esbuild"
   }
-}
+}

package/useAsyncValidator/component.cjs

@@ -1,89 +0,0 @@
-'use strict';
-
-var vue = require('vue');
-var shared = require('@vueuse/shared');
-var Schema = require('async-validator');
-
-const AsyncValidatorSchema = Schema.default || Schema;
-function useAsyncValidator(value, rules, options = {}) {
-  const {
-    validateOption = {},
-    immediate = true,
-    manual = false
-  } = options;
-  const valueRef = shared.toRef(value);
-  const errorInfo = vue.shallowRef(null);
-  const isFinished = vue.ref(true);
-  const pass = vue.ref(!immediate || manual);
-  const errors = vue.computed(() => errorInfo.value?.errors || []);
-  const errorFields = vue.computed(() => errorInfo.value?.fields || {});
-  const validator = vue.computed(() => new AsyncValidatorSchema(shared.toValue(rules)));
-  const execute = async () => {
-    isFinished.value = false;
-    pass.value = false;
-    try {
-      await validator.value.validate(valueRef.value, validateOption);
-      pass.value = true;
-      errorInfo.value = null;
-    } catch (err) {
-      errorInfo.value = err;
-    } finally {
-      isFinished.value = true;
-    }
-    return {
-      pass: pass.value,
-      errorInfo: errorInfo.value,
-      errors: errors.value,
-      errorFields: errorFields.value
-    };
-  };
-  if (!manual) {
-    vue.watch(
-      [valueRef, validator],
-      () => execute(),
-      { immediate, deep: true }
-    );
-  }
-  const shell = {
-    isFinished,
-    pass,
-    errors,
-    errorInfo,
-    errorFields,
-    execute
-  };
-  function waitUntilFinished() {
-    return new Promise((resolve, reject) => {
-      shared.until(isFinished).toBe(true).then(() => resolve(shell)).catch((error) => reject(error));
-    });
-  }
-  return {
-    ...shell,
-    then(onFulfilled, onRejected) {
-      return waitUntilFinished().then(onFulfilled, onRejected);
-    }
-  };
-}
-
-const UseAsyncValidator = /* @__PURE__ */ /* #__PURE__ */ vue.defineComponent({
-  name: "UseAsyncValidator",
-  props: {
-    form: {
-      type: Object,
-      required: true
-    },
-    rules: {
-      type: Object,
-      required: true
-    }
-  },
-  setup(props, { slots }) {
-    const data = vue.reactive(useAsyncValidator(props.form, props.rules));
-    return () => {
-      if (slots.default)
-        return slots.default(data);
-    };
-  }
-});
-
-exports.UseAsyncValidator = UseAsyncValidator;

package/useAsyncValidator/component.d.cts

@@ -1,27 +0,0 @@
-import * as vue from 'vue';
-import { PropType } from 'vue';
-import { Rules } from 'async-validator';
-
-declare const UseAsyncValidator: vue.DefineComponent<vue.ExtractPropTypes<{
-    form: {
-        type: PropType<Record<string, any>>;
-        required: true;
-    };
-    rules: {
-        type: PropType<Rules>;
-        required: true;
-    };
-}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-    [key: string]: any;
-}>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
-    form: {
-        type: PropType<Record<string, any>>;
-        required: true;
-    };
-    rules: {
-        type: PropType<Rules>;
-        required: true;
-    };
-}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
-
-export { UseAsyncValidator };

package/useAsyncValidator/component.d.mts

@@ -1,27 +0,0 @@
-import * as vue from 'vue';
-import { PropType } from 'vue';
-import { Rules } from 'async-validator';
-
-declare const UseAsyncValidator: vue.DefineComponent<vue.ExtractPropTypes<{
-    form: {
-        type: PropType<Record<string, any>>;
-        required: true;
-    };
-    rules: {
-        type: PropType<Rules>;
-        required: true;
-    };
-}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-    [key: string]: any;
-}>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
-    form: {
-        type: PropType<Record<string, any>>;
-        required: true;
-    };
-    rules: {
-        type: PropType<Rules>;
-        required: true;
-    };
-}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
-
-export { UseAsyncValidator };

package/useAsyncValidator/component.d.ts

@@ -1,27 +0,0 @@
-import * as vue from 'vue';
-import { PropType } from 'vue';
-import { Rules } from 'async-validator';
-
-declare const UseAsyncValidator: vue.DefineComponent<vue.ExtractPropTypes<{
-    form: {
-        type: PropType<Record<string, any>>;
-        required: true;
-    };
-    rules: {
-        type: PropType<Rules>;
-        required: true;
-    };
-}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-    [key: string]: any;
-}>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
-    form: {
-        type: PropType<Record<string, any>>;
-        required: true;
-    };
-    rules: {
-        type: PropType<Rules>;
-        required: true;
-    };
-}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
-
-export { UseAsyncValidator };

package/useAsyncValidator/component.mjs

@@ -1,87 +0,0 @@
-import { shallowRef, ref, computed, watch, defineComponent, reactive } from 'vue';
-import { toRef, toValue, until } from '@vueuse/shared';
-import Schema from 'async-validator';
-
-const AsyncValidatorSchema = Schema.default || Schema;
-function useAsyncValidator(value, rules, options = {}) {
-  const {
-    validateOption = {},
-    immediate = true,
-    manual = false
-  } = options;
-  const valueRef = toRef(value);
-  const errorInfo = shallowRef(null);
-  const isFinished = ref(true);
-  const pass = ref(!immediate || manual);
-  const errors = computed(() => errorInfo.value?.errors || []);
-  const errorFields = computed(() => errorInfo.value?.fields || {});
-  const validator = computed(() => new AsyncValidatorSchema(toValue(rules)));
-  const execute = async () => {
-    isFinished.value = false;
-    pass.value = false;
-    try {
-      await validator.value.validate(valueRef.value, validateOption);
-      pass.value = true;
-      errorInfo.value = null;
-    } catch (err) {
-      errorInfo.value = err;
-    } finally {
-      isFinished.value = true;
-    }
-    return {
-      pass: pass.value,
-      errorInfo: errorInfo.value,
-      errors: errors.value,
-      errorFields: errorFields.value
-    };
-  };
-  if (!manual) {
-    watch(
-      [valueRef, validator],
-      () => execute(),
-      { immediate, deep: true }
-    );
-  }
-  const shell = {
-    isFinished,
-    pass,
-    errors,
-    errorInfo,
-    errorFields,
-    execute
-  };
-  function waitUntilFinished() {
-    return new Promise((resolve, reject) => {
-      until(isFinished).toBe(true).then(() => resolve(shell)).catch((error) => reject(error));
-    });
-  }
-  return {
-    ...shell,
-    then(onFulfilled, onRejected) {
-      return waitUntilFinished().then(onFulfilled, onRejected);
-    }
-  };
-}
-
-const UseAsyncValidator = /* @__PURE__ */ /* #__PURE__ */ defineComponent({
-  name: "UseAsyncValidator",
-  props: {
-    form: {
-      type: Object,
-      required: true
-    },
-    rules: {
-      type: Object,
-      required: true
-    }
-  },
-  setup(props, { slots }) {
-    const data = reactive(useAsyncValidator(props.form, props.rules));
-    return () => {
-      if (slots.default)
-        return slots.default(data);
-    };
-  }
-});
-
-export { UseAsyncValidator };

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.mts

@@ -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/component.mjs

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

package/useSortable/component.cjs

@@ -1,91 +0,0 @@
-'use strict';
-
-var core = require('@vueuse/core');
-var vue = require('vue');
-var Sortable = require('sortablejs');
-
-function useSortable(el, list, options = {}) {
-  let sortable;
-  const { document = core.defaultDocument, ...resetOptions } = options;
-  const defaultOptions = {
-    onUpdate: (e) => {
-      moveArrayElement(list, e.oldIndex, e.newIndex, e);
-    }
-  };
-  const start = () => {
-    const target = typeof el === "string" ? document?.querySelector(el) : core.unrefElement(el);
-    if (!target || sortable !== void 0)
-      return;
-    sortable = new Sortable(target, { ...defaultOptions, ...resetOptions });
-  };
-  const stop = () => {
-    sortable?.destroy();
-    sortable = void 0;
-  };
-  const option = (name, value) => {
-    if (value !== void 0)
-      sortable?.option(name, value);
-    else
-      return sortable?.option(name);
-  };
-  core.tryOnMounted(start);
-  core.tryOnScopeDispose(stop);
-  return {
-    stop,
-    start,
-    option
-  };
-}
-function insertNodeAt(parentElement, element, index) {
-  const refElement = parentElement.children[index];
-  parentElement.insertBefore(element, refElement);
-}
-function removeNode(node) {
-  if (node.parentNode)
-    node.parentNode.removeChild(node);
-}
-function moveArrayElement(list, from, to, e = null) {
-  if (e != null) {
-    removeNode(e.item);
-    insertNodeAt(e.from, e.item, from);
-  }
-  const _valueIsRef = vue.isRef(list);
-  const array = _valueIsRef ? [...core.toValue(list)] : core.toValue(list);
-  if (to >= 0 && to < array.length) {
-    const element = array.splice(from, 1)[0];
-    vue.nextTick(() => {
-      array.splice(to, 0, element);
-      if (_valueIsRef)
-        list.value = array;
-    });
-  }
-}
-
-const UseSortable = /* @__PURE__ */ /* #__PURE__ */ vue.defineComponent({
-  name: "UseSortable",
-  props: {
-    modelValue: {
-      type: Array,
-      required: true
-    },
-    tag: {
-      type: String,
-      default: "div"
-    },
-    options: {
-      type: Object,
-      required: true
-    }
-  },
-  setup(props, { slots }) {
-    const list = core.useVModel(props, "modelValue");
-    const target = vue.ref();
-    const data = vue.reactive(useSortable(target, list, props.options));
-    return () => {
-      if (slots.default)
-        return vue.h(props.tag, { ref: target }, slots.default(data));
-    };
-  }
-});
-
-exports.UseSortable = UseSortable;

package/useSortable/component.d.cts

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

package/useSortable/component.d.mts

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

package/useSortable/component.d.ts

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

package/useSortable/component.mjs

@@ -1,89 +0,0 @@
-import { tryOnMounted, tryOnScopeDispose, unrefElement, defaultDocument, toValue, useVModel } from '@vueuse/core';
-import { isRef, nextTick, defineComponent, ref, reactive, h } from 'vue';
-import Sortable from 'sortablejs';
-
-function useSortable(el, list, options = {}) {
-  let sortable;
-  const { document = defaultDocument, ...resetOptions } = options;
-  const defaultOptions = {
-    onUpdate: (e) => {
-      moveArrayElement(list, e.oldIndex, e.newIndex, e);
-    }
-  };
-  const start = () => {
-    const target = typeof el === "string" ? document?.querySelector(el) : unrefElement(el);
-    if (!target || sortable !== void 0)
-      return;
-    sortable = new Sortable(target, { ...defaultOptions, ...resetOptions });
-  };
-  const stop = () => {
-    sortable?.destroy();
-    sortable = void 0;
-  };
-  const option = (name, value) => {
-    if (value !== void 0)
-      sortable?.option(name, value);
-    else
-      return sortable?.option(name);
-  };
-  tryOnMounted(start);
-  tryOnScopeDispose(stop);
-  return {
-    stop,
-    start,
-    option
-  };
-}
-function insertNodeAt(parentElement, element, index) {
-  const refElement = parentElement.children[index];
-  parentElement.insertBefore(element, refElement);
-}
-function removeNode(node) {
-  if (node.parentNode)
-    node.parentNode.removeChild(node);
-}
-function moveArrayElement(list, from, to, e = null) {
-  if (e != null) {
-    removeNode(e.item);
-    insertNodeAt(e.from, e.item, from);
-  }
-  const _valueIsRef = isRef(list);
-  const array = _valueIsRef ? [...toValue(list)] : toValue(list);
-  if (to >= 0 && to < array.length) {
-    const element = array.splice(from, 1)[0];
-    nextTick(() => {
-      array.splice(to, 0, element);
-      if (_valueIsRef)
-        list.value = array;
-    });
-  }
-}
-
-const UseSortable = /* @__PURE__ */ /* #__PURE__ */ defineComponent({
-  name: "UseSortable",
-  props: {
-    modelValue: {
-      type: Array,
-      required: true
-    },
-    tag: {
-      type: String,
-      default: "div"
-    },
-    options: {
-      type: Object,
-      required: true
-    }
-  },
-  setup(props, { slots }) {
-    const list = useVModel(props, "modelValue");
-    const target = ref();
-    const data = reactive(useSortable(target, list, props.options));
-    return () => {
-      if (slots.default)
-        return h(props.tag, { ref: target }, slots.default(data));
-    };
-  }
-});
-
-export { UseSortable };