mrxy-yk 1.1.2 → 1.1.4

package/dist/components/adaptive-box/AdaptiveBox.vue.js

@@ -1,7 +1,170 @@
-import _sfc_main from "./AdaptiveBox.vue2.js";
-/* empty css                 */
-import _export_sfc from "../../_virtual/_plugin-vue_export-helper.js";
-var AdaptiveBox = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-e8305a54"]]);
+import { defineComponent, onMounted, onBeforeUnmount, useTemplateRef, ref, createElementBlock, openBlock, createElementVNode, normalizeStyle, unref, renderSlot } from "vue";
+import { ObjectUtil } from "../../utils/prototype/lib/ObjectUtil.js";
+const _hoisted_1 = { class: "adaptive-box" };
+const errorValue = 0.01;
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "AdaptiveBox",
+  props: {
+    reference: { default: void 0 },
+    minWidth: { default: -Infinity },
+    maxWidth: { default: Infinity },
+    updateWidth: { type: Boolean, default: false },
+    observeNodeUpdate: { type: Boolean, default: false },
+    mode: { default: "equal-width" }
+  },
+  setup(__props, { expose: __expose }) {
+    const props = __props;
+    onMounted(function() {
+      initReference();
+      resize();
+      initResizeMonitor();
+    });
+    onBeforeUnmount(function() {
+      removeResizeMonitor();
+    });
+    let _reference = null;
+    const adaptiveBoxRef = useTemplateRef("adaptiveBoxRef");
+    const adaptiveContentRef = useTemplateRef("adaptiveContentRef");
+    function initReference() {
+      _reference = props.reference ?? window;
+      resizeHandel = resizeType[props.mode];
+    }
+    const resizeType = {
+      "equal-width": resizeIsEqualWidth,
+      contain: resizeIsContain,
+      "full-height": resizeIsFullHeight
+    };
+    let resizeHandel = null;
+    function resize() {
+      if (resizeHandel) resizeHandel();
+    }
+    function resizeIsEqualWidth() {
+      const referenceWidth = isWindow(_reference) ? _reference.innerWidth : _reference.offsetWidth;
+      const $content = adaptiveContentRef.value;
+      let scale = referenceWidth / $content.offsetWidth;
+      let width = $content.offsetWidth * scale;
+      if (props.minWidth && width < props.minWidth) {
+        scale = props.minWidth / $content.scrollWidth;
+        width = props.minWidth;
+      }
+      if (props.maxWidth && width > props.maxWidth) {
+        scale = props.maxWidth / $content.scrollWidth;
+        width = props.maxWidth;
+      }
+      if (Math.abs(1 - scale) < errorValue) scale = 1;
+      $content.style.transform = `scale(${scale})`;
+      const height = $content.offsetHeight * scale;
+      adaptiveBoxRef.value.style.height = `${height}px`;
+      if (props.updateWidth) {
+        adaptiveBoxRef.value.style.width = `${width}px`;
+      }
+    }
+    function resizeIsContain() {
+      let referenceWidth;
+      let referenceHeight;
+      if (isWindow(_reference)) {
+        referenceWidth = _reference.innerWidth;
+        referenceHeight = _reference.innerHeight;
+      } else {
+        referenceWidth = _reference.offsetWidth;
+        referenceHeight = _reference.offsetHeight;
+      }
+      const $content = adaptiveContentRef.value;
+      let scale = referenceWidth / $content.offsetWidth;
+      let height = $content.offsetHeight * scale;
+      let width = $content.offsetWidth * scale;
+      if (height > referenceHeight) {
+        scale = referenceHeight / $content.offsetHeight;
+        height = $content.offsetHeight * scale;
+        width = $content.offsetWidth * scale;
+      }
+      if (Math.abs(1 - scale) < errorValue) scale = 1;
+      $content.style.transform = `scale(${scale})`;
+      adaptiveBoxRef.value.style.height = `${height}px`;
+      adaptiveBoxRef.value.style.width = `${width}px`;
+    }
+    const fullHeight = ref("");
+    function resizeIsFullHeight() {
+      let referenceWidth;
+      let referenceHeight;
+      if (isWindow(_reference)) {
+        referenceWidth = _reference.innerWidth;
+        referenceHeight = _reference.innerHeight;
+      } else {
+        referenceWidth = _reference.offsetWidth;
+        referenceHeight = _reference.offsetHeight;
+      }
+      const $content = adaptiveContentRef.value;
+      let scale = referenceWidth / $content.offsetWidth;
+      let width = $content.offsetWidth * scale;
+      if (props.minWidth && width < props.minWidth) {
+        scale = props.minWidth / $content.scrollWidth;
+        width = props.minWidth;
+      }
+      if (props.maxWidth && width > props.maxWidth) {
+        scale = props.maxWidth / $content.scrollWidth;
+        width = props.maxWidth;
+      }
+      if (Math.abs(1 - scale) < errorValue) scale = 1;
+      $content.style.transform = `scale(${scale})`;
+      const height = referenceHeight / scale;
+      adaptiveBoxRef.value.style.height = `${referenceHeight}px`;
+      adaptiveContentRef.value.style.height = fullHeight.value = `${height}px`;
+      if (props.updateWidth) {
+        adaptiveBoxRef.value.style.width = `${width}px`;
+      }
+    }
+    function isWindow(obj) {
+      return obj === window;
+    }
+    function initResizeMonitor() {
+      if (isWindow(_reference)) window.addEventListener("resize", resize);
+      else loadResizeObserver();
+      if (props.observeNodeUpdate) observeNode();
+    }
+    function removeResizeMonitor() {
+      window.removeEventListener("resize", resize);
+      if (observer) observer.disconnect();
+      if (resizeObserver) resizeObserver.disconnect();
+    }
+    let resizeObserver = null;
+    function loadResizeObserver() {
+      if (!isWindow(_reference)) {
+        resizeObserver = new ResizeObserver(ObjectUtil.debounce(resize, 50));
+        resizeObserver.observe(_reference);
+      }
+    }
+    let observer = null;
+    function observeNode() {
+      const config = {
+        attributes: true,
+        childList: true,
+        subtree: true
+      };
+      observer = new MutationObserver(resize);
+      observer.observe(adaptiveBoxRef.value, config);
+    }
+    __expose({ resize });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createElementVNode("div", {
+          ref_key: "adaptiveBoxRef",
+          ref: adaptiveBoxRef,
+          class: "adaptive-box__body"
+        }, [
+          createElementVNode("div", {
+            ref_key: "adaptiveContentRef",
+            ref: adaptiveContentRef,
+            class: "adaptive-box__content",
+            style: normalizeStyle({ "--adaptive-height": unref(fullHeight) })
+          }, [
+            renderSlot(_ctx.$slots, "default")
+          ], 4)
+        ], 512)
+      ]);
+    };
+  }
+});
 export {
-  AdaptiveBox as default
+  _sfc_main as default
 };

