@vunk/form 1.1.84 → 1.2.0

package/components/form/index.cjs

@@ -0,0 +1,220 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var elementPlus = require('element-plus');
+var utilsVue = require('@vunk/core/shared/utils-vue');
+var utilsFunction = require('@vunk/core/shared/utils-function');
+var vue = require('vue');
+var formItemRenderer = require('@vunk/form/components/form-item-renderer');
+var elementPlus$1 = require('@vunk/form/shared/element-plus');
+var helper = require('@vunk/core/shared/helper');
+var templatesDefault = require('@vunk/form/components/templates-default');
+var templatesLayout = require('@vunk/form/components/templates-layout');
+var utilsObject = require('@vunk/core/shared/utils-object');
+var form = require('@vunk/form/shared/form');
+var _pluginVue_exportHelper = require('../_plugin-vue_export-helper.cjs');
+
+const props = {
+  ...elementPlus.formProps,
+  data: {
+    type: Object,
+    default: () => ({})
+  },
+  formItems: {
+    type: Array,
+    default: () => []
+  },
+  readonly: {
+    type: Boolean
+  },
+  elRef: {
+    type: Function,
+    default: () => utilsFunction.NOOP
+  },
+  /**
+   * 是否开启布局模式
+   */
+  layout: {
+    type: Boolean,
+    default: false
+  },
+  /**
+   * layout 为 true 时，
+   * 该值生效
+   * el-row 添加额外属性
+   */
+  rowSource: {
+    type: Object,
+    default: () => ({})
+  },
+  /**
+   * layout 为 true 时，
+   * 该值生效
+   * el-col 添加额外属性
+   */
+  colSource: {
+    type: Object,
+    default: () => ({})
+  }
+};
+const createBindProps = utilsVue.bindPropsFactory(props);
+const emits = {
+  ...elementPlus.formEmits,
+  setData: (e) => e,
+  validate: null,
+  submit: null
+};
+const createOnEmits = utilsVue.onEmitsFactory(emits);
+
+var ctx = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  createBindProps: createBindProps,
+  createOnEmits: createOnEmits,
+  emits: emits,
+  props: props
+});
+
+const getRowEmptySpan = (row) => {
+  return 24 - row.templateSlots.reduce((a, c) => {
+    if (!c.span) {
+      throw new Error("ElColSource span is required");
+    }
+    return a + c.span;
+  }, 0);
+};
+const genColItem = (formItem, options = {}) => {
+  const span = formItem.span ?? options.span;
+  if (span === void 0 || span === null) {
+    throw new Error("genColItem ElColSource span is required");
+  }
+  return {
+    ...options,
+    templateType: "ElCol",
+    span,
+    templateSlots: [
+      utilsObject.pickObject(formItem, {
+        excludes: ["span"]
+      })
+    ]
+  };
+};
+const genRowItem = (defaultItem, options = {}) => {
+  return {
+    ...options,
+    templateType: "ElRow",
+    templateSlots: defaultItem ? [
+      defaultItem
+    ] : []
+  };
+};
+
+var _sfc_main = vue.defineComponent({
+  name: "VkfForm",
+  components: {
+    ElForm: elementPlus.ElForm,
+    VkfFormItemRenderer: formItemRenderer.VkfFormItemRenderer,
+    VkfTemplatesDefault: templatesDefault.VkfTemplatesDefault,
+    VkfTemplatesLayout: templatesLayout.VkfTemplatesLayout
+  },
+  props,
+  emits,
+  setup(props2, { emit }) {
+    const formProps = elementPlus$1.createFormBindProps(props2, ["model"]);
+    const formEmits = elementPlus$1.createFormOnEmits(emit);
+    const formRef = vue.shallowRef();
+    const vm = vue.getCurrentInstance();
+    vue.provide("vkfFormVm", vm);
+    vue.provide("elFormRef", formRef);
+    const getRef = (e) => {
+      formRef.value = e;
+      props2.elRef(e);
+    };
+    const rendererSource = vue.computed(() => {
+      if (props2.layout) {
+        return props2.formItems.reduce((a, c) => {
+          const lastRow = a[a.length - 1];
+          const itemSpan = c.span ?? props2.colSource.span;
+          if (!itemSpan) {
+            a.push(c);
+            return a;
+          }
+          if (Reflect.has(c, "templateIf")) {
+            const templateIfFunc = form.genTemplateIfFunc(c.templateIf);
+            const flag = templateIfFunc(props2.data);
+            if (!flag) {
+              return a;
+            }
+          }
+          const colItem = genColItem(c, props2.colSource);
+          if (!lastRow || getRowEmptySpan(lastRow) < itemSpan) {
+            a.push(genRowItem(colItem, props2.rowSource));
+          } else {
+            lastRow.templateSlots.push(colItem);
+          }
+          return a;
+        }, []);
+      }
+      return props2.formItems;
+    });
+    const handleSubmit = (e) => {
+      e.preventDefault();
+      emit("submit", e);
+    };
+    return {
+      formProps,
+      formEmits,
+      getValue: helper.getValue,
+      getRef,
+      computed: vue.computed,
+      rendererSource,
+      handleSubmit
+    };
+  }
+});
+
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_VkfTemplatesDefault = vue.resolveComponent("VkfTemplatesDefault");
+  const _component_VkfTemplatesLayout = vue.resolveComponent("VkfTemplatesLayout");
+  const _component_VkfFormItemRenderer = vue.resolveComponent("VkfFormItemRenderer");
+  const _component_ElForm = vue.resolveComponent("ElForm");
+  return vue.openBlock(), vue.createBlock(_component_ElForm, vue.mergeProps(_ctx.formProps, {
+    ref: _ctx.getRef,
+    class: {
+      "is-readonly": _ctx.readonly
+    },
+    model: _ctx.model || _ctx.data
+  }, vue.toHandlers(_ctx.formEmits), { onSubmit: _ctx.handleSubmit }), {
+    default: vue.withCtx(() => [
+      vue.createVNode(_component_VkfFormItemRenderer, { source: _ctx.rendererSource }, {
+        default: vue.withCtx(() => [
+          vue.createVNode(_component_VkfTemplatesDefault, {
+            data: _ctx.data,
+            onSetData: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("setData", $event))
+          }, null, 8, ["data"]),
+          vue.createVNode(_component_VkfTemplatesLayout, { data: _ctx.data }, null, 8, ["data"]),
+          vue.renderSlot(_ctx.$slots, "rendererTemplate")
+        ]),
+        _: 3
+        /* FORWARDED */
+      }, 8, ["source"]),
+      vue.renderSlot(_ctx.$slots, "default")
+    ]),
+    _: 3
+    /* FORWARDED */
+  }, 16, ["class", "model", "onSubmit"]);
+}
+var VkfForm = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "/home/runner/work/private-vunk-form/private-vunk-form/packages/components/form/src/index.vue"]]);
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+VkfForm.install = (app) => {
+  app.component(VkfForm.name, VkfForm);
+};
+
+exports.VkfForm = VkfForm;
+exports._VkfFormCtx = ctx;
+exports.__VkfForm = types;
+exports.default = VkfForm;

