ym-giswidget-2d 1.0.5 → 1.0.8

package/components/popup/Popup.vue2.js

@@ -0,0 +1,266 @@
+import { ElTable, ElTableColumn, ElPagination, ElSelect, ElOption } from "element-plus/es";
+import "element-plus/es/components/base/style/css";
+import "element-plus/es/components/pagination/style/css";
+import "element-plus/es/components/table/style/css";
+import "element-plus/es/components/table-column/style/css";
+import "element-plus/es/components/select/style/css";
+import "element-plus/es/components/option/style/css";
+import { defineComponent, reactive, ref, watch, onMounted, onUnmounted, withDirectives, createBlock, openBlock, withCtx, createElementVNode, createVNode, unref, toDisplayString, createElementBlock, Fragment, renderList, vShow } from "vue";
+import DraggablePanel from "../../panel/DraggablePanel.vue.js";
+import Overlay from "../../node_modules/.pnpm/ol@9.2.4/node_modules/ol/Overlay.js";
+import { getLayerFields } from "../../http/LayerField.js";
+import { ElMessage } from "element-plus";
+import FeatureManager from "ym-giscomm-2d/feature/FeatureManager";
+const _hoisted_1 = { class: "identify-popup-content" };
+const _hoisted_2 = { class: "pagination-block" };
+const overlayId = "identify-popup";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "Popup",
+  props: {
+    map: {},
+    features: {},
+    postion: {}
+  },
+  emits: ["close"],
+  setup(__props, { emit: __emit }) {
+    const emit = __emit;
+    const props = __props;
+    let reactiveValue = reactive({
+      layerInfos: [],
+      currentData: [],
+      currentPage: 1,
+      pageTotal: 1,
+      visible: true
+    });
+    const popupDom = ref(null);
+    watch(() => props.features, (newVal) => {
+      init();
+    });
+    watch(() => reactiveValue.currentPage, (newVal) => {
+      flashFeatures();
+    });
+    onMounted(() => {
+      init();
+    });
+    onUnmounted(() => {
+      const overlayTip = props.map.getOverlayById(overlayId);
+      if (overlayTip) {
+        reactiveValue.visible = false;
+        props.map.removeOverlay(overlayTip);
+      }
+    });
+    function handleClose() {
+      reactiveValue.visible = false;
+      emit("close");
+    }
+    async function init() {
+      try {
+        if (!props.features || props.features.length == 0) {
+          reactiveValue.visible = false;
+          return;
+        }
+        reactiveValue.layerInfos = await getLayerInfos();
+        reactiveValue.currentLayer = reactiveValue.layerInfos[0];
+        reactiveValue.pageTotal = reactiveValue.currentLayer.features.length;
+        if (reactiveValue.currentPage == 1) {
+          flashFeatures();
+        } else {
+          reactiveValue.currentPage = 1;
+        }
+        reactiveValue.visible = true;
+        if (!popupDom.value) {
+          return;
+        }
+        let overlayTip = props.map.getOverlayById(overlayId);
+        if (!overlayTip) {
+          overlayTip = new Overlay({
+            id: overlayId,
+            element: popupDom.value.$el,
+            autoPan: {
+              animation: {
+                duration: 250
+              }
+            }
+          });
+          props.map.addOverlay(overlayTip);
+        }
+        overlayTip.setPosition(props.postion);
+      } catch (error) {
+        ElMessage.error("获取要素信息失败");
+        handleClose();
+      }
+    }
+    function flashFeatures() {
+      var _a;
+      const feature = (_a = reactiveValue.currentLayer) == null ? void 0 : _a.features[reactiveValue.currentPage - 1].feature;
+      if (!feature) {
+        return;
+      }
+      const featureManager = new FeatureManager(props.map);
+      featureManager.flashFeatures([feature], 6);
+    }
+    function onChangeLayer(layer) {
+      reactiveValue.currentLayer = layer;
+      if (reactiveValue.currentPage == 1) {
+        flashFeatures();
+      } else {
+        reactiveValue.currentPage = 1;
+      }
+      reactiveValue.pageTotal = reactiveValue.currentLayer.features.length;
+    }
+    async function getLayerInfos() {
+      if (!props.features || props.features.length == 0) {
+        return [];
+      }
+      const layerIds = props.features.map((feature) => feature.layerId ?? "");
+      if (!layerIds || layerIds.length == 0) {
+        return [];
+      }
+      const uniqueArr = Array.from(new Set(layerIds));
+      const layers = props.map.getLayersByIds(uniqueArr);
+      if (!layers || layers.length == 0) {
+        return [];
+      }
+      let layerInfos = [];
+      for (let i = 0; i < layers.length; i++) {
+        const layer = layers[i];
+        if (!layer) {
+          continue;
+        }
+        const layerInfo = { ...layer.layerInfo, features: [] };
+        layerInfo.features = await getFeatures(layerInfo);
+        layerInfos.push(layerInfo);
+      }
+      return layerInfos;
+    }
+    async function getFeatures(layerInfo) {
+      if (!layerInfo) {
+        return [];
+      }
+      if (layerInfo.features && layerInfo.features.length > 0) {
+        return layerInfo.features;
+      }
+      const features = props.features.filter((t) => t.layerId == layerInfo.id);
+      if (features.length == 0) {
+        return [];
+      }
+      if (!layerInfo.fields) {
+        await getLayerFields(layerInfo);
+      }
+      const fields = layerInfo.fields;
+      if (!fields) {
+        return [];
+      }
+      let featuresInfo = [];
+      for (let i = 0; i < features.length; i++) {
+        const feature = features[i];
+        const attributes = feature.getProperties();
+        if (!attributes) {
+          continue;
+        }
+        let attributesInfos = [];
+        for (const key in attributes) {
+          const field = fields.find((t) => t.name.toLowerCase() == key.toLowerCase());
+          if (!field || field.fieldType == 6) {
+            continue;
+          }
+          let value = attributes[key];
+          if (field.fieldType == 4 && value) {
+            value = new Date(attributes[key]).toLocaleDateString();
+          }
+          attributesInfos.push({ ...field, value });
+        }
+        featuresInfo.push({ attributes: attributesInfos, geometry: feature.getGeometry(), feature });
+      }
+      return featuresInfo;
+    }
+    return (_ctx, _cache) => {
+      const _component_el_option = ElOption;
+      const _component_el_select = ElSelect;
+      const _component_el_table_column = ElTableColumn;
+      const _component_el_table = ElTable;
+      const _component_el_pagination = ElPagination;
+      return withDirectives((openBlock(), createBlock(DraggablePanel, {
+        ref_key: "popupDom",
+        ref: popupDom,
+        class: "identify-popup el-current",
+        width: 300,
+        height: 400,
+        showMaximize: false,
+        onClose: handleClose
+      }, {
+        header: withCtx(() => [
+          createVNode(_component_el_select, {
+            modelValue: unref(reactiveValue).currentLayer,
+            "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => unref(reactiveValue).currentLayer = $event),
+            "value-key": "id",
+            placeholder: "请选择",
+            onChange: onChangeLayer,
+            "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"])
+        ]),
+        default: withCtx(() => {
+          var _a;
+          return [
+            createElementVNode("div", _hoisted_1, [
+              createVNode(_component_el_table, {
+                data: (_a = unref(reactiveValue).currentLayer) == null ? void 0 : _a.features[unref(reactiveValue).currentPage - 1].attributes,
+                "cell-style": { border: "0px", padding: "3px 0" },
+                "show-header": false,
+                style: { "width": "100%" }
+              }, {
+                default: withCtx(() => [
+                  createVNode(_component_el_table_column, {
+                    prop: "aliasName",
+                    label: "字段名",
+                    width: "auto",
+                    align: "left"
+                  }, {
+                    default: withCtx((scope) => [
+                      createElementVNode("span", null, toDisplayString(scope.row.aliasName + ":"), 1)
+                    ]),
+                    _: 1
+                  }),
+                  createVNode(_component_el_table_column, {
+                    prop: "value",
+                    label: "值",
+                    width: "auto",
+                    align: "left"
+                  })
+                ]),
+                _: 1
+              }, 8, ["data"]),
+              createElementVNode("div", _hoisted_2, [
+                createVNode(_component_el_pagination, {
+                  "current-page": unref(reactiveValue).currentPage,
+                  "onUpdate:currentPage": _cache[1] || (_cache[1] = ($event) => unref(reactiveValue).currentPage = $event),
+                  layout: "prev, pager, next",
+                  "page-size": 1,
+                  "pager-count": 5,
+                  total: unref(reactiveValue).pageTotal
+                }, null, 8, ["current-page", "total"])
+              ])
+            ])
+          ];
+        }),
+        _: 1
+      }, 512)), [
+        [vShow, unref(reactiveValue).visible]
+      ]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/components/popup/index.css

@@ -0,0 +1,61 @@
+.identify-popup[data-v-61fb39d3] {
+  top: unset !important;
+  overflow: unset !important;
+  transform: unset !important;
+  position: absolute !important;
+  bottom: 12px;
+  left: -50px;
+  transform: unset !important;
+}
+.identify-popup[data-v-61fb39d3]::after, .identify-popup[data-v-61fb39d3]::before {
+  top: 100%;
+  border: solid transparent;
+  content: " ";
+  height: 0;
+  width: 0;
+  position: absolute;
+  pointer-events: none;
+}
+.identify-popup[data-v-61fb39d3]::after {
+  border-top-color: white;
+  border-width: 10px;
+  left: 48px;
+  margin-left: -10px;
+}
+.identify-popup[data-v-61fb39d3]::before {
+  border-top-color: #cccccc;
+  border-width: 11px;
+  left: 48px;
+  margin-left: -11px;
+}
+.identify-popup .panel-header .el-select[data-v-61fb39d3] {
+  --el-fill-color-blank: "";
+  --el-input-text-color: var(--system-primary-text-color);
+  --el-input-icon-color: var(--system-primary-text-color);
+}
+.identify-popup .identify-popup-content[data-v-61fb39d3] {
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+}
+.identify-popup .identify-popup-content .el-table[data-v-61fb39d3] {
+  --el-table-bg-color: "";
+  --el-table-tr-bg-color: "";
+  --el-table-text-color: var(--system-primary-text-color);
+  --el-table-row-hover-bg-color: "";
+  height: 100%;
+}
+.identify-popup .identify-popup-content .pagination-block[data-v-61fb39d3] {
+  margin-top: 10px;
+}
+.identify-popup .identify-popup-content .pagination-block .el-pagination[data-v-61fb39d3] {
+  justify-content: center;
+  --el-pagination-bg-color: "";
+  --el-pagination-text-color: var(--system-primary-text-color);
+  --el-pagination-button-bg-color: "";
+  --el-pagination-button-disabled-bg-color: "";
+  --el-pagination-button-color: var(--system-primary-text-color);
+}
+.identify-popup .identify-popup-content .pagination-block .el-pagination[data-v-61fb39d3] .el-icon {
+  color: var(--system-primary-text-color);
+}

package/components/popup/index.d.ts

@@ -0,0 +1,157 @@
+export declare const Popup: import('../../utils').WithInstall<import('vue').DefineComponent<{
+    map: import('ym-giscomm-2d/mapView/Map').default;
+    features: import('ym-giscomm-2d/entity/Feature').default[];
+    postion: import('ol/coordinate').Coordinate;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<{
+    map: import('ym-giscomm-2d/mapView/Map').default;
+    features: import('ym-giscomm-2d/entity/Feature').default[];
+    postion: import('ol/coordinate').Coordinate;
+}> & Readonly<{
+    onClose?: ((...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;
+}, any>>;
+export default Popup;

package/components/popup/index.js

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

package/components/popup/index2.css

@@ -0,0 +1,5 @@
+.popup-select-items {
+  --el-bg-color-overlay: var(--system-primary-color);
+  --el-color-primary: var(--system-primary-text-active-color);
+  --el-fill-color-light: "";
+}

package/components/select/Select.vue.d.ts

@@ -0,0 +1,13 @@
+import { default as OLMap } from 'ym-giscomm-2d/mapView/Map';
+import { default as Style } from 'ol/style/Style';
+type __VLS_Props = {
+    map: OLMap;
+    pointStyle?: Style;
+    cancePointStyle?: Style;
+    lineStyle?: Style;
+    canceLineStyle?: Style;
+    polygonStyle?: Style;
+    cancePolygonStyle?: Style;
+};
+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/select/Select.vue.js

@@ -0,0 +1,142 @@
+import { defineComponent, onMounted, onUnmounted } from "vue";
+import Select from "ym-giscomm-2d/interaction/Select";
+import { ElLoading } from "element-plus";
+import FeatureManager from "ym-giscomm-2d/feature/FeatureManager";
+import { intersects } from "ym-giscomm-2d/utils/GeometryUtil";
+import { getSelectPointStyle, getSelectCancePointStyle, getSelectLineStyle, getSelectCancelLineStyle, getSelectPolygonStyle, getSelectCancelPolygonStyle } from "ym-giscomm-2d/style/StyleManager";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "Select",
+  props: {
+    map: {},
+    pointStyle: {},
+    cancePointStyle: {},
+    lineStyle: {},
+    canceLineStyle: {},
+    polygonStyle: {},
+    cancePolygonStyle: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const pointStyle = props.pointStyle || getSelectPointStyle();
+    const cancePointStyle = props.cancePointStyle || getSelectCancePointStyle();
+    const lineStyle = props.lineStyle || getSelectLineStyle();
+    const canceLineStyle = props.canceLineStyle || getSelectCancelLineStyle();
+    const polygonStyle = props.polygonStyle || getSelectPolygonStyle();
+    const cancePolygonStyle = props.cancePolygonStyle || getSelectCancelPolygonStyle();
+    const tempType = ["copy", "cut", "draw", "import", "union"];
+    let holdCtrl = false;
+    onMounted(() => {
+      const select = new Select("rectangle", {
+        pointStyle,
+        cancePointStyle,
+        lineStyle,
+        canceLineStyle,
+        polygonStyle,
+        cancePolygonStyle,
+        addTempLayer: false
+      });
+      props.map.interactionManager.addInteraction("select", select);
+      let loadingInstance;
+      select.on("selectstart", (event) => {
+        loadingInstance = ElLoading.service({ text: "正在查询...", background: "rgba(0, 0, 0, 0.5)", target: props.map.getTarget() });
+      });
+      select.on("selected", (event) => {
+        loadingInstance.close();
+        holdCtrl = event.holdCtrl;
+        if (event.selectGeom) {
+          clearSelected(event.selectGeom);
+        }
+        if (event.allFeatures) {
+          addFeaturesToTempLayer(event.allFeatures);
+        }
+      });
+    });
+    onUnmounted(() => {
+      props.map.interactionManager.removeInteraction("select");
+    });
+    function addFeaturesToTempLayer(features) {
+      var _a;
+      for (const feature of features) {
+        let tempLayer = props.map.getPolygonTempLayer();
+        let style = polygonStyle;
+        switch ((_a = feature.getGeometry()) == null ? void 0 : _a.getType()) {
+          case "Point":
+          case "MultiPoint":
+            tempLayer = props.map.getPointTempLayer();
+            style = pointStyle;
+            break;
+          case "LineString":
+          case "MultiLineString":
+            tempLayer = props.map.getLineTempLayer();
+            style = lineStyle;
+            break;
+          case "Polygon":
+          case "MultiPolygon":
+            tempLayer = props.map.getPolygonTempLayer();
+            style = polygonStyle;
+            break;
+        }
+        const source = tempLayer.getSource();
+        if (source) {
+          feature.isSelected = true;
+          feature.tempLayer = tempLayer;
+          feature.setStyle(style);
+          if (!feature.fromType || !tempType.includes(feature.fromType)) {
+            source.addFeature(feature);
+          }
+        }
+      }
+    }
+    function clearSelected(geo) {
+      var _a;
+      const featureManager = new FeatureManager(props.map);
+      const features = featureManager.getSelectedFeatures(void 0, true);
+      if (!features || features.length == 0) {
+        return;
+      }
+      let clearFeatures = [];
+      for (const feature of features) {
+        const featureGeo = feature.getGeometry();
+        if (!featureGeo) {
+          continue;
+        }
+        const isIntersects = intersects(featureGeo, geo);
+        if (holdCtrl && isIntersects) {
+          clearFeatures.push(feature);
+        } else if (!holdCtrl) {
+          clearFeatures.push(feature);
+        }
+      }
+      for (const feature of clearFeatures) {
+        if (feature.fromType && tempType.includes(feature.fromType)) {
+          feature.isSelected = false;
+          switch ((_a = feature.getGeometry()) == null ? void 0 : _a.getType()) {
+            case "Point":
+            case "MultiPoint":
+              feature.setStyle(cancePointStyle);
+              break;
+            case "LineString":
+            case "MultiLineString":
+              feature.setStyle(canceLineStyle);
+              break;
+            case "Polygon":
+            case "MultiPolygon":
+              feature.setStyle(cancePolygonStyle);
+              break;
+          }
+        } else if (feature.tempLayer && feature.tempLayer.getSource()) {
+          const source = feature.tempLayer.getSource();
+          if (source) {
+            source.removeFeature(feature);
+          }
+        }
+      }
+    }
+    return (_ctx, _cache) => {
+      return null;
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/components/select/Select.vue2.js

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

package/components/select/index.d.ts

@@ -0,0 +1,18 @@
+export declare const Select: import('../../utils').WithInstall<import('vue').DefineComponent<{
+    map: import('ym-giscomm-2d/mapView/Map').default;
+    pointStyle?: import('ol/style').Style;
+    cancePointStyle?: import('ol/style').Style;
+    lineStyle?: import('ol/style').Style;
+    canceLineStyle?: import('ol/style').Style;
+    polygonStyle?: import('ol/style').Style;
+    cancePolygonStyle?: import('ol/style').Style;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    map: import('ym-giscomm-2d/mapView/Map').default;
+    pointStyle?: import('ol/style').Style;
+    cancePointStyle?: import('ol/style').Style;
+    lineStyle?: import('ol/style').Style;
+    canceLineStyle?: import('ol/style').Style;
+    polygonStyle?: import('ol/style').Style;
+    cancePolygonStyle?: import('ol/style').Style;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>>;
+export default Select;