package/dist/components/adaptive-box/AdaptiveBox.vue3.js

@@ -0,0 +1,5 @@
+import _sfc_main from "./AdaptiveBox.vue.js";
+/* empty css                 */
+export {
+  _sfc_main as default
+};

package/dist/components/coordinate-pickup/CoordinatePickup.vue.js

@@ -1,8 +1,302 @@
-import _sfc_main from "./CoordinatePickup.vue2.js";
-/* empty css                      */
-/* empty css                      */
-import _export_sfc from "../../_virtual/_plugin-vue_export-helper.js";
-var CoordinatePickup = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-50d6439a"]]);
+import { ElDialog, ElForm, ElFormItem, ElAutocomplete, ElInput, ElButton, ElCheckbox } from "element-plus/es";
+import { defineComponent, onMounted, watch, nextTick, computed, ref, onUnmounted, createBlock, openBlock, withCtx, createVNode, createElementVNode, toDisplayString, createElementBlock, createCommentVNode, createTextVNode } from "vue";
+import { ElMessage } from "element-plus";
+import { AMapLoader } from "../../utils/amap/index.js";
+import { AMapConfig } from "../../config/index.js";
+const _hoisted_1 = { class: "autocomplete-subtitle" };
+const _hoisted_2 = { key: 0 };
+const _hoisted_3 = { key: 1 };
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "CoordinatePickup",
+  props: {
+    modelValue: { type: Boolean },
+    lnglat: {},
+    address: {},
+    regeocodeRequired: { type: Boolean, default: false },
+    mapKey: {},
+    mapSecret: {},
+    modal: { type: Boolean },
+    mapStyle: {}
+  },
+  emits: ["change", "update:modelValue", "update:lnglat", "update:address", "open"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    onMounted(() => {
+      if (props.modelValue) {
+        loadAMap();
+      }
+    });
+    const mapKey = props.mapKey || AMapConfig.mapKey;
+    const mapSecret = props.mapSecret || AMapConfig.mapSecret;
+    watch(() => props.modelValue, (nv) => {
+      if (nv && !map) {
+        nextTick(() => {
+          loadAMap();
+        });
+      } else {
+        placeSearch.clear();
+        showMarker(props.lnglat, props.address);
+        emits("open", map);
+      }
+    });
+    const changeDialogCustomer = computed({
+      get() {
+        return props.modelValue;
+      },
+      set(val) {
+        emits("update:modelValue", val);
+      }
+    });
+    const searchParam = ref("");
+    const pickupForm = ref({
+      lnglat: "",
+      address: ""
+    });
+    const submitHandler = async () => {
+      if (regeocode && regeocode.lnglat !== pickupForm.value.lnglat) regeocode = null;
+      if (props.regeocodeRequired && !regeocode && pickupForm.value.lnglat) {
+        await getAddressBylnglat(pickupForm.value.lnglat);
+      }
+      emits("change", { value: pickupForm.value, regeocode });
+      emits("update:lnglat", pickupForm.value.lnglat);
+      emits("update:address", pickupForm.value.address);
+      emits("update:modelValue", false);
+    };
+    let AMap = null;
+    let map = null;
+    const coordinatePickupRef = ref();
+    function loadAMap() {
+      AMapLoader({
+        key: mapKey,
+        secret: mapSecret,
+        el: coordinatePickupRef.value,
+        plugins: ["AMap.PlaceSearch", "AMap.AutoComplete", "AMap.Geocoder"],
+        mapStyle: props.mapStyle
+      }).then((res) => {
+        AMap = res.AMap;
+        map = res.map;
+        satelliteLayer = new AMap["TileLayer"].Satellite();
+        map.on("click", clickHandler);
+        autoComplete = new AMap["Autocomplete"]({ city: "全国" });
+        placeSearch = new AMap["PlaceSearch"]({ map, city: "全国", autoFitView: true });
+        placeSearch.on("markerClick", placeMarkerClick);
+        geocoder = new AMap["Geocoder"]();
+        showMarker(props.lnglat, props.address);
+        emits("open", { map, AMap });
+      });
+    }
+    const clickHandler = async (e) => {
+      const { lng, lat } = e.lnglat;
+      const lnglat = `${lng},${lat}`;
+      const address = await getAddressBylnglat(lnglat);
+      showMarker(lnglat, address);
+    };
+    onUnmounted(function() {
+      if (map) {
+        map.off("click", clickHandler);
+        map.destroy();
+      }
+    });
+    let autoComplete = null;
+    const searchComplete = (queryString, cb) => {
+      const empty = [];
+      if (queryString.length === 0) {
+        cb(empty);
+      } else {
+        autoComplete.search(queryString, function(status, result) {
+          if (result.info === "OK") {
+            result.tips.unshift({ name: queryString });
+            cb(result.tips);
+          } else {
+            cb(empty);
+          }
+        });
+      }
+    };
+    function handleSelect(item) {
+      if (!item.address || !item.location) {
+        placeSearchHandler(item.name);
+      } else {
+        placeSearch.clear();
+        const { lng, lat } = item.location;
+        const lnglat = [lng, lat].join(",");
+        let address = item.district;
+        if (item.district.includes(item.name)) {
+          address += item.name;
+        }
+        showMarker(lnglat, address);
+      }
+    }
+    let placeSearch = null;
+    function placeSearchHandler(queryString) {
+      placeSearch.search(queryString, function(status, result) {
+        if (result.info === "TIP_CITIES") {
+          ElMessage.info("条件内结果过多请精确搜索");
+        }
+      });
+    }
+    function placeMarkerClick(e) {
+      const { lng, lat } = e.data.location;
+      pickupForm.value.lnglat = `${lng},${lat}`;
+      const data = e.data;
+      let _address = data.pname;
+      if (data.pname !== data.cityname) {
+        _address += data.cityname;
+      }
+      _address += data.adname + data.name;
+      pickupForm.value.address = _address;
+    }
+    let geocoder = null;
+    let regeocode = null;
+    function getAddressBylnglat(lnglat) {
+      const position = lnglat.split(",");
+      return new Promise(function(resolve) {
+        geocoder.getAddress(position, function(status, result) {
+          if (status === "complete" && result.regeocode) {
+            result.regeocode.lnglat = lnglat;
+            regeocode = result.regeocode;
+            resolve(result.regeocode.formattedAddress);
+          } else {
+            regeocode = null;
+            resolve("");
+          }
+        });
+      });
+    }
+    let marker = null;
+    function showMarker(lnglat, address) {
+      if (lnglat) {
+        const position = lnglat.split(",");
+        if (marker) {
+          marker.setPosition(position);
+          marker.setTitle(address || "-");
+        } else {
+          marker = new AMap.Marker({
+            map,
+            position,
+            title: address
+          });
+        }
+        map.setCenter(position);
+        pickupForm.value = { lnglat, address };
+      }
+    }
+    let satelliteLayer = null;
+    const isSatelliteLayer = ref(false);
+    function setSatelliteLayer() {
+      if (isSatelliteLayer.value) {
+        map.add(satelliteLayer);
+      } else {
+        map.remove(satelliteLayer);
+      }
+    }
+    return (_ctx, _cache) => {
+      const _component_el_autocomplete = ElAutocomplete;
+      const _component_el_form_item = ElFormItem;
+      const _component_el_input = ElInput;
+      const _component_el_button = ElButton;
+      const _component_el_checkbox = ElCheckbox;
+      const _component_el_form = ElForm;
+      const _component_el_dialog = ElDialog;
+      return openBlock(), createBlock(_component_el_dialog, {
+        modelValue: changeDialogCustomer.value,
+        "onUpdate:modelValue": _cache[4] || (_cache[4] = ($event) => changeDialogCustomer.value = $event),
+        title: "坐标拾取",
+        "close-on-click-modal": false,
+        draggable: "",
+        modal: props.modal
+      }, {
+        default: withCtx(() => [
+          createVNode(_component_el_form, {
+            class: "yk-coordinate-pickup-form",
+            inline: true
+          }, {
+            default: withCtx(() => [
+              createVNode(_component_el_form_item, null, {
+                default: withCtx(() => [
+                  createVNode(_component_el_autocomplete, {
+                    modelValue: searchParam.value,
+                    "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => searchParam.value = $event),
+                    "fetch-suggestions": searchComplete,
+                    "value-key": "name",
+                    placeholder: "请输入搜索内容",
+                    "popper-class": "yk-coordinate-pickup-autocomplete",
+                    onSelect: handleSelect
+                  }, {
+                    default: withCtx((scope) => [
+                      createElementVNode("div", null, toDisplayString(scope.item.name), 1),
+                      createElementVNode("div", _hoisted_1, [
+                        scope.item.district ? (openBlock(), createElementBlock("span", _hoisted_2, toDisplayString(scope.item.district), 1)) : createCommentVNode("", true),
+                        scope.item.address && scope.item.address.length > 0 ? (openBlock(), createElementBlock("span", _hoisted_3, toDisplayString(scope.item.address), 1)) : createCommentVNode("", true)
+                      ])
+                    ]),
+                    _: 1
+                  }, 8, ["modelValue"])
+                ]),
+                _: 1
+              }),
+              createVNode(_component_el_form_item, null, {
+                default: withCtx(() => [
+                  createVNode(_component_el_input, {
+                    modelValue: pickupForm.value.lnglat,
+                    "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => pickupForm.value.lnglat = $event),
+                    placeholder: "拾取坐标"
+                  }, null, 8, ["modelValue"])
+                ]),
+                _: 1
+              }),
+              createVNode(_component_el_form_item, null, {
+                default: withCtx(() => [
+                  createVNode(_component_el_input, {
+                    modelValue: pickupForm.value.address,
+                    "onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => pickupForm.value.address = $event),
+                    placeholder: "地址",
+                    style: { "width": "300px" }
+                  }, null, 8, ["modelValue"])
+                ]),
+                _: 1
+              }),
+              createVNode(_component_el_form_item, null, {
+                default: withCtx(() => [
+                  createVNode(_component_el_button, {
+                    disabled: !pickupForm.value.lnglat,
+                    type: "primary",
+                    onClick: submitHandler
+                  }, {
+                    default: withCtx(() => [..._cache[5] || (_cache[5] = [
+                      createTextVNode("确认", -1)
+                    ])]),
+                    _: 1
+                  }, 8, ["disabled"])
+                ]),
+                _: 1
+              }),
+              createVNode(_component_el_form_item, null, {
+                default: withCtx(() => [
+                  createVNode(_component_el_checkbox, {
+                    modelValue: isSatelliteLayer.value,
+                    "onUpdate:modelValue": _cache[3] || (_cache[3] = ($event) => isSatelliteLayer.value = $event),
+                    label: "卫星图",
+                    onChange: setSatelliteLayer
+                  }, null, 8, ["modelValue"])
+                ]),
+                _: 1
+              })
+            ]),
+            _: 1
+          }),
+          createElementVNode("div", {
+            ref_key: "coordinatePickupRef",
+            ref: coordinatePickupRef,
+            class: "coordinate-pickup"
+          }, null, 512)
+        ]),
+        _: 1
+      }, 8, ["modelValue", "modal"]);
+    };
+  }
+});
 export {
-  CoordinatePickup as default
+  _sfc_main as default
 };