package/components/form-item/index.cjs

@@ -0,0 +1,162 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var elementPlus = require('element-plus');
+var utilsVue = require('@vunk/core/shared/utils-vue');
+var vue = require('vue');
+var elementPlus$1 = require('@vunk/form/shared/element-plus');
+var composables = require('@vunk/form/composables');
+var utilsObject = require('@vunk/core/shared/utils-object');
+var rules = require('@vunk/form/shared/rules');
+var _pluginVue_exportHelper = require('../_plugin-vue_export-helper.cjs');
+
+const _props = {
+  ...elementPlus.formItemProps,
+  formItemSize: {
+    type: String,
+    default: void 0
+  },
+  formItemSlots: {
+    type: Object,
+    default: void 0
+  },
+  elRef: {
+    type: Function,
+    required: false
+  },
+  inline: {
+    type: Boolean,
+    default: false
+  },
+  readonly: {
+    type: Boolean,
+    default: void 0
+  },
+  labelPosition: {
+    type: String,
+    default: ""
+  }
+};
+Reflect.deleteProperty(_props, "size");
+const props = _props;
+const createBindProps = utilsVue.bindPropsFactory(props);
+
+var ctx = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  createBindProps: createBindProps,
+  props: props
+});
+
+var _sfc_main = vue.defineComponent({
+  name: "VkfFormItem",
+  components: {
+    ElFormItem: elementPlus.ElFormItem
+  },
+  props,
+  setup(props2) {
+    const formItemBindProps = elementPlus$1.createFormItemBindProps(props2, ["rules"]);
+    const readonly = composables.useComputedReadonly(props2);
+    const globalConfig = elementPlus.useGlobalConfig();
+    const localeName = vue.computed(() => {
+      return globalConfig.value?.locale?.name;
+    });
+    const requiredMessage = `${props2.label || "\u8BE5\u5B57\u6BB5"}\u4E0D\u80FD\u4E3A\u7A7A`;
+    const setDefaultMessage = (rule) => {
+      if (localeName.value === "zh-cn") {
+        if (rule.message) return;
+        if (rule.required) {
+          rule.message = requiredMessage;
+        }
+        const ruleInfo = rules.PATTERN_OPTIONS.find((i) => i.value === rule.pattern);
+        if (ruleInfo) {
+          rule.message = `\u8F93\u5165 ${props2.label || "\u8BE5\u5B57\u6BB5"} ${ruleInfo.title}`;
+        }
+      }
+    };
+    const rules$1 = vue.computed(() => {
+      let data = [];
+      if (!props2.rules) {
+        if (props2.required) {
+          data.push({
+            required: true
+          });
+        }
+      }
+      if (utilsObject.isPlainObject(props2.rules)) {
+        data = [props2.rules];
+      }
+      if (Array.isArray(props2.rules)) {
+        data = props2.rules;
+        if (props2.required) {
+          if (!props2.rules.find((item) => item.required)) {
+            data.push({
+              required: true
+            });
+          }
+        }
+      }
+      data = data.filter((rule) => {
+        if (!rule) return;
+        if (utilsObject.isPlainObject(rule)) {
+          const enableKeys = Object.keys(rule).filter((key) => !key.startsWith("data-"));
+          return enableKeys.length > 0;
+        }
+      });
+      data.forEach((rule) => {
+        setDefaultMessage(rule);
+      });
+      return data;
+    });
+    return {
+      formItemBindProps,
+      readonly,
+      rules: rules$1,
+      localeName
+    };
+  }
+});
+
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_ElFormItem = vue.resolveComponent("ElFormItem");
+  return vue.openBlock(), vue.createBlock(_component_ElFormItem, vue.mergeProps({
+    class: ["vkf-form-item", {
+      "is-readonly": _ctx.readonly,
+      "vkf-form-item--inline": _ctx.inline,
+      "vkf-form-item--label-right": _ctx.labelPosition === "right"
+    }]
+  }, _ctx.formItemBindProps, {
+    size: _ctx.formItemSize,
+    ref: _ctx.elRef,
+    rules: _ctx.rules
+  }), vue.createSlots({
+    default: vue.withCtx(() => [
+      vue.renderSlot(_ctx.$slots, "default")
+    ]),
+    _: 2
+    /* DYNAMIC */
+  }, [
+    vue.renderList(_ctx.formItemSlots, (item, key) => {
+      return {
+        name: key,
+        fn: vue.withCtx((e) => [
+          (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(item?.(e))))
+        ])
+      };
+    })
+  ]), 1040, ["class", "size", "rules"]);
+}
+var VkfFormItem = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "/home/runner/work/private-vunk-form/private-vunk-form/packages/components/form-item/src/index.vue"]]);
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+VkfFormItem.install = (app) => {
+  app.component(VkfFormItem.name, VkfFormItem);
+};
+
+exports.VkfFormItem = VkfFormItem;
+exports._VkfFormItemCtx = ctx;
+exports.__VkfFormItem = types;
+exports.default = VkfFormItem;

