@fangzhongya/fang-ui 0.0.12 → 0.0.14

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

@@ -0,0 +1,115 @@
+import { defineComponent, useSlots, ref, createElementBlock, openBlock, normalizeClass, unref, createBlock, createCommentVNode, mergeProps, toHandlers, createSlots, renderList, withCtx, renderSlot, normalizeProps, guardReactiveProps } from "vue";
+import { ElTables } from "../../el-tables/index.js";
+import { VxeTables } from "../../vxe-tables/index.js";
+import { Pagin } from "../../pagin/index.js";
+import { dataEmit, dataProps, useInit } from "../common/pagin.js";
+import { useCssName } from "../../../hooks/cssname/index.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "index",
+  props: dataProps,
+  emits: dataEmit,
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const cs = useCssName("table-pag");
+    const slots = useSlots();
+    const props = __props;
+    const emit = __emit;
+    const refTable = ref();
+    const {
+      getSelection,
+      initData,
+      getData,
+      empty,
+      loading,
+      tableList,
+      tableConfig,
+      onRadioChange,
+      onSortChange,
+      onListEvents,
+      onSelect,
+      onRowClick,
+      onChange,
+      pagconfig,
+      formEvent,
+      onSizeChange,
+      onCurrentChange,
+      paginat,
+      data
+    } = useInit(props, emit, refTable);
+    __expose({
+      getSelection,
+      initData,
+      getList: getData,
+      empty
+    });
+    return (_ctx, _cache) => {
+      var _a, _b, _c, _d;
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(unref(cs).z())
+      }, [
+        unref(tableConfig).type == 1 ? (openBlock(), createBlock(unref(VxeTables), mergeProps({ key: 0 }, unref(tableConfig).config, toHandlers(unref(formEvent)), {
+          ref_key: "refTable",
+          ref: refTable,
+          class: [unref(cs).z("main")],
+          size: (_a = unref(tableConfig).config) == null ? void 0 : _a.size,
+          value: unref(data).list,
+          list: unref(tableList),
+          paginat: unref(paginat),
+          loading: unref(loading),
+          options: props.options,
+          compons: props.compons,
+          onSortChange: unref(onSortChange),
+          onRadioChange: unref(onRadioChange),
+          onSelectionChange: unref(onChange),
+          onListEvents: unref(onListEvents)
+        }), createSlots({ _: 2 }, [
+          renderList(Object.keys(unref(slots)), (k, i) => {
+            return {
+              name: k,
+              fn: withCtx((scope) => [
+                renderSlot(_ctx.$slots, k, normalizeProps(guardReactiveProps(scope)), void 0, true)
+              ])
+            };
+          })
+        ]), 1040, ["class", "size", "value", "list", "paginat", "loading", "options", "compons", "onSortChange", "onRadioChange", "onSelectionChange", "onListEvents"])) : (openBlock(), createBlock(unref(ElTables), mergeProps({ key: 1 }, unref(tableConfig).config, toHandlers(unref(formEvent)), {
+          ref_key: "refTable",
+          ref: refTable,
+          class: [
+            unref(cs).z("main"),
+            unref(cs).is("radio", (_b = unref(tableConfig).config) == null ? void 0 : _b.isradio)
+          ],
+          value: unref(data).list,
+          list: unref(tableList),
+          size: (_c = unref(tableConfig).config) == null ? void 0 : _c.size,
+          paginat: unref(paginat),
+          loading: unref(loading),
+          options: props.options,
+          compons: props.compons,
+          onSortChange: unref(onSortChange),
+          onListEvents: unref(onListEvents),
+          onSelect: unref(onSelect),
+          onRowClick: unref(onRowClick),
+          onSelectionChange: unref(onChange)
+        }), createSlots({ _: 2 }, [
+          renderList(Object.keys(unref(slots)), (k, i) => {
+            return {
+              name: k,
+              fn: withCtx((scope) => [
+                renderSlot(_ctx.$slots, k, normalizeProps(guardReactiveProps(scope)), void 0, true)
+              ])
+            };
+          })
+        ]), 1040, ["class", "value", "list", "size", "paginat", "loading", "options", "compons", "onSortChange", "onListEvents", "onSelect", "onRowClick", "onSelectionChange"])),
+        ((_d = unref(tableConfig).paginat) == null ? void 0 : _d.is) ? (openBlock(), createBlock(unref(Pagin), mergeProps({ key: 2 }, unref(pagconfig), {
+          class: unref(cs).z("paginat"),
+          paginat: unref(paginat),
+          total: unref(data).total,
+          onSizeChange: unref(onSizeChange),
+          onCurrentChange: unref(onCurrentChange)
+        }), null, 16, ["class", "paginat", "total", "onSizeChange", "onCurrentChange"])) : createCommentVNode("", true)
+      ], 2);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/tables-form/index.cjs

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

