@fangzhongya/fang-ui 0.0.38 → 0.0.40

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

@@ -1,4 +1,247 @@
 "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;
+const vue = require("vue");
+const table = require("vxe-table/es/table");
+const data = require("./data.cjs");
+require("./columns.cjs");
+const use = require("../../common/use.cjs");
+const index$1 = require("../../../hooks/inherit/index.cjs");
+const index = require("../../../hooks/cssname/index.cjs");
+const compons = require("../../common/compons.cjs");
+const columns_vue_vue_type_script_lang = require("./columns2.cjs");
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  props: data.dataProps,
+  emits: data.dataEmits,
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const cs = index.useCssName("tablesv");
+    const slots = vue.useSlots();
+    const attrs = index$1.useInherit(vue.useAttrs());
+    const props = __props;
+    vue.provide("tables-compons", compons.getCompons(props.compons));
+    const tableRef = vue.ref();
+    const emit = __emit;
+    const rowObj = vue.ref();
+    const isfocus = vue.ref(false);
+    function onClick() {
+      isfocus.value = true;
+    }
+    function isComponSelected(obj, scope) {
+      if (use.uesObjComponSelected(obj, props)) {
+        if (rowObj.value === scope.row) {
+          if (isfocus.value) {
+            return true;
+          } else {
+            return false;
+          }
+        } else {
+          return false;
+        }
+      } else {
+        return true;
+      }
+    }
+    let isSort = false;
+    const orderMap = {
+      asc: "asc",
+      ascending: "asc",
+      desc: "desc",
+      descending: "desc"
+    };
+    const sizeMap = {
+      large: "",
+      default: "medium",
+      small: "small"
+    };
+    const size = vue.computed(() => {
+      return sizeMap[props.size] || "";
+    });
+    const tableDefaultSort = vue.computed(() => {
+      return {
+        prop: props.defaultSort?.prop,
+        order: orderMap[props.defaultSort?.order] || ""
+      };
+    });
+    const setHover = () => {
+      const is = attrs.assem.highlightCurrentRow;
+      if (is === true) {
+        return true;
+      } else {
+        return false;
+      }
+    };
+    const config = vue.ref({
+      nocustomize: attrs.assem.__B("nocustomize"),
+      row: {
+        isCurrent: setHover(),
+        isHover: setHover()
+      },
+      column: {
+        minWidth: attrs.assem.minWidth,
+        resizable: attrs.assem.resizable
+      },
+      sort: {
+        remote: Boolean(attrs.assem.sort),
+        defaultSort: {
+          field: tableDefaultSort.value.prop,
+          order: tableDefaultSort.value.order
+        }
+      },
+      seq: {},
+      checkbox: {
+        trigger: attrs.assem.noRowSelect ? "cell" : "row"
+      },
+      radio: {
+        trigger: attrs.assem.noRowSelect ? "cell" : "row"
+      }
+    });
+    const rowStyle = vue.computed(() => {
+      const height = props.lineHeight;
+      const rowStyle2 = attrs.assem.rowStyle;
+      if (height) {
+        if (rowStyle2) {
+          if (typeof rowStyle2 == "object") {
+            rowStyle2["height"] = height + "px";
+            return rowStyle2;
+          } else {
+            return rowStyle2;
+          }
+        } else {
+          return {
+            height: height + "px"
+          };
+        }
+      } else {
+        return {
+          height: "",
+          ...rowStyle2
+        };
+      }
+    });
+    vue.watch(tableDefaultSort, (newValue, oldValue) => {
+      let prop = tableDefaultSort.value.prop;
+      let order = tableDefaultSort.value.order;
+      if (tableRef.value) {
+        if (prop) {
+          isSort = true;
+          tableRef.value.sort(prop, order);
+        } else {
+          tableRef.value.clearSort();
+        }
+      }
+    });
+    function sortChange(obj) {
+      if (isSort) {
+        isSort = false;
+        return false;
+      }
+      emit("sort-change", obj);
+    }
+    function onListEvents(key, ...arr) {
+      if (key == "checkbox-all") {
+        const $table = tableRef.value;
+        if ($table) {
+          $table.toggleAllCheckboxRow();
+          selectChangeEvent({
+            records: $table.getCheckboxRecords()
+          });
+        }
+      } else {
+        emit("list-events", key, ...arr);
+      }
+    }
+    function selectAllChangeEvent(obj) {
+      const arr = obj.records;
+      emit("selection-change", arr);
+    }
+    function selectChangeEvent(obj) {
+      const arr = obj.records;
+      emit("selection-change", arr);
+    }
+    function onCellClick(scope) {
+      rowObj.value = scope.row;
+    }
+    function toggleRowSelection(row) {
+      tableRef.value.toggleRowSelection(row);
+    }
+    function clearSelection() {
+      tableRef.value.clearCheckboxRow();
+    }
+    function clearRadioRow() {
+      tableRef.value.clearRadioRow();
+    }
+    vue.onMounted(() => {
+      if (window) {
+        window.addEventListener("click", () => {
+          isfocus.value = false;
+        });
+      }
+    });
+    __expose({
+      ...data.dataExpose,
+      clearSelection,
+      clearRadioRow
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", vue.mergeProps({
+        class: vue.unref(cs).z()
+      }, vue.unref(attrs).root), [
+        vue.createVNode(vue.unref(table.VxeTable), vue.mergeProps(vue.unref(attrs).assem, {
+          ref_key: "tableRef",
+          ref: tableRef,
+          height: props.height == "auto" ? "" : props.height,
+          class: [vue.unref(cs).z("table"), vue.unref(cs).is("absolute", props.adaptive)],
+          size: size.value,
+          loading: props.loading,
+          "column-config": config.value.column,
+          "row-style": rowStyle.value,
+          "row-config": config.value.row,
+          "seq-config": config.value.seq,
+          "sort-config": config.value.sort,
+          "checkbox-config": config.value.checkbox,
+          "radio-config": config.value.radio,
+          data: props.value,
+          onCellClick,
+          onSortChange: sortChange,
+          onCheckboxAll: selectAllChangeEvent,
+          onCheckboxChange: selectChangeEvent,
+          onClick: vue.withModifiers(onClick, ["stop"])
+        }), {
+          empty: vue.withCtx(() => [
+            vue.renderSlot(_ctx.$slots, "no-data", {}, () => [
+              vue.createElementVNode("div", {
+                class: vue.normalizeClass(vue.unref(cs).z("no-data"))
+              }, _cache[0] || (_cache[0] = [
+                vue.createElementVNode("span", null, "暂无数据", -1)
+              ]), 2)
+            ])
+          ]),
+          default: vue.withCtx(() => [
+            vue.createVNode(columns_vue_vue_type_script_lang.default, {
+              table: vue.unref(attrs).assem,
+              vxeconfig: config.value,
+              value: props.value,
+              list: props.list,
+              options: props.options,
+              isComponSelected,
+              onListEvents
+            }, vue.createSlots({ _: 2 }, [
+              vue.renderList(Object.keys(vue.unref(slots)).filter(
+                (v) => !["empty", "no-data"].includes(v)
+              ), (k) => {
+                return {
+                  name: k,
+                  fn: vue.withCtx((scope) => [
+                    vue.renderSlot(_ctx.$slots, k, vue.normalizeProps(vue.guardReactiveProps(scope)))
+                  ])
+                };
+              })
+            ]), 1032, ["table", "vxeconfig", "value", "list", "options"])
+          ]),
+          _: 3
+        }, 16, ["height", "class", "size", "loading", "column-config", "row-style", "row-config", "seq-config", "sort-config", "checkbox-config", "radio-config", "data"])
+      ], 16);
+    };
+  }
+});
+exports.default = _sfc_main;

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

