@fangzhongya/fang-ui 0.0.3

package/dist/components/forms/src/index.js

@@ -0,0 +1,221 @@
+import { defineComponent, computed, reactive, ref, watch, openBlock, createElementBlock, normalizeClass, unref, createElementVNode, createVNode, withCtx, Fragment, renderList, toDisplayString, normalizeStyle, withDirectives, vShow, createBlock, createTextVNode, createCommentVNode } from "vue";
+import { dataProps, dataEmits, dataExpose } from "./data.js";
+import { FormsItem } from "../../forms-item/index.js";
+import { ElForm, ElFormItem, ElButton } from "element-plus";
+import { useCssName } from "../../../hooks/cssname/index.js";
+import "../../../hooks/global-config/index.js";
+import { setObjStyle } from "../../../utils/css.js";
+import { useLocale } from "../../../hooks/locale/index.js";
+import { getRule } from "./util.js";
+const _hoisted_1 = { key: 0 };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "index",
+  props: dataProps,
+  emits: dataEmits,
+  setup(__props, { expose, emit }) {
+    const props = __props;
+    const { getLocale } = useLocale();
+    const cs = useCssName("forms");
+    const buts = computed(() => {
+      if (typeof props.buts == "undefined") {
+        return [
+          {
+            pid: "2",
+            label: getLocale("form.cancel")
+          },
+          {
+            pid: "1",
+            type: "primary",
+            label: getLocale("form.confirm")
+          }
+        ];
+      } else {
+        return props.buts;
+      }
+    });
+    const data = reactive({
+      form: {},
+      rules: {},
+      defObj: {}
+    });
+    const refForm = ref();
+    function setStyles(v) {
+      let width = v.width;
+      let display = v.display || "inline-block";
+      if (v.whole) {
+        display = "block";
+      }
+      return setObjStyle(
+        {},
+        {
+          display,
+          width
+        }
+      );
+    }
+    function setForm() {
+      var _a;
+      let defObj = {};
+      let rules = {};
+      (_a = props.list) == null ? void 0 : _a.forEach((v) => {
+        if (v.prop) {
+          defObj[v.prop] = "";
+        }
+        if (v.rules) {
+          rules[v.prop] = v.rules;
+        } else if (v.rule) {
+          rules[v.prop] = getRule(v, getLocale);
+        } else {
+          rules[v.prop] = [];
+        }
+      });
+      data.defObj = defObj;
+      data.rules = rules;
+      data.form = Object.assign({}, data.defObj, props.value);
+    }
+    watch(
+      () => props.value,
+      () => {
+        data.form = Object.assign(
+          {},
+          data.defObj,
+          props.value
+        );
+      }
+    );
+    watch(
+      () => props.refresh,
+      () => {
+        submitForm();
+      }
+    );
+    function getValue() {
+      return Object.assign({}, props.value, data.form);
+    }
+    function getForm() {
+      return new Promise((resolve, reject) => {
+        var _a;
+        (_a = refForm.value) == null ? void 0 : _a.validate((valid) => {
+          if (valid) {
+            let obj = getValue();
+            resolve(obj);
+          } else {
+            reject();
+          }
+        });
+      });
+    }
+    function submitForm() {
+      getForm().then((obj) => {
+      }).catch(() => {
+      });
+    }
+    function resetFields() {
+      let f = refForm.value;
+      if (f) {
+        f.resetFields();
+      }
+    }
+    function closeForm() {
+      resetFields();
+      emit("cancel");
+    }
+    function onClickButs(obj) {
+      if (obj.pid == 1) {
+        submitForm();
+      } else if (obj.pid == 2) {
+        closeForm();
+      } else {
+        emit("buts", obj);
+      }
+    }
+    setForm();
+    expose({
+      ...dataExpose,
+      submitForm,
+      getForm
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(unref(cs).z())
+      }, [
+        createElementVNode("div", {
+          class: normalizeClass(unref(cs).z("div"))
+        }, [
+          createVNode(unref(ElForm), {
+            "status-icon": "",
+            class: normalizeClass(unref(cs).z("el")),
+            model: data.form,
+            disabled: props.disabled,
+            rules: data.rules,
+            ref_key: "refForm",
+            ref: refForm,
+            "label-width": props.width
+          }, {
+            default: withCtx(() => [
+              (openBlock(true), createElementBlock(Fragment, null, renderList(props.list, (val, key) => {
+                return openBlock(), createElementBlock(Fragment, null, [
+                  val.type == "title" ? (openBlock(), createElementBlock("div", _hoisted_1, [
+                    createElementVNode("span", null, toDisplayString(val.label), 1)
+                  ])) : (openBlock(), createElementBlock("div", {
+                    key: 1,
+                    style: normalizeStyle(setStyles(val))
+                  }, [
+                    withDirectives(createVNode(unref(ElFormItem), {
+                      class: normalizeClass(
+                        unref(cs).z("el-item", val.class)
+                      ),
+                      label: val.label,
+                      prop: val.prop,
+                      required: val.required,
+                      "label-width": val.labelWidth
+                    }, {
+                      default: withCtx(() => [
+                        createVNode(unref(FormsItem), {
+                          configs: val,
+                          selects: props.selects,
+                          type: val.type,
+                          config: val.config,
+                          multiple: val.multiple,
+                          modelValue: data.form,
+                          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => data.form = $event)
+                        }, null, 8, ["configs", "selects", "type", "config", "multiple", "modelValue"])
+                      ]),
+                      _: 2
+                    }, 1032, ["class", "label", "prop", "required", "label-width"]), [
+                      [vShow, !val.hide]
+                    ])
+                  ], 4))
+                ], 64);
+              }), 256)),
+              unref(buts) && unref(buts).length > 0 ? (openBlock(), createBlock(unref(ElFormItem), {
+                key: 0,
+                class: normalizeClass(unref(cs).z("buts"))
+              }, {
+                default: withCtx(() => [
+                  (openBlock(true), createElementBlock(Fragment, null, renderList(unref(buts), (item, index) => {
+                    return openBlock(), createBlock(unref(ElButton), {
+                      key: index,
+                      type: item.type,
+                      onClick: ($event) => onClickButs(item)
+                    }, {
+                      default: withCtx(() => [
+                        createTextVNode(toDisplayString(item.label), 1)
+                      ]),
+                      _: 2
+                    }, 1032, ["type", "onClick"]);
+                  }), 128))
+                ]),
+                _: 1
+              }, 8, ["class"])) : createCommentVNode("", true)
+            ]),
+            _: 1
+          }, 8, ["class", "model", "disabled", "rules", "label-width"])
+        ], 2)
+      ], 2);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/forms/src/index2.cjs

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index_vue_vue_type_script_setup_true_lang = require("./index.cjs");
+exports.default = index_vue_vue_type_script_setup_true_lang.default;

