@vunk/form 1.1.84 → 1.2.0

package/components/geoinput-read/index.cjs

@@ -0,0 +1,304 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var wrapper = require('@vunk/core/components/wrapper');
+var input = require('@vunk/form/components/input');
+var _static = require('@vumap/core/shared/static');
+var geojsonLayer = require('@vumap/core/components/geojson-layer');
+var utilsVue = require('@vunk/core/shared/utils-vue');
+var utilsObject = require('@vunk/core/shared/utils-object');
+var elementPlus = require('element-plus');
+var index = require('../index2.cjs');
+var _pluginVue_exportHelper = require('../_plugin-vue_export-helper.cjs');
+var core = require('@vumap/core');
+var utils = require('@vumap/core/shared/utils');
+
+const props = {
+  ...input._VkfInputCtx.props,
+  ...geojsonLayer._VmGeojsonLayerCtx.props,
+  modelValue: {
+    type: Object,
+    default: () => _static.EMPTY_FEATURE_COLLECTION
+  },
+  editStyles: {
+    type: Array,
+    default: () => []
+  },
+  editTypes: {
+    type: [Array, String],
+    default: "polygon"
+  },
+  paint: {
+    type: Object,
+    default: void 0
+  },
+  type: {
+    type: String,
+    default: void 0
+  },
+  custom: {
+    type: Boolean,
+    default: false
+  },
+  showMap: {
+    type: Boolean,
+    default: false
+  }
+};
+const createBindProps = utilsVue.bindPropsFactory(props);
+const emits = {
+  ...utilsObject.pickObject(geojsonLayer._VmGeojsonLayerCtx.emits, {
+    excludes: ["click"]
+  }),
+  ...input._VkfInputCtx.emits,
+  "layerChange": (layer) => layer,
+  "update:modelValue": (e) => e,
+  "layerClick": (e) => e
+};
+const createOnEmits = utilsVue.onEmitsFactory(emits);
+
+var ctx = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  createBindProps: createBindProps,
+  createOnEmits: createOnEmits,
+  emits: emits,
+  props: props
+});
+
+var _sfc_main$2 = vue.defineComponent({
+  components: {
+    ElButton: elementPlus.ElButton,
+    ElIcon: elementPlus.ElIcon,
+    ElButtonGroup: elementPlus.ElButtonGroup,
+    MapLocation: index.map_location_default
+  },
+  emits: {
+    mapLocationClick: null
+  }
+});
+
+function _sfc_render$2(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_MapLocation = vue.resolveComponent("MapLocation");
+  const _component_ElIcon = vue.resolveComponent("ElIcon");
+  const _component_ElButton = vue.resolveComponent("ElButton");
+  const _component_ElButtonGroup = vue.resolveComponent("ElButtonGroup");
+  return vue.openBlock(), vue.createBlock(_component_ElButtonGroup, null, {
+    default: vue.withCtx(() => [
+      vue.createVNode(_component_ElButton, {
+        class: "vk-geoinput-read-map-location-x",
+        onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("mapLocationClick"))
+      }, {
+        default: vue.withCtx(() => [
+          vue.createVNode(_component_ElIcon, { color: "var(--el-color-primary)" }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(_component_MapLocation)
+            ]),
+            _: 1
+            /* STABLE */
+          })
+        ]),
+        _: 1
+        /* STABLE */
+      })
+    ]),
+    _: 1
+    /* STABLE */
+  });
+}
+var AppendVue = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main$2, [["render", _sfc_render$2], ["__file", "/home/runner/work/private-vunk-form/private-vunk-form/packages/components/geoinput-read/src/append.vue"]]);
+
+var _sfc_main$1 = /* @__PURE__ */ vue.defineComponent({
+  name: "VkfGeoinputReadCore",
+  components: {
+    VkfInput: input.VkfInput,
+    VmGeojsonLayer: core.VmGeojsonLayer,
+    ElIcon: elementPlus.ElIcon,
+    MapLocation: index.map_location_default
+  },
+  emits,
+  props,
+  setup(props2, {
+    emit
+  }) {
+    const inputBindProps = input._VkfInputCtx.createBindProps(props2, ["inputSlots", "readonly", "modelValue", "type", "id"]);
+    const inputOnEmits = input._VkfInputCtx.createOnEmits(emit, ["update:modelValue"]);
+    const mapBindProps = core._VmGeojsonLayerCtx.createBindProps(props2, ["data", "type", "paint"]);
+    const mapOnEmits = core._VmGeojsonLayerCtx.createOnEmits(emit, ["change"]);
+    const map = core.useMap();
+    const geoType = vue.computed(() => {
+      if (props2.type) return props2.type;
+      const typeRaw = props2.modelValue?.features[0]?.geometry?.type;
+      const typeRawTo = {
+        LineString: "line",
+        Polygon: "fill",
+        MultiLineString: "line",
+        MultiPolygon: "fill"
+      };
+      return typeRawTo[typeRaw] || "fill";
+    });
+    const paintFromEditStyles = vue.computed(() => {
+      return props2.editStyles.reduce((a, c) => {
+        if (geoType.value === "fill") {
+          if (c.id.includes("polygon-fill-inactive") || c.id.includes("polygon-stroke-inactive")) {
+            const cPaint = c.paint;
+            a = {
+              ...a,
+              ...cPaint
+            };
+          }
+        }
+        if (geoType.value === "line") {
+          if (c.id.includes("line-inactive")) {
+            const cPaint = c.paint;
+            a = {
+              ...a,
+              ...cPaint
+            };
+          }
+        }
+        return a;
+      }, {});
+    });
+    const mapFit = () => {
+      utils.fitGeojson(map, props2.modelValue, {
+        duration: 1500
+      });
+    };
+    const append = () => vue.createVNode(AppendVue, {
+      "onMapLocationClick": mapFit
+    }, null);
+    return {
+      mapFit,
+      inputBindProps,
+      inputOnEmits,
+      mapBindProps,
+      mapOnEmits,
+      append,
+      geoType,
+      paintFromEditStyles
+    };
+  }
+});
+
+function _sfc_render$1(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_VkfInput = vue.resolveComponent("VkfInput");
+  const _component_MapLocation = vue.resolveComponent("MapLocation");
+  const _component_ElIcon = vue.resolveComponent("ElIcon");
+  const _component_VmGeojsonLayer = vue.resolveComponent("VmGeojsonLayer");
+  return vue.openBlock(), vue.createElementBlock(
+    vue.Fragment,
+    null,
+    [
+      vue.withDirectives(vue.createVNode(_component_VkfInput, vue.mergeProps({
+        readonly: true,
+        modelValue: JSON.stringify(_ctx.modelValue)
+      }, _ctx.inputBindProps, vue.toHandlers(_ctx.inputOnEmits), {
+        inputSlots: {
+          append: _ctx.append
+        }
+      }), null, 16, ["modelValue", "inputSlots"]), [
+        [vue.vShow, !_ctx.custom]
+      ]),
+      _ctx.custom ? vue.renderSlot(_ctx.$slots, "default", {
+        key: 0,
+        mapFit: _ctx.mapFit
+      }, () => [
+        vue.createVNode(_component_ElIcon, {
+          color: "var(--el-color-primary)",
+          onClick: _ctx.mapFit
+        }, {
+          default: vue.withCtx(() => [
+            vue.createVNode(_component_MapLocation)
+          ]),
+          _: 1
+          /* STABLE */
+        }, 8, ["onClick"])
+      ]) : vue.createCommentVNode("v-if", true),
+      vue.createVNode(_component_VmGeojsonLayer, vue.mergeProps(_ctx.mapBindProps, {
+        data: _ctx.modelValue,
+        type: _ctx.geoType,
+        paint: _ctx.paint || _ctx.paintFromEditStyles
+      }, vue.toHandlers(_ctx.mapOnEmits), {
+        onChange: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("layerChange", $event)),
+        onClick: _cache[1] || (_cache[1] = ($event) => _ctx.$emit("layerClick", $event))
+      }), null, 16, ["data", "type", "paint"])
+    ],
+    64
+    /* STABLE_FRAGMENT */
+  );
+}
+var CoreVue = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main$1, [["render", _sfc_render$1], ["__file", "/home/runner/work/private-vunk-form/private-vunk-form/packages/components/geoinput-read/src/core.vue"]]);
+
+var _sfc_main = vue.defineComponent({
+  name: "VkfGeoinputRead",
+  components: {
+    CoreVue,
+    VkWrapper: wrapper.VkWrapper,
+    VmTdtLayers: core.VmTdtLayers
+  },
+  props,
+  emits,
+  setup(props2, { emit }) {
+    const coreBindProps = createBindProps(props2);
+    const coreOnEmits = createOnEmits(emit);
+    return {
+      VmMap: core.VmMap,
+      coreBindProps,
+      coreOnEmits
+    };
+  }
+});
+
+const _hoisted_1 = { class: "vk-geoinput-read-x" };
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_VmTdtLayers = vue.resolveComponent("VmTdtLayers");
+  const _component_CoreVue = vue.resolveComponent("CoreVue");
+  const _component_VkWrapper = vue.resolveComponent("VkWrapper");
+  return vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
+    vue.createVNode(_component_VkWrapper, {
+      is: _ctx.VmMap,
+      show: _ctx.showMap,
+      className: "vk-geoinput-read-map"
+    }, {
+      default: vue.withCtx(() => [
+        vue.renderSlot(_ctx.$slots, "map", {}, () => [
+          _ctx.showMap ? (vue.openBlock(), vue.createBlock(_component_VmTdtLayers, {
+            key: 0,
+            type: "vec_w"
+          })) : vue.createCommentVNode("v-if", true)
+        ]),
+        vue.createVNode(
+          _component_CoreVue,
+          vue.mergeProps(_ctx.coreBindProps, vue.toHandlers(_ctx.coreOnEmits)),
+          {
+            default: vue.withCtx((e) => [
+              vue.renderSlot(_ctx.$slots, "default", vue.normalizeProps(vue.guardReactiveProps(e)))
+            ]),
+            _: 3
+            /* FORWARDED */
+          },
+          16
+          /* FULL_PROPS */
+        )
+      ]),
+      _: 3
+      /* FORWARDED */
+    }, 8, ["is", "show"])
+  ]);
+}
+var VkfGeoinputRead = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "/home/runner/work/private-vunk-form/private-vunk-form/packages/components/geoinput-read/src/index.vue"]]);
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+VkfGeoinputRead.install = (app) => {
+  app.component(VkfGeoinputRead.name, VkfGeoinputRead);
+};
+
+exports.VkfGeoinputRead = VkfGeoinputRead;
+exports._VkfGeoinputReadCtx = ctx;
+exports.__VkfGeoinputRead = types;
+exports.default = VkfGeoinputRead;