package/dist/components/coordinate-pickup/CoordinatePickup.vue3.js

@@ -0,0 +1,5 @@
+import _sfc_main from "./CoordinatePickup.vue.js";
+/* empty css                      */
+export {
+  _sfc_main as default
+};

package/dist/components/drag-drop-box/DragDropBox.vue.js

@@ -1,7 +1,59 @@
-import _sfc_main from "./DragDropBox.vue2.js";
-/* empty css                 */
-import _export_sfc from "../../_virtual/_plugin-vue_export-helper.js";
-var DragDropBox = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-382a0b07"]]);
+import { defineComponent, ref, watchEffect, computed, createElementBlock, openBlock, normalizeStyle, unref, renderSlot } from "vue";
+import { ObjectUtil } from "../../utils/prototype/lib/ObjectUtil.js";
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "DragDropBox",
+  props: {
+    top: { default: "0" },
+    left: { default: "0" },
+    disabled: { type: Boolean, default: false }
+  },
+  emits: ["update:top", "update:left"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    let downPoint = null;
+    let downRefPoint = null;
+    const translate = ref({ x: 0, y: 0 });
+    watchEffect(() => {
+      if (props.top) translate.value.y = Number(props.top.replace("px", ""));
+      if (props.left) translate.value.x = Number(props.left.replace("px", ""));
+    });
+    const translateStyle = computed(() => {
+      return { left: translate.value.x + "px", top: translate.value.y + "px" };
+    });
+    const mousedown = (e) => {
+      if (props.disabled) return;
+      downPoint = { x: e.x, y: e.y };
+      downRefPoint = ObjectUtil.toJSON(translate.value);
+      document.addEventListener("mousemove", mousemove);
+      document.addEventListener("mouseup", mouseup);
+    };
+    const mousemove = (e) => {
+      const offsetPoint = {
+        x: e.x - downPoint.x,
+        y: e.y - downPoint.y
+      };
+      translate.value.x = downRefPoint.x + offsetPoint.x;
+      translate.value.y = downRefPoint.y + offsetPoint.y;
+    };
+    const mouseup = () => {
+      document.removeEventListener("mousemove", mousemove);
+      document.removeEventListener("mouseup", mouseup);
+      emits("update:top", translate.value.y + "px");
+      emits("update:left", translate.value.x + "px");
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: "yk-drag-drop-box",
+        ondragstart: "return false",
+        style: normalizeStyle(unref(translateStyle)),
+        onMousedown: mousedown
+      }, [
+        renderSlot(_ctx.$slots, "default")
+      ], 36);
+    };
+  }
+});
 export {
-  DragDropBox as default
+  _sfc_main as default
 };