package/components/form-item-renderer/index.cjs

@@ -0,0 +1,103 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var form = require('@vunk/form/shared/form');
+var _pluginVue_exportHelper = require('../_plugin-vue_export-helper.cjs');
+
+const props = {
+  source: {
+    type: Array,
+    default: () => []
+  },
+  templateInstances: {
+    type: Object,
+    default: void 0
+  },
+  k: {
+    // 在递归调用的情况下 标记当前 source 相对于 原source，所处的位置
+    type: Array,
+    default: () => []
+  }
+};
+
+const S_TEMPLATE_INSTANCES = Symbol("templateInstances");
+
+const VkfFormItemRenderer$1 = vue.defineComponent({
+  name: "VkfFormItemRenderer",
+  props: props,
+  setup(props$1, ctx) {
+    const templateInstances = props$1.templateInstances ?? vue.shallowReactive({});
+    vue.provide(S_TEMPLATE_INSTANCES, templateInstances);
+    const Renderer = vue.defineComponent({
+      props: props,
+      setup(props2) {
+        return () => vue.h(VkfFormItemRenderer$1, {
+          templateInstances,
+          source: props2.source,
+          k: props2.k
+        });
+      }
+    });
+    const renderFormItems = (data, pK = []) => {
+      return data.reduce((a, c, index) => {
+        const currentK = [...props$1.k, ...pK, index];
+        const validateTemplateType = () => {
+          vue.nextTick(() => {
+            if (c.templateType && !templateInstances[c.templateType]) {
+              console.warn(c.templateType, "templateType\u4E0D\u5B58\u5728\u5C06\u8DF3\u8FC7");
+            }
+          });
+        };
+        if (c.templateType && templateInstances[c.templateType]) {
+          const slotData = { ...c };
+          Reflect.deleteProperty(slotData, "templateType");
+          Reflect.deleteProperty(slotData, "templateSlots");
+          Reflect.deleteProperty(slotData, "templateIf");
+          const nodes = templateInstances[c.templateType].slots.default?.({
+            data: slotData,
+            raw: c,
+            Renderer,
+            k: currentK,
+            key: currentK.join(",") + "-" + c.templateType + "-" + c?.prop || "no-prop",
+            templateIf: form.genTemplateIfFunc(c.templateIf)
+          });
+          nodes && a.push(nodes);
+        } else if (c.templateSlots?.default) {
+          validateTemplateType();
+          currentK.push("templateSlots", "default");
+          if (Array.isArray(c.templateSlots?.default)) {
+            const subNode = renderFormItems(c.templateSlots.default, currentK);
+            a = a.concat(subNode);
+          }
+        } else {
+          validateTemplateType();
+        }
+        return a;
+      }, []);
+    };
+    return () => {
+      const tempSlots = ctx.slots.default?.();
+      return [
+        tempSlots,
+        renderFormItems(props$1.source)
+      ];
+    };
+  }
+});
+
+var VkfFormItemRenderer = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(VkfFormItemRenderer$1, [["__file", "/home/runner/work/private-vunk-form/private-vunk-form/packages/components/form-item-renderer/src/index.vue"]]);
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+VkfFormItemRenderer.install = (app) => {
+  app.component(VkfFormItemRenderer.name, VkfFormItemRenderer);
+};
+
+exports.S_TEMPLATE_INSTANCES = S_TEMPLATE_INSTANCES;
+exports.VkfFormItemRenderer = VkfFormItemRenderer;
+exports.__VkfFormItemRenderer = types;
+exports.default = VkfFormItemRenderer;