package/dist/components/forms/src/index2.js

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

package/dist/components/forms/src/util.cjs

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const types = [
+  "select",
+  "inputs",
+  "cascader",
+  "date",
+  "time",
+  "upload",
+  "position",
+  "search"
+];
+const judge = {};
+function getRule(v, getLocale) {
+  let type = v.type, name = v.label, multiple = v.multiple, obj = v.rule;
+  if (typeof v.multiple != "boolean") {
+    multiple = false;
+  }
+  let trigger = 1;
+  let required = true;
+  let jyjudgev = "";
+  if (typeof obj == "string") {
+    trigger = 1;
+    jyjudgev = obj;
+    required = false;
+  } else if (typeof obj == "number") {
+    required = true;
+    trigger = obj;
+  } else if (typeof obj == "boolean") {
+    required = true;
+    trigger = 1;
+    if (types.includes(type)) {
+      trigger = 2;
+    }
+  } else {
+    trigger = obj.type || 1;
+    required = obj.must || true;
+    jyjudgev = obj.judge;
+  }
+  let typename = trigger == 1 ? getLocale("form.import") : getLocale("form.select");
+  let validator = function(rule, val, callback) {
+    callback();
+  };
+  if (jyjudgev && judge[jyjudgev]) {
+    let jyf = judge[jyjudgev];
+    let isjy = function(val) {
+      return !jyf(val);
+    };
+    if (required) {
+      validator = function(rule, val, callback) {
+        if (v.hide) {
+          callback();
+        } else if (!val && val !== 0) {
+          callback(new Error(typename + name));
+        } else if (multiple && val.length == 0) {
+          callback(new Error(typename + name));
+        } else if (isjy(val)) {
+          callback(
+            new Error(
+              name + getLocale("form.verif")
+            )
+          );
+        } else {
+          callback();
+        }
+      };
+    } else {
+      validator = function(rule, val, callback) {
+        if (v.hide) {
+          callback();
+        } else if (val && val !== 0 && isjy(val)) {
+          callback(
+            new Error(
+              name + getLocale("form.verif")
+            )
+          );
+        } else {
+          callback();
+        }
+      };
+    }
+  } else {
+    if (required) {
+      validator = function(rule, val, callback) {
+        if (v.hide) {
+          callback();
+        } else if (!val && val !== 0) {
+          callback(new Error(typename + name));
+        } else if (multiple && val.length == 0) {
+          callback(new Error(typename + name));
+        } else {
+          callback();
+        }
+      };
+    }
+  }
+  return {
+    required,
+    validator,
+    trigger: ["blur", "change"]
+  };
+}
+exports.getRule = getRule;

