@fangzhongya/fang-ui 0.0.3

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

@@ -0,0 +1,153 @@
+import type { ExtractPropTypes } from 'vue';
+import type { ObjAny } from '../../../types';
+export type ListObj = {
+    /**
+     * 表单类型
+     */
+    type: string;
+    /**
+     * 展示字段名称
+     */
+    label: string;
+    /**
+     * 表单取值字段名称
+     */
+    prop: string;
+    /**
+     * 是否多选
+     */
+    multiple: string | boolean;
+    /**
+     * 是否显示隐藏
+     */
+    hide: boolean;
+    /**
+     * element-plus 的表单验证规则
+     */
+    rules: any[];
+    /**
+     * 是否校验
+     */
+    rule: string | boolean | 0 | 1 | {
+        /**
+         * 类型
+         */
+        type: 1 | 2;
+        /**
+         * 是否必传
+         */
+        must: boolean;
+        /**
+         * 校验方法
+         */
+        judge: string;
+    };
+    /**
+     * 表单样式
+     */
+    class: string;
+    /**
+     * 是否为必填项
+     */
+    required: boolean;
+    /**
+     * 标签宽度
+     */
+    labelWidth: string | number;
+    /**
+     * 子表单宽度
+     */
+    width: string | number;
+    /**
+     * 是否占整行
+     */
+    whole: boolean;
+    /**
+     * 子表单类型
+     */
+    display: string;
+    /**
+     * 子组件的配置数据
+     */
+    config: ObjAny;
+};
+export type ButObj = {
+    /**
+     * 按钮类型
+     */
+    type: '' | 'default' | 'primary' | 'success' | 'warning' | 'info' | 'danger' | 'text';
+    /**
+     * 按钮名称
+     */
+    label: string;
+    [key: string]: any;
+};
+export declare const dataProps: {
+    list: import("../../../utils").EpPropFinalized<{
+        (arrayLength: number): ListObj[];
+        (...items: ListObj[]): ListObj[];
+        new (arrayLength: number): ListObj[];
+        new (...items: ListObj[]): ListObj[];
+        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, () => never[], boolean>;
+    disabled: {
+        readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    selects: import("../../../utils").EpPropFinalized<ObjectConstructor, unknown, unknown, () => {}, boolean>;
+    width: import("../../../utils").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    value: import("../../../utils").EpPropFinalized<ObjectConstructor, unknown, unknown, () => {}, boolean>;
+    buts: {
+        readonly type: import("vue").PropType<ButObj[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    ajax: {
+        readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<(StringConstructor | FunctionConstructor)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    param: import("../../../utils").EpPropFinalized<ObjectConstructor, unknown, unknown, () => {}, boolean>;
+    axios: {
+        readonly type: import("vue").PropType<Record<string, any>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    refresh: import("../../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    inDataFilter: import("../../../utils").EpPropFinalized<FunctionConstructor, unknown, unknown, (res: any) => any, boolean>;
+    inParamFilter: {
+        readonly type: import("vue").PropType<Function>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+};
+export type DataProps = ExtractPropTypes<typeof dataProps>;
+/**
+ * @emits submit 提交数据
+ * @emits cancel 取消
+ * @emits buts buts的其他事件 ( )
+ */
+export declare const dataEmits: string[];
+export type DataEmits = typeof dataEmits;
+/**
+ * @expose submitForm
+ * 提交表单
+ */
+/**
+ * @expose {Object} getForm
+ * 获取表单数据
+ */
+export declare const dataExpose: string[];

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

@@ -0,0 +1,59 @@
+import { buildProps } from "../../../utils/vue/props/runtime.js";
+import "vue";
+import { props } from "../../common/data/urls.js";
+const dataProps = buildProps({
+  ...props,
+  /**
+   * @props { Array<ListObj> } list 展示数据列表
+   */
+  list: {
+    type: Array,
+    default() {
+      return [];
+    }
+  },
+  /**
+   * @props { Boolean } disabled 是否全部禁用
+   */
+  disabled: { type: Boolean },
+  /**
+   * @props { Object } selects 选择数据集合
+   */
+  selects: {
+    type: Object,
+    default() {
+      return {};
+    }
+  },
+  /**
+   * @props { String } width=80px ( )
+   * 标签的长度
+   */
+  width: {
+    type: String,
+    default: "80px"
+  },
+  /**
+   * @props { Object } value 默认展示数据
+   */
+  value: {
+    type: Object,
+    default() {
+      return {};
+    }
+  },
+  /**
+   * @props { Object } buts=[] 表单按钮
+   * pid: {1, 调用确认提交的方法; 2, 调用取消的方法}
+   */
+  buts: {
+    type: Array
+  }
+});
+const dataEmits = ["submit", "cancel", "buts"];
+const dataExpose = ["submitForm", "getForm"];
+export {
+  dataEmits,
+  dataExpose,
+  dataProps
+};

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

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const data = require("./data.cjs");
+const index$2 = require("../../forms-item/index.cjs");
+const elementPlus = require("element-plus");
+const index$1 = require("../../../hooks/cssname/index.cjs");
+require("../../../hooks/global-config/index.cjs");
+const css = require("../../../utils/css.cjs");
+const index = require("../../../hooks/locale/index.cjs");
+const util = require("./util.cjs");
+const _hoisted_1 = { key: 0 };
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  props: data.dataProps,
+  emits: data.dataEmits,
+  setup(__props, { expose, emit }) {
+    const props = __props;
+    const { getLocale } = index.useLocale();
+    const cs = index$1.useCssName("forms");
+    const buts = vue.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$1 = vue.reactive({
+      form: {},
+      rules: {},
+      defObj: {}
+    });
+    const refForm = vue.ref();
+    function setStyles(v) {
+      let width = v.width;
+      let display = v.display || "inline-block";
+      if (v.whole) {
+        display = "block";
+      }
+      return css.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] = util.getRule(v, getLocale);
+        } else {
+          rules[v.prop] = [];
+        }
+      });
+      data$1.defObj = defObj;
+      data$1.rules = rules;
+      data$1.form = Object.assign({}, data$1.defObj, props.value);
+    }
+    vue.watch(
+      () => props.value,
+      () => {
+        data$1.form = Object.assign(
+          {},
+          data$1.defObj,
+          props.value
+        );
+      }
+    );
+    vue.watch(
+      () => props.refresh,
+      () => {
+        submitForm();
+      }
+    );
+    function getValue() {
+      return Object.assign({}, props.value, data$1.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({
+      ...data.dataExpose,
+      submitForm,
+      getForm
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: vue.normalizeClass(vue.unref(cs).z())
+      }, [
+        vue.createElementVNode("div", {
+          class: vue.normalizeClass(vue.unref(cs).z("div"))
+        }, [
+          vue.createVNode(vue.unref(elementPlus.ElForm), {
+            "status-icon": "",
+            class: vue.normalizeClass(vue.unref(cs).z("el")),
+            model: data$1.form,
+            disabled: props.disabled,
+            rules: data$1.rules,
+            ref_key: "refForm",
+            ref: refForm,
+            "label-width": props.width
+          }, {
+            default: vue.withCtx(() => [
+              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(props.list, (val, key) => {
+                return vue.openBlock(), vue.createElementBlock(vue.Fragment, null, [
+                  val.type == "title" ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
+                    vue.createElementVNode("span", null, vue.toDisplayString(val.label), 1)
+                  ])) : (vue.openBlock(), vue.createElementBlock("div", {
+                    key: 1,
+                    style: vue.normalizeStyle(setStyles(val))
+                  }, [
+                    vue.withDirectives(vue.createVNode(vue.unref(elementPlus.ElFormItem), {
+                      class: vue.normalizeClass(
+                        vue.unref(cs).z("el-item", val.class)
+                      ),
+                      label: val.label,
+                      prop: val.prop,
+                      required: val.required,
+                      "label-width": val.labelWidth
+                    }, {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(vue.unref(index$2.FormsItem), {
+                          configs: val,
+                          selects: props.selects,
+                          type: val.type,
+                          config: val.config,
+                          multiple: val.multiple,
+                          modelValue: data$1.form,
+                          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => data$1.form = $event)
+                        }, null, 8, ["configs", "selects", "type", "config", "multiple", "modelValue"])
+                      ]),
+                      _: 2
+                    }, 1032, ["class", "label", "prop", "required", "label-width"]), [
+                      [vue.vShow, !val.hide]
+                    ])
+                  ], 4))
+                ], 64);
+              }), 256)),
+              vue.unref(buts) && vue.unref(buts).length > 0 ? (vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElFormItem), {
+                key: 0,
+                class: vue.normalizeClass(vue.unref(cs).z("buts"))
+              }, {
+                default: vue.withCtx(() => [
+                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(buts), (item, index2) => {
+                    return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElButton), {
+                      key: index2,
+                      type: item.type,
+                      onClick: ($event) => onClickButs(item)
+                    }, {
+                      default: vue.withCtx(() => [
+                        vue.createTextVNode(vue.toDisplayString(item.label), 1)
+                      ]),
+                      _: 2
+                    }, 1032, ["type", "onClick"]);
+                  }), 128))
+                ]),
+                _: 1
+              }, 8, ["class"])) : vue.createCommentVNode("", true)
+            ]),
+            _: 1
+          }, 8, ["class", "model", "disabled", "rules", "label-width"])
+        ], 2)
+      ], 2);
+    };
+  }
+});
+exports.default = _sfc_main;

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