package/components/geoinput-update/index.cjs

@@ -0,0 +1,406 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var input = require('@vunk/form/components/input');
+var _static = require('@vumap/core/shared/static');
+var utilsVue = require('@vunk/core/shared/utils-vue');
+var elementPlus = require('element-plus');
+var index = require('../index2.cjs');
+var _pluginVue_exportHelper = require('../_plugin-vue_export-helper.cjs');
+var core = require('@vumap/core');
+var tdtLayers = require('@vumap/core/components/tdt-layers');
+var controlDraw = require('@vumap/core/components/control-draw');
+var utilsPromise = require('@vunk/core/shared/utils-promise');
+var index$1 = require('../index3.cjs');
+var core$1 = require('@vunk/core');
+var controlDrawUi = require('@vumap/core/components/control-draw-ui');
+
+const props = {
+  ...input._VkfInputCtx.props,
+  showMap: {
+    type: Boolean,
+    default: false
+  },
+  dialogEdit: {
+    type: Boolean,
+    default: true
+  },
+  dialogEditFullscreen: {
+    type: Boolean,
+    default: true
+  },
+  dialogEditTitle: {
+    type: String,
+    default: "\u7ED8\u5236\u56FE\u6591"
+  },
+  modelValue: {
+    type: Object,
+    default: () => _static.EMPTY_FEATURE_COLLECTION
+  },
+  editControls: {
+    type: Array,
+    default: () => ["trash"]
+  },
+  editTypes: {
+    type: [Array, String],
+    default: () => "polygon"
+  },
+  multiple: {
+    type: Boolean,
+    default: true
+  },
+  mapTo: {
+    type: [Object, String],
+    default: void 0
+  },
+  mapCenter: {
+    type: [Object, Array],
+    default: [120, 30]
+  },
+  editStyles: {
+    type: Array,
+    default: () => []
+  },
+  slots: {
+    type: Object,
+    default: () => ({})
+  },
+  spikSave: {
+    type: Boolean,
+    default: false
+  }
+};
+const createBindProps = utilsVue.bindPropsFactory(props);
+const emits = {
+  ...input._VkfInputCtx.emits,
+  "update:modelValue": (e) => e,
+  "editUpdate": (e) => e
+};
+const createOnEmits = utilsVue.onEmitsFactory(emits);
+
+var ctx = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  createBindProps: createBindProps,
+  createOnEmits: createOnEmits,
+  emits: emits,
+  props: props
+});
+
+var _sfc_main$1 = vue.defineComponent({
+  components: {
+    ElButton: elementPlus.ElButton,
+    ElIcon: elementPlus.ElIcon,
+    ElButtonGroup: elementPlus.ElButtonGroup,
+    Upload: index.upload_default,
+    Edit: index.edit_default,
+    ElUpload: elementPlus.ElUpload
+  },
+  props: {
+    disabled: Boolean,
+    dialog: Boolean
+  },
+  emits: {
+    upload: (e) => e,
+    edit: null
+  },
+  methods: {
+    getFile(file) {
+      this.$emit("upload", file);
+    }
+  }
+});
+
+function _sfc_render$1(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_Upload = vue.resolveComponent("Upload");
+  const _component_ElIcon = vue.resolveComponent("ElIcon");
+  const _component_ElUpload = vue.resolveComponent("ElUpload");
+  const _component_ElButton = vue.resolveComponent("ElButton");
+  const _component_Edit = vue.resolveComponent("Edit");
+  const _component_ElButtonGroup = vue.resolveComponent("ElButtonGroup");
+  return vue.openBlock(), vue.createBlock(_component_ElButtonGroup, null, {
+    default: vue.withCtx(() => [
+      vue.createVNode(_component_ElButton, { class: "vk-geoinput-upload-x" }, {
+        default: vue.withCtx(() => [
+          vue.createVNode(_component_ElUpload, {
+            class: vue.normalizeClass("vk-geoinput-upload"),
+            action: "",
+            accept: "file",
+            multiple: false,
+            "show-file-list": false,
+            "auto-upload": false,
+            "on-change": _ctx.getFile,
+            disabled: _ctx.disabled
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(_component_ElIcon, { color: "var(--el-color-primary)" }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(_component_Upload)
+                ]),
+                _: 1
+                /* STABLE */
+              })
+            ]),
+            _: 1
+            /* STABLE */
+          }, 8, ["on-change", "disabled"])
+        ]),
+        _: 1
+        /* STABLE */
+      }),
+      _ctx.dialog ? (vue.openBlock(), vue.createBlock(_component_ElButton, {
+        key: 0,
+        onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("edit")),
+        disabled: _ctx.disabled
+      }, {
+        default: vue.withCtx(() => [
+          vue.createVNode(_component_ElIcon, { color: "var(--el-color-primary)" }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(_component_Edit)
+            ]),
+            _: 1
+            /* STABLE */
+          })
+        ]),
+        _: 1
+        /* STABLE */
+      }, 8, ["disabled"])) : vue.createCommentVNode("v-if", true)
+    ]),
+    _: 1
+    /* STABLE */
+  });
+}
+var AppendVue = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main$1, [["render", _sfc_render$1], ["__file", "/home/runner/work/private-vunk-form/private-vunk-form/packages/components/geoinput-update/src/append.vue"]]);
+
+var _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  name: "VkfGeoinputUpdate",
+  components: {
+    VkfInput: input.VkfInput,
+    ElDialog: elementPlus.ElDialog,
+    VmMap: core.VmMap,
+    VmTdtLayers: tdtLayers.VmTdtLayers,
+    VmControlDraw: controlDraw.VmControlDraw,
+    VkAsyncTeleport: core$1.VkAsyncTeleport,
+    VmControlDrawUi: controlDrawUi.VmControlDrawUi,
+    ElIcon: elementPlus.ElIcon,
+    Checked: index.checked_default
+  },
+  emits,
+  props,
+  setup(props2, {
+    emit
+  }) {
+    const inputBindProps = input._VkfInputCtx.createBindProps(props2, ["inputSlots", "readonly", "modelValue"]);
+    const inputOnEmits = input._VkfInputCtx.createOnEmits(emit, ["update:modelValue"]);
+    const mapOptions = vue.computed(() => {
+      return {
+        center: props2.mapCenter
+      };
+    });
+    const geoInputMapDialogNode = vue.shallowRef();
+    const geoInputMapXNode = vue.shallowRef();
+    const editPlayground = vue.ref(geoInputMapXNode.value);
+    vue.onMounted(() => {
+      editPlayground.value = geoInputMapXNode.value;
+    });
+    const mapTo = vue.computed(() => {
+      return editPlayground.value === geoInputMapDialogNode.value ? geoInputMapDialogNode.value : props2.mapTo ?? editPlayground.value;
+    });
+    const mapControls = vue.computed(() => {
+      return props2.readonly ? [] : typeof props2.editTypes === "string" ? [props2.editTypes, ...props2.editControls] : [...props2.editTypes, ...props2.editControls];
+    });
+    const currentDrawCacheValue = vue.ref(props2.modelValue);
+    const currentDrawValue = vue.computed(() => {
+      return props2.spikSave ? props2.modelValue : currentDrawCacheValue.value;
+    });
+    const setCurrentDrawValue = value => {
+      if (props2.spikSave) {
+        emit("update:modelValue", value);
+      } else {
+        currentDrawCacheValue.value = value;
+      }
+    };
+    const doSave = () => {
+      emit("update:modelValue", currentDrawCacheValue.value);
+      elementPlus.ElMessage({
+        message: "\u4FDD\u5B58\u6210\u529F",
+        type: "success"
+      });
+      dialogShow.value = false;
+    };
+    const dialogShow = vue.ref(false);
+    const mapDef = new utilsPromise.Deferred();
+    const dialogOnOpen = async () => {
+      await vue.nextTick();
+      editPlayground.value = geoInputMapDialogNode.value;
+      await vue.nextTick();
+      const map = await mapDef.promise;
+      currentDrawCacheValue.value = props2.modelValue;
+      map.resize();
+    };
+    const dialogOnClose = async () => {
+      editPlayground.value = geoInputMapXNode.value;
+      const map = await mapDef.promise;
+      map.resize();
+    };
+    const append = () => vue.createVNode(AppendVue, {
+      "dialog": props2.dialogEdit,
+      "disabled": props2.disabled,
+      "onUpload": onUpload,
+      "onEdit": onEdit
+    }, null);
+    async function onUpload(e) {
+      if (!e.raw) return;
+      index$1.toGeojson(e.raw).then(res => {
+        emit("update:modelValue", res);
+      });
+    }
+    function onEdit() {
+      dialogShow.value = true;
+    }
+    return {
+      inputBindProps,
+      inputOnEmits,
+      append,
+      dialogShow,
+      mapDef,
+      dialogOnOpen,
+      dialogOnClose,
+      mapOptions,
+      geoInputMapDialogNode,
+      geoInputMapXNode,
+      mapTo,
+      mapControls,
+      doSave,
+      currentDrawValue,
+      setCurrentDrawValue
+    };
+  }
+});
+
+const _hoisted_1 = { class: "vkf-form-item" };
+const _hoisted_2 = {
+  class: "geoinput-map-dialog",
+  ref: "geoInputMapDialogNode"
+};
+const _hoisted_3 = {
+  class: "geoinput-map-x",
+  ref: "geoInputMapXNode"
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_VkfInput = vue.resolveComponent("VkfInput");
+  const _component_VmTdtLayers = vue.resolveComponent("VmTdtLayers");
+  const _component_Checked = vue.resolveComponent("Checked");
+  const _component_ElIcon = vue.resolveComponent("ElIcon");
+  const _component_VmControlDrawUi = vue.resolveComponent("VmControlDrawUi");
+  const _component_VmControlDraw = vue.resolveComponent("VmControlDraw");
+  const _component_VmMap = vue.resolveComponent("VmMap");
+  const _component_VkAsyncTeleport = vue.resolveComponent("VkAsyncTeleport");
+  const _component_ElDialog = vue.resolveComponent("ElDialog");
+  return vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
+    vue.createVNode(_component_VkfInput, vue.mergeProps({
+      readonly: true,
+      modelValue: JSON.stringify(_ctx.modelValue)
+    }, _ctx.inputBindProps, vue.toHandlers(_ctx.inputOnEmits), {
+      inputSlots: _ctx.readonly ? {} : {
+        append: _ctx.append
+      }
+    }), null, 16, ["modelValue", "inputSlots"]),
+    vue.createVNode(_component_VkAsyncTeleport, { to: _ctx.mapTo }, {
+      default: vue.withCtx(() => [
+        vue.createVNode(_component_VmMap, {
+          defaultOptions: _ctx.mapOptions,
+          class: "vk-geoinput-edit-map",
+          onLoad: _cache[1] || (_cache[1] = ($event) => _ctx.mapDef.resolve($event.map))
+        }, {
+          default: vue.withCtx(() => [
+            vue.createVNode(_component_VmTdtLayers),
+            vue.createVNode(_component_VmControlDraw, {
+              styles: _ctx.editStyles,
+              modelValue: _ctx.currentDrawValue,
+              "onUpdate:modelValue": _ctx.setCurrentDrawValue,
+              onUpdate: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("editUpdate", $event)),
+              controls: _ctx.mapControls,
+              multiple: _ctx.multiple
+            }, {
+              default: vue.withCtx(() => [
+                !_ctx.spikSave ? (vue.openBlock(), vue.createBlock(_component_VmControlDrawUi, {
+                  key: 0,
+                  onClick: vue.withModifiers(_ctx.doSave, ["prevent"])
+                }, {
+                  default: vue.withCtx(() => [
+                    vue.createVNode(_component_ElIcon, null, {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(_component_Checked)
+                      ]),
+                      _: 1
+                      /* STABLE */
+                    })
+                  ]),
+                  _: 1
+                  /* STABLE */
+                }, 8, ["onClick"])) : vue.createCommentVNode("v-if", true)
+              ]),
+              _: 1
+              /* STABLE */
+            }, 8, ["styles", "modelValue", "onUpdate:modelValue", "controls", "multiple"]),
+            vue.renderSlot(_ctx.$slots, "map"),
+            _ctx.slots.map ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(typeof _ctx.slots.map === "function" ? _ctx.slots.map() : _ctx.slots.map), { key: 0 })) : vue.createCommentVNode("v-if", true)
+          ]),
+          _: 3
+          /* FORWARDED */
+        }, 8, ["defaultOptions"])
+      ]),
+      _: 3
+      /* FORWARDED */
+    }, 8, ["to"]),
+    vue.createVNode(_component_ElDialog, {
+      modelValue: _ctx.dialogShow,
+      "onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => _ctx.dialogShow = $event),
+      title: _ctx.dialogEditTitle,
+      fullscreen: _ctx.dialogEditFullscreen,
+      modalClass: "vk-geoinput-edit-dialog-x",
+      appendToBody: true,
+      onOpen: _ctx.dialogOnOpen,
+      onClose: _ctx.dialogOnClose,
+      closeOnClickModal: false,
+      draggable: true
+    }, {
+      default: vue.withCtx(() => [
+        vue.createElementVNode(
+          "div",
+          _hoisted_2,
+          null,
+          512
+          /* NEED_PATCH */
+        )
+      ]),
+      _: 1
+      /* STABLE */
+    }, 8, ["modelValue", "title", "fullscreen", "onOpen", "onClose"]),
+    vue.withDirectives(vue.createElementVNode(
+      "div",
+      _hoisted_3,
+      null,
+      512
+      /* NEED_PATCH */
+    ), [
+      [vue.vShow, _ctx.showMap]
+    ])
+  ]);
+}
+var VkfGeoinputUpdate = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "/home/runner/work/private-vunk-form/private-vunk-form/packages/components/geoinput-update/src/index.vue"]]);
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+VkfGeoinputUpdate.install = (app) => {
+  app.component(VkfGeoinputUpdate.name, VkfGeoinputUpdate);
+};
+
+exports.VkfGeoinputUpdate = VkfGeoinputUpdate;
+exports._VkfGeoinputUpdateCtx = ctx;
+exports.__VkfGeoinputUpdate = types;
+exports.default = VkfGeoinputUpdate;