@fangzhongya/fang-ui 0.0.12 → 0.0.14

package/dist/components/vxe-tables/src/data.d.ts

@@ -0,0 +1,129 @@
+import { ExtractPropTypes, Component } from 'vue';
+export type DefaultSort = {
+    prop: string;
+    order: 'ascending' | 'descending';
+};
+/**
+ * @title FTable 表格
+ * @author 方忠亚
+ * @description 对el-table进行二次封装，减少写html，自适应自身高度
+ * @date 2022年11月21日19点34分
+ */
+export declare const dataProps: {
+    /**
+     * @props { Object } defaultSort 排序
+     */
+    defaultSort: {
+        type: () => DefaultSort;
+        default(): {};
+    };
+    height: {
+        type: (NumberConstructor | StringConstructor)[];
+        default(): string;
+    };
+    /**
+     * 加载中
+     */
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    adaptive: BooleanConstructor;
+    /**
+     * @props { Array<Object> } list table展示的列
+     * @props { String } list.class table展示的列class
+     * @props { String } list.label table展示的列头名称
+     * @props { Array<Object> } list.children 用来展示多级头
+     * @props { boolean } list.hide=false 当前列是否隐藏
+     * @props { function } list.sethide 当前列是否隐藏方法模式
+     * @props { function } list.formatter (row, column, cellValue, index) 用来格式化内容
+     * @props { String } list.align=left (left , center , right) 对齐方式
+     * @props { string , number } list.width table展示的宽度
+     * @props { string , number } list.minWidth table展示的最小宽度
+     * @props { string , boolean } list.fixed (true , 'left' , 'right') 列是否固定在左侧或者右侧。 true 表示固定在左侧
+     * @props { String } list.compon (component, color, list, but) table的扩展组件配置
+     * @props { Object } list.config table的扩展组件的配置对象
+     */
+    list: {
+        type: {
+            (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, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default(): never[];
+    };
+    /**
+     * @props { Array } value table列表数据
+     */
+    value: {
+        type: {
+            (arrayLength: number): ObjAny[];
+            (...items: ObjAny[]): ObjAny[];
+            new (arrayLength: number): ObjAny[];
+            new (...items: ObjAny[]): ObjAny[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default(): never[];
+    };
+    /**
+     * 行高度
+     */
+    lineHeight: {
+        type: (NumberConstructor | StringConstructor)[];
+    };
+    size: {
+        type: StringConstructor;
+        default(): string;
+    };
+    /**
+     * @props { Object } options 选择数据集合
+     */
+    options: {
+        type: ObjectConstructor;
+        default(): {};
+    };
+    /**
+     * @props { Object } compons 外部组件集合
+     */
+    compons: {
+        type: () => {
+            [key: string]: Component;
+        };
+        default(): {};
+    };
+};
+export type DataProps = ExtractPropTypes<typeof dataProps>;
+/**
+ * @emits scroll-bottom 滚动到列表底部触发事件
+ */
+export declare const dataEmits: string[];
+export type DataEmits = typeof dataEmits;
+/**
+ * @expose clearSelection ( ) 清除多选
+ * @expose toggleRowSelectionList (row, selected, key ) 切换选择
+ * @expose clearSelectionList ( ) 清空选中
+ * @expose { Object: {  value: 值,
+                    list: 当前列,
+                    key: key的名称,} } getRowSelectionsCheckList (row, key ) 获取选中的值
+ */
+export declare const dataExpose: {};

package/dist/components/vxe-tables/src/data.js

@@ -0,0 +1,100 @@
+const dataProps = {
+  /**
+   * @props { Object } defaultSort 排序
+   */
+  defaultSort: {
+    type: Object,
+    default() {
+      return {};
+    }
+  },
+  height: {
+    type: [String, Number],
+    default() {
+      return "auto";
+    }
+  },
+  /**
+   * 加载中
+   */
+  loading: {
+    type: Boolean,
+    default: false
+  },
+  // 高度自适应
+  adaptive: Boolean,
+  /**
+   * @props { Array<Object> } list table展示的列
+   * @props { String } list.class table展示的列class
+   * @props { String } list.label table展示的列头名称
+   * @props { Array<Object> } list.children 用来展示多级头
+   * @props { boolean } list.hide=false 当前列是否隐藏
+   * @props { function } list.sethide 当前列是否隐藏方法模式
+   * @props { function } list.formatter (row, column, cellValue, index) 用来格式化内容
+   * @props { String } list.align=left (left , center , right) 对齐方式
+   * @props { string , number } list.width table展示的宽度
+   * @props { string , number } list.minWidth table展示的最小宽度
+   * @props { string , boolean } list.fixed (true , 'left' , 'right') 列是否固定在左侧或者右侧。 true 表示固定在左侧
+   * @props { String } list.compon (component, color, list, but) table的扩展组件配置
+   * @props { Object } list.config table的扩展组件的配置对象
+   */
+  list: {
+    type: Array,
+    default() {
+      return [];
+    }
+  },
+  /**
+   * @props { Array } value table列表数据
+   */
+  value: {
+    type: Array,
+    default() {
+      return [];
+    }
+  },
+  /**
+   * 行高度
+   */
+  lineHeight: {
+    type: [String, Number]
+  },
+  size: {
+    type: String,
+    default() {
+      return "default";
+    }
+  },
+  /**
+   * @props { Object } options 选择数据集合
+   */
+  options: {
+    type: Object,
+    default() {
+      return {};
+    }
+  },
+  /**
+   * @props { Object } compons 外部组件集合
+   */
+  compons: {
+    type: Object,
+    default() {
+      return {};
+    }
+  }
+};
+const dataEmits = [
+  "sort-change",
+  "scroll-bottom",
+  "scope-click",
+  "selection-list",
+  "list-events",
+  "selection-change"
+];
+const dataExpose = {};
+export {
+  dataEmits,
+  dataExpose,
+  dataProps
+};

package/dist/components/vxe-tables/src/index.cjs

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const require$$0 = require("vue");
+const table = require("vxe-table/es/table");
+const data = require("./data.cjs");
+const columns_vue_vue_type_script_lang = 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 _sfc_main = /* @__PURE__ */ require$$0.defineComponent({
+  __name: "index",
+  props: data.dataProps,
+  emits: data.dataEmits,
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const cs = index.useCssName("vtables");
+    const slots = require$$0.useSlots();
+    const attrs = index$1.useInherit(require$$0.useAttrs());
+    const props = __props;
+    require$$0.provide("tables-compons", compons.getCompons(props.compons));
+    const tableRef = require$$0.ref();
+    const emit = __emit;
+    const rowObj = require$$0.ref();
+    const isfocus = require$$0.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 = require$$0.computed(() => {
+      return sizeMap[props.size] || "";
+    });
+    const tableDefaultSort = require$$0.computed(() => {
+      var _a, _b;
+      return {
+        prop: (_a = props.defaultSort) == null ? void 0 : _a.prop,
+        order: orderMap[(_b = props.defaultSort) == null ? void 0 : _b.order] || ""
+      };
+    });
+    const setHover = () => {
+      const is = attrs.assem.highlightCurrentRow;
+      if (is === true) {
+        return true;
+      } else {
+        return false;
+      }
+    };
+    const config = require$$0.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 = require$$0.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
+        };
+      }
+    });
+    require$$0.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 clearSelection() {
+      tableRef.value.clearCheckboxRow();
+    }
+    function clearRadioRow() {
+      tableRef.value.clearRadioRow();
+    }
+    require$$0.onMounted(() => {
+      if (window) {
+        window.addEventListener("click", () => {
+          isfocus.value = false;
+        });
+      }
+    });
+    __expose({
+      ...data.dataExpose,
+      clearSelection,
+      clearRadioRow
+    });
+    return (_ctx, _cache) => {
+      return require$$0.openBlock(), require$$0.createElementBlock("div", require$$0.mergeProps({
+        class: require$$0.unref(cs).z()
+      }, require$$0.unref(attrs).root), [
+        require$$0.createVNode(require$$0.unref(table.VxeTable), require$$0.mergeProps(require$$0.unref(attrs).assem, {
+          ref_key: "tableRef",
+          ref: tableRef,
+          height: props.height == "auto" ? "" : props.height,
+          class: [require$$0.unref(cs).z("table"), require$$0.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: require$$0.withModifiers(onClick, ["stop"])
+        }), {
+          empty: require$$0.withCtx(() => [
+            require$$0.renderSlot(_ctx.$slots, "no-data", {}, () => [
+              require$$0.createElementVNode("div", {
+                class: require$$0.normalizeClass(require$$0.unref(cs).z("no-data"))
+              }, _cache[0] || (_cache[0] = [
+                require$$0.createElementVNode("span", null, "暂无数据", -1)
+              ]), 2)
+            ])
+          ]),
+          default: require$$0.withCtx(() => [
+            require$$0.createVNode(columns_vue_vue_type_script_lang.default, {
+              table: require$$0.unref(attrs).assem,
+              vxeconfig: config.value,
+              value: props.value,
+              list: props.list,
+              options: props.options,
+              isComponSelected,
+              onListEvents
+            }, require$$0.createSlots({ _: 2 }, [
+              require$$0.renderList(Object.keys(require$$0.unref(slots)).filter(
+                (v) => !["empty", "no-data"].includes(v)
+              ), (k) => {
+                return {
+                  name: k,
+                  fn: require$$0.withCtx((scope) => [
+                    require$$0.renderSlot(_ctx.$slots, k, require$$0.normalizeProps(require$$0.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/vxe-tables/src/index.d.ts

@@ -0,0 +1,176 @@
+declare function clearSelection(): void;
+declare function clearRadioRow(): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Partial<Record<string, (_: any) => any>> & {
+        'no-data'?(_: {}): any;
+    };
+    refs: {
+        tableRef: unknown;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    defaultSort: {
+        type: () => import('./data').DefaultSort;
+        default(): {};
+    };
+    height: {
+        type: (NumberConstructor | StringConstructor)[];
+        default(): string;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    adaptive: BooleanConstructor;
+    list: {
+        type: {
+            (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, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default(): never[];
+    };
+    value: {
+        type: {
+            (arrayLength: number): ObjAny[];
+            (...items: ObjAny[]): ObjAny[];
+            new (arrayLength: number): ObjAny[];
+            new (...items: ObjAny[]): ObjAny[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default(): never[];
+    };
+    lineHeight: {
+        type: (NumberConstructor | StringConstructor)[];
+    };
+    size: {
+        type: StringConstructor;
+        default(): string;
+    };
+    options: {
+        type: ObjectConstructor;
+        default(): {};
+    };
+    compons: {
+        type: () => {
+            [key: string]: import('vue').Component;
+        };
+        default(): {};
+    };
+}>, {
+    clearSelection: typeof clearSelection;
+    clearRadioRow: typeof clearRadioRow;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    defaultSort: {
+        type: () => import('./data').DefaultSort;
+        default(): {};
+    };
+    height: {
+        type: (NumberConstructor | StringConstructor)[];
+        default(): string;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    adaptive: BooleanConstructor;
+    list: {
+        type: {
+            (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, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default(): never[];
+    };
+    value: {
+        type: {
+            (arrayLength: number): ObjAny[];
+            (...items: ObjAny[]): ObjAny[];
+            new (arrayLength: number): ObjAny[];
+            new (...items: ObjAny[]): ObjAny[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default(): never[];
+    };
+    lineHeight: {
+        type: (NumberConstructor | StringConstructor)[];
+    };
+    size: {
+        type: StringConstructor;
+        default(): string;
+    };
+    options: {
+        type: ObjectConstructor;
+        default(): {};
+    };
+    compons: {
+        type: () => {
+            [key: string]: import('vue').Component;
+        };
+        default(): {};
+    };
+}>> & Readonly<{}>, {
+    size: string;
+    value: ObjAny[];
+    list: ListObj[];
+    loading: boolean;
+    options: Record<string, any>;
+    height: string | number;
+    compons: {
+        [key: string]: import('vue').Component;
+    };
+    defaultSort: import('./data').DefaultSort;
+    adaptive: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    tableRef: unknown;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};