package/dist/components/forms/src/util.d.ts

@@ -0,0 +1,11 @@
+import type { ListObj } from './data';
+import type { Translator } from '../../../types';
+/**
+ * 后期要实现 v.rule 多匹配，
+ * 错误提示自定义
+ */
+export declare function getRule(v: ListObj, getLocale: Translator): {
+    required: boolean;
+    validator: (rule: any, val: any, callback: Function) => void;
+    trigger: string[];
+};

package/dist/components/forms/src/util.js

@@ -0,0 +1,103 @@
+const types = [
+  "select",
+  "inputs",
+  "cascader",
+  "date",
+  "time",
+  "upload",
+  "position",
+  "search"
+];
+const judge = {};
+function getRule(v, getLocale) {
+  let type = v.type, name = v.label, multiple = v.multiple, obj = v.rule;
+  if (typeof v.multiple != "boolean") {
+    multiple = false;
+  }
+  let trigger = 1;
+  let required = true;
+  let jyjudgev = "";
+  if (typeof obj == "string") {
+    trigger = 1;
+    jyjudgev = obj;
+    required = false;
+  } else if (typeof obj == "number") {
+    required = true;
+    trigger = obj;
+  } else if (typeof obj == "boolean") {
+    required = true;
+    trigger = 1;
+    if (types.includes(type)) {
+      trigger = 2;
+    }
+  } else {
+    trigger = obj.type || 1;
+    required = obj.must || true;
+    jyjudgev = obj.judge;
+  }
+  let typename = trigger == 1 ? getLocale("form.import") : getLocale("form.select");
+  let validator = function(rule, val, callback) {
+    callback();
+  };
+  if (jyjudgev && judge[jyjudgev]) {
+    let jyf = judge[jyjudgev];
+    let isjy = function(val) {
+      return !jyf(val);
+    };
+    if (required) {
+      validator = function(rule, val, callback) {
+        if (v.hide) {
+          callback();
+        } else if (!val && val !== 0) {
+          callback(new Error(typename + name));
+        } else if (multiple && val.length == 0) {
+          callback(new Error(typename + name));
+        } else if (isjy(val)) {
+          callback(
+            new Error(
+              name + getLocale("form.verif")
+            )
+          );
+        } else {
+          callback();
+        }
+      };
+    } else {
+      validator = function(rule, val, callback) {
+        if (v.hide) {
+          callback();
+        } else if (val && val !== 0 && isjy(val)) {
+          callback(
+            new Error(
+              name + getLocale("form.verif")
+            )
+          );
+        } else {
+          callback();
+        }
+      };
+    }
+  } else {
+    if (required) {
+      validator = function(rule, val, callback) {
+        if (v.hide) {
+          callback();
+        } else if (!val && val !== 0) {
+          callback(new Error(typename + name));
+        } else if (multiple && val.length == 0) {
+          callback(new Error(typename + name));
+        } else {
+          callback();
+        }
+      };
+    }
+  }
+  return {
+    required,
+    validator,
+    trigger: ["blur", "change"]
+  };
+}
+export {
+  getRule
+};

