@vunk/form 1.1.84 → 1.2.0

package/components/esri-input-geojson/index.cjs

@@ -0,0 +1,1120 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var input = require('@vunk/form/components/input');
+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('@vuesri/core');
+var MapView = require('@arcgis/core/views/MapView');
+var SceneView = require('@arcgis/core/views/SceneView');
+var index$1 = require('../index3.cjs');
+var core$1 = require('@vunk/core');
+var Graphic = require('@arcgis/core/Graphic');
+var composables = require('@vunk/form/composables');
+var utilsPromise = require('@vunk/core/shared/utils-promise');
+
+var EDIT_TYPE = /* @__PURE__ */ ((EDIT_TYPE2) => {
+  EDIT_TYPE2["POINT"] = "point";
+  EDIT_TYPE2["POLYGON"] = "polygon";
+  EDIT_TYPE2["LINE_STRING"] = "line_string";
+  return EDIT_TYPE2;
+})(EDIT_TYPE || {});
+const EDIT_TYPE_OPTIONS = [
+  {
+    label: "\u70B9",
+    value: "point" /* POINT */,
+    availableCreatureTools: ["point"]
+  },
+  {
+    label: "\u7EBF",
+    value: "line_string" /* LINE_STRING */,
+    availableCreatureTools: ["polyline"]
+  },
+  {
+    label: "\u9762",
+    value: "polygon" /* POLYGON */,
+    availableCreatureTools: ["polygon", "circle", "rectangle"]
+  }
+];
+const EDIT_TYPE_REFLECT = EDIT_TYPE_OPTIONS.reduce((acc, cur) => {
+  acc[cur.value] = cur;
+  return acc;
+}, {});
+const EMPTY_FEATURE_COLLECTION = {
+  type: "FeatureCollection",
+  features: []
+};
+
+const props = {
+  ...input._VkfInputCtx.props,
+  viewComponent: null,
+  viewComponentAttrs: null,
+  readonly: {
+    type: Boolean,
+    default: void 0
+  },
+  view: {
+    type: Object
+  },
+  editTypes: {
+    type: [Array, String],
+    default: () => "polygon"
+  },
+  viewModelActiveFillSymbol: {
+    type: Object,
+    default: () => ({
+      // 红色虚线，无色填充
+      type: "simple-fill",
+      color: [0, 0, 0, 0],
+      style: "solid",
+      outline: {
+        color: [255, 0, 0, 1],
+        width: 2,
+        style: "dash"
+      }
+    })
+  },
+  viewModelActiveLineSymbol: null,
+  viewModelActivePointSymbol: null,
+  modelValue: {
+    type: Object,
+    default: () => EMPTY_FEATURE_COLLECTION
+  },
+  multiple: {
+    type: Boolean,
+    default: true
+  },
+  skipSave: {
+    type: Boolean,
+    default: false
+  },
+  showMap: {
+    type: Boolean,
+    default: false
+  },
+  dialogEdit: {
+    type: Boolean,
+    default: true
+  },
+  dialogEditFullscreen: {
+    type: Boolean,
+    default: true
+  },
+  dialogEditTitle: {
+    type: String,
+    default: "\u7ED8\u5236\u56FE\u6591"
+  },
+  flying: {
+    type: Boolean,
+    default: false
+  },
+  layerIndex: {
+    type: Number,
+    default: 100
+  },
+  visibleElements: {
+    type: Object,
+    default: void 0
+  }
+};
+const createBindProps = utilsVue.bindPropsFactory(props);
+const emits = {
+  ...input._VkfInputCtx.emits,
+  "update:modelValue": (e) => e,
+  "update:flying": null,
+  /**
+   * 点击地图定位按钮
+   */
+  "appendFly": null,
+  appendEdit: null
+};
+const createOnEmits = utilsVue.onEmitsFactory(emits);
+
+var ctx = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  createBindProps: createBindProps,
+  createOnEmits: createOnEmits,
+  emits: emits,
+  props: props
+});
+
+var _sfc_main$3 = vue.defineComponent({
+  components: {
+    ElButton: elementPlus.ElButton,
+    ElIcon: elementPlus.ElIcon,
+    ElButtonGroup: elementPlus.ElButtonGroup,
+    Upload: index.upload_default,
+    Edit: index.edit_default,
+    ElUpload: elementPlus.ElUpload,
+    MapLocation: index.map_location_default
+  },
+  props: {
+    disabled: Boolean,
+    dialog: Boolean,
+    upload: {
+      type: Boolean,
+      default: true
+    }
+  },
+  emits: {
+    upload: (e) => e,
+    edit: null,
+    fly: null
+  },
+  methods: {
+    getFile(file) {
+      this.$emit("upload", file);
+    },
+    uploadClick(e) {
+      const target = e.target.querySelector("input[type=file]");
+      if (!target) return;
+      target.click();
+    }
+  }
+});
+
+function _sfc_render$3(_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_Edit = vue.resolveComponent("Edit");
+  const _component_ElButton = vue.resolveComponent("ElButton");
+  const _component_MapLocation = vue.resolveComponent("MapLocation");
+  const _component_ElButtonGroup = vue.resolveComponent("ElButtonGroup");
+  return vue.openBlock(), vue.createBlock(_component_ElButtonGroup, null, {
+    default: vue.withCtx(() => [
+      _ctx.upload ? (vue.openBlock(), vue.createBlock(_component_ElUpload, {
+        key: 0,
+        class: "el-button el-button--default vkf-esri-input-geojson__upload",
+        action: "",
+        accept: "file",
+        multiple: false,
+        "show-file-list": false,
+        "auto-upload": false,
+        "on-change": _ctx.getFile,
+        disabled: _ctx.disabled,
+        onClick: _ctx.uploadClick
+      }, {
+        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", "onClick"])) : vue.createCommentVNode("v-if", true),
+      _ctx.dialog ? (vue.openBlock(), vue.createBlock(_component_ElButton, {
+        key: 1,
+        disabled: _ctx.disabled,
+        onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("edit"))
+      }, {
+        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),
+      vue.createVNode(_component_ElButton, {
+        onClick: _cache[1] || (_cache[1] = ($event) => _ctx.$emit("fly"))
+      }, {
+        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$3, [["render", _sfc_render$3], ["__file", "/home/runner/work/private-vunk-form/private-vunk-form/packages/components/esri-input-geojson/src/append.vue"]]);
+
+var _sfc_main$2 = /* @__PURE__ */ vue.defineComponent({
+  __name: "default-view",
+  setup(__props, { expose: __expose }) {
+    __expose();
+    const __returned__ = { get VaTdtBasemap() {
+      return core.VaTdtBasemap;
+    }, get VaMapView() {
+      return core.VaMapView;
+    } };
+    Object.defineProperty(__returned__, "__isScriptSetup", { enumerable: false, value: true });
+    return __returned__;
+  }
+});
+
+function _sfc_render$2(_ctx, _cache, $props, $setup, $data, $options) {
+  return vue.openBlock(), vue.createBlock($setup["VaMapView"], null, {
+    default: vue.withCtx(() => [
+      vue.createVNode($setup["VaTdtBasemap"]),
+      vue.renderSlot(_ctx.$slots, "default")
+    ]),
+    _: 3
+    /* FORWARDED */
+  });
+}
+var DefaultView = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main$2, [["render", _sfc_render$2], ["__file", "/home/runner/work/private-vunk-form/private-vunk-form/packages/components/esri-input-geojson/src/default-view.vue"]]);
+
+var _sfc_main$1 = vue.defineComponent({
+  components: {
+    VaTdtBasemap: core.VaTdtBasemap,
+    VaMapView: core.VaMapView
+  },
+  props: {
+    view: {
+      type: Object,
+      default: void 0
+    },
+    viewComponent: {
+      type: [Object, Function],
+      default: () => DefaultView
+    },
+    viewComponentAttrs: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  setup(props) {
+    if (props.view) {
+      vue.provide("vaView", props.view);
+      if (props.view instanceof MapView) {
+        vue.provide("vaMapView", props.view);
+      }
+      if (props.view instanceof SceneView) {
+        vue.provide("vaSceneView", props.view);
+      }
+    }
+    return {};
+  }
+});
+
+function _sfc_render$1(_ctx, _cache, $props, $setup, $data, $options) {
+  return !_ctx.view ? (vue.openBlock(), vue.createBlock(
+    vue.resolveDynamicComponent(_ctx.viewComponent),
+    vue.normalizeProps(vue.mergeProps({ key: 0 }, _ctx.viewComponentAttrs)),
+    {
+      default: vue.withCtx(() => [
+        vue.renderSlot(_ctx.$slots, "default")
+      ]),
+      _: 3
+      /* FORWARDED */
+    },
+    16
+    /* FULL_PROPS */
+  )) : vue.renderSlot(_ctx.$slots, "default", { key: 1 });
+}
+var ViewerVue = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main$1, [["render", _sfc_render$1], ["__file", "/home/runner/work/private-vunk-form/private-vunk-form/packages/components/esri-input-geojson/src/viewer.vue"]]);
+
+/* @preserve
+* @terraformer/arcgis - v2.1.1 - MIT
+* Copyright (c) 2012-2022 Environmental Systems Research Institute, Inc.
+* Tue Aug 02 2022 14:23:48 GMT-0700 (Pacific Daylight Time)
+*/
+/* Copyright (c) 2012-2019 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+var edgeIntersectsEdge = function edgeIntersectsEdge(a1, a2, b1, b2) {
+  var uaT = (b2[0] - b1[0]) * (a1[1] - b1[1]) - (b2[1] - b1[1]) * (a1[0] - b1[0]);
+  var ubT = (a2[0] - a1[0]) * (a1[1] - b1[1]) - (a2[1] - a1[1]) * (a1[0] - b1[0]);
+  var uB = (b2[1] - b1[1]) * (a2[0] - a1[0]) - (b2[0] - b1[0]) * (a2[1] - a1[1]);
+
+  if (uB !== 0) {
+    var ua = uaT / uB;
+    var ub = ubT / uB;
+
+    if (ua >= 0 && ua <= 1 && ub >= 0 && ub <= 1) {
+      return true;
+    }
+  }
+
+  return false;
+};
+var coordinatesContainPoint = function coordinatesContainPoint(coordinates, point) {
+  var contains = false;
+
+  for (var i = -1, l = coordinates.length, j = l - 1; ++i < l; j = i) {
+    if ((coordinates[i][1] <= point[1] && point[1] < coordinates[j][1] || coordinates[j][1] <= point[1] && point[1] < coordinates[i][1]) && point[0] < (coordinates[j][0] - coordinates[i][0]) * (point[1] - coordinates[i][1]) / (coordinates[j][1] - coordinates[i][1]) + coordinates[i][0]) {
+      contains = !contains;
+    }
+  }
+
+  return contains;
+};
+var pointsEqual = function pointsEqual(a, b) {
+  for (var i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+
+  return true;
+};
+var arrayIntersectsArray = function arrayIntersectsArray(a, b) {
+  for (var i = 0; i < a.length - 1; i++) {
+    for (var j = 0; j < b.length - 1; j++) {
+      if (edgeIntersectsEdge(a[i], a[i + 1], b[j], b[j + 1])) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+};
+
+/* Copyright (c) 2012-2019 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+var closeRing = function closeRing(coordinates) {
+  if (!pointsEqual(coordinates[0], coordinates[coordinates.length - 1])) {
+    coordinates.push(coordinates[0]);
+  }
+
+  return coordinates;
+}; // determine if polygon ring coordinates are clockwise. clockwise signifies outer ring, counter-clockwise an inner ring
+// or hole. this logic was found at http://stackoverflow.com/questions/1165647/how-to-determine-if-a-list-of-polygon-
+// points-are-in-clockwise-order
+
+var ringIsClockwise = function ringIsClockwise(ringToTest) {
+  var total = 0;
+  var i = 0;
+  var rLength = ringToTest.length;
+  var pt1 = ringToTest[i];
+  var pt2;
+
+  for (i; i < rLength - 1; i++) {
+    pt2 = ringToTest[i + 1];
+    total += (pt2[0] - pt1[0]) * (pt2[1] + pt1[1]);
+    pt1 = pt2;
+  }
+
+  return total >= 0;
+}; // This function ensures that rings are oriented in the right directions
+// from http://jsperf.com/cloning-an-object/2
+
+var shallowClone = function shallowClone(obj) {
+  var target = {};
+
+  for (var i in obj) {
+    // both arcgis attributes and geojson props are just hardcoded keys
+    if (obj.hasOwnProperty(i)) {
+      // eslint-disable-line no-prototype-builtins
+      target[i] = obj[i];
+    }
+  }
+
+  return target;
+};
+
+/* Copyright (c) 2012-2019 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+var coordinatesContainCoordinates = function coordinatesContainCoordinates(outer, inner) {
+  var intersects = arrayIntersectsArray(outer, inner);
+  var contains = coordinatesContainPoint(outer, inner[0]);
+
+  if (!intersects && contains) {
+    return true;
+  }
+
+  return false;
+}; // do any polygons in this array contain any other polygons in this array?
+// used for checking for holes in arcgis rings
+
+
+var convertRingsToGeoJSON = function convertRingsToGeoJSON(rings) {
+  var outerRings = [];
+  var holes = [];
+  var x; // iterator
+
+  var outerRing; // current outer ring being evaluated
+
+  var hole; // current hole being evaluated
+  // for each ring
+
+  for (var r = 0; r < rings.length; r++) {
+    var ring = closeRing(rings[r].slice(0));
+
+    if (ring.length < 4) {
+      continue;
+    } // is this ring an outer ring? is it clockwise?
+
+
+    if (ringIsClockwise(ring)) {
+      var polygon = [ring.slice().reverse()]; // wind outer rings counterclockwise for RFC 7946 compliance
+
+      outerRings.push(polygon); // push to outer rings
+    } else {
+      holes.push(ring.slice().reverse()); // wind inner rings clockwise for RFC 7946 compliance
+    }
+  }
+
+  var uncontainedHoles = []; // while there are holes left...
+
+  while (holes.length) {
+    // pop a hole off out stack
+    hole = holes.pop(); // loop over all outer rings and see if they contain our hole.
+
+    var contained = false;
+
+    for (x = outerRings.length - 1; x >= 0; x--) {
+      outerRing = outerRings[x][0];
+
+      if (coordinatesContainCoordinates(outerRing, hole)) {
+        // the hole is contained push it into our polygon
+        outerRings[x].push(hole);
+        contained = true;
+        break;
+      }
+    } // ring is not contained in any outer ring
+    // sometimes this happens https://github.com/Esri/esri-leaflet/issues/320
+
+
+    if (!contained) {
+      uncontainedHoles.push(hole);
+    }
+  } // if we couldn't match any holes using contains we can try intersects...
+
+
+  while (uncontainedHoles.length) {
+    // pop a hole off out stack
+    hole = uncontainedHoles.pop(); // loop over all outer rings and see if any intersect our hole.
+
+    var intersects = false;
+
+    for (x = outerRings.length - 1; x >= 0; x--) {
+      outerRing = outerRings[x][0];
+
+      if (arrayIntersectsArray(outerRing, hole)) {
+        // the hole is contained push it into our polygon
+        outerRings[x].push(hole);
+        intersects = true;
+        break;
+      }
+    }
+
+    if (!intersects) {
+      outerRings.push([hole.reverse()]);
+    }
+  }
+
+  if (outerRings.length === 1) {
+    return {
+      type: 'Polygon',
+      coordinates: outerRings[0]
+    };
+  } else {
+    return {
+      type: 'MultiPolygon',
+      coordinates: outerRings
+    };
+  }
+};
+
+var getId = function getId(attributes, idAttribute) {
+  var keys = ['OBJECTID', 'FID'];
+
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+
+    if (key in attributes && (typeof attributes[key] === 'string' || typeof attributes[key] === 'number')) {
+      return attributes[key];
+    }
+  }
+
+  throw Error('No valid id attribute found');
+};
+
+var arcgisToGeoJSON = function arcgisToGeoJSON(arcgis, idAttribute) {
+  var geojson = {};
+
+  if (arcgis.features) {
+    geojson.type = 'FeatureCollection';
+    geojson.features = [];
+
+    for (var i = 0; i < arcgis.features.length; i++) {
+      geojson.features.push(arcgisToGeoJSON(arcgis.features[i], idAttribute));
+    }
+  }
+
+  if (typeof arcgis.x === 'number' && typeof arcgis.y === 'number') {
+    geojson.type = 'Point';
+    geojson.coordinates = [arcgis.x, arcgis.y];
+
+    if (typeof arcgis.z === 'number') {
+      geojson.coordinates.push(arcgis.z);
+    }
+  }
+
+  if (arcgis.points) {
+    geojson.type = 'MultiPoint';
+    geojson.coordinates = arcgis.points.slice(0);
+  }
+
+  if (arcgis.paths) {
+    if (arcgis.paths.length === 1) {
+      geojson.type = 'LineString';
+      geojson.coordinates = arcgis.paths[0].slice(0);
+    } else {
+      geojson.type = 'MultiLineString';
+      geojson.coordinates = arcgis.paths.slice(0);
+    }
+  }
+
+  if (arcgis.rings) {
+    geojson = convertRingsToGeoJSON(arcgis.rings.slice(0));
+  }
+
+  if (typeof arcgis.xmin === 'number' && typeof arcgis.ymin === 'number' && typeof arcgis.xmax === 'number' && typeof arcgis.ymax === 'number') {
+    geojson.type = 'Polygon';
+    geojson.coordinates = [[[arcgis.xmax, arcgis.ymax], [arcgis.xmin, arcgis.ymax], [arcgis.xmin, arcgis.ymin], [arcgis.xmax, arcgis.ymin], [arcgis.xmax, arcgis.ymax]]];
+  }
+
+  if (arcgis.geometry || arcgis.attributes) {
+    geojson.type = 'Feature';
+    geojson.geometry = arcgis.geometry ? arcgisToGeoJSON(arcgis.geometry) : null;
+    geojson.properties = arcgis.attributes ? shallowClone(arcgis.attributes) : null;
+
+    if (arcgis.attributes) {
+      try {
+        geojson.id = getId(arcgis.attributes, idAttribute);
+      } catch (err) {// don't set an id
+      }
+    }
+  } // if no valid geometry was encountered
+
+
+  if (JSON.stringify(geojson.geometry) === JSON.stringify({})) {
+    geojson.geometry = null;
+  }
+
+  if (arcgis.spatialReference && arcgis.spatialReference.wkid && arcgis.spatialReference.wkid !== 4326) {
+    console.warn('Object converted in non-standard crs - ' + JSON.stringify(arcgis.spatialReference));
+  }
+
+  return geojson;
+};
+
+/* Copyright (c) 2012-2019 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+// outer rings are clockwise, holes are counterclockwise
+// used for converting GeoJSON Polygons to ArcGIS Polygons
+
+var orientRings = function orientRings(poly) {
+  var output = [];
+  var polygon = poly.slice(0);
+  var outerRing = closeRing(polygon.shift().slice(0));
+
+  if (outerRing.length >= 4) {
+    if (!ringIsClockwise(outerRing)) {
+      outerRing.reverse();
+    }
+
+    output.push(outerRing);
+
+    for (var i = 0; i < polygon.length; i++) {
+      var hole = closeRing(polygon[i].slice(0));
+
+      if (hole.length >= 4) {
+        if (ringIsClockwise(hole)) {
+          hole.reverse();
+        }
+
+        output.push(hole);
+      }
+    }
+  }
+
+  return output;
+}; // This function flattens holes in multipolygons to one array of polygons
+// used for converting GeoJSON Polygons to ArcGIS Polygons
+
+
+var flattenMultiPolygonRings = function flattenMultiPolygonRings(rings) {
+  var output = [];
+
+  for (var i = 0; i < rings.length; i++) {
+    var polygon = orientRings(rings[i]);
+
+    for (var x = polygon.length - 1; x >= 0; x--) {
+      var ring = polygon[x].slice(0);
+      output.push(ring);
+    }
+  }
+
+  return output;
+};
+
+var geojsonToArcGIS = function geojsonToArcGIS(geojson, idAttribute) {
+  idAttribute = idAttribute || 'OBJECTID';
+  var spatialReference = {
+    wkid: 4326
+  };
+  var result = {};
+  var i;
+
+  switch (geojson.type) {
+    case 'Point':
+      result.x = geojson.coordinates[0];
+      result.y = geojson.coordinates[1];
+
+      if (geojson.coordinates[2] != null) {
+        result.z = geojson.coordinates[2];
+      }
+
+      result.spatialReference = spatialReference;
+      break;
+
+    case 'MultiPoint':
+      result.points = geojson.coordinates.slice(0);
+
+      if (geojson.coordinates[0][2] != null) {
+        result.hasZ = true;
+      }
+
+      result.spatialReference = spatialReference;
+      break;
+
+    case 'LineString':
+      result.paths = [geojson.coordinates.slice(0)];
+
+      if (geojson.coordinates[0][2] != null) {
+        result.hasZ = true;
+      }
+
+      result.spatialReference = spatialReference;
+      break;
+
+    case 'MultiLineString':
+      result.paths = geojson.coordinates.slice(0);
+
+      if (geojson.coordinates[0][0][2] != null) {
+        result.hasZ = true;
+      }
+
+      result.spatialReference = spatialReference;
+      break;
+
+    case 'Polygon':
+      result.rings = orientRings(geojson.coordinates.slice(0));
+
+      if (geojson.coordinates[0][0][2] != null) {
+        result.hasZ = true;
+      }
+
+      result.spatialReference = spatialReference;
+      break;
+
+    case 'MultiPolygon':
+      result.rings = flattenMultiPolygonRings(geojson.coordinates.slice(0));
+
+      if (geojson.coordinates[0][0][0][2] != null) {
+        result.hasZ = true;
+      }
+
+      result.spatialReference = spatialReference;
+      break;
+
+    case 'Feature':
+      if (geojson.geometry) {
+        result.geometry = geojsonToArcGIS(geojson.geometry, idAttribute);
+      }
+
+      result.attributes = geojson.properties ? shallowClone(geojson.properties) : {};
+
+      if (geojson.id) {
+        result.attributes[idAttribute] = geojson.id;
+      }
+
+      break;
+
+    case 'FeatureCollection':
+      result = [];
+
+      for (i = 0; i < geojson.features.length; i++) {
+        result.push(geojsonToArcGIS(geojson.features[i], idAttribute));
+      }
+
+      break;
+
+    case 'GeometryCollection':
+      result = [];
+
+      for (i = 0; i < geojson.geometries.length; i++) {
+        result.push(geojsonToArcGIS(geojson.geometries[i], idAttribute));
+      }
+
+      break;
+  }
+
+  return result;
+};
+
+var _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  name: "VkfEsriInputGeojson",
+  components: {
+    VkfInput: input.VkfInput,
+    VaSketch: core.VaSketch,
+    ViewerVue,
+    VkAsyncTeleport: core$1.VkAsyncTeleport,
+    DocumentChecked: index.document_checked_default,
+    VaGraphicsLayer: core.VaGraphicsLayer
+  },
+  props,
+  emits,
+  setup(props2, {
+    emit
+  }) {
+    const inputBindProps = input._VkfInputCtx.createBindProps(props2, ["inputSlots", "readonly", "modelValue"]);
+    const inputOnEmits = input._VkfInputCtx.createOnEmits(emit, ["update:modelValue"]);
+    const getInputModelValue = v => {
+      const emptyStr = "\u6682\u65E0\u6570\u636E";
+      if (!v) return emptyStr;
+      if (!v.features.length) return emptyStr;
+      return JSON.stringify(v);
+    };
+    const readonly = composables.useComputedReadonly(props2);
+    const sketchIf = vue.ref(!props2.view);
+    const sketchRef = vue.shallowRef();
+    const shetchPanel = vue.computed(() => {
+      const container = sketchRef.value?.container;
+      return container?.querySelector(".esri-sketch__panel");
+    });
+    const viewDef = new utilsPromise.Deferred();
+    const layerRef = vue.shallowRef();
+    const sketchLoad = async e => {
+      await e.sketch.when();
+      sketchRef.value = e.sketch;
+      viewDef.resolve(sketchRef.value.view);
+    };
+    const layerLoad = async ({
+      view,
+      layer
+    }) => {
+      viewDef.resolve(view);
+      layerRef.value = layer;
+    };
+    const availableCreatureTools = vue.computed(() => {
+      if (Array.isArray(props2.editTypes)) {
+        return props2.editTypes.reduce((pre, cur) => {
+          return pre.concat(EDIT_TYPE_REFLECT[cur].availableCreatureTools);
+        }, []);
+      } else {
+        return EDIT_TYPE_REFLECT[props2.editTypes].availableCreatureTools;
+      }
+    });
+    const sketchValueUpdating = vue.ref(false);
+    const sketchValue = vue.shallowRef([]);
+    vue.watch(() => props2.modelValue, (v, ov) => {
+      if (sketchValueUpdating.value) return;
+      uSketchValue();
+      if (!ov?.features.length) {
+        fly();
+      }
+    }, {
+      immediate: true
+    });
+    const handleUpdateSketchValue = e => {
+      sketchValue.value = e;
+      if (props2.skipSave) {
+        u();
+      }
+    };
+    const normalMapRef = vue.shallowRef();
+    const dialogMapRef = vue.shallowRef();
+    const mapTo = vue.shallowRef();
+    vue.onMounted(() => {
+      mapTo.value = normalMapRef.value;
+    });
+    const dialogShow = vue.ref(false);
+    const setDialogShow = v => {
+      dialogShow.value = v;
+    };
+    const dialogOnOpen = async () => {
+      mapTo.value = dialogMapRef.value;
+    };
+    const dialogOnClose = async () => {
+      mapTo.value = normalMapRef.value;
+    };
+    const doSave = () => {
+      u();
+      elementPlus.ElMessage({
+        message: "\u4FDD\u5B58\u6210\u529F",
+        type: "success"
+      });
+      dialogShow.value = false;
+      if (props2.view) {
+        sketchIf.value = false;
+      }
+    };
+    const append = () => vue.createVNode(AppendVue, {
+      "dialog": !readonly.value && props2.dialogEdit,
+      "upload": !readonly.value,
+      "disabled": props2.disabled,
+      "onUpload": onUpload,
+      "onEdit": onEdit,
+      "onFly": () => {
+        if (!props2.showMap && !props2.view) {
+          dialogShow.value = true;
+        }
+        emit("appendFly");
+        fly();
+      }
+    }, null);
+    async function onUpload(e) {
+      if (!e.raw) return;
+      index$1.toGeojson(e.raw).then(res => {
+        emit("update:modelValue", res);
+      }).then(() => {
+        elementPlus.ElMessage.success("\u4E0A\u4F20\u6210\u529F");
+      }).then(fly);
+    }
+    function onEdit() {
+      if (!props2.view) {
+        dialogShow.value = true;
+      } else {
+        sketchIf.value = true;
+      }
+      emit("appendEdit");
+    }
+    function u() {
+      sketchValueUpdating.value = true;
+      const features = sketchValue.value.map(item => {
+        return arcgisToGeoJSON(item);
+      });
+      emit("update:modelValue", {
+        type: "FeatureCollection",
+        features
+      });
+      vue.nextTick(() => {
+        sketchValueUpdating.value = false;
+      });
+    }
+    function uSketchValue() {
+      const esriData = geojsonToArcGIS(props2.modelValue);
+      const graphics = esriData.map(item => {
+        const g = item.geometry;
+        if (g.rings) {
+          g.type = "polygon";
+          item.symbol = props2.viewModelActiveFillSymbol;
+        } else if (g.paths) {
+          g.type = "polyline";
+          item.symbol = props2.viewModelActiveLineSymbol;
+        } else if (g.x) {
+          g.type = "point";
+          item.symbol = props2.viewModelActivePointSymbol;
+        }
+        return new Graphic(item);
+      });
+      sketchValue.value = graphics;
+    }
+    vue.watch(() => props2.flying, v => {
+      v && fly();
+    });
+    async function fly() {
+      const view = await viewDef.promise;
+      if (!view) return;
+      emit("update:flying", true);
+      await view.when();
+      view.goTo(sketchValue.value).finally(() => {
+        emit("update:flying", false);
+      });
+    }
+    return {
+      inputBindProps,
+      inputOnEmits,
+      append,
+      availableCreatureTools,
+      sketchValue,
+      handleUpdateSketchValue,
+      sketchRef,
+      sketchLoad,
+      shetchPanel,
+      dialogShow,
+      setDialogShow,
+      normalMapRef,
+      dialogMapRef,
+      dialogOnOpen,
+      dialogOnClose,
+      mapTo,
+      doSave,
+      readonly,
+      layerLoad,
+      sketchIf,
+      fly,
+      layerRef,
+      getInputModelValue
+    };
+  }
+});
+
+const _hoisted_1 = { class: "vkf-form-item" };
+const _hoisted_2 = {
+  ref: "normalMapRef",
+  class: "vkf-esri-input-geojson__map"
+};
+const _hoisted_3 = {
+  ref: "dialogMapRef",
+  class: "vkf-esri-input-geojson-dialog__map"
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_VkfInput = vue.resolveComponent("VkfInput");
+  const _component_DocumentChecked = vue.resolveComponent("DocumentChecked");
+  const _component_ElIcon = vue.resolveComponent("ElIcon");
+  const _component_VkAsyncTeleport = vue.resolveComponent("VkAsyncTeleport");
+  const _component_VaSketch = vue.resolveComponent("VaSketch");
+  const _component_VaGraphicsLayer = vue.resolveComponent("VaGraphicsLayer");
+  const _component_ViewerVue = vue.resolveComponent("ViewerVue");
+  const _component_ElDialog = vue.resolveComponent("ElDialog");
+  return vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
+    vue.renderSlot(_ctx.$slots, "custom", {
+      modelValue: _ctx.modelValue,
+      fly: _ctx.fly,
+      setDialogShow: _ctx.setDialogShow,
+      layer: _ctx.layerRef,
+      showMap: _ctx.showMap
+    }, () => [
+      vue.createVNode(_component_VkfInput, vue.mergeProps({
+        readonly: true,
+        "model-value": _ctx.getInputModelValue(_ctx.modelValue)
+      }, _ctx.inputBindProps, {
+        "input-slots": {
+          append: _ctx.append
+        }
+      }, vue.toHandlers(_ctx.inputOnEmits)), null, 16, ["model-value", "input-slots"])
+    ]),
+    vue.createVNode(_component_VkAsyncTeleport, { to: _ctx.mapTo }, {
+      default: vue.withCtx(() => [
+        vue.createVNode(_component_ViewerVue, {
+          view: _ctx.view,
+          "view-component": _ctx.viewComponent,
+          "view-component-attrs": _ctx.viewComponentAttrs
+        }, {
+          default: vue.withCtx(() => [
+            vue.createVNode(_component_VaGraphicsLayer, {
+              index: _ctx.layerIndex,
+              graphics: _ctx.sketchValue,
+              onLoad: _ctx.layerLoad
+            }, {
+              default: vue.withCtx(() => [
+                !(_ctx.readonly || !_ctx.sketchIf) ? (vue.openBlock(), vue.createBlock(_component_VaSketch, {
+                  key: 0,
+                  "view-model-active-fill-symbol": _ctx.viewModelActiveFillSymbol,
+                  "view-model-active-line-symbol": _ctx.viewModelActiveLineSymbol,
+                  "view-model-active-point-symbol": _ctx.viewModelActivePointSymbol,
+                  multiple: _ctx.multiple,
+                  "available-creature-tools": _ctx.availableCreatureTools,
+                  "model-value": _ctx.sketchValue,
+                  "visible-elements": _ctx.visibleElements,
+                  "onUpdate:modelValue": _ctx.handleUpdateSketchValue,
+                  onLoad: _ctx.sketchLoad
+                }, {
+                  default: vue.withCtx(() => [
+                    !_ctx.skipSave && _ctx.shetchPanel ? (vue.openBlock(), vue.createBlock(_component_VkAsyncTeleport, {
+                      key: 0,
+                      to: _ctx.shetchPanel
+                    }, {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(_component_ElIcon, {
+                          class: "esri-sketch-ui-save esri-widget--button",
+                          onClick: _ctx.doSave
+                        }, {
+                          default: vue.withCtx(() => [
+                            vue.createVNode(_component_DocumentChecked)
+                          ]),
+                          _: 1
+                          /* STABLE */
+                        }, 8, ["onClick"])
+                      ]),
+                      _: 1
+                      /* STABLE */
+                    }, 8, ["to"])) : vue.createCommentVNode("v-if", true)
+                  ]),
+                  _: 1
+                  /* STABLE */
+                }, 8, ["view-model-active-fill-symbol", "view-model-active-line-symbol", "view-model-active-point-symbol", "multiple", "available-creature-tools", "model-value", "visible-elements", "onUpdate:modelValue", "onLoad"])) : vue.createCommentVNode("v-if", true)
+              ]),
+              _: 1
+              /* STABLE */
+            }, 8, ["index", "graphics", "onLoad"])
+          ]),
+          _: 1
+          /* STABLE */
+        }, 8, ["view", "view-component", "view-component-attrs"])
+      ]),
+      _: 1
+      /* STABLE */
+    }, 8, ["to"]),
+    vue.withDirectives(vue.createElementVNode(
+      "div",
+      _hoisted_2,
+      null,
+      512
+      /* NEED_PATCH */
+    ), [
+      [vue.vShow, _ctx.showMap]
+    ]),
+    vue.createVNode(_component_ElDialog, {
+      modelValue: _ctx.dialogShow,
+      "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.dialogShow = $event),
+      title: _ctx.dialogEditTitle,
+      fullscreen: _ctx.dialogEditFullscreen,
+      "modal-class": "vkf-esri-input-geojson-dialog",
+      "append-to-body": true,
+      "close-on-click-modal": false,
+      draggable: true,
+      onOpen: _ctx.dialogOnOpen,
+      onClose: _ctx.dialogOnClose
+    }, {
+      default: vue.withCtx(() => [
+        vue.createElementVNode(
+          "div",
+          _hoisted_3,
+          null,
+          512
+          /* NEED_PATCH */
+        )
+      ]),
+      _: 1
+      /* STABLE */
+    }, 8, ["modelValue", "title", "fullscreen", "onOpen", "onClose"])
+  ]);
+}
+var VkfEsriInputGeojson = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "/home/runner/work/private-vunk-form/private-vunk-form/packages/components/esri-input-geojson/src/index.vue"]]);
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+VkfEsriInputGeojson.install = (app) => {
+  app.component(VkfEsriInputGeojson.name, VkfEsriInputGeojson);
+};
+
+exports.EDIT_TYPE = EDIT_TYPE;
+exports.EDIT_TYPE_OPTIONS = EDIT_TYPE_OPTIONS;
+exports.EDIT_TYPE_REFLECT = EDIT_TYPE_REFLECT;
+exports.EMPTY_FEATURE_COLLECTION = EMPTY_FEATURE_COLLECTION;
+exports.VkfEsriInputGeojson = VkfEsriInputGeojson;
+exports._VkfEsriInputGeojsonCtx = ctx;
+exports.__VkfEsriInputGeojson = types;
+exports.default = VkfEsriInputGeojson;