package/components/form-item-renderer-template/index.cjs

@@ -0,0 +1,47 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var formItemRenderer = require('@vunk/form/components/form-item-renderer');
+var _pluginVue_exportHelper = require('../_plugin-vue_export-helper.cjs');
+
+const props = {
+  type: {
+    type: String,
+    required: true,
+    default: ""
+  }
+};
+
+var _sfc_main = vue.defineComponent({
+  name: "VkfFormItemRendererTemplate",
+  props,
+  setup(props2) {
+    const templateInstances = vue.inject(formItemRenderer.S_TEMPLATE_INSTANCES);
+    if (!templateInstances) throw new Error();
+    const vm = vue.getCurrentInstance();
+    const oVm = templateInstances[props2.type];
+    if (vm && templateInstances) {
+      templateInstances[props2.type] = vm;
+    }
+    vue.onUnmounted(() => {
+      templateInstances[props2.type] = oVm;
+    });
+    return () => null;
+  }
+});
+
+var VkfFormItemRendererTemplate = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["__file", "/home/runner/work/private-vunk-form/private-vunk-form/packages/components/form-item-renderer-template/src/index.vue"]]);
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+VkfFormItemRendererTemplate.install = (app) => {
+  app.component(VkfFormItemRendererTemplate.name, VkfFormItemRendererTemplate);
+};
+
+exports.VkfFormItemRendererTemplate = VkfFormItemRendererTemplate;
+exports.__VkfFormItemRendererTemplate = types;
+exports.default = VkfFormItemRendererTemplate;