package/dist/components/tables-form/index.js

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

package/dist/components/tables-form/src/column.cjs

@@ -0,0 +1,269 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require$$0 = require("vue");
+const common = require("../../../utils/vues/common.cjs");
+require("../../../utils/vues/getBuildProps.cjs");
+require("@fangzhongya/utils/css/setObjStyle");
+require("@fangzhongya/utils/css/getCss");
+require("@fangzhongya/utils/basic/string/splitUpper");
+const isArray = require("@fangzhongya/utils/basic/array/isArray");
+require("@fangzhongya/utils/basic/object/isObject");
+const firstLower = require("@fangzhongya/utils/basic/string/firstLower");
+require("@fangzhongya/utils/basic/object/hasOwn");
+require("@fangzhongya/utils/basic/string/firstUpper");
+const lineToLargeHump = require("@fangzhongya/utils/name/lineToLargeHump");
+require("@fangzhongya/utils/name/lineToSmallHump");
+require("@fangzhongya/utils/name/humpToLine");
+require("@fangzhongya/utils/basic/object/deepCopy");
+require("@fangzhongya/utils/basic/Array/toggleArray");
+require("@fangzhongya/utils/basic/object/objValue");
+const elementPlus = require("element-plus");
+const noProps = ["children", "class", "minWidth", "label"];
+function setProps(obj, table) {
+  const robj = {};
+  const issort = table["sort"];
+  robj["header-align"] = table["align"];
+  robj["align"] = obj["header-align"] || table["align"];
+  Object.keys(obj).forEach((key) => {
+    if (!noProps.includes(key)) {
+      if (obj[key] !== "") {
+        robj[key] = obj[key];
+        if (key == "sortable") {
+          if (issort && obj[key]) {
+            robj[key] = "custom";
+          }
+        }
+      }
+    }
+  });
+  return robj;
+}
+function getOnObjs(list, scope, emit) {
+  const obj = {};
+  const es = list.events || {};
+  Object.keys(es).forEach((key) => {
+    let ml = key;
+    if (!/on[A-Z]/.test(key)) {
+      ml = "on" + lineToLargeHump.lineToLargeHump(key);
+    }
+    ml = firstLower.firstLower(lineToLargeHump.lineToLargeHump(ml));
+    obj[ml] = (...data) => {
+      if (es[key] && typeof es[key] == "function") {
+        es[key](...data, scope, list);
+      } else {
+        emit("list-events", key, ...data, scope, list);
+      }
+    };
+  });
+  return obj;
+}
+function getFormValue(obj, scope) {
+  const prop = obj.prop || "";
+  const row = scope.row;
+  const cellValue = row[prop];
+  if (obj.formvalue) {
+    return obj.formvalue(row, scope.column, cellValue, scope.$index);
+  } else if (obj.formatter) {
+    return obj.formatter(row, scope.column, cellValue, scope.$index);
+  } else {
+    return cellValue;
+  }
+}
+function setSslot(obj, scope, emit, table, index, form, formValue) {
+  if (obj.isform) {
+    const prop = form.prop;
+    const defaultFormfilter = () => {
+      return obj.compon && prop && scope.row[prop];
+    };
+    const formfilter = obj.formfilter || defaultFormfilter;
+    if (formfilter(scope, obj, form, formValue)) {
+      const key = scope.row[prop];
+      const fv = { ...scope, row: formValue[key] || {} };
+      const componValueName = obj.componValueName || "modelValue";
+      const componObj = {
+        ...obj.config,
+        ...getOnObjs(obj, fv, emit),
+        [componValueName]: getFormValue(obj, fv),
+        "onUpdate:modelValue": (value) => {
+          formValue[key] = formValue[key] || {};
+          formValue[key][obj.prop] = value;
+        },
+        tableList: obj,
+        tableScope: fv
+      };
+      let rules = obj.rules || [];
+      if (!(rules instanceof Array)) {
+        rules = [rules];
+      }
+      if (obj.required) {
+        rules.unshift({
+          required: true,
+          message: obj.label + "不能为空",
+          trigger: ["blur", "change"]
+        });
+      }
+      return require$$0.h(
+        elementPlus.ElFormItem,
+        {
+          class: "table-form-item",
+          "inline-message": true,
+          prop: key + "." + obj.prop,
+          rules
+        },
+        {
+          default: () => {
+            if (typeof obj.compon == "string") {
+              return require$$0.h(require$$0.resolveComponent(obj.compon), componObj);
+            } else {
+              return require$$0.h(obj.compon, componObj);
+            }
+          }
+        }
+      );
+    } else {
+      return defaultDom(obj, scope, table, index);
+    }
+  } else if (obj.compon) {
+    const componValueName = obj.componValueName || "modelValue";
+    const componObj = {
+      ...obj.config,
+      ...getOnObjs(obj, scope, emit),
+      [componValueName]: getValue(obj, scope),
+      "onUpdate:modelValue": (value) => scope.row[obj.prop] = value,
+      tableList: obj,
+      tableScope: scope
+    };
+    if (typeof obj.compon == "string") {
+      return require$$0.h(require$$0.resolveComponent(obj.compon), componObj);
+    } else {
+      return require$$0.h(obj.compon, componObj);
+    }
+  } else {
+    return defaultDom(obj, scope, table, index);
+  }
+}
+function getValue(obj, scope) {
+  const prop = obj.prop || "";
+  const row = scope.row;
+  const cellValue = row[prop];
+  if (obj.formatter) {
+    return obj.formatter(row, scope.column, cellValue, scope.$index);
+  } else {
+    return cellValue;
+  }
+}
+function defaultDom(obj, scope, table, index) {
+  let domValue = "";
+  const prop = obj.prop || "";
+  const row = scope.row;
+  const cellValue = row[prop];
+  if (obj.type == "index") {
+    if (obj.index) {
+      domValue = obj.index(scope.$index, table.paginat);
+    } else {
+      if (table.paginat && table.paginat.current && table.paginat.size) {
+        domValue = (table.paginat.current - 1) * table.paginat.size + scope.$index + 1;
+      } else {
+        domValue = scope.$index + 1;
+      }
+    }
+  } else if (obj.type == "selection") {
+    return;
+  } else if (obj.formatter) {
+    domValue = obj.formatter(row, scope.column, cellValue, scope.$index);
+  } else if (obj.asynccall) {
+    const key = "_async_" + (prop || "_" + index);
+    if (!row[key] || typeof row[key].value == "undefined") {
+      row[key] = require$$0.reactive({
+        value: cellValue || ""
+      });
+      obj.asynccall(scope, (v) => {
+        row[key].value = v;
+      });
+    }
+    return require$$0.h(
+      "span",
+      {
+        class: "text"
+      },
+      row[key].value
+    );
+  } else {
+    domValue = cellValue;
+  }
+  domValue = domValue ?? "";
+  return require$$0.h(
+    "span",
+    {
+      class: "text",
+      onClick(event) {
+        if (obj.click) {
+          obj.click(event, scope, obj);
+        }
+      }
+    },
+    domValue
+  );
+}
+function setHeader(obj) {
+  if (isArray.isArray(obj.label)) {
+    return require$$0.h(
+      "span",
+      {
+        class: "th-header " + (obj.required ? "is-required " : "") + (obj.class || "")
+      },
+      obj.label.map((v) => {
+        return require$$0.h("span", { class: "th-header-span" }, v);
+      })
+    );
+  } else if (obj.required) {
+    return require$$0.h(
+      "span",
+      { class: "th-header is-required " + (obj.class || "") },
+      obj.label
+    );
+  } else {
+    return obj.label;
+  }
+}
+function getDom(obj, emit, table, index, form, formValue) {
+  if (common.setHide(obj)) {
+    const props = setProps(obj, table);
+    return require$$0.h(
+      elementPlus.ElTableColumn,
+      {
+        ...props,
+        className: obj.class,
+        minWidth: common.setMinWidth(obj)
+      },
+      {
+        default: (scope) => {
+          if (obj.compon) {
+            return setSslot(
+              obj,
+              scope,
+              emit,
+              table,
+              index,
+              form,
+              formValue
+            );
+          }
+          return defaultDom(obj, scope, table, index);
+        },
+        header: () => {
+          return setHeader(obj);
+        }
+      }
+    );
+  } else {
+    return;
+  }
+}
+function columnRender(obj, emit, table, index, form, formValue) {
+  return getDom(obj, emit, table, index, form, formValue);
+}
+exports.columnRender = columnRender;
+exports.getOnObjs = getOnObjs;
+exports.setHeader = setHeader;
+exports.setProps = setProps;

