@vunk/form 0.0.1-alpha.9 → 1.1.1

package/components/geoinput-read/index.js

@@ -0,0 +1,355 @@
+import { openBlock, createElementBlock, createElementVNode, defineComponent, resolveComponent, createBlock, withCtx, createVNode, computed, Fragment, withDirectives, mergeProps, toHandlers, vShow, renderSlot, createCommentVNode, normalizeProps, guardReactiveProps } from 'vue';
+import { VkWrapper } from '@vunk/core/components/wrapper';
+import { _VkfInputCtx, VkfInput } from '@vunk/form/components/input';
+import { EMPTY_FEATURE_COLLECTION } from '@vumap/core/shared/static';
+import { _VmGeojsonLayerCtx } from '@vumap/core/components/geojson-layer';
+import { bindPropsFactory, onEmitsFactory } from '@vunk/core/shared/utils-vue';
+import { ElButton, ElIcon, ElButtonGroup } from 'element-plus';
+import { VmGeojsonLayer, _VmGeojsonLayerCtx as _VmGeojsonLayerCtx$1, useMap, VmTdtLayers, VmMap } from '@vumap/core';
+import { fitGeojson } from '@vumap/core/shared/utils';
+
+var __defProp$1 = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const props = __spreadProps(__spreadValues$1(__spreadValues$1({}, _VkfInputCtx.props), _VmGeojsonLayerCtx.props), {
+  modelValue: {
+    type: Object,
+    default: () => EMPTY_FEATURE_COLLECTION
+  },
+  editStyles: {
+    type: Array,
+    default: () => []
+  },
+  editTypes: {
+    type: [Array, String],
+    default: "polygon"
+  },
+  paint: {
+    type: Object,
+    default: void 0
+  },
+  type: {
+    type: String,
+    default: void 0
+  },
+  custom: {
+    type: Boolean,
+    default: false
+  },
+  showMap: {
+    type: Boolean,
+    default: false
+  }
+});
+const createBindProps = bindPropsFactory(props);
+const emits = __spreadProps(__spreadValues$1(__spreadValues$1({}, _VmGeojsonLayerCtx.emits), _VkfInputCtx.emits), {
+  "layerChange": (layer) => layer,
+  "update:modelValue": (e) => e
+});
+const createOnEmits = onEmitsFactory(emits);
+
+var ctx = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  props: props,
+  createBindProps: createBindProps,
+  emits: emits,
+  createOnEmits: createOnEmits
+});
+
+/*! Element Plus Icons Vue v2.1.0 */
+
+// unplugin-vue:/plugin-vue/export-helper
+var export_helper_default = (sfc, props) => {
+  let target = sfc.__vccOpts || sfc;
+  for (let [key, val] of props)
+    target[key] = val;
+  return target;
+};
+
+// unplugin-vue:/home/runner/work/element-plus-icons/element-plus-icons/packages/vue/src/components/map-location.vue?vue&type=script&lang.ts
+var map_location_vue_vue_type_script_lang_default = {
+  name: "MapLocation"
+};
+var _hoisted_1160 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  viewBox: "0 0 1024 1024"
+}, _hoisted_2160 = /* @__PURE__ */ createElementVNode(
+  "path",
+  {
+    fill: "currentColor",
+    d: "M800 416a288 288 0 1 0-576 0c0 118.144 94.528 272.128 288 456.576C705.472 688.128 800 534.144 800 416zM512 960C277.312 746.688 160 565.312 160 416a352 352 0 0 1 704 0c0 149.312-117.312 330.688-352 544z"
+  },
+  null,
+  -1
+  /* HOISTED */
+), _hoisted_3159 = /* @__PURE__ */ createElementVNode(
+  "path",
+  {
+    fill: "currentColor",
+    d: "M512 448a64 64 0 1 0 0-128 64 64 0 0 0 0 128zm0 64a128 128 0 1 1 0-256 128 128 0 0 1 0 256zm345.6 192L960 960H672v-64H352v64H64l102.4-256h691.2zm-68.928 0H235.328l-76.8 192h706.944l-76.8-192z"
+  },
+  null,
+  -1
+  /* HOISTED */
+), _hoisted_444 = [
+  _hoisted_2160,
+  _hoisted_3159
+];
+function _sfc_render160(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("svg", _hoisted_1160, _hoisted_444);
+}
+var map_location_default = /* @__PURE__ */ export_helper_default(map_location_vue_vue_type_script_lang_default, [["render", _sfc_render160], ["__file", "map-location.vue"]]);
+
+var _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+
+const _sfc_main$2 = defineComponent({
+  components: {
+    ElButton,
+    ElIcon,
+    ElButtonGroup,
+    MapLocation: map_location_default
+  },
+  emits: {
+    mapLocationClick: null
+  }
+});
+function _sfc_render$2(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_MapLocation = resolveComponent("MapLocation");
+  const _component_ElIcon = resolveComponent("ElIcon");
+  const _component_ElButton = resolveComponent("ElButton");
+  const _component_ElButtonGroup = resolveComponent("ElButtonGroup");
+  return openBlock(), createBlock(_component_ElButtonGroup, null, {
+    default: withCtx(() => [
+      createVNode(_component_ElButton, {
+        class: "vk-geoinput-read-map-location-x",
+        onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("mapLocationClick"))
+      }, {
+        default: withCtx(() => [
+          createVNode(_component_ElIcon, { color: "var(--el-color-primary)" }, {
+            default: withCtx(() => [
+              createVNode(_component_MapLocation)
+            ]),
+            _: 1
+          }, 8, ["color"])
+        ]),
+        _: 1
+      })
+    ]),
+    _: 1
+  });
+}
+var AppendVue = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["render", _sfc_render$2], ["__file", "append.vue"]]);
+
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var _sfc_main$1 = defineComponent({
+  name: "VkfGeoinputReadCore",
+  components: {
+    VkfInput,
+    VmGeojsonLayer,
+    ElIcon,
+    MapLocation: map_location_default
+  },
+  emits,
+  props,
+  setup(props2, { emit }) {
+    const inputBindProps = _VkfInputCtx.createBindProps(props2, [
+      "inputSlots",
+      "readonly",
+      "modelValue",
+      "type",
+      "id"
+    ]);
+    const inputOnEmits = _VkfInputCtx.createOnEmits(emit, ["update:modelValue"]);
+    const mapBindProps = _VmGeojsonLayerCtx$1.createBindProps(props2, ["data", "type", "paint"]);
+    const mapOnEmits = _VmGeojsonLayerCtx$1.createOnEmits(emit, ["change"]);
+    const map = useMap();
+    const geoType = computed(() => {
+      var _a, _b, _c;
+      if (props2.type)
+        return props2.type;
+      const typeRaw = (_c = (_b = (_a = props2.modelValue) == null ? void 0 : _a.features[0]) == null ? void 0 : _b.geometry) == null ? void 0 : _c.type;
+      const typeRawTo = {
+        LineString: "line",
+        Polygon: "fill",
+        MultiLineString: "line",
+        MultiPolygon: "fill"
+      };
+      return typeRawTo[typeRaw] || "fill";
+    });
+    const paintFromEditStyles = computed(() => {
+      return props2.editStyles.reduce((a, c) => {
+        if (geoType.value === "fill") {
+          if (c.id.includes("polygon-fill-inactive") || c.id.includes("polygon-stroke-inactive")) {
+            const cPaint = c.paint;
+            a = __spreadValues(__spreadValues({}, a), cPaint);
+          }
+        }
+        if (geoType.value === "line") {
+          if (c.id.includes("line-inactive")) {
+            const cPaint = c.paint;
+            a = __spreadValues(__spreadValues({}, a), cPaint);
+          }
+        }
+        return a;
+      }, {});
+    });
+    const mapFit = () => {
+      fitGeojson(map, props2.modelValue, {
+        duration: 1500
+      });
+    };
+    const append = () => /* @__PURE__ */ React.createElement(AppendVue, {
+      onMapLocationClick: mapFit
+    });
+    return {
+      mapFit,
+      inputBindProps,
+      inputOnEmits,
+      mapBindProps,
+      mapOnEmits,
+      append,
+      geoType,
+      paintFromEditStyles
+    };
+  }
+});
+
+function _sfc_render$1(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_VkfInput = resolveComponent("VkfInput");
+  const _component_MapLocation = resolveComponent("MapLocation");
+  const _component_ElIcon = resolveComponent("ElIcon");
+  const _component_VmGeojsonLayer = resolveComponent("VmGeojsonLayer");
+
+  return (openBlock(), createElementBlock(Fragment, null, [
+    withDirectives(createVNode(_component_VkfInput, mergeProps({
+      readonly: true,
+      modelValue: JSON.stringify(_ctx.modelValue)
+    }, _ctx.inputBindProps, toHandlers(_ctx.inputOnEmits), {
+      inputSlots: {
+      append: _ctx.append
+    }
+    }), null, 16 /* FULL_PROPS */, ["modelValue", "inputSlots"]), [
+      [vShow, !_ctx.custom]
+    ]),
+    (_ctx.custom)
+      ? renderSlot(_ctx.$slots, "default", {
+          key: 0,
+          mapFit: _ctx.mapFit
+        }, () => [
+          createVNode(_component_ElIcon, {
+            color: 'var(--el-color-primary)',
+            onClick: _ctx.mapFit
+          }, {
+            default: withCtx(() => [
+              createVNode(_component_MapLocation)
+            ]),
+            _: 1 /* STABLE */
+          }, 8 /* PROPS */, ["color", "onClick"])
+        ])
+      : createCommentVNode("v-if", true),
+    createVNode(_component_VmGeojsonLayer, mergeProps(_ctx.mapBindProps, {
+      data: _ctx.modelValue,
+      type: _ctx.geoType,
+      onChange: _cache[0] || (_cache[0] = $event => (_ctx.$emit('layerChange', $event))),
+      paint: _ctx.paint || _ctx.paintFromEditStyles
+    }, toHandlers(_ctx.mapOnEmits)), null, 16 /* FULL_PROPS */, ["data", "type", "paint"])
+  ], 64 /* STABLE_FRAGMENT */))
+}
+var CoreVue = /*#__PURE__*/_export_sfc(_sfc_main$1, [['render',_sfc_render$1],['__file',"core.vue"]]);
+
+const _sfc_main = defineComponent({
+  name: "VkfGeoinputRead",
+  components: {
+    CoreVue,
+    VkWrapper,
+    VmTdtLayers
+  },
+  props,
+  emits,
+  setup(props2, { emit }) {
+    const coreBindProps = createBindProps(props2);
+    const coreOnEmits = createOnEmits(emit);
+    return {
+      VmMap,
+      coreBindProps,
+      coreOnEmits
+    };
+  }
+});
+const _hoisted_1 = { class: "vk-geoinput-read-x" };
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_VmTdtLayers = resolveComponent("VmTdtLayers");
+  const _component_CoreVue = resolveComponent("CoreVue");
+  const _component_VkWrapper = resolveComponent("VkWrapper");
+  return openBlock(), createElementBlock("div", _hoisted_1, [
+    createVNode(_component_VkWrapper, {
+      is: _ctx.VmMap,
+      show: _ctx.showMap,
+      className: "vk-geoinput-read-map"
+    }, {
+      default: withCtx(() => [
+        renderSlot(_ctx.$slots, "map", {}, () => [
+          _ctx.showMap ? (openBlock(), createBlock(_component_VmTdtLayers, {
+            key: 0,
+            type: "vec_w"
+          })) : createCommentVNode("v-if", true)
+        ]),
+        createVNode(_component_CoreVue, mergeProps(_ctx.coreBindProps, toHandlers(_ctx.coreOnEmits)), {
+          default: withCtx((e) => [
+            renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(e)))
+          ]),
+          _: 3
+        }, 16)
+      ]),
+      _: 3
+    }, 8, ["is", "show"])
+  ]);
+}
+var VkfGeoinputRead = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "index.vue"]]);
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+VkfGeoinputRead.install = (app) => {
+  app.component(VkfGeoinputRead.name, VkfGeoinputRead);
+};
+
+export { VkfGeoinputRead, ctx as _VkfGeoinputReadCtx, types as __VkfGeoinputRead, VkfGeoinputRead as default };

package/components/geoinput-read/src/append.vue.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    mapLocationClick: null;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>> & {
+    onMapLocationClick?: ((...args: any[]) => any) | undefined;
+}, {}>;
+export default _default;