@vunk/form 1.0.1 → 1.1.1

package/components/geoinput/index.d.ts

@@ -0,0 +1,4 @@
+import VkfGeoinput from './src/index.vue';
+export * as __VkfGeoinput from './src/types';
+export { VkfGeoinput, };
+export default VkfGeoinput;

package/components/geoinput/index.js

@@ -0,0 +1,94 @@
+import { defineComponent, resolveComponent, openBlock, createBlock, mergeProps, toHandlers } from 'vue';
+import { _VkfGeoinputReadCtx, VkfGeoinputRead } from '@vunk/form/components/geoinput-read';
+import { _VkfGeoinputUpdateCtx, VkfGeoinputUpdate } from '@vunk/form/components/geoinput-update';
+import { useComputedReadonly } from '@vunk/form/composables';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+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 __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const props = __spreadProps(__spreadValues(__spreadValues({}, _VkfGeoinputReadCtx.props), _VkfGeoinputUpdateCtx.props), {
+  readonly: {
+    type: Boolean,
+    default: void 0
+  },
+  showMap: {
+    type: Boolean,
+    default: true
+  },
+  type: {
+    type: String,
+    default: ""
+  }
+});
+const emits = __spreadValues(__spreadValues({}, _VkfGeoinputReadCtx.emits), _VkfGeoinputUpdateCtx.emits);
+
+var _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+
+const _sfc_main = defineComponent({
+  name: "VkfGeoinput",
+  inheritAttrs: false,
+  components: {
+    VkfGeoinputRead,
+    VkfGeoinputUpdate
+  },
+  emits,
+  props,
+  setup(props2, { emit }) {
+    const readonly = useComputedReadonly(props2);
+    const readProps = _VkfGeoinputReadCtx.createBindProps(props2);
+    const updateProps = _VkfGeoinputUpdateCtx.createBindProps(props2);
+    const readEmits = _VkfGeoinputReadCtx.createOnEmits(emit);
+    const updateEmits = _VkfGeoinputUpdateCtx.createOnEmits(emit);
+    return {
+      readonly,
+      readProps,
+      updateProps,
+      readEmits,
+      updateEmits
+    };
+  }
+});
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_VkfGeoinputRead = resolveComponent("VkfGeoinputRead");
+  const _component_VkfGeoinputUpdate = resolveComponent("VkfGeoinputUpdate");
+  return _ctx.readonly ? (openBlock(), createBlock(_component_VkfGeoinputRead, mergeProps({ key: 0 }, {
+    ..._ctx.readProps,
+    ..._ctx.$attrs
+  }, toHandlers(_ctx.readEmits)), null, 16)) : (openBlock(), createBlock(_component_VkfGeoinputUpdate, mergeProps({ key: 1 }, {
+    ..._ctx.updateProps,
+    ..._ctx.$attrs
+  }, toHandlers(_ctx.updateEmits)), null, 16));
+}
+var VkfGeoinput = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "index.vue"]]);
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+VkfGeoinput.install = (app) => {
+  app.component(VkfGeoinput.name, VkfGeoinput);
+};
+
+export { VkfGeoinput, types as __VkfGeoinput, VkfGeoinput as default };

package/components/geoinput/src/ctx.d.ts