@@ -1,4 +1,247 @@
-import _sfc_main from "./index.js";
+import { defineComponent, useSlots, useAttrs, provide, ref, computed, watch, onMounted, createElementBlock, openBlock, mergeProps, unref, createVNode, withModifiers, withCtx, createSlots, renderList, renderSlot, normalizeProps, guardReactiveProps, createElementVNode, normalizeClass } from "vue";
+import { VxeTable } from "vxe-table/es/table";
+import { dataExpose, dataEmits, dataProps } from "./data.js";
+import "./columns.js";
+import { uesObjComponSelected } from "../../common/use.js";
+import { useInherit } from "../../../hooks/inherit/index.js";
+import { useCssName } from "../../../hooks/cssname/index.js";
+import { getCompons } from "../../common/compons.js";
+import _sfc_main$1 from "./columns2.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "index",
+  props: dataProps,
+  emits: dataEmits,
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const cs = useCssName("tablesv");
+    const slots = useSlots();
+    const attrs = useInherit(useAttrs());
+    const props = __props;
+    provide("tables-compons", getCompons(props.compons));
+    const tableRef = ref();
+    const emit = __emit;
+    const rowObj = ref();
+    const isfocus = ref(false);
+    function onClick() {
+      isfocus.value = true;
+    }
+    function isComponSelected(obj, scope) {
+      if (uesObjComponSelected(obj, props)) {
+        if (rowObj.value === scope.row) {
+          if (isfocus.value) {
+            return true;
+          } else {
+            return false;
+          }
+        } else {
+          return false;
+        }
+      } else {
+        return true;
+      }
+    }
+    let isSort = false;
+    const orderMap = {
+      asc: "asc",
+      ascending: "asc",
+      desc: "desc",
+      descending: "desc"
+    };
+    const sizeMap = {
+      large: "",
+      default: "medium",
+      small: "small"
+    };
+    const size = computed(() => {
+      return sizeMap[props.size] || "";
+    });
+    const tableDefaultSort = computed(() => {
+      return {
+        prop: props.defaultSort?.prop,
+        order: orderMap[props.defaultSort?.order] || ""
+      };
+    });
+    const setHover = () => {
+      const is = attrs.assem.highlightCurrentRow;
+      if (is === true) {
+        return true;
+      } else {
+        return false;
+      }
+    };
+    const config = ref({
+      nocustomize: attrs.assem.__B("nocustomize"),
+      row: {
+        isCurrent: setHover(),
+        isHover: setHover()
+      },
+      column: {
+        minWidth: attrs.assem.minWidth,
+        resizable: attrs.assem.resizable
+      },
+      sort: {
+        remote: Boolean(attrs.assem.sort),
+        defaultSort: {
+          field: tableDefaultSort.value.prop,
+          order: tableDefaultSort.value.order
+        }
+      },
+      seq: {},
+      checkbox: {
+        trigger: attrs.assem.noRowSelect ? "cell" : "row"
+      },
+      radio: {
+        trigger: attrs.assem.noRowSelect ? "cell" : "row"
+      }
+    });
+    const rowStyle = computed(() => {
+      const height = props.lineHeight;
+      const rowStyle2 = attrs.assem.rowStyle;
+      if (height) {
+        if (rowStyle2) {
+          if (typeof rowStyle2 == "object") {
+            rowStyle2["height"] = height + "px";
+            return rowStyle2;
+          } else {
+            return rowStyle2;
+          }
+        } else {
+          return {
+            height: height + "px"
+          };
+        }
+      } else {
+        return {
+          height: "",
+          ...rowStyle2
+        };
+      }
+    });
+    watch(tableDefaultSort, (newValue, oldValue) => {
+      let prop = tableDefaultSort.value.prop;
+      let order = tableDefaultSort.value.order;
+      if (tableRef.value) {
+        if (prop) {
+          isSort = true;
+          tableRef.value.sort(prop, order);
+        } else {
+          tableRef.value.clearSort();
+        }
+      }
+    });
+    function sortChange(obj) {
+      if (isSort) {
+        isSort = false;
+        return false;
+      }
+      emit("sort-change", obj);
+    }
+    function onListEvents(key, ...arr) {
+      if (key == "checkbox-all") {
+        const $table = tableRef.value;
+        if ($table) {
+          $table.toggleAllCheckboxRow();
+          selectChangeEvent({
+            records: $table.getCheckboxRecords()
+          });
+        }
+      } else {
+        emit("list-events", key, ...arr);
+      }
+    }
+    function selectAllChangeEvent(obj) {
+      const arr = obj.records;
+      emit("selection-change", arr);
+    }
+    function selectChangeEvent(obj) {
+      const arr = obj.records;
+      emit("selection-change", arr);
+    }
+    function onCellClick(scope) {
+      rowObj.value = scope.row;
+    }
+    function toggleRowSelection(row) {
+      tableRef.value.toggleRowSelection(row);
+    }
+    function clearSelection() {
+      tableRef.value.clearCheckboxRow();
+    }
+    function clearRadioRow() {
+      tableRef.value.clearRadioRow();
+    }
+    onMounted(() => {
+      if (window) {
+        window.addEventListener("click", () => {
+          isfocus.value = false;
+        });
+      }
+    });
+    __expose({
+      ...dataExpose,
+      clearSelection,
+      clearRadioRow
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", mergeProps({
+        class: unref(cs).z()
+      }, unref(attrs).root), [
+        createVNode(unref(VxeTable), mergeProps(unref(attrs).assem, {
+          ref_key: "tableRef",
+          ref: tableRef,
+          height: props.height == "auto" ? "" : props.height,
+          class: [unref(cs).z("table"), unref(cs).is("absolute", props.adaptive)],
+          size: size.value,
+          loading: props.loading,
+          "column-config": config.value.column,
+          "row-style": rowStyle.value,
+          "row-config": config.value.row,
+          "seq-config": config.value.seq,
+          "sort-config": config.value.sort,
+          "checkbox-config": config.value.checkbox,
+          "radio-config": config.value.radio,
+          data: props.value,
+          onCellClick,
+          onSortChange: sortChange,
+          onCheckboxAll: selectAllChangeEvent,
+          onCheckboxChange: selectChangeEvent,
+          onClick: withModifiers(onClick, ["stop"])
+        }), {
+          empty: withCtx(() => [
+            renderSlot(_ctx.$slots, "no-data", {}, () => [
+              createElementVNode("div", {
+                class: normalizeClass(unref(cs).z("no-data"))
+              }, _cache[0] || (_cache[0] = [
+                createElementVNode("span", null, "暂无数据", -1)
+              ]), 2)
+            ])
+          ]),
+          default: withCtx(() => [
+            createVNode(_sfc_main$1, {
+              table: unref(attrs).assem,
+              vxeconfig: config.value,
+              value: props.value,
+              list: props.list,
+              options: props.options,
+              isComponSelected,
+              onListEvents
+            }, createSlots({ _: 2 }, [
+              renderList(Object.keys(unref(slots)).filter(
+                (v) => !["empty", "no-data"].includes(v)
+              ), (k) => {
+                return {
+                  name: k,
+                  fn: withCtx((scope) => [
+                    renderSlot(_ctx.$slots, k, normalizeProps(guardReactiveProps(scope)))
+                  ])
+                };
+              })
+            ]), 1032, ["table", "vxeconfig", "value", "list", "options"])
+          ]),
+          _: 3
+        }, 16, ["height", "class", "size", "loading", "column-config", "row-style", "row-config", "seq-config", "sort-config", "checkbox-config", "radio-config", "data"])
+      ], 16);
+    };
+  }
+});
 export {
   _sfc_main as default
 };

