bm-admin-ui 1.0.0-alpha → 1.0.3-alpha

package/es/components/button/index.d.ts

@@ -27,12 +27,12 @@ declare const BmButton: import("bm-admin-ui/es/utils/with-install").SFCWithInsta
             $props: Partial<{
                 block: boolean;
                 disabled: boolean;
-                ghost: boolean;
-                danger: boolean;
-                htmlType: import("ant-design-vue/lib/button/buttonTypes").ButtonHTMLType;
                 loading: boolean | {
                     delay?: number | undefined;
                 };
+                ghost: boolean;
+                danger: boolean;
+                htmlType: import("ant-design-vue/lib/button/buttonTypes").ButtonHTMLType;
             }> & Omit<Readonly<import("vue").ExtractPropTypes<{
                 prefixCls: StringConstructor;
                 type: import("vue").PropType<import("ant-design-vue/lib/button").ButtonType>;
@@ -144,12 +144,12 @@ declare const BmButton: import("bm-admin-ui/es/utils/with-install").SFCWithInsta
             }>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, {
                 block: boolean;
                 disabled: boolean;
-                ghost: boolean;
-                danger: boolean;
-                htmlType: import("ant-design-vue/lib/button/buttonTypes").ButtonHTMLType;
                 loading: boolean | {
                     delay?: number | undefined;
                 };
+                ghost: boolean;
+                danger: boolean;
+                htmlType: import("ant-design-vue/lib/button/buttonTypes").ButtonHTMLType;
             }> & {
                 beforeCreate?: (() => void) | (() => void)[] | undefined;
                 created?: (() => void) | (() => void)[] | undefined;
@@ -271,12 +271,12 @@ declare const BmButton: import("bm-admin-ui/es/utils/with-install").SFCWithInsta
     }>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, {
         block: boolean;
         disabled: boolean;
-        ghost: boolean;
-        danger: boolean;
-        htmlType: import("ant-design-vue/lib/button/buttonTypes").ButtonHTMLType;
         loading: boolean | {
             delay?: number | undefined;
         };
+        ghost: boolean;
+        danger: boolean;
+        htmlType: import("ant-design-vue/lib/button/buttonTypes").ButtonHTMLType;
     }> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("@vue/runtime-core").Plugin & {
         readonly Group: import("vue").DefineComponent<{
             prefixCls: StringConstructor;

package/es/components/button/index.js

@@ -42,7 +42,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     };
   }
 });
-var Button = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "/Users/hesiying/work/bm-admin-ui/packages/components/button/src/button.vue"]]);
+var Button = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "button.vue"]]);
 
 const BmButton = withInstall(Button);
 

package/es/components/button/src/button.vue.d.ts

