ym-giswidget-2d 1.0.5 → 1.0.8

package/_virtual/_commonjs-dynamic-modules.js

@@ -0,0 +1,6 @@
+function commonjsRequire(path) {
+  throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
+}
+export {
+  commonjsRequire
+};

package/_virtual/_commonjsHelpers.js

@@ -0,0 +1,8 @@
+var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+export {
+  commonjsGlobal,
+  getDefaultExportFromCjs
+};

package/_virtual/jszip.min.js

@@ -0,0 +1,4 @@
+var jszip_min = { exports: {} };
+export {
+  jszip_min as __module
+};

package/components/clear/Clear.vue.d.ts

@@ -0,0 +1,6 @@
+import { default as OLMap } from 'ym-giscomm-2d/mapView/Map';
+type __VLS_Props = {
+    map: OLMap;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/components/clear/Clear.vue.js

@@ -0,0 +1,19 @@
+import { defineComponent, onMounted } from "vue";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "Clear",
+  props: {
+    map: {}
+  },
+  setup(__props) {
+    const props = __props;
+    onMounted(() => {
+      props.map.clearTempFeatures();
+    });
+    return (_ctx, _cache) => {
+      return null;
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/components/clear/Clear.vue2.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./Clear.vue.js";
+export {
+  _sfc_main as default
+};

package/components/clear/index.d.ts

@@ -0,0 +1,6 @@
+export declare const Clear: import('../../utils').WithInstall<import('vue').DefineComponent<{
+    map: import('ym-giscomm-2d/mapView/Map').default;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    map: import('ym-giscomm-2d/mapView/Map').default;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>>;
+export default Clear;

package/components/clear/index.js

@@ -0,0 +1,8 @@
+import "./index.css";
+import { withInstall } from "../../utils/wthInstall.js";
+import _sfc_main from "./Clear.vue.js";
+const Clear = withInstall(_sfc_main);
+export {
+  Clear,
+  Clear as default
+};

package/components/draw/Draw.vue.d.ts

@@ -0,0 +1,6 @@
+import { default as OLMap } from 'ym-giscomm-2d/mapView/Map';
+type __VLS_Props = {
+    map: OLMap;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/components/draw/Draw.vue.js

@@ -0,0 +1,71 @@
+import { defineComponent, onMounted, onUnmounted } from "vue";
+import Draw from "ym-giscomm-2d/interaction/Draw";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "Draw",
+  props: {
+    map: {}
+  },
+  setup(__props) {
+    const props = __props;
+    onMounted(() => {
+      const currentLayerInfo = props.map.currentEditLayer;
+      let geometryType = "polygon";
+      if (currentLayerInfo && currentLayerInfo.geometryType) {
+        switch (currentLayerInfo.geometryType) {
+          case 1:
+            geometryType = "point";
+            break;
+          case 2:
+            geometryType = "polyline";
+            break;
+          case 3:
+            geometryType = "polygon";
+            break;
+        }
+      }
+      const tempLayer = getTempLayerByGeometryType(geometryType);
+      let source = void 0;
+      const layersource = tempLayer == null ? void 0 : tempLayer.getSource();
+      if (layersource) {
+        source = layersource;
+      }
+      const draw = new Draw(geometryType, {
+        source
+      });
+      props.map.interactionManager.addInteraction("draw", draw);
+      draw.on("drawend", (event) => {
+        const features = event.feature;
+        if (features) {
+          features.isSelected = true;
+          features.tempLayer = tempLayer;
+          features.fromType = "draw";
+        }
+      });
+    });
+    onUnmounted(() => {
+      props.map.interactionManager.removeInteraction("draw");
+    });
+    function getTempLayerByGeometryType(geometryType) {
+      switch (geometryType) {
+        case "point":
+          return props.map.getPointTempLayer();
+        case "polyline":
+          return props.map.getLineTempLayer();
+        case "polygon":
+          return props.map.getPolygonTempLayer();
+        case "rectangle":
+          return props.map.getPolygonTempLayer();
+        case "circle":
+          return props.map.getPolygonTempLayer();
+        default:
+          return void 0;
+      }
+    }
+    return (_ctx, _cache) => {
+      return null;
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/components/draw/Draw.vue2.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./Draw.vue.js";
+export {
+  _sfc_main as default
+};

package/components/draw/index.d.ts

@@ -0,0 +1,6 @@
+export declare const Draw: import('../../utils').WithInstall<import('vue').DefineComponent<{
+    map: import('ym-giscomm-2d/mapView/Map').default;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    map: import('ym-giscomm-2d/mapView/Map').default;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>>;
+export default Draw;

package/components/draw/index.js

@@ -0,0 +1,8 @@
+import "./index.css";
+import { withInstall } from "../../utils/wthInstall.js";
+import _sfc_main from "./Draw.vue.js";
+const Draw = withInstall(_sfc_main);
+export {
+  Draw,
+  Draw as default
+};

package/components/export/Export.vue.d.ts

@@ -0,0 +1,154 @@
+import { default as OLMap } from 'ym-giscomm-2d/mapView/Map';
+type __VLS_Props = {
+    map: OLMap;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    activeInteraction: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onActiveInteraction?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    popupDom: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly title?: string | undefined;
+            readonly width?: number | undefined;
+            readonly height?: number | undefined;
+            readonly minWidth?: number | undefined;
+            readonly minHeight?: number | undefined;
+            readonly resizable?: boolean | undefined;
+            readonly showClose?: boolean | undefined;
+            readonly showMinimize?: boolean | undefined;
+            readonly showMaximize?: boolean | undefined;
+            readonly showDock?: boolean | undefined;
+            readonly drag?: boolean | undefined;
+            readonly showOk?: boolean | undefined;
+            readonly showCancel?: boolean | undefined;
+            readonly okText?: string | undefined;
+            readonly cancelText?: string | undefined;
+            readonly onClose?: ((...args: any[]) => any) | undefined;
+            readonly onResize?: ((...args: any[]) => any) | undefined;
+            readonly onMove?: ((...args: any[]) => any) | undefined;
+            readonly onOk?: ((...args: any[]) => any) | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            panelRef: HTMLDivElement;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "close", ...args: any[]) => void) & ((event: "resize", ...args: any[]) => void) & ((event: "move", ...args: any[]) => void) & ((event: "ok", ...args: any[]) => void);
+        $el: HTMLDivElement;
+        $options: import('vue').ComponentOptionsBase<Readonly<{
+            title?: string;
+            width?: number;
+            height?: number;
+            minWidth?: number;
+            minHeight?: number;
+            resizable?: boolean;
+            showClose?: boolean;
+            showMinimize?: boolean;
+            showMaximize?: boolean;
+            showDock?: boolean;
+            drag?: boolean;
+            showOk?: boolean;
+            showCancel?: boolean;
+            okText?: string;
+            cancelText?: string;
+        }> & Readonly<{
+            onClose?: ((...args: any[]) => any) | undefined;
+            onResize?: ((...args: any[]) => any) | undefined;
+            onMove?: ((...args: any[]) => any) | undefined;
+            onOk?: ((...args: any[]) => any) | undefined;
+        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            close: (...args: any[]) => void;
+            resize: (...args: any[]) => void;
+            move: (...args: any[]) => void;
+            ok: (...args: any[]) => void;
+        }, string, {
+            title: string;
+            showClose: boolean;
+            drag: boolean;
+            minWidth: number;
+            minHeight: number;
+            resizable: boolean;
+            showMinimize: boolean;
+            showMaximize: boolean;
+            showDock: boolean;
+            showOk: boolean;
+            showCancel: boolean;
+            okText: string;
+            cancelText: string;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import('vue').nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        title: string;
+        showClose: boolean;
+        drag: boolean;
+        minWidth: number;
+        minHeight: number;
+        resizable: boolean;
+        showMinimize: boolean;
+        showMaximize: boolean;
+        showDock: boolean;
+        showOk: boolean;
+        showCancel: boolean;
+        okText: string;
+        cancelText: string;
+    }> & Omit<Readonly<{
+        title?: string;
+        width?: number;
+        height?: number;
+        minWidth?: number;
+        minHeight?: number;
+        resizable?: boolean;
+        showClose?: boolean;
+        showMinimize?: boolean;
+        showMaximize?: boolean;
+        showDock?: boolean;
+        drag?: boolean;
+        showOk?: boolean;
+        showCancel?: boolean;
+        okText?: string;
+        cancelText?: string;
+    }> & Readonly<{
+        onClose?: ((...args: any[]) => any) | undefined;
+        onResize?: ((...args: any[]) => any) | undefined;
+        onMove?: ((...args: any[]) => any) | undefined;
+        onOk?: ((...args: any[]) => any) | undefined;
+    }>, "title" | "showClose" | "drag" | "minWidth" | "minHeight" | "resizable" | "showMinimize" | "showMaximize" | "showDock" | "showOk" | "showCancel" | "okText" | "cancelText"> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            header?(_: {}): any;
+            default?(_: {}): any;
+            footer?(_: {}): any;
+        };
+    }) | null;
+    formRef: unknown;
+}, HTMLDivElement>;
+export default _default;

package/components/export/Export.vue.js

@@ -0,0 +1,7 @@
+import _sfc_main from "./Export.vue2.js";
+/* empty css            */
+import _export_sfc from "../../_virtual/_plugin-vue_export-helper.js";
+const _Export = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-c8a32131"]]);
+export {
+  _Export as default
+};

package/components/export/Export.vue2.js

@@ -0,0 +1,298 @@
+import { ElForm, ElFormItem, ElSelect, ElOption, ElInput } from "element-plus/es";
+import "element-plus/es/components/base/style/css";
+import "element-plus/es/components/form/style/css";
+import "element-plus/es/components/input/style/css";
+import "element-plus/es/components/form-item/style/css";
+import "element-plus/es/components/select/style/css";
+import "element-plus/es/components/option/style/css";
+import { defineComponent, reactive, ref, onMounted, onUnmounted, withDirectives, createBlock, openBlock, withCtx, createVNode, unref, createCommentVNode, createElementBlock, Fragment, renderList, vShow } from "vue";
+import DraggablePanel from "../../panel/DraggablePanel.vue.js";
+import FeatureManager from "ym-giscomm-2d/feature/FeatureManager";
+import { toKml } from "ym-giscomm-2d/conver/kml";
+import GeoJSON from "../../node_modules/.pnpm/ol@9.2.4/node_modules/ol/format/GeoJSON.js";
+import { downloadBlob } from "ym-giscomm-2d/utils/UrlUtil";
+import JSZip from "../../node_modules/.pnpm/jszip@3.10.1/node_modules/jszip/dist/jszip.min.js";
+import { exportFeatures } from "../../http/SpaceFile.js";
+import { ElLoading, ElMessage } from "element-plus";
+import { base64ToBlob } from "ym-giscomm-2d/utils/StringUtil";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "Export",
+  props: {
+    map: {}
+  },
+  emits: ["activeInteraction"],
+  setup(__props, { emit: __emit }) {
+    const emit = __emit;
+    const props = __props;
+    let reactiveValue = reactive({
+      visible: true,
+      exportType: "shp",
+      fileName: "",
+      exportLayer: null,
+      layerInfos: []
+    });
+    const formRef = ref();
+    onMounted(() => {
+      init();
+    });
+    onUnmounted(() => {
+      reactiveValue.visible = false;
+    });
+    function handleClose() {
+      reactiveValue.visible = false;
+    }
+    function handleOk() {
+      if (!formRef || !formRef.value) return;
+      formRef.value.validate(async (valid) => {
+        if (valid) {
+          const loadingInstance = ElLoading.service({ text: "正在导出...", background: "rgba(0, 0, 0, 0.5)", target: props.map.getTarget() });
+          try {
+            if (reactiveValue.exportType == "shp") {
+              await exportShp();
+            } else if (reactiveValue.exportType == "kml") {
+              const kml = exportKml();
+              const blob = new Blob([kml]);
+              downloadBlob(blob, reactiveValue.fileName + ".kml");
+            } else if (reactiveValue.exportType == "kmz") {
+              const kml = exportKml();
+              const zip = new JSZip();
+              zip.file(reactiveValue.fileName + ".kml", kml);
+              const blob = await zip.generateAsync({
+                type: "blob"
+              });
+              downloadBlob(blob, reactiveValue.fileName + ".kmz");
+            } else {
+              ElMessage.error("不支持的文件格式");
+            }
+            ElMessage.success("导出成功");
+            loadingInstance.close();
+          } catch (error) {
+            loadingInstance.close();
+            ElMessage.error("导出失败");
+          }
+        }
+      });
+    }
+    function init() {
+      const featureManager = new FeatureManager(props.map);
+      const features = featureManager.getSelectedFeatures(void 0, true);
+      if (!features || features.length == 0) {
+        emit("activeInteraction", { success: false, message: "请先选择要素" });
+        return;
+      }
+      reactiveValue.layerInfos = getLayerInfos(features);
+    }
+    function getLayerInfos(features) {
+      if (!features || features.length === 0) {
+        return [];
+      }
+      const layerIds = features.map((feature) => feature.layerId ?? "");
+      if (!layerIds || layerIds.length == 0) {
+        return [];
+      }
+      const uniqueArr = Array.from(new Set(layerIds));
+      const layers = props.map.getLayersByIds(uniqueArr);
+      let layerInfos = [];
+      if (layers && layers.length > 0) {
+        for (let i = 0; i < layers.length; i++) {
+          const layer = layers[i];
+          if (!layer) {
+            continue;
+          }
+          const layerInfo = { ...layer.layerInfo, features: [] };
+          const newfeatures = features.filter((t) => t.layerId == layerInfo.id);
+          layerInfo.features = newfeatures;
+          layerInfos.push(layerInfo);
+        }
+      }
+      let tempPointLayerInfo = { id: "tempPoint", title: "临时点要素", features: [] };
+      let tempLineLayerInfo = { id: "tempLine", title: "临时线要素", features: [] };
+      let tempPolygonLayerInfo = { id: "tempPolygon", title: "临时面要素", features: [] };
+      for (let i = 0, length = features.length; i < length; i++) {
+        const feature = features[i];
+        if (feature.layerId) {
+          continue;
+        }
+        const geometry = feature.getGeometry();
+        if (!geometry) {
+          continue;
+        }
+        const type = geometry.getType();
+        switch (type) {
+          case "Point":
+          case "MultiPoint":
+            tempPointLayerInfo.features.push(feature);
+            break;
+          case "LineString":
+          case "MultiLineString":
+            tempLineLayerInfo.features.push(feature);
+            break;
+          case "Polygon":
+          case "MultiPolygon":
+            tempPolygonLayerInfo.features.push(feature);
+            break;
+        }
+      }
+      if (tempPointLayerInfo.features.length > 0) {
+        layerInfos.push(tempPointLayerInfo);
+      }
+      if (tempLineLayerInfo.features.length > 0) {
+        layerInfos.push(tempLineLayerInfo);
+      }
+      if (tempPolygonLayerInfo.features.length > 0) {
+        layerInfos.push(tempPolygonLayerInfo);
+      }
+      return layerInfos;
+    }
+    async function exportShp() {
+      var _a;
+      const features = (_a = reactiveValue.exportLayer) == null ? void 0 : _a.features;
+      if (!features || features.length == 0) {
+        return;
+      }
+      const res = await exportFeatures(features, 4326, reactiveValue.fileName, "shp");
+      const blob = base64ToBlob(res);
+      downloadBlob(blob, reactiveValue.fileName + ".zip");
+    }
+    function exportKml() {
+      var _a;
+      const geojsonCollection = {
+        type: "FeatureCollection",
+        features: []
+      };
+      const features = (_a = reactiveValue.exportLayer) == null ? void 0 : _a.features;
+      if (!features || features.length == 0) {
+        return "";
+      }
+      const geojson = new GeoJSON();
+      for (let feature of features) {
+        const json = geojson.writeFeature(feature);
+        geojsonCollection.features.push(JSON.parse(json));
+      }
+      const kml = toKml(geojsonCollection, {});
+      return kml;
+    }
+    return (_ctx, _cache) => {
+      const _component_el_option = ElOption;
+      const _component_el_select = ElSelect;
+      const _component_el_form_item = ElFormItem;
+      const _component_el_input = ElInput;
+      const _component_el_form = ElForm;
+      return withDirectives((openBlock(), createBlock(DraggablePanel, {
+        ref: "popupDom",
+        class: "el-current",
+        title: "导出",
+        drag: true,
+        width: 300,
+        height: 267,
+        showMaximize: false,
+        showOk: true,
+        onClose: handleClose,
+        onOk: handleOk
+      }, {
+        default: withCtx(() => [
+          createVNode(_component_el_form, {
+            ref_key: "formRef",
+            ref: formRef,
+            model: unref(reactiveValue),
+            "label-width": "auto"
+          }, {
+            default: withCtx(() => [
+              unref(reactiveValue).layerInfos && unref(reactiveValue).layerInfos.length > 0 ? (openBlock(), createBlock(_component_el_form_item, {
+                key: 0,
+                label: "导出图层",
+                prop: "exportLayer",
+                rules: {
+                  required: true,
+                  message: "请选择导出图层",
+                  trigger: "change"
+                }
+              }, {
+                default: withCtx(() => [
+                  createVNode(_component_el_select, {
+                    modelValue: unref(reactiveValue).exportLayer,
+                    "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => unref(reactiveValue).exportLayer = $event),
+                    "value-key": "id",
+                    class: "el-current",
+                    "popper-class": "el-current"
+                  }, {
+                    default: withCtx(() => [
+                      (openBlock(true), createElementBlock(Fragment, null, renderList(unref(reactiveValue).layerInfos, (item) => {
+                        return openBlock(), createBlock(_component_el_option, {
+                          key: item.id,
+                          label: item.title,
+                          value: item
+                        }, null, 8, ["label", "value"]);
+                      }), 128))
+                    ]),
+                    _: 1
+                  }, 8, ["modelValue"])
+                ]),
+                _: 1
+              })) : createCommentVNode("", true),
+              createVNode(_component_el_form_item, {
+                label: "导出格式",
+                prop: "exportType",
+                rules: {
+                  required: true,
+                  message: "请选择文件格式",
+                  trigger: "change"
+                }
+              }, {
+                default: withCtx(() => [
+                  createVNode(_component_el_select, {
+                    modelValue: unref(reactiveValue).exportType,
+                    "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => unref(reactiveValue).exportType = $event),
+                    class: "el-current",
+                    "popper-class": "el-current"
+                  }, {
+                    default: withCtx(() => [
+                      createVNode(_component_el_option, {
+                        label: "shp文件",
+                        value: "shp"
+                      }),
+                      createVNode(_component_el_option, {
+                        label: "kml",
+                        value: "kml"
+                      }),
+                      createVNode(_component_el_option, {
+                        label: "kmz",
+                        value: "kmz"
+                      })
+                    ]),
+                    _: 1
+                  }, 8, ["modelValue"])
+                ]),
+                _: 1
+              }),
+              createVNode(_component_el_form_item, {
+                label: "文件名",
+                prop: "fileName",
+                rules: {
+                  required: true,
+                  message: "请输入文件名",
+                  trigger: "blur"
+                }
+              }, {
+                default: withCtx(() => [
+                  createVNode(_component_el_input, {
+                    modelValue: unref(reactiveValue).fileName,
+                    "onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => unref(reactiveValue).fileName = $event)
+                  }, null, 8, ["modelValue"])
+                ]),
+                _: 1
+              })
+            ]),
+            _: 1
+          }, 8, ["model"])
+        ]),
+        _: 1
+      }, 512)), [
+        [vShow, unref(reactiveValue).visible]
+      ]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/components/export/index.css

@@ -0,0 +1,3 @@
+.panel-content[data-v-c8a32131] .el-form-item {
+  margin-bottom: 10px;
+}