package/dist/components/drag-drop-box/DragDropBox.vue3.js

@@ -0,0 +1,5 @@
+import _sfc_main from "./DragDropBox.vue.js";
+/* empty css                 */
+export {
+  _sfc_main as default
+};

package/dist/components/drag-drop-container/DragDropContainer.vue.js

@@ -1,7 +1,114 @@
-import _sfc_main from "./DragDropContainer.vue2.js";
-/* empty css                       */
-import _export_sfc from "../../_virtual/_plugin-vue_export-helper.js";
-var DragDropContainer = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-3f6ac8f9"]]);
+import { defineComponent, ref, createElementBlock, openBlock, createElementVNode, normalizeStyle, renderSlot } from "vue";
+import { ObjectUtil } from "../../utils/prototype/lib/ObjectUtil.js";
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "DragDropContainer",
+  props: {
+    step: { default: 0.1 },
+    scale: { type: Boolean, default: true }
+  },
+  setup(__props, { expose: __expose }) {
+    const props = __props;
+    let downPoint = null;
+    let downRefPoint = null;
+    const translate = ref({ x: 0, y: 0 });
+    const _scale = ref(1);
+    const mousedown = (e) => {
+      downPoint = {
+        x: e.x,
+        y: e.y
+      };
+      downRefPoint = ObjectUtil.toJSON(translate.value);
+      document.addEventListener("mousemove", mousemove);
+      document.addEventListener("mouseup", mouseup);
+    };
+    const mousemove = (e) => {
+      const offsetPoint = {
+        x: e.x - downPoint.x,
+        y: e.y - downPoint.y
+      };
+      translate.value.x = downRefPoint.x + offsetPoint.x;
+      translate.value.y = downRefPoint.y + offsetPoint.y;
+    };
+    const mouseup = () => {
+      document.removeEventListener("mousemove", mousemove);
+      document.removeEventListener("mouseup", mouseup);
+    };
+    const mouseover = () => {
+      if (props.scale) {
+        document.addEventListener("mousewheel", mousewheel, { passive: false });
+      }
+    };
+    const mouseout = () => {
+      document.removeEventListener("mousewheel", mousewheel);
+    };
+    const mousewheel = (e) => {
+      e.preventDefault();
+      if (e.deltaY > 0) {
+        if (_scale.value - props.step >= 0) {
+          _scale.value = _scale.value - props.step;
+        }
+      } else {
+        _scale.value = _scale.value + props.step;
+      }
+    };
+    const reset = () => {
+      translate.value.x = 0;
+      translate.value.y = 0;
+      _scale.value = 1;
+    };
+    const dragDropRef = ref();
+    const dragDropContentRef = ref();
+    const autoSize = () => {
+      if (dragDropRef.value && dragDropContentRef.value) {
+        const width = dragDropRef.value?.offsetWidth;
+        const height = dragDropRef.value?.offsetHeight;
+        const cWidth = dragDropContentRef.value?.offsetWidth;
+        const cHeight = dragDropContentRef.value?.offsetHeight;
+        const hScale = height / cHeight;
+        const wScale = width / cWidth;
+        _scale.value = hScale * cWidth <= width ? hScale : wScale;
+        translate.value.y = -(cHeight - cHeight * hScale) / 2;
+        translate.value.x = -(cWidth - cWidth * wScale) / 2;
+      }
+    };
+    function getOption() {
+      return {
+        translate: translate.value,
+        scale: _scale.value
+      };
+    }
+    function setOption(option) {
+      translate.value = option.translate;
+      _scale.value = option.scale;
+    }
+    __expose({
+      reset,
+      autoSize,
+      getOption,
+      setOption
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        ref_key: "dragDropRef",
+        ref: dragDropRef,
+        class: "yk-drag-drop-container",
+        ondragstart: "return false",
+        onMousedown: mousedown,
+        onMouseout: mouseout,
+        onMouseover: mouseover
+      }, [
+        createElementVNode("div", {
+          ref_key: "dragDropContentRef",
+          ref: dragDropContentRef,
+          class: "drag-drop-content",
+          style: normalizeStyle({ transform: `translate(${translate.value.x}px,${translate.value.y}px) scale(${_scale.value})` })
+        }, [
+          renderSlot(_ctx.$slots, "default")
+        ], 4)
+      ], 544);
+    };
+  }
+});
 export {
-  DragDropContainer as default
+  _sfc_main as default
 };