package/dist/components/tables-form/src/column.d.ts

@@ -0,0 +1,8 @@
+export declare function setProps(obj: ObjAny, table: ObjAny): ObjAny;
+export declare function getOnObjs(list: ObjAny, scope: any, emit: any): {
+    [key: string]: () => void;
+};
+export declare function setHeader(obj: any): any;
+export declare function columnRender(obj: ObjAny, emit: any, table: ObjAny, index: number, form: ObjAny, formValue: ObjAny): import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}> | undefined;

package/dist/components/tables-form/src/column.js

@@ -0,0 +1,269 @@
+import { h, resolveComponent, reactive } from "vue";
+import { setHide, setMinWidth } from "../../../utils/vues/common.js";
+import "../../../utils/vues/getBuildProps.js";
+import "@fangzhongya/utils/css/setObjStyle";
+import "@fangzhongya/utils/css/getCss";
+import "@fangzhongya/utils/basic/string/splitUpper";
+import { isArray } from "@fangzhongya/utils/basic/array/isArray";
+import "@fangzhongya/utils/basic/object/isObject";
+import { firstLower } from "@fangzhongya/utils/basic/string/firstLower";
+import "@fangzhongya/utils/basic/object/hasOwn";
+import "@fangzhongya/utils/basic/string/firstUpper";
+import { lineToLargeHump } from "@fangzhongya/utils/name/lineToLargeHump";
+import "@fangzhongya/utils/name/lineToSmallHump";
+import "@fangzhongya/utils/name/humpToLine";
+import "@fangzhongya/utils/basic/object/deepCopy";
+import "@fangzhongya/utils/basic/Array/toggleArray";
+import "@fangzhongya/utils/basic/object/objValue";
+import { ElTableColumn, ElFormItem } from "element-plus";
+const noProps = ["children", "class", "minWidth", "label"];
+function setProps(obj, table) {
+  const robj = {};
+  const issort = table["sort"];
+  robj["header-align"] = table["align"];
+  robj["align"] = obj["header-align"] || table["align"];
+  Object.keys(obj).forEach((key) => {
+    if (!noProps.includes(key)) {
+      if (obj[key] !== "") {
+        robj[key] = obj[key];
+        if (key == "sortable") {
+          if (issort && obj[key]) {
+            robj[key] = "custom";
+          }
+        }
+      }
+    }
+  });
+  return robj;
+}
+function getOnObjs(list, scope, emit) {
+  const obj = {};
+  const es = list.events || {};
+  Object.keys(es).forEach((key) => {
+    let ml = key;
+    if (!/on[A-Z]/.test(key)) {
+      ml = "on" + lineToLargeHump(key);
+    }
+    ml = firstLower(lineToLargeHump(ml));
+    obj[ml] = (...data) => {
+      if (es[key] && typeof es[key] == "function") {
+        es[key](...data, scope, list);
+      } else {
+        emit("list-events", key, ...data, scope, list);
+      }
+    };
+  });
+  return obj;
+}
+function getFormValue(obj, scope) {
+  const prop = obj.prop || "";
+  const row = scope.row;
+  const cellValue = row[prop];
+  if (obj.formvalue) {
+    return obj.formvalue(row, scope.column, cellValue, scope.$index);
+  } else if (obj.formatter) {
+    return obj.formatter(row, scope.column, cellValue, scope.$index);
+  } else {
+    return cellValue;
+  }
+}
+function setSslot(obj, scope, emit, table, index, form, formValue) {
+  if (obj.isform) {
+    const prop = form.prop;
+    const defaultFormfilter = () => {
+      return obj.compon && prop && scope.row[prop];
+    };
+    const formfilter = obj.formfilter || defaultFormfilter;
+    if (formfilter(scope, obj, form, formValue)) {
+      const key = scope.row[prop];
+      const fv = { ...scope, row: formValue[key] || {} };
+      const componValueName = obj.componValueName || "modelValue";
+      const componObj = {
+        ...obj.config,
+        ...getOnObjs(obj, fv, emit),
+        [componValueName]: getFormValue(obj, fv),
+        "onUpdate:modelValue": (value) => {
+          formValue[key] = formValue[key] || {};
+          formValue[key][obj.prop] = value;
+        },
+        tableList: obj,
+        tableScope: fv
+      };
+      let rules = obj.rules || [];
+      if (!(rules instanceof Array)) {
+        rules = [rules];
+      }
+      if (obj.required) {
+        rules.unshift({
+          required: true,
+          message: obj.label + "不能为空",
+          trigger: ["blur", "change"]
+        });
+      }
+      return h(
+        ElFormItem,
+        {
+          class: "table-form-item",
+          "inline-message": true,
+          prop: key + "." + obj.prop,
+          rules
+        },
+        {
+          default: () => {
+            if (typeof obj.compon == "string") {
+              return h(resolveComponent(obj.compon), componObj);
+            } else {
+              return h(obj.compon, componObj);
+            }
+          }
+        }
+      );
+    } else {
+      return defaultDom(obj, scope, table, index);
+    }
+  } else if (obj.compon) {
+    const componValueName = obj.componValueName || "modelValue";
+    const componObj = {
+      ...obj.config,
+      ...getOnObjs(obj, scope, emit),
+      [componValueName]: getValue(obj, scope),
+      "onUpdate:modelValue": (value) => scope.row[obj.prop] = value,
+      tableList: obj,
+      tableScope: scope
+    };
+    if (typeof obj.compon == "string") {
+      return h(resolveComponent(obj.compon), componObj);
+    } else {
+      return h(obj.compon, componObj);
+    }
+  } else {
+    return defaultDom(obj, scope, table, index);
+  }
+}
+function getValue(obj, scope) {
+  const prop = obj.prop || "";
+  const row = scope.row;
+  const cellValue = row[prop];
+  if (obj.formatter) {
+    return obj.formatter(row, scope.column, cellValue, scope.$index);
+  } else {
+    return cellValue;
+  }
+}
+function defaultDom(obj, scope, table, index) {
+  let domValue = "";
+  const prop = obj.prop || "";
+  const row = scope.row;
+  const cellValue = row[prop];
+  if (obj.type == "index") {
+    if (obj.index) {
+      domValue = obj.index(scope.$index, table.paginat);
+    } else {
+      if (table.paginat && table.paginat.current && table.paginat.size) {
+        domValue = (table.paginat.current - 1) * table.paginat.size + scope.$index + 1;
+      } else {
+        domValue = scope.$index + 1;
+      }
+    }
+  } else if (obj.type == "selection") {
+    return;
+  } else if (obj.formatter) {
+    domValue = obj.formatter(row, scope.column, cellValue, scope.$index);
+  } else if (obj.asynccall) {
+    const key = "_async_" + (prop || "_" + index);
+    if (!row[key] || typeof row[key].value == "undefined") {
+      row[key] = reactive({
+        value: cellValue || ""
+      });
+      obj.asynccall(scope, (v) => {
+        row[key].value = v;
+      });
+    }
+    return h(
+      "span",
+      {
+        class: "text"
+      },
+      row[key].value
+    );
+  } else {
+    domValue = cellValue;
+  }
+  domValue = domValue ?? "";
+  return h(
+    "span",
+    {
+      class: "text",
+      onClick(event) {
+        if (obj.click) {
+          obj.click(event, scope, obj);
+        }
+      }
+    },
+    domValue
+  );
+}
+function setHeader(obj) {
+  if (isArray(obj.label)) {
+    return h(
+      "span",
+      {
+        class: "th-header " + (obj.required ? "is-required " : "") + (obj.class || "")
+      },
+      obj.label.map((v) => {
+        return h("span", { class: "th-header-span" }, v);
+      })
+    );
+  } else if (obj.required) {
+    return h(
+      "span",
+      { class: "th-header is-required " + (obj.class || "") },
+      obj.label
+    );
+  } else {
+    return obj.label;
+  }
+}
+function getDom(obj, emit, table, index, form, formValue) {
+  if (setHide(obj)) {
+    const props = setProps(obj, table);
+    return h(
+      ElTableColumn,
+      {
+        ...props,
+        className: obj.class,
+        minWidth: setMinWidth(obj)
+      },
+      {
+        default: (scope) => {
+          if (obj.compon) {
+            return setSslot(
+              obj,
+              scope,
+              emit,
+              table,
+              index,
+              form,
+              formValue
+            );
+          }
+          return defaultDom(obj, scope, table, index);
+        },
+        header: () => {
+          return setHeader(obj);
+        }
+      }
+    );
+  } else {
+    return;
+  }
+}
+function columnRender(obj, emit, table, index, form, formValue) {
+  return getDom(obj, emit, table, index, form, formValue);
+}
+export {
+  columnRender,
+  getOnObjs,
+  setHeader,
+  setProps
+};