@@ -0,0 +1,218 @@
+export declare const props: {
+    readonly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    showMap: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * @description geoinput-read GeojsonLayer 的 type
+     */
+    type: {
+        type: StringConstructor;
+        default: string;
+    };
+    dialogEdit: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    dialogEditFullscreen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    dialogEditTitle: {
+        type: StringConstructor;
+        default: string;
+    };
+    modelValue: {
+        type: import("vue").PropType<import("geojson").FeatureCollection<import("geojson").Geometry, any>>;
+        default: () => import("geojson").FeatureCollection<import("geojson").Geometry, import("geojson").GeoJsonProperties>;
+    };
+    editControls: {
+        type: import("vue").PropType<import("../../geoinput-update/src/types").EditType[]>;
+        default: () => string[];
+    };
+    editTypes: {
+        type: import("vue").PropType<import("../../geoinput-update/src/types").EditType | import("../../geoinput-update/src/types").EditType[]>;
+        default: () => string;
+    };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    mapTo: {
+        type: import("vue").PropType<string | import("vue").RendererElement>;
+        default: undefined;
+    };
+    mapCenter: {
+        type: import("vue").PropType<import("mapbox-gl").LngLatLike>;
+        default: number[];
+    };
+    editStyles: {
+        type: import("vue").PropType<import("@vumap/core/components/control-draw/src/types").StyleLayer[]>;
+        default: () => never[];
+    };
+    slots: {
+        type: import("vue").PropType<import("../../geoinput-update/src/types").Slots>;
+        default: () => {};
+    };
+    spikSave: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maxlength: {
+        type: NumberConstructor;
+        required: boolean;
+    };
+    minlength: {
+        type: NumberConstructor;
+        required: boolean;
+    };
+    inputSlots: {
+        type: import("vue").PropType<import("../../input/src/types").InputSlots>;
+        default: undefined;
+    };
+    rows: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    label: StringConstructor;
+    labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+    prop: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemProp & {}) | (() => import("element-plus").FormItemProp) | ((new (...args: any[]) => import("element-plus").FormItemProp & {}) | (() => import("element-plus").FormItemProp))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    rules: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>) | ((new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    error: StringConstructor;
+    validateStatus: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    for: StringConstructor;
+    inlineMessage: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, BooleanConstructor], unknown, unknown, "", boolean>;
+    showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    formItemSize: {
+        type: import("vue").PropType<"default" | "small" | "large">;
+        default: string;
+    };
+    formItemSlots: {
+        type: import("vue").PropType<import("../../form-item/src/types").FormItemSlots>;
+        default: undefined;
+    };
+    elRef: {
+        type: import("vue").PropType<any>;
+        required: boolean;
+    };
+    inline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+    size: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    disabled: BooleanConstructor;
+    resize: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "none" | "both" | "horizontal" | "vertical", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    autosize: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("element-plus").InputAutoSize & {}) | (() => import("element-plus").InputAutoSize) | ((new (...args: any[]) => import("element-plus").InputAutoSize & {}) | (() => import("element-plus").InputAutoSize))[], unknown, unknown, false, boolean>;
+    autocomplete: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "off", boolean>;
+    formatter: {
+        readonly type: import("vue").PropType<Function>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    parser: {
+        readonly type: import("vue").PropType<Function>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    placeholder: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    form: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    clearable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    showPassword: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    showWordLimit: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    suffixIcon: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    prefixIcon: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    containerRole: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+    tabindex: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, 0, boolean>;
+    validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    inputStyle: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{}>, boolean>;
+    paint: {
+        type: import("vue").PropType<import("mapbox-gl").FillPaint | import("mapbox-gl").LinePaint>;
+        default: undefined;
+    };
+    custom: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maxzoom: NumberConstructor;
+    minzoom: NumberConstructor;
+    cursor: {
+        type: StringConstructor;
+        default: string;
+    };
+    before: StringConstructor;
+    data: {
+        type: import("vue").PropType<any>;
+        default: () => import("geojson").FeatureCollection<import("geojson").Geometry, import("geojson").GeoJsonProperties>;
+    };
+};
+export declare const emits: {
+    'update:modelValue': (e: import("geojson").FeatureCollection<import("geojson").Geometry, import("geojson").GeoJsonProperties>) => import("geojson").FeatureCollection<import("geojson").Geometry, import("geojson").GeoJsonProperties>;
+    editUpdate: (e: any) => any;
+    input: (value: string) => boolean;
+    change: (value: string) => boolean;
+    focus: (evt: FocusEvent) => boolean;
+    blur: (evt: FocusEvent) => boolean;
+    clear: () => boolean;
+    mouseleave: (evt: MouseEvent) => boolean;
+    mouseenter: (evt: MouseEvent) => boolean;
+    keydown: (evt: Event | KeyboardEvent) => boolean;
+    compositionstart: (evt: CompositionEvent) => boolean;
+    compositionupdate: (evt: CompositionEvent) => boolean;
+    compositionend: (evt: CompositionEvent) => boolean;
+    layerChange: (layer: import("@vumap/core/components/geojson-add-layer/src/types").LoadEvent) => import("@vumap/core/components/geojson-add-layer/src/types").LoadEvent;
+    click: (e: import("@vumap/core/components/geojson-layer-set/src/types").ClickEvent) => import("@vumap/core/components/geojson-layer-set/src/types").ClickEvent;
+    load: (e: import("@vumap/core/components/geojson-add-layer/src/types").LoadEvent) => import("@vumap/core/components/geojson-add-layer/src/types").LoadEvent;
+};

package/components/geoinput/src/ctx.js

@@ -0,0 +1,39 @@
+import { _VkfGeoinputReadCtx } from '@vunk/form/components/geoinput-read';
+import { _VkfGeoinputUpdateCtx } from '@vunk/form/components/geoinput-update';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+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 __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const props = __spreadProps(__spreadValues(__spreadValues({}, _VkfGeoinputReadCtx.props), _VkfGeoinputUpdateCtx.props), {
+  readonly: {
+    type: Boolean,
+    default: void 0
+  },
+  showMap: {
+    type: Boolean,
+    default: true
+  },
+  type: {
+    type: String,
+    default: ""
+  }
+});
+const emits = __spreadValues(__spreadValues({}, _VkfGeoinputReadCtx.emits), _VkfGeoinputUpdateCtx.emits);
+
+export { emits, props };