@@ -29,12 +29,12 @@ declare const _default: import("vue").DefineComponent<{
             $props: Partial<{
                 block: boolean;
                 disabled: boolean;
-                ghost: boolean;
-                danger: boolean;
-                htmlType: import("ant-design-vue/lib/button/buttonTypes").ButtonHTMLType;
                 loading: boolean | {
                     delay?: number | undefined;
                 };
+                ghost: boolean;
+                danger: boolean;
+                htmlType: import("ant-design-vue/lib/button/buttonTypes").ButtonHTMLType;
             }> & Omit<Readonly<import("vue").ExtractPropTypes<{
                 prefixCls: StringConstructor;
                 type: import("vue").PropType<ButtonType>;
@@ -146,12 +146,12 @@ declare const _default: import("vue").DefineComponent<{
             }>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, {
                 block: boolean;
                 disabled: boolean;
-                ghost: boolean;
-                danger: boolean;
-                htmlType: import("ant-design-vue/lib/button/buttonTypes").ButtonHTMLType;
                 loading: boolean | {
                     delay?: number | undefined;
                 };
+                ghost: boolean;
+                danger: boolean;
+                htmlType: import("ant-design-vue/lib/button/buttonTypes").ButtonHTMLType;
             }> & {
                 beforeCreate?: (() => void) | (() => void)[] | undefined;
                 created?: (() => void) | (() => void)[] | undefined;
@@ -273,12 +273,12 @@ declare const _default: import("vue").DefineComponent<{
     }>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, {
         block: boolean;
         disabled: boolean;
-        ghost: boolean;
-        danger: boolean;
-        htmlType: import("ant-design-vue/lib/button/buttonTypes").ButtonHTMLType;
         loading: boolean | {
             delay?: number | undefined;
         };
+        ghost: boolean;
+        danger: boolean;
+        htmlType: import("ant-design-vue/lib/button/buttonTypes").ButtonHTMLType;
     }> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("@vue/runtime-core").Plugin & {
         readonly Group: import("vue").DefineComponent<{
             prefixCls: StringConstructor;

package/es/components/float-table/index.d.ts

@@ -0,0 +1,70 @@
+declare const BmFloatTable: import("bm-admin-ui/es/utils/with-install").SFCWithInstall<{
+    name: string;
+    props: {
+        config: {
+            type: ObjectConstructor;
+            required: boolean;
+            default: () => {};
+        };
+        pagerProps: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        events: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        isNeedFloatHandle: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        size: {
+            type: StringConstructor;
+            default: string;
+        };
+    };
+    emits: string[];
+    setup(props: any, { emit }: {
+        emit: any;
+    }): {
+        setItemRef(el: any, column: any, rowid: any): void;
+        leaveFloatTable(): void;
+        scrollTo(config?: {}): void;
+        pageNoChange(val: any): Promise<void>;
+        pageSizeChange(val: any, size: any): Promise<void>;
+        floatMouseLeave(): void;
+        floatOverMouse(): void;
+        goAnimationEndFn(): void;
+        scrollNotShowFloat(): void;
+        classes: import("vue").ComputedRef<(string | {
+            floatHandleTable: any;
+        })[]>;
+        gridOptions: import("vue").ComputedRef<any>;
+        gridEvents: import("vue").ComputedRef<any>;
+        pager: import("vue").ComputedRef<any>;
+        simpleImage: import("vue").Ref<JSX.Element | (string | number | boolean | void | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | null | undefined) | (string | number | boolean | void | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | null | undefined)[]>;
+        floatRefsId: import("vue").Ref<{}>;
+        floatId: import("vue").Ref<string>;
+        isShowFloatHandle: import("vue").Ref<boolean>;
+        atVisible: import("vue").Ref<boolean>;
+        goAnimationEnd: import("vue").Ref<boolean>;
+        floatPosition: import("vue").Ref<{
+            top: string;
+            height: string;
+        }>;
+        trNodes: import("vue").Ref<any>;
+        isInScroll: import("vue").Ref<boolean>;
+        inMaxScorllX: import("vue").Ref<boolean>;
+        floatRow: import("vue").Ref<{}>;
+        floatRowIndex: import("vue").Ref<undefined>;
+        floatHandleDomCol: import("vue").Ref<any>;
+        floatTable: import("vue").Ref<any>;
+        xGrid: import("vue").Ref<any>;
+    };
+}>;
+export { BmFloatTable };
+export default BmFloatTable;

package/es/components/float-table/index.js

@@ -0,0 +1,421 @@
+import { withInstall } from 'bm-admin-ui/es/utils/with-install';
+import { ref, onBeforeUnmount, reactive, computed, watch, toRefs, resolveComponent, openBlock, createElementBlock, normalizeClass, createVNode, mergeProps, toHandlers, createSlots, withCtx, createCommentVNode, createElementVNode, renderList, renderSlot, withDirectives, normalizeStyle, vShow, nextTick } from 'vue';
+import { Empty } from 'ant-design-vue';
+
+var _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+
+const _sfc_main = {
+  name: "BmFloatTable",
+  props: {
+    config: {
+      type: Object,
+      required: true,
+      default: () => {
+        return {};
+      }
+    },
+    pagerProps: {
+      type: Object,
+      default: () => {
+        return {};
+      }
+    },
+    events: {
+      type: Object,
+      default: () => {
+        return {};
+      }
+    },
+    isNeedFloatHandle: {
+      type: Boolean,
+      default: false
+    },
+    size: {
+      type: String,
+      default: "middle"
+    }
+  },
+  emits: [
+    "radioChange",
+    "checkboxChange",
+    "checkboxChangeAll",
+    "pageChange",
+    "pageSizeChange"
+  ],
+  setup(props, { emit }) {
+    const floatTable = ref();
+    const xGrid = ref();
+    onBeforeUnmount(function() {
+      inObserverDom && inObserverDom.disconnect();
+      scrollNotShowFloatTime && clearTimeout(scrollNotShowFloatTime);
+    });
+    const state = reactive({
+      simpleImage: Empty.PRESENTED_IMAGE_SIMPLE,
+      floatRefsId: {},
+      floatId: "",
+      isShowFloatHandle: true,
+      gridOptions: {
+        resizable: false,
+        border: "default",
+        highlightHoverRow: true,
+        showOverflow: false,
+        showHeaderOverflow: true,
+        align: null,
+        columns: [],
+        tooltipConfig: { leaveDelay: 1e6 },
+        data: [],
+        pagerConfig: {},
+        emptyText: "\u6682\u65E0\u6570\u636E",
+        checkboxConfig: {
+          reserve: false,
+          highlight: computed(function() {
+            return props.config.columns.some(function(item) {
+              return item.type === "checkbox" || item.type === "checkbox";
+            });
+          }),
+          trigger: "row"
+        },
+        rowClassName: "tb-row",
+        sortConfig: {
+          trigger: "cell",
+          orders: ["desc", "asc", null]
+        }
+      },
+      gridEvents: {
+        radioChange(val) {
+          emit("radioChange", val);
+        },
+        checkboxChange(val) {
+          emit("checkboxChange", val);
+        },
+        checkboxAll(val) {
+          emit("checkboxChangeAll", val);
+        }
+      },
+      atVisible: false,
+      goAnimationEnd: false,
+      floatPosition: {
+        top: "0",
+        height: "0"
+      },
+      trNodes: [],
+      isInScroll: false,
+      inMaxScorllX: false,
+      floatRow: {},
+      floatRowIndex: void 0,
+      floatHandleDomCol: null
+    });
+    const classes = computed(() => {
+      return [
+        "floatTable",
+        "bm-table",
+        `table-${props.size}`,
+        {
+          floatHandleTable: props.isNeedFloatHandle && (!state.atVisible || state.inMaxScorllX) && state.floatHandleDomCol
+        }
+      ];
+    });
+    const gridOptions = computed(() => {
+      return {
+        ...state.gridOptions,
+        ...props.config
+      };
+    });
+    let mouseenterCellTime;
+    const gridEvents = computed(() => {
+      let extraFn = {};
+      if (props.isNeedFloatHandle) {
+        let propscellMouseenter = props.events.cellMouseenter;
+        extraFn.cellMouseenter = (e) => {
+          if (props.isNeedFloatHandle) {
+            if (state.isInScroll) {
+              state.isShowFloatHandle = false;
+              return;
+            }
+            if (state.inMaxScorllX) {
+              state.isShowFloatHandle = false;
+            }
+            let rowid = e.rowid;
+            let row = e.row;
+            clearTimeout(mouseenterCellTime);
+            mouseenterCellTime = setTimeout(function() {
+              if (state.floatId !== rowid) {
+                state.goAnimationEnd = false;
+              } else {
+                return;
+              }
+              state.floatId = rowid;
+              state.floatRow = row;
+              state.floatRowIndex = e.rowIndex;
+              let domEl = state.floatRefsId[rowid];
+              let tdDom = domEl && domEl.closest("td");
+              if (!tdDom)
+                return;
+              let clientHeight = tdDom.clientHeight - 1 + "px";
+              let trDoms = document.querySelectorAll(`[rowid='${rowid}']`);
+              state.trNodes = trDoms;
+              let top = e.cell.getBoundingClientRect().top;
+              let parentTop = floatTable.value.getBoundingClientRect().top;
+              top = top - parentTop + "px";
+              state.floatPosition = {
+                top,
+                height: clientHeight
+              };
+              if (!state.atVisible && !state.inMaxScorllX) {
+                state.isShowFloatHandle = true;
+              }
+              nextTick(() => {
+                let $floatHandle = document.querySelector(".floatHandle");
+                if ($floatHandle.clientWidth === 32) {
+                  $floatHandle.style.padding = 0;
+                }
+              });
+            }, 200);
+          }
+          propscellMouseenter && propscellMouseenter(e);
+        };
+        extraFn.scroll = (e) => {
+          let propsscroll = props.events.scroll;
+          if (e.isY && props.isNeedFloatHandle) {
+            methods.scrollNotShowFloat();
+          }
+          if (e.isX && props.isNeedFloatHandle && state.floatHandleDomCol && gridOptions.value.data && gridOptions.value.data.length > 0) {
+            if (e.scrollLeft + e.$event.target.clientWidth >= e.$event.target.scrollWidth - state.floatHandleDomCol.clientWidth) {
+              state.inMaxScorllX = true;
+              state.isShowFloatHandle = false;
+            } else {
+              state.inMaxScorllX = false;
+              state.isShowFloatHandle = true;
+            }
+          }
+          propsscroll && propsscroll(e);
+        };
+        extraFn.cellMouseleave = (e) => {
+          let propsCellMouseLeave = props.events.cellMouseleave;
+          methods.floatMouseLeave();
+          propsCellMouseLeave && propsCellMouseLeave(e);
+        };
+      }
+      return {
+        ...state.gridEvents,
+        ...props.events,
+        ...extraFn
+      };
+    });
+    const pager = computed(() => {
+      let pager2 = {
+        size: "small",
+        showTotal: (total) => `\u5171 ${total} \u6761`,
+        showQuickJumper: true,
+        showSizeChanger: true,
+        current: 1,
+        pageSize: 10,
+        total: 0,
+        hideOnSinglePage: false,
+        pageSizeOptions: ["10", "30", "50", "100"]
+      };
+      return {
+        ...pager2,
+        ...props.pagerProps
+      };
+    });
+    let scrollNotShowFloatTime;
+    const methods = {
+      setItemRef(el, column, rowid) {
+        if (!props.isNeedFloatHandle)
+          return;
+        state.floatRefsId[rowid] = el;
+        if (state.floatHandleDomCol)
+          return;
+        let id = column.id;
+        state.floatHandleDomCol = floatTable.value.querySelector(`.vxe-table--header-wrapper .vxe-header--row .${id}`);
+      },
+      leaveFloatTable() {
+        let timer = setTimeout(() => {
+          state.isShowFloatHandle = false;
+          state.floatId = "";
+          clearTimeout(timer);
+        }, 210);
+      },
+      scrollTo(config = {}) {
+        config = {
+          top: 0,
+          ...config
+        };
+        floatTable.value?.querySelectorAll(".vxe-table--body-wrapper")?.forEach((table) => table?.scrollTo?.(config));
+      },
+      async pageNoChange(val) {
+        await emit("pageChange", val);
+        methods.scrollTo();
+      },
+      async pageSizeChange(val, size) {
+        await emit("pageSizeChange", size);
+        methods.scrollTo();
+      },
+      floatMouseLeave() {
+        if (!state.trNodes || state.trNodes?.length === 0)
+          return;
+        state.trNodes.forEach((item) => {
+          if (item && item.className.includes("floatHoverTr")) {
+            item.className = `${item.className.replace(/floatHoverTr/g, "")}`;
+          }
+        });
+      },
+      floatOverMouse() {
+        if (!state.trNodes || state.trNodes?.length === 0)
+          return;
+        state.trNodes.forEach((item) => {
+          if (item && !item.className.includes("floatHoverTr")) {
+            item.className = `${item.className} floatHoverTr`;
+          }
+        });
+      },
+      goAnimationEndFn() {
+        state.goAnimationEnd = true;
+      },
+      scrollNotShowFloat() {
+        state.isInScroll = true;
+        state.isShowFloatHandle = false;
+        clearTimeout(scrollNotShowFloatTime);
+        if (!state.atVisible) {
+          scrollNotShowFloatTime = setTimeout(function() {
+            state.isInScroll = false;
+          }, 300);
+        }
+      }
+    };
+    let inObserverDom;
+    let isHasOver;
+    let closeSetRow;
+    let headerWrapper;
+    if (props.isNeedFloatHandle) {
+      inObserverDom = new IntersectionObserver((entries) => {
+        entries.forEach((item) => {
+          if (item.intersectionRatio > 0.1) {
+            closeSetRow = closeSetRow || item.target.closest(".vxe-header--row");
+            headerWrapper = headerWrapper || item.target.closest(".vxe-table--header-wrapper");
+            if (closeSetRow.clientWidth <= headerWrapper.clientWidth && !isHasOver) {
+              inObserverDom.disconnect();
+            } else {
+              isHasOver = true;
+            }
+            state.isShowFloatHandle = false;
+            state.atVisible = true;
+          } else {
+            if (gridOptions.value.data && gridOptions.value.data.length > 0) {
+              state.goAnimationEnd = false;
+              state.isShowFloatHandle = true;
+              state.atVisible = false;
+            }
+          }
+        });
+      }, {
+        threshold: 0.1
+      });
+      watch(() => state.floatHandleDomCol, function(col) {
+        if (col) {
+          inObserverDom.observe(col);
+        }
+      }, {
+        immediate: true
+      });
+    }
+    return {
+      floatTable,
+      xGrid,
+      ...toRefs(state),
+      classes,
+      gridOptions,
+      gridEvents,
+      pager,
+      ...methods
+    };
+  }
+};
+const _hoisted_1 = {
+  key: 0,
+  class: "floatPager"
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_a_pagination = resolveComponent("a-pagination");
+  const _component_a_empty = resolveComponent("a-empty");
+  const _component_vxe_grid = resolveComponent("vxe-grid");
+  return openBlock(), createElementBlock("div", {
+    ref: "floatTable",
+    class: normalizeClass($setup.classes),
+    onMouseleave: _cache[3] || (_cache[3] = (...args) => _ctx.leaveFloatTable && _ctx.leaveFloatTable(...args))
+  }, [
+    createVNode(_component_vxe_grid, mergeProps({ ref: "xGrid" }, $setup.gridOptions, toHandlers($setup.gridEvents)), createSlots({
+      pager: withCtx(() => [
+        $setup.pager.total && !$setup.pager.hideOnSinglePage ? (openBlock(), createElementBlock("div", _hoisted_1, [
+          createVNode(_component_a_pagination, mergeProps($setup.pager, {
+            onChange: _ctx.pageNoChange,
+            onShowSizeChange: _ctx.pageSizeChange
+          }), null, 16, ["onChange", "onShowSizeChange"])
+        ])) : createCommentVNode("v-if", true)
+      ]),
+      empty: withCtx(() => [
+        createElementVNode("div", null, [
+          createVNode(_component_a_empty, { image: _ctx.simpleImage }, null, 8, ["image"])
+        ])
+      ]),
+      _: 2
+    }, [
+      renderList(_ctx.$slots, (slot, key) => {
+        return {
+          name: key,
+          fn: withCtx((data) => [
+            key !== "floatHandle" ? renderSlot(_ctx.$slots, key, {
+              key: 0,
+              rowIndex: data.rowIndex,
+              row: data.row,
+              column: data.column
+            }) : (openBlock(), createElementBlock("div", {
+              key: 1,
+              ref: (el) => _ctx.setItemRef(el, data.column, data.rowid)
+            }, [
+              renderSlot(_ctx.$slots, "floatHandle", {
+                row: data.row,
+                rowIndex: data.rowIndex,
+                column: data.column
+              })
+            ], 512))
+          ])
+        };
+      })
+    ]), 1040),
+    withDirectives(createElementVNode("div", {
+      ref: "floatHandle",
+      class: normalizeClass(["floatHandle", {
+        floatRightIn: _ctx.isShowFloatHandle && !_ctx.goAnimationEnd
+      }]),
+      style: normalizeStyle({
+        top: _ctx.floatPosition?.top,
+        height: _ctx.floatPosition?.height
+      }),
+      onAnimationend: _cache[0] || (_cache[0] = (...args) => _ctx.goAnimationEndFn && _ctx.goAnimationEndFn(...args)),
+      onMouseenter: _cache[1] || (_cache[1] = (...args) => _ctx.floatOverMouse && _ctx.floatOverMouse(...args)),
+      onMouseleave: _cache[2] || (_cache[2] = (...args) => _ctx.floatMouseLeave && _ctx.floatMouseLeave(...args))
+    }, [
+      createElementVNode("div", null, [
+        renderSlot(_ctx.$slots, "floatHandle", {
+          row: _ctx.floatRow,
+          rowIndex: _ctx.floatRowIndex
+        })
+      ])
+    ], 38), [
+      [vShow, _ctx.floatPosition?.top && $props.isNeedFloatHandle && _ctx.isShowFloatHandle]
+    ])
+  ], 34);
+}
+var FloatTable = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "float-table.vue"]]);
+
+const BmFloatTable = withInstall(FloatTable);
+
+export { BmFloatTable, BmFloatTable as default };

package/es/components/float-table/src/float-table.vue.d.ts

@@ -0,0 +1,69 @@
+declare const _default: {
+    name: string;
+    props: {
+        config: {
+            type: ObjectConstructor;
+            required: boolean;
+            default: () => {};
+        };
+        pagerProps: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        events: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        isNeedFloatHandle: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        size: {
+            type: StringConstructor;
+            default: string;
+        };
+    };
+    emits: string[];
+    setup(props: any, { emit }: {
+        emit: any;
+    }): {
+        setItemRef(el: any, column: any, rowid: any): void;
+        leaveFloatTable(): void;
+        scrollTo(config?: {}): void;
+        pageNoChange(val: any): Promise<void>;
+        pageSizeChange(val: any, size: any): Promise<void>;
+        floatMouseLeave(): void;
+        floatOverMouse(): void;
+        goAnimationEndFn(): void;
+        scrollNotShowFloat(): void;
+        classes: import("vue").ComputedRef<(string | {
+            floatHandleTable: any;
+        })[]>;
+        gridOptions: import("vue").ComputedRef<any>;
+        gridEvents: import("vue").ComputedRef<any>;
+        pager: import("vue").ComputedRef<any>;
+        simpleImage: import("vue").Ref<JSX.Element | (string | number | boolean | void | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | null | undefined) | (string | number | boolean | void | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | null | undefined)[]>;
+        floatRefsId: import("vue").Ref<{}>;
+        floatId: import("vue").Ref<string>;
+        isShowFloatHandle: import("vue").Ref<boolean>;
+        atVisible: import("vue").Ref<boolean>;
+        goAnimationEnd: import("vue").Ref<boolean>;
+        floatPosition: import("vue").Ref<{
+            top: string;
+            height: string;
+        }>;
+        trNodes: import("vue").Ref<any>;
+        isInScroll: import("vue").Ref<boolean>;
+        inMaxScorllX: import("vue").Ref<boolean>;
+        floatRow: import("vue").Ref<{}>;
+        floatRowIndex: import("vue").Ref<undefined>;
+        floatHandleDomCol: import("vue").Ref<any>;
+        floatTable: import("vue").Ref<any>;
+        xGrid: import("vue").Ref<any>;
+    };
+};
+export default _default;

package/es/components/flow-designer/index.js

@@ -37,7 +37,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     };
   }
 });
-var FlowDesigner = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "/Users/hesiying/work/bm-admin-ui/packages/components/flow-designer/src/flow-designer.vue"]]);
+var FlowDesigner = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "flow-designer.vue"]]);
 
 const BmFlowDesigner = withInstall(FlowDesigner);
 

package/es/components/form-designer/index.js

@@ -28,7 +28,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     };
   }
 });
-var FormDesigner = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "/Users/hesiying/work/bm-admin-ui/packages/components/form-designer/src/form-designer.vue"]]);
+var FormDesigner = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "form-designer.vue"]]);
 
 const BmFormDesigner = withInstall(FormDesigner);