@vunk/form 1.1.76 → 1.1.79

package/components/geoinput-update/index.mjs

@@ -0,0 +1,399 @@
+import { defineComponent, resolveComponent, openBlock, createBlock, withCtx, createVNode, normalizeClass, createCommentVNode, computed, shallowRef, ref, onMounted, nextTick, createElementBlock, mergeProps, toHandlers, withModifiers, renderSlot, resolveDynamicComponent, createElementVNode, withDirectives, vShow } from 'vue';
+import { _VkfInputCtx, VkfInput } from '@vunk/form/components/input';
+import { EMPTY_FEATURE_COLLECTION } from '@vumap/core/shared/static';
+import { bindPropsFactory, onEmitsFactory } from '@vunk/core/shared/utils-vue';
+import { ElButton, ElIcon, ElButtonGroup, ElUpload, ElDialog, ElMessage } from 'element-plus';
+import { u as upload_default, e as edit_default, b as checked_default } from '../index2.mjs';
+import { _ as _export_sfc } from '../_plugin-vue_export-helper.mjs';
+import { VmMap } from '@vumap/core';
+import { VmTdtLayers } from '@vumap/core/components/tdt-layers';
+import { VmControlDraw } from '@vumap/core/components/control-draw';
+import { Deferred } from '@vunk/core/shared/utils-promise';
+import { t as toGeojson } from '../index3.mjs';
+import { VkAsyncTeleport } from '@vunk/core';
+import { VmControlDrawUi } from '@vumap/core/components/control-draw-ui';
+
+const props = {
+  ..._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: () => 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 = bindPropsFactory(props);
+const emits = {
+  ..._VkfInputCtx.emits,
+  "update:modelValue": (e) => e,
+  "editUpdate": (e) => e
+};
+const createOnEmits = onEmitsFactory(emits);
+
+var ctx = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  createBindProps: createBindProps,
+  createOnEmits: createOnEmits,
+  emits: emits,
+  props: props
+});
+
+var _sfc_main$1 = defineComponent({
+  components: {
+    ElButton,
+    ElIcon,
+    ElButtonGroup,
+    Upload: upload_default,
+    Edit: edit_default,
+    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 = resolveComponent("Upload");
+  const _component_ElIcon = resolveComponent("ElIcon");
+  const _component_ElUpload = resolveComponent("ElUpload");
+  const _component_ElButton = resolveComponent("ElButton");
+  const _component_Edit = resolveComponent("Edit");
+  const _component_ElButtonGroup = resolveComponent("ElButtonGroup");
+  return openBlock(), createBlock(_component_ElButtonGroup, null, {
+    default: withCtx(() => [
+      createVNode(_component_ElButton, { class: "vk-geoinput-upload-x" }, {
+        default: withCtx(() => [
+          createVNode(_component_ElUpload, {
+            class: normalizeClass("vk-geoinput-upload"),
+            action: "",
+            accept: "file",
+            multiple: false,
+            "show-file-list": false,
+            "auto-upload": false,
+            "on-change": _ctx.getFile,
+            disabled: _ctx.disabled
+          }, {
+            default: withCtx(() => [
+              createVNode(_component_ElIcon, { color: "var(--el-color-primary)" }, {
+                default: withCtx(() => [
+                  createVNode(_component_Upload)
+                ]),
+                _: 1
+                /* STABLE */
+              })
+            ]),
+            _: 1
+            /* STABLE */
+          }, 8, ["on-change", "disabled"])
+        ]),
+        _: 1
+        /* STABLE */
+      }),
+      _ctx.dialog ? (openBlock(), createBlock(_component_ElButton, {
+        key: 0,
+        onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("edit")),
+        disabled: _ctx.disabled
+      }, {
+        default: withCtx(() => [
+          createVNode(_component_ElIcon, { color: "var(--el-color-primary)" }, {
+            default: withCtx(() => [
+              createVNode(_component_Edit)
+            ]),
+            _: 1
+            /* STABLE */
+          })
+        ]),
+        _: 1
+        /* STABLE */
+      }, 8, ["disabled"])) : createCommentVNode("v-if", true)
+    ]),
+    _: 1
+    /* STABLE */
+  });
+}
+var AppendVue = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["render", _sfc_render$1], ["__file", "D:\\labCode\\vunk-form2\\packages\\components\\geoinput-update\\src\\append.vue"]]);
+
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  name: "VkfGeoinputUpdate",
+  components: {
+    VkfInput,
+    ElDialog,
+    VmMap,
+    VmTdtLayers,
+    VmControlDraw,
+    VkAsyncTeleport,
+    VmControlDrawUi,
+    ElIcon,
+    Checked: checked_default
+  },
+  emits,
+  props,
+  setup(props2, {
+    emit
+  }) {
+    const inputBindProps = _VkfInputCtx.createBindProps(props2, ["inputSlots", "readonly", "modelValue"]);
+    const inputOnEmits = _VkfInputCtx.createOnEmits(emit, ["update:modelValue"]);
+    const mapOptions = computed(() => {
+      return {
+        center: props2.mapCenter
+      };
+    });
+    const geoInputMapDialogNode = shallowRef();
+    const geoInputMapXNode = shallowRef();
+    const editPlayground = ref(geoInputMapXNode.value);
+    onMounted(() => {
+      editPlayground.value = geoInputMapXNode.value;
+    });
+    const mapTo = computed(() => {
+      return editPlayground.value === geoInputMapDialogNode.value ? geoInputMapDialogNode.value : props2.mapTo ?? editPlayground.value;
+    });
+    const mapControls = computed(() => {
+      return props2.readonly ? [] : typeof props2.editTypes === "string" ? [props2.editTypes, ...props2.editControls] : [...props2.editTypes, ...props2.editControls];
+    });
+    const currentDrawCacheValue = ref(props2.modelValue);
+    const currentDrawValue = 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);
+      ElMessage({
+        message: "\u4FDD\u5B58\u6210\u529F",
+        type: "success"
+      });
+      dialogShow.value = false;
+    };
+    const dialogShow = ref(false);
+    const mapDef = new Deferred();
+    const dialogOnOpen = async () => {
+      await nextTick();
+      editPlayground.value = geoInputMapDialogNode.value;
+      await 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 = () => createVNode(AppendVue, {
+      "dialog": props2.dialogEdit,
+      "disabled": props2.disabled,
+      "onUpload": onUpload,
+      "onEdit": onEdit
+    }, null);
+    async function onUpload(e) {
+      if (!e.raw) return;
+      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 = resolveComponent("VkfInput");
+  const _component_VmTdtLayers = resolveComponent("VmTdtLayers");
+  const _component_Checked = resolveComponent("Checked");
+  const _component_ElIcon = resolveComponent("ElIcon");
+  const _component_VmControlDrawUi = resolveComponent("VmControlDrawUi");
+  const _component_VmControlDraw = resolveComponent("VmControlDraw");
+  const _component_VmMap = resolveComponent("VmMap");
+  const _component_VkAsyncTeleport = resolveComponent("VkAsyncTeleport");
+  const _component_ElDialog = resolveComponent("ElDialog");
+  return openBlock(), createElementBlock("div", _hoisted_1, [
+    createVNode(_component_VkfInput, mergeProps({
+      readonly: true,
+      modelValue: JSON.stringify(_ctx.modelValue)
+    }, _ctx.inputBindProps, toHandlers(_ctx.inputOnEmits), {
+      inputSlots: _ctx.readonly ? {} : {
+        append: _ctx.append
+      }
+    }), null, 16, ["modelValue", "inputSlots"]),
+    createVNode(_component_VkAsyncTeleport, { to: _ctx.mapTo }, {
+      default: withCtx(() => [
+        createVNode(_component_VmMap, {
+          defaultOptions: _ctx.mapOptions,
+          class: "vk-geoinput-edit-map",
+          onLoad: _cache[1] || (_cache[1] = ($event) => _ctx.mapDef.resolve($event.map))
+        }, {
+          default: withCtx(() => [
+            createVNode(_component_VmTdtLayers),
+            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: withCtx(() => [
+                !_ctx.spikSave ? (openBlock(), createBlock(_component_VmControlDrawUi, {
+                  key: 0,
+                  onClick: withModifiers(_ctx.doSave, ["prevent"])
+                }, {
+                  default: withCtx(() => [
+                    createVNode(_component_ElIcon, null, {
+                      default: withCtx(() => [
+                        createVNode(_component_Checked)
+                      ]),
+                      _: 1
+                      /* STABLE */
+                    })
+                  ]),
+                  _: 1
+                  /* STABLE */
+                }, 8, ["onClick"])) : createCommentVNode("v-if", true)
+              ]),
+              _: 1
+              /* STABLE */
+            }, 8, ["styles", "modelValue", "onUpdate:modelValue", "controls", "multiple"]),
+            renderSlot(_ctx.$slots, "map"),
+            _ctx.slots.map ? (openBlock(), createBlock(resolveDynamicComponent(typeof _ctx.slots.map === "function" ? _ctx.slots.map() : _ctx.slots.map), { key: 0 })) : createCommentVNode("v-if", true)
+          ]),
+          _: 3
+          /* FORWARDED */
+        }, 8, ["defaultOptions"])
+      ]),
+      _: 3
+      /* FORWARDED */
+    }, 8, ["to"]),
+    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: withCtx(() => [
+        createElementVNode(
+          "div",
+          _hoisted_2,
+          null,
+          512
+          /* NEED_PATCH */
+        )
+      ]),
+      _: 1
+      /* STABLE */
+    }, 8, ["modelValue", "title", "fullscreen", "onOpen", "onClose"]),
+    withDirectives(createElementVNode(
+      "div",
+      _hoisted_3,
+      null,
+      512
+      /* NEED_PATCH */
+    ), [
+      [vShow, _ctx.showMap]
+    ])
+  ]);
+}
+var VkfGeoinputUpdate = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "D:\\labCode\\vunk-form2\\packages\\components\\geoinput-update\\src\\index.vue"]]);
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+VkfGeoinputUpdate.install = (app) => {
+  app.component(VkfGeoinputUpdate.name, VkfGeoinputUpdate);
+};
+
+export { VkfGeoinputUpdate, ctx as _VkfGeoinputUpdateCtx, types as __VkfGeoinputUpdate, VkfGeoinputUpdate as default };