package/dist/components/forms-item/index.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+require("vue");
+const withInstall = require("../../utils/vue/withInstall.cjs");
+const index_vue_vue_type_script_setup_true_lang = require("./src/index.cjs");
+const FormsItem = withInstall.withInstall(index_vue_vue_type_script_setup_true_lang.default, "FormsItem");
+exports.FormsItem = FormsItem;
+exports.default = FormsItem;

package/dist/components/forms-item/index.d.ts

@@ -0,0 +1,121 @@
+import { withInstall } from '../../utils';
+declare const FormsItem: withInstall<import("vue").DefineComponent<{
+    selects: import("../../utils").EpPropFinalized<ObjectConstructor, unknown, unknown, () => {}, boolean>;
+    modelValue: {
+        readonly type: import("vue").PropType<any>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    type: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    prop: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    multiple: {
+        readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(BooleanConstructor | StringConstructor)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    disabled: {
+        readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<BooleanConstructor[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    computed: {
+        readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(ObjectConstructor | {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        })[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    config: {
+        readonly type: import("vue").PropType<Record<string, any>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, string[], string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    selects: import("../../utils").EpPropFinalized<ObjectConstructor, unknown, unknown, () => {}, boolean>;
+    modelValue: {
+        readonly type: import("vue").PropType<any>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    type: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    prop: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    multiple: {
+        readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(BooleanConstructor | StringConstructor)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    disabled: {
+        readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<BooleanConstructor[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    computed: {
+        readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(ObjectConstructor | {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        })[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    config: {
+        readonly type: import("vue").PropType<Record<string, any>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>> & {
+    [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}, {
+    selects: Record<string, any>;
+}>>;
+export { FormsItem, FormsItem as default };

package/dist/components/forms-item/index.js

@@ -0,0 +1,8 @@
+import "vue";
+import { withInstall } from "../../utils/vue/withInstall.js";
+import _sfc_main from "./src/index.js";
+const FormsItem = withInstall(_sfc_main, "FormsItem");
+export {
+  FormsItem,
+  FormsItem as default
+};

package/dist/components/forms-item/src/data.cjs

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const runtime = require("../../../utils/vue/props/runtime.cjs");
+require("vue");
+const dataProps = runtime.buildProps({
+  /**
+   * @props { Object } selects 选择数据集合
+   */
+  selects: {
+    type: Object,
+    default() {
+      return {};
+    }
+  },
+  /**
+   * 传入值
+   * @props { String } modelValue= ( )
+   */
+  modelValue: {
+    type: null
+  },
+  /**
+   * 表单类型
+   * @props { String } type= ( )
+   */
+  type: {
+    type: String
+  },
+  /**
+   * 表单取值字段名称
+   *   @props { String } prop= ( )
+   */
+  prop: {
+    type: String
+  },
+  /**
+   * 是否多选
+   * @props { String , Boolean } multiple= ( )
+   */
+  multiple: {
+    type: [String, Boolean]
+  },
+  /**
+   * 是否禁用
+   *  @props {Boolean } disabled= ( )
+   */
+  disabled: {
+    type: [Boolean]
+  },
+  /**
+   * 处理 v-model 值
+   * @props { Object, Array<string> } computed= ( )
+   */
+  computed: {
+    type: [Object, Array]
+  },
+  /**
+   * 子表单配置
+   * @props { Object } config= ( )
+   */
+  config: {
+    type: Object
+  }
+});
+const dataEmits = ["update:modelValue"];
+const dataExpose = {};
+exports.dataEmits = dataEmits;
+exports.dataExpose = dataExpose;
+exports.dataProps = dataProps;