package/components/geoinput/index.cjs

@@ -0,0 +1,95 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var geoinputRead = require('@vunk/form/components/geoinput-read');
+var geoinputUpdate = require('@vunk/form/components/geoinput-update');
+var composables = require('@vunk/form/composables');
+var _pluginVue_exportHelper = require('../_plugin-vue_export-helper.cjs');
+
+const props = {
+  ...geoinputRead._VkfGeoinputReadCtx.props,
+  ...geoinputUpdate._VkfGeoinputUpdateCtx.props,
+  readonly: {
+    type: Boolean,
+    default: void 0
+  },
+  showMap: {
+    type: Boolean,
+    default: true
+  },
+  /**
+   * @description geoinput-read GeojsonLayer 的 type
+   */
+  type: {
+    type: String,
+    default: ""
+  }
+};
+const emits = {
+  ...geoinputRead._VkfGeoinputReadCtx.emits,
+  ...geoinputUpdate._VkfGeoinputUpdateCtx.emits
+};
+
+var _sfc_main = vue.defineComponent({
+  name: "VkfGeoinput",
+  inheritAttrs: false,
+  components: {
+    VkfGeoinputRead: geoinputRead.VkfGeoinputRead,
+    VkfGeoinputUpdate: geoinputUpdate.VkfGeoinputUpdate
+  },
+  emits,
+  props,
+  setup(props2, { emit }) {
+    const readonly = composables.useComputedReadonly(props2);
+    const readProps = geoinputRead._VkfGeoinputReadCtx.createBindProps(props2);
+    const updateProps = geoinputUpdate._VkfGeoinputUpdateCtx.createBindProps(props2);
+    const readEmits = geoinputRead._VkfGeoinputReadCtx.createOnEmits(emit);
+    const updateEmits = geoinputUpdate._VkfGeoinputUpdateCtx.createOnEmits(emit);
+    return {
+      readonly,
+      readProps,
+      updateProps,
+      readEmits,
+      updateEmits
+    };
+  }
+});
+
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_VkfGeoinputRead = vue.resolveComponent("VkfGeoinputRead");
+  const _component_VkfGeoinputUpdate = vue.resolveComponent("VkfGeoinputUpdate");
+  return _ctx.readonly ? (vue.openBlock(), vue.createBlock(
+    _component_VkfGeoinputRead,
+    vue.mergeProps({ key: 0 }, {
+      ..._ctx.readProps,
+      ..._ctx.$attrs
+    }, vue.toHandlers(_ctx.readEmits)),
+    null,
+    16
+    /* FULL_PROPS */
+  )) : (vue.openBlock(), vue.createBlock(
+    _component_VkfGeoinputUpdate,
+    vue.mergeProps({ key: 1 }, {
+      ..._ctx.updateProps,
+      ..._ctx.$attrs
+    }, vue.toHandlers(_ctx.updateEmits)),
+    null,
+    16
+    /* FULL_PROPS */
+  ));
+}
+var VkfGeoinput = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "/home/runner/work/private-vunk-form/private-vunk-form/packages/components/geoinput/src/index.vue"]]);
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+VkfGeoinput.install = (app) => {
+  app.component(VkfGeoinput.name, VkfGeoinput);
+};
+
+exports.VkfGeoinput = VkfGeoinput;
+exports.__VkfGeoinput = types;
+exports.default = VkfGeoinput;