package/dist/components/tablesvp/index.cjs

@@ -2,7 +2,8 @@
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 ;/* empty css                   */
 const withInstall = require("../../utils/vues/withInstall.cjs");
-const index_vue_vue_type_script_setup_true_lang = require("./src/index.cjs");
+require("./src/index.cjs");
+const index_vue_vue_type_script_setup_true_lang = require("./src/index2.cjs");
 const Tablesvp = withInstall.withInstall(index_vue_vue_type_script_setup_true_lang.default, "Tablesvp");
 exports.Tablesvp = Tablesvp;
 exports.default = Tablesvp;

package/dist/components/tablesvp/index.js

@@ -1,6 +1,7 @@
 /* empty css                 */
 import { withInstall } from "../../utils/vues/withInstall.js";
-import _sfc_main from "./src/index.js";
+import "./src/index.js";
+import _sfc_main from "./src/index2.js";
 const Tablesvp = withInstall(_sfc_main, "Tablesvp");
 export {
   Tablesvp,

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

@@ -1,86 +1,4 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const vue = require("vue");
-const index$1 = require("../../tablesv/index.cjs");
-const index$2 = require("../../paging/index.cjs");
-const pagin = require("../../tables/common/pagin.cjs");
-const index = require("../../../hooks/cssname/index.cjs");
-const _sfc_main = /* @__PURE__ */ vue.defineComponent({
-  __name: "index",
-  props: pagin.dataProps,
-  emits: pagin.dataEmit,
-  setup(__props, { expose: __expose, emit: __emit }) {
-    const cs = index.useCssName("tablesvp");
-    const slots = vue.useSlots();
-    const props = __props;
-    const emit = __emit;
-    const refTable = vue.ref();
-    const {
-      height,
-      getSelection,
-      initData,
-      getData,
-      empty,
-      loading,
-      tableList,
-      tableConfig,
-      onRadioChange,
-      onSortChange,
-      onListEvents,
-      onChange,
-      pagconfig,
-      formEvent,
-      onSizeChange,
-      onCurrentChange,
-      paginat,
-      data
-    } = pagin.useInit(props, emit, refTable);
-    __expose({
-      getSelection,
-      initData,
-      getList: getData,
-      empty
-    });
-    return (_ctx, _cache) => {
-      return vue.openBlock(), vue.createElementBlock("div", {
-        class: vue.normalizeClass(vue.unref(cs).z()),
-        style: vue.normalizeStyle(vue.unref(cs).vdo({ height: vue.unref(height) }))
-      }, [
-        vue.createVNode(vue.unref(index$1.Tablesv), vue.mergeProps(vue.unref(tableConfig).config, vue.toHandlers(vue.unref(formEvent)), {
-          height: vue.unref(height) == "auto" ? "auto" : "100%",
-          ref_key: "refTable",
-          ref: refTable,
-          class: [vue.unref(cs).z("main")],
-          size: vue.unref(tableConfig).config?.size,
-          value: vue.unref(data).list,
-          list: vue.unref(tableList),
-          paginat: vue.unref(paginat),
-          loading: vue.unref(loading),
-          options: props.options,
-          compons: props.compons,
-          onSortChange: vue.unref(onSortChange),
-          onRadioChange: vue.unref(onRadioChange),
-          onSelectionChange: vue.unref(onChange),
-          onListEvents: vue.unref(onListEvents)
-        }), vue.createSlots({ _: 2 }, [
-          vue.renderList(Object.keys(vue.unref(slots)), (k, i) => {
-            return {
-              name: k,
-              fn: vue.withCtx((scope) => [
-                vue.renderSlot(_ctx.$slots, k, vue.normalizeProps(vue.guardReactiveProps(scope)))
-              ])
-            };
-          })
-        ]), 1040, ["height", "class", "size", "value", "list", "paginat", "loading", "options", "compons", "onSortChange", "onRadioChange", "onSelectionChange", "onListEvents"]),
-        vue.unref(tableConfig).paginat?.is ? (vue.openBlock(), vue.createBlock(vue.unref(index$2.Paging), vue.mergeProps({ key: 0 }, vue.unref(pagconfig), {
-          class: vue.unref(cs).z("paginat"),
-          paginat: vue.unref(paginat),
-          total: vue.unref(data).total,
-          onSizeChange: vue.unref(onSizeChange),
-          onCurrentChange: vue.unref(onCurrentChange)
-        }), null, 16, ["class", "paginat", "total", "onSizeChange", "onCurrentChange"])) : vue.createCommentVNode("", true)
-      ], 6);
-    };
-  }
-});
-exports.default = _sfc_main;
+const index_vue_vue_type_script_setup_true_lang = require("./index2.cjs");
+exports.default = index_vue_vue_type_script_setup_true_lang.default;

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

@@ -1,86 +1,4 @@
-import { defineComponent, useSlots, ref, createElementBlock, openBlock, normalizeStyle, normalizeClass, unref, createVNode, createBlock, createCommentVNode, mergeProps, toHandlers, createSlots, renderList, withCtx, renderSlot, normalizeProps, guardReactiveProps } from "vue";
-import { Tablesv } from "../../tablesv/index.js";
-import { Paging } from "../../paging/index.js";
-import { dataEmit, dataProps, useInit } from "../../tables/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("tablesvp");
-    const slots = useSlots();
-    const props = __props;
-    const emit = __emit;
-    const refTable = ref();
-    const {
-      height,
-      getSelection,
-      initData,
-      getData,
-      empty,
-      loading,
-      tableList,
-      tableConfig,
-      onRadioChange,
-      onSortChange,
-      onListEvents,
-      onChange,
-      pagconfig,
-      formEvent,
-      onSizeChange,
-      onCurrentChange,
-      paginat,
-      data
-    } = useInit(props, emit, refTable);
-    __expose({
-      getSelection,
-      initData,
-      getList: getData,
-      empty
-    });
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", {
-        class: normalizeClass(unref(cs).z()),
-        style: normalizeStyle(unref(cs).vdo({ height: unref(height) }))
-      }, [
-        createVNode(unref(Tablesv), mergeProps(unref(tableConfig).config, toHandlers(unref(formEvent)), {
-          height: unref(height) == "auto" ? "auto" : "100%",
-          ref_key: "refTable",
-          ref: refTable,
-          class: [unref(cs).z("main")],
-          size: unref(tableConfig).config?.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)))
-              ])
-            };
-          })
-        ]), 1040, ["height", "class", "size", "value", "list", "paginat", "loading", "options", "compons", "onSortChange", "onRadioChange", "onSelectionChange", "onListEvents"]),
-        unref(tableConfig).paginat?.is ? (openBlock(), createBlock(unref(Paging), mergeProps({ key: 0 }, 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)
-      ], 6);
-    };
-  }
-});
+import _sfc_main from "./index2.js";
 export {
   _sfc_main as default
 };