@@ -0,0 +1,170 @@
+import { type ListObj, type ButObj } from './data';
+declare const _sfc_main: import("vue").DefineComponent<{
+    list: import("../../../utils").EpPropFinalized<{
+        (arrayLength: number): ListObj[];
+        (...items: ListObj[]): ListObj[];
+        new (arrayLength: number): ListObj[];
+        new (...items: ListObj[]): ListObj[];
+        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, () => never[], boolean>;
+    disabled: {
+        readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    selects: import("../../../utils").EpPropFinalized<ObjectConstructor, unknown, unknown, () => {}, boolean>;
+    width: import("../../../utils").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    value: import("../../../utils").EpPropFinalized<ObjectConstructor, unknown, unknown, () => {}, boolean>;
+    buts: {
+        readonly type: import("vue").PropType<ButObj[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    ajax: {
+        readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<(StringConstructor | FunctionConstructor)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    param: import("../../../utils").EpPropFinalized<ObjectConstructor, unknown, unknown, () => {}, boolean>;
+    axios: {
+        readonly type: import("vue").PropType<Record<string, any>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    refresh: import("../../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    inDataFilter: import("../../../utils").EpPropFinalized<FunctionConstructor, unknown, unknown, (res: any) => any, boolean>;
+    inParamFilter: {
+        readonly type: import("vue").PropType<Function>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}, {
+    submitForm: () => void;
+    getForm: () => Promise<unknown>;
+    length: number;
+    toString(): string;
+    toLocaleString(): string;
+    pop(): string | undefined;
+    push(...items: string[]): number;
+    concat(...items: ConcatArray<string>[]): string[];
+    concat(...items: (string | ConcatArray<string>)[]): string[];
+    join(separator?: string | undefined): string;
+    reverse(): string[];
+    shift(): string | undefined;
+    slice(start?: number | undefined, end?: number | undefined): string[];
+    sort(compareFn?: ((a: string, b: string) => number) | undefined): string[];
+    splice(start: number, deleteCount?: number | undefined): string[];
+    splice(start: number, deleteCount: number, ...items: string[]): string[];
+    unshift(...items: string[]): number;
+    indexOf(searchElement: string, fromIndex?: number | undefined): number;
+    lastIndexOf(searchElement: string, fromIndex?: number | undefined): number;
+    every<S extends string>(predicate: (value: string, index: number, array: string[]) => value is S, thisArg?: any): this is S[];
+    every(predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): boolean;
+    some(predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): boolean;
+    forEach(callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any): void;
+    map<U_2>(callbackfn: (value: string, index: number, array: string[]) => U_2, thisArg?: any): U_2[];
+    filter<S_1 extends string>(predicate: (value: string, index: number, array: string[]) => value is S_1, thisArg?: any): S_1[];
+    filter(predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): string[];
+    reduce(callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string): string;
+    reduce(callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue: string): string;
+    reduce<U_3>(callbackfn: (previousValue: U_3, currentValue: string, currentIndex: number, array: string[]) => U_3, initialValue: U_3): U_3;
+    reduceRight(callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string): string;
+    reduceRight(callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue: string): string;
+    reduceRight<U_4>(callbackfn: (previousValue: U_4, currentValue: string, currentIndex: number, array: string[]) => U_4, initialValue: U_4): U_4;
+    find<S_2 extends string>(predicate: (this: void, value: string, index: number, obj: string[]) => value is S_2, thisArg?: any): S_2 | undefined;
+    find(predicate: (value: string, index: number, obj: string[]) => unknown, thisArg?: any): string | undefined;
+    findIndex(predicate: (value: string, index: number, obj: string[]) => unknown, thisArg?: any): number;
+    fill(value: string, start?: number | undefined, end?: number | undefined): string[];
+    copyWithin(target: number, start: number, end?: number | undefined): string[];
+    entries(): IterableIterator<[number, string]>;
+    keys(): IterableIterator<number>;
+    values(): IterableIterator<string>;
+    includes(searchElement: string, fromIndex?: number | undefined): boolean;
+    flatMap<U_5, This = undefined>(callback: (this: This, value: string, index: number, array: string[]) => U_5 | readonly U_5[], thisArg?: This | undefined): U_5[];
+    flat<A, D extends number = 1>(this: A, depth?: D | undefined): FlatArray<A, D>[];
+    at(index: number): string | undefined;
+    [Symbol.iterator](): IterableIterator<string>;
+    [Symbol.unscopables](): {
+        copyWithin: boolean;
+        entries: boolean;
+        fill: boolean;
+        find: boolean;
+        findIndex: boolean;
+        keys: boolean;
+        values: boolean;
+    };
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, string[], string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    list: import("../../../utils").EpPropFinalized<{
+        (arrayLength: number): ListObj[];
+        (...items: ListObj[]): ListObj[];
+        new (arrayLength: number): ListObj[];
+        new (...items: ListObj[]): ListObj[];
+        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, () => never[], boolean>;
+    disabled: {
+        readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    selects: import("../../../utils").EpPropFinalized<ObjectConstructor, unknown, unknown, () => {}, boolean>;
+    width: import("../../../utils").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    value: import("../../../utils").EpPropFinalized<ObjectConstructor, unknown, unknown, () => {}, boolean>;
+    buts: {
+        readonly type: import("vue").PropType<ButObj[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    ajax: {
+        readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<(StringConstructor | FunctionConstructor)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    param: import("../../../utils").EpPropFinalized<ObjectConstructor, unknown, unknown, () => {}, boolean>;
+    axios: {
+        readonly type: import("vue").PropType<Record<string, any>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    refresh: import("../../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    inDataFilter: import("../../../utils").EpPropFinalized<FunctionConstructor, unknown, unknown, (res: any) => any, boolean>;
+    inParamFilter: {
+        readonly type: import("vue").PropType<Function>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>> & {
+    [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}, {
+    value: Record<string, any>;
+    list: ListObj[];
+    selects: Record<string, any>;
+    width: string;
+    param: Record<string, any>;
+    refresh: number;
+    inDataFilter: Function;
+}>;
+export default _sfc_main;