@fangzhongya/fang-ui 0.0.12 → 0.0.13

package/dist/components/vxe-tables/index.d.ts

@@ -0,0 +1,272 @@
+declare const VxeTables: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        defaultSort: {
+            type: () => import('./src/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<{}>, {
+        clearSelection: () => void;
+        clearRadioRow: () => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        size: string;
+        value: ObjAny[];
+        list: ListObj[];
+        loading: boolean;
+        options: Record<string, any>;
+        height: string | number;
+        compons: {
+            [key: string]: import('vue').Component;
+        };
+        defaultSort: import('./src/data').DefaultSort;
+        adaptive: boolean;
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        tableRef: unknown;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<{
+        defaultSort: {
+            type: () => import('./src/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<{}>, {
+        clearSelection: () => void;
+        clearRadioRow: () => void;
+    }, {}, {}, {}, {
+        size: string;
+        value: ObjAny[];
+        list: ListObj[];
+        loading: boolean;
+        options: Record<string, any>;
+        height: string | number;
+        compons: {
+            [key: string]: import('vue').Component;
+        };
+        defaultSort: import('./src/data').DefaultSort;
+        adaptive: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+    defaultSort: {
+        type: () => import('./src/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<{}>, {
+    clearSelection: () => void;
+    clearRadioRow: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+    size: string;
+    value: ObjAny[];
+    list: ListObj[];
+    loading: boolean;
+    options: Record<string, any>;
+    height: string | number;
+    compons: {
+        [key: string]: import('vue').Component;
+    };
+    defaultSort: import('./src/data').DefaultSort;
+    adaptive: boolean;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: Partial<Record<string, (_: any) => any>> & {
+        'no-data'?(_: {}): any;
+    };
+}) & import('vue').Plugin;
+export { VxeTables, VxeTables as default };

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

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

package/dist/components/vxe-tables/index.scss

@@ -0,0 +1,92 @@
+@use '../css/common.scss' as *;
+
+$vtables: 'vtables';
+@include b($vtables) {
+	// height: 100%;
+	width: 100%;
+	min-height: 100px;
+	position: relative;
+	flex: 1;
+	display: flex;
+	flex-direction: column;
+	&-table {
+		&.#{is('absolute')} {
+			position: absolute;
+			top: 0;
+			right: 0;
+			bottom: 0;
+			left: 0;
+		}
+		// flex: 1;
+		// width: 100%;
+		// 去掉背景色
+		background-color: transparent;
+		.vxe-body--column {
+			overflow: hidden;
+			padding: 8px 0;
+		}
+		.col--checkbox {
+			.vxe-checkbox--label {
+				padding-left: 0;
+			}
+		}
+	}
+	.fv-custom-checkbox {
+		cursor: pointer;
+		&.is-disabled {
+			cursor: not-allowed;
+		}
+		.#{$namespace}-checkbox__label {
+			color: var(--vxe-table-header-font-color);
+			font-weight: var(--vxe-table-header-font-weight);
+		}
+		position: relative;
+		.fv-custom-checkbox-mask {
+			position: absolute;
+			top: 0;
+			right: 0;
+			bottom: 0;
+			left: 0;
+			z-index: 1;
+			opacity: 0;
+		}
+	}
+	.fv-custom-radio {
+		cursor: pointer;
+		&.is-disabled {
+			cursor: not-allowed;
+		}
+		position: relative;
+		.#{$namespace}-radio {
+			height: auto;
+		}
+		&.center {
+			.#{$namespace}-radio {
+				text-align: center;
+				display: table-cell;
+			}
+			.#{$namespace}-radio__label {
+				display: none;
+			}
+		}
+		&.right {
+			.#{$namespace}-radio {
+				text-align: right;
+				display: table-cell;
+			}
+			.#{$namespace}-radio__label {
+				display: none;
+			}
+		}
+		.fv-custom-radio-mask {
+			position: absolute;
+			top: 0;
+			right: 0;
+			bottom: 0;
+			left: 0;
+			z-index: 1;
+			opacity: 0;
+		}
+	}
+	// 在cms中，checkbox的样式无效，无法加载:before 样式
+}

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

@@ -0,0 +1,283 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require$$0 = require("vue");
+const use = require("../../common/use.cjs");
+const index = require("../../../hooks/inherit/index.cjs");
+const compons = require("../../common/compons.cjs");
+const util = require("../../tables/common/util.cjs");
+require("@fangzhongya/utils/basic/string/splitUpper");
+require("@fangzhongya/utils/basic/array/isArray");
+require("@fangzhongya/utils/basic/object/isObject");
+require("@fangzhongya/utils/basic/string/firstLower");
+require("@fangzhongya/utils/basic/object/hasOwn");
+require("@fangzhongya/utils/basic/string/firstUpper");
+require("@fangzhongya/utils/name/lineToLargeHump");
+const lineToSmallHump = 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");
+require("../../../utils/vues/getBuildProps.cjs");
+require("@fangzhongya/utils/css/setObjStyle");
+require("@fangzhongya/utils/css/getCss");
+const column = require("vxe-table/es/column");
+const elementPlus = require("element-plus");
+function setBox(props, obj, emit, propss, slots, index2) {
+  if (props.type == "radio") {
+    return require$$0.h(
+      column.VxeColumn,
+      {
+        ...props,
+        className: obj.class,
+        minWidth: util.setMinWidth(obj, propss)
+      },
+      {
+        radio: (scope) => {
+          return require$$0.h(
+            "span",
+            {
+              class: "fv-custom-radio " + props.align + " " + (scope.disabled ? "is-disabled" : ""),
+              onClick(event) {
+                emit("list-events", "radio", scope);
+              }
+            },
+            [
+              require$$0.h(
+                elementPlus.ElRadio,
+                {
+                  modelValue: scope.checked,
+                  value: true,
+                  label: true,
+                  disabled: scope.disabled
+                },
+                {
+                  default() {
+                    return "";
+                  }
+                }
+              ),
+              require$$0.h("span", {
+                class: "fv-custom-radio-mask"
+              })
+            ]
+          );
+        }
+      }
+    );
+  } else {
+    return require$$0.h(
+      column.VxeColumn,
+      {
+        ...props,
+        className: obj.class,
+        minWidth: util.setMinWidth(obj, propss)
+      },
+      {
+        header: (scope) => {
+          return require$$0.h(
+            "span",
+            {
+              class: "fv-custom-checkbox",
+              onClick(event) {
+                emit("list-events", "checkbox-all", scope);
+              }
+            },
+            [
+              require$$0.h(
+                elementPlus.ElCheckbox,
+                {
+                  indeterminate: scope.indeterminate,
+                  modelValue: scope.checked
+                },
+                obj.label
+              ),
+              require$$0.h("span", {
+                class: "fv-custom-checkbox-mask"
+              })
+            ]
+          );
+        },
+        checkbox: (scope) => {
+          return require$$0.h(
+            "span",
+            {
+              class: "fv-custom-checkbox " + (scope.disabled ? "is-disabled" : ""),
+              onClick(event) {
+                emit("list-events", "checkbox", scope);
+              }
+            },
+            [
+              require$$0.h(elementPlus.ElCheckbox, {
+                indeterminate: scope.indeterminate,
+                modelValue: scope.checked,
+                disabled: scope.disabled
+              }),
+              require$$0.h("span", {
+                class: "fv-custom-checkbox-mask"
+              })
+            ]
+          );
+        }
+      }
+    );
+  }
+}
+const noProps = ["children", "class", "minWidth"];
+function setProps(obj, props) {
+  const table = props.table;
+  const vxeconfig = props.vxeconfig;
+  const robj = {};
+  robj["header-align"] = table["align"];
+  robj["align"] = index.useAttrValue(obj, "headerAlign") || table["align"];
+  const tooltip = index.useAttrValue(table, "showOverflowTooltip");
+  if (tooltip === "" || tooltip === true) {
+    robj["show-overflow"] = "tooltip";
+  }
+  Object.keys(obj).forEach((key) => {
+    const ckey = lineToSmallHump.lineToSmallHump(key);
+    if (!noProps.includes(ckey)) {
+      if (obj[key] !== "") {
+        robj[key] = obj[key];
+        if (key == "label") {
+          robj["title"] = obj[key];
+        } else if (ckey == "showOverflowTooltip") {
+          if (obj[key]) {
+            robj["show-overflow"] = "tooltip";
+          }
+        } else if (key == "prop") {
+          robj["field"] = obj[key];
+        } else if (key == "fixed") {
+          robj["fixed"] = obj[key] === true ? "left" : obj[key];
+        } else if (key == "type") {
+          if (obj[key] == "selection") {
+            robj[key] = table.isradio ? "radio" : "checkbox";
+            if (obj.selectable) {
+              if (table.isradio) {
+                vxeconfig.radio = vxeconfig.checkbox || {};
+                vxeconfig.radio.checkMethod = function(scope) {
+                  return obj.selectable(
+                    scope.row,
+                    scope.$rowIndex
+                  );
+                };
+              } else {
+                vxeconfig.checkbox = vxeconfig.checkbox || {};
+                vxeconfig.checkbox.checkMethod = function(scope) {
+                  return obj.selectable(
+                    scope.row,
+                    scope.$rowIndex
+                  );
+                };
+              }
+            }
+          } else if (obj[key] == "index") {
+            robj[key] = "seq";
+          }
+        }
+      }
+    }
+  });
+  return robj;
+}
+function setSslot(obj, scope, emit, slots, props, index2) {
+  const slot = use.useSetSlot(obj, scope.row, slots, index2);
+  if (slot) {
+    return slot;
+  }
+  if (obj.compon) {
+    const isComponSelected = props.isComponSelected;
+    if (isComponSelected(obj, scope)) {
+      const optionss = props.options || {};
+      const compons$1 = require$$0.inject("tables-compons", {});
+      const column2 = use.useSetCompon(
+        obj,
+        scope.row,
+        optionss,
+        compons.getCompons(compons$1),
+        emit,
+        index2
+      );
+      if (column2) {
+        return column2;
+      }
+    }
+  }
+  return defaultDom(obj, scope, props);
+}
+function defaultDom(obj, scope, props, index2) {
+  const table = props.table;
+  let domValue = "";
+  if (obj.type == "index") {
+    if (obj.index) {
+      domValue = obj.index(scope.$rowIndex, table.paginat);
+    } else {
+      if (table.paginat && table.paginat.current && table.paginat.pageSize) {
+        domValue = (table.paginat.current - 1) * table.paginat.pageSize + scope.$rowIndex + 1;
+      } else {
+        domValue = scope.$rowIndex + 1;
+      }
+    }
+    return domValue;
+  } else if (obj.type == "selection") {
+    return;
+  }
+  domValue = use.useGetDomValue(obj, scope.row, props.options, scope.$index);
+  return require$$0.h(
+    "span",
+    {
+      class: "text",
+      onClick(event) {
+        if (obj.click) {
+          obj.click(event, scope, obj);
+        }
+      }
+    },
+    domValue ?? ""
+  );
+}
+function setHeader(obj, scope, slots, emit, props, index2) {
+  const optionss = props.options || {};
+  const compons2 = require$$0.inject("tables-compons", {});
+  return use.useGetDomLabel(
+    obj.label,
+    obj,
+    scope.row,
+    slots,
+    optionss,
+    compons2,
+    emit,
+    index2
+  );
+}
+function getDom(obj, emit, propss, slots, index2) {
+  const props = setProps(obj, propss);
+  const vxeconfig = propss.vxeconfig;
+  if (!vxeconfig.nocustomize && obj.type == "selection") {
+    return setBox(props, obj, emit, propss);
+  }
+  const slotObj = {
+    default: (scope) => {
+      return setSslot(obj, scope, emit, slots, propss, index2);
+    }
+  };
+  if (obj.type != "selection") {
+    slotObj.header = (scope) => {
+      return setHeader(obj, scope, slots, emit, propss, index2);
+    };
+  }
+  return require$$0.h(
+    column.VxeColumn,
+    {
+      ...props,
+      className: obj.class,
+      minWidth: util.setMinWidth(obj, propss)
+    },
+    slotObj
+  );
+}
+function columnRender(obj, emit, props, slots, index2) {
+  return getDom(obj, emit, props, slots, index2);
+}
+exports.columnRender = columnRender;
+exports.setHeader = setHeader;
+exports.setProps = setProps;

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

@@ -0,0 +1,5 @@
+export declare function setProps(obj: ListObj, props: ObjAny): ObjAny;
+export declare function setHeader(obj: ListObj, scope: ObjAny, slots: ObjAny, emit: Function, props: ObjAny, index: number): any;
+export declare function columnRender(obj: ListObj, emit: Function, props: ObjAny, slots: ObjAny, index: number): import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>;