bm-admin-ui 1.0.35-alpha → 1.0.37-alpha

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

@@ -0,0 +1,3 @@
+declare const BmFloatTable: any;
+export { BmFloatTable };
+export default BmFloatTable;

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

@@ -234,9 +234,7 @@ const _sfc_main = {
         if (state.floatHandleDomCol)
           return;
         let id = column.id;
-        state.floatHandleDomCol = floatTable.value.querySelector(
-          `.vxe-table--header-wrapper .vxe-header--row .${id}`
-        );
+        state.floatHandleDomCol = floatTable.value.querySelector(`.vxe-table--header-wrapper .vxe-header--row .${id}`);
       },
       leaveFloatTable() {
         let timer = setTimeout(() => {
@@ -297,43 +295,36 @@ const _sfc_main = {
     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;
+      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 {
-              if (gridOptions.value.data && gridOptions.value.data.length > 0) {
-                state.goAnimationEnd = false;
-                state.isShowFloatHandle = true;
-                state.atVisible = false;
-              }
+              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
+        });
+      }, {
+        threshold: 0.1
+      });
+      watch(() => state.floatHandleDomCol, function(col) {
+        if (col) {
+          inObserverDom.observe(col);
         }
-      );
+      }, {
+        immediate: true
+      });
     }
     return {
       floatTable,

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<(string | number | boolean | void | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | null | undefined) | JSX.Element | (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.d.ts

@@ -0,0 +1,3 @@
+declare const BmFlowDesigner: any;
+export { BmFlowDesigner };
+export default BmFlowDesigner;

package/es/components/flow-designer/src/bm-nodes/AddCondition.d.ts

@@ -0,0 +1,26 @@
+import { RectNode, RectNodeModel } from '@logicflow/core';
+import { NodeTextTheme } from '@logicflow/core/types/constant/DefaultTheme';
+declare class AddCondition extends RectNode {
+}
+declare class AddConditionModel extends RectNodeModel {
+    __branchs: never[];
+    __branchLengths: Map<any, any>;
+    __outNode: null;
+    initNodeData(data: any): void;
+    getNodeStyle(): {
+        [x: string]: any;
+        width?: number;
+        height?: number;
+        radius?: number;
+        fill?: string;
+        stroke?: string;
+        strokeWidth?: number;
+    };
+    getTextStyle(): NodeTextTheme;
+}
+declare const _default: {
+    type: string;
+    view: typeof AddCondition;
+    model: typeof AddConditionModel;
+};
+export default _default;

package/es/components/flow-designer/src/bm-nodes/AddFlowNode.d.ts

@@ -0,0 +1,29 @@
+import { RectNode, RectNodeModel } from '@logicflow/core';
+import { NodeTextTheme } from '@logicflow/core/types/constant/DefaultTheme';
+declare class AddFlowNodeModel extends RectNodeModel {
+    __flowChildren: any;
+    __ACChildren: any;
+    updateChild(node: any): void;
+    private FLOWTYPE;
+    private addConditionItem;
+    setAttributes(): void;
+    initNodeData(data: any): void;
+    getTextStyle(): NodeTextTheme;
+    getNodeStyle(): {
+        [x: string]: any;
+        width?: number | undefined;
+        height?: number | undefined;
+        radius?: number | undefined;
+        fill?: string | undefined;
+        stroke?: string | undefined;
+        strokeWidth?: number | undefined;
+    };
+}
+declare class AddFlowNode extends RectNode {
+}
+declare const _default: {
+    type: string;
+    view: typeof AddFlowNode;
+    model: typeof AddFlowNodeModel;
+};
+export default _default;

package/es/components/flow-designer/src/bm-nodes/BmConditionNode.vue.d.ts

@@ -0,0 +1,247 @@
+declare const _default: import("vue").DefineComponent<{
+    isCustom: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    priority: {
+        type: NumberConstructor;
+        default: number;
+    };
+    desc: {
+        type: StringConstructor;
+        default: string;
+    };
+    copyCallback: {
+        type: FunctionConstructor;
+        default: () => void;
+    };
+    deleteCallback: {
+        type: FunctionConstructor;
+        default: () => void;
+    };
+}, {
+    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+        isCustom: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        title: {
+            type: StringConstructor;
+            default: string;
+        };
+        priority: {
+            type: NumberConstructor;
+            default: number;
+        };
+        desc: {
+            type: StringConstructor;
+            default: string;
+        };
+        copyCallback: {
+            type: FunctionConstructor;
+            default: () => void;
+        };
+        deleteCallback: {
+            type: FunctionConstructor;
+            default: () => void;
+        };
+    }>> & {}>>;
+    CopyOutlined: import("@ant-design/icons-vue/lib/icons/CopyOutlined").CopyOutlinedIconType;
+    CloseOutlined: import("@ant-design/icons-vue/lib/icons/CloseOutlined").CloseOutlinedIconType;
+    RightOutlined: import("@ant-design/icons-vue/lib/icons/RightOutlined").RightOutlinedIconType;
+    Tag: {
+        new (...args: any[]): {
+            $: import("vue").ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                visible: boolean;
+                closable: boolean;
+            }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+                prefixCls: StringConstructor;
+                color: {
+                    type: import("vue").PropType<import("ant-design-vue/lib/_util/type").LiteralUnion<"default" | "success" | "error" | "warning" | "blue" | "cyan" | "gold" | "green" | "lime" | "magenta" | "orange" | "pink" | "purple" | "red" | "yellow" | "processing" | "geekblue" | "volcano", string>>;
+                };
+                closable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                closeIcon: import("vue-types").VueTypeValidableDef<any>;
+                visible: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                onClose: {
+                    type: import("vue").PropType<(e: MouseEvent) => void>;
+                };
+                'onUpdate:visible': import("vue").PropType<(vis: boolean) => void>;
+                icon: import("vue-types").VueTypeValidableDef<any>;
+            }>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "visible" | "closable">;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import("vue").Slot;
+            }>;
+            $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
+            $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: any;
+            $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+                prefixCls: StringConstructor;
+                color: {
+                    type: import("vue").PropType<import("ant-design-vue/lib/_util/type").LiteralUnion<"default" | "success" | "error" | "warning" | "blue" | "cyan" | "gold" | "green" | "lime" | "magenta" | "orange" | "pink" | "purple" | "red" | "yellow" | "processing" | "geekblue" | "volcano", string>>;
+                };
+                closable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                closeIcon: import("vue-types").VueTypeValidableDef<any>;
+                visible: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                onClose: {
+                    type: import("vue").PropType<(e: MouseEvent) => void>;
+                };
+                'onUpdate:visible': import("vue").PropType<(vis: boolean) => void>;
+                icon: import("vue-types").VueTypeValidableDef<any>;
+            }>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+                visible: boolean;
+                closable: boolean;
+            }> & {
+                beforeCreate?: (() => void) | (() => void)[] | undefined;
+                created?: (() => void) | (() => void)[] | undefined;
+                beforeMount?: (() => void) | (() => void)[] | undefined;
+                mounted?: (() => void) | (() => void)[] | undefined;
+                beforeUpdate?: (() => void) | (() => void)[] | undefined;
+                updated?: (() => void) | (() => void)[] | undefined;
+                activated?: (() => void) | (() => void)[] | undefined;
+                deactivated?: (() => void) | (() => void)[] | undefined;
+                beforeDestroy?: (() => void) | (() => void)[] | undefined;
+                beforeUnmount?: (() => void) | (() => void)[] | undefined;
+                destroyed?: (() => void) | (() => void)[] | undefined;
+                unmounted?: (() => void) | (() => void)[] | undefined;
+                renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[] | undefined;
+                renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[] | undefined;
+                errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void)[] | undefined;
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import("vue").nextTick;
+            $watch(source: string | Function, cb: Function, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
+        } & Readonly<import("vue").ExtractPropTypes<{
+            prefixCls: StringConstructor;
+            color: {
+                type: import("vue").PropType<import("ant-design-vue/lib/_util/type").LiteralUnion<"default" | "success" | "error" | "warning" | "blue" | "cyan" | "gold" | "green" | "lime" | "magenta" | "orange" | "pink" | "purple" | "red" | "yellow" | "processing" | "geekblue" | "volcano", string>>;
+            };
+            closable: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            closeIcon: import("vue-types").VueTypeValidableDef<any>;
+            visible: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            onClose: {
+                type: import("vue").PropType<(e: MouseEvent) => void>;
+            };
+            'onUpdate:visible': import("vue").PropType<(vis: boolean) => void>;
+            icon: import("vue-types").VueTypeValidableDef<any>;
+        }>> & import("vue").ShallowUnwrapRef<() => JSX.Element> & import("vue").ComponentCustomProperties;
+        __isFragment?: undefined;
+        __isTeleport?: undefined;
+        __isSuspense?: undefined;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+        prefixCls: StringConstructor;
+        color: {
+            type: import("vue").PropType<import("ant-design-vue/lib/_util/type").LiteralUnion<"default" | "success" | "error" | "warning" | "blue" | "cyan" | "gold" | "green" | "lime" | "magenta" | "orange" | "pink" | "purple" | "red" | "yellow" | "processing" | "geekblue" | "volcano", string>>;
+        };
+        closable: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        closeIcon: import("vue-types").VueTypeValidableDef<any>;
+        visible: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        onClose: {
+            type: import("vue").PropType<(e: MouseEvent) => void>;
+        };
+        'onUpdate:visible': import("vue").PropType<(vis: boolean) => void>;
+        icon: import("vue-types").VueTypeValidableDef<any>;
+    }>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+        visible: boolean;
+        closable: boolean;
+    }> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("@vue/runtime-core").Plugin & {
+        readonly CheckableTag: import("vue").DefineComponent<{
+            prefixCls: StringConstructor;
+            checked: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            onChange: {
+                type: import("vue").PropType<(checked: boolean) => void>;
+            };
+            onClick: {
+                type: import("vue").PropType<(e: MouseEvent) => void>;
+            };
+            'onUpdate:checked': import("vue").PropType<(checked: boolean) => void>;
+        }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+            prefixCls: StringConstructor;
+            checked: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            onChange: {
+                type: import("vue").PropType<(checked: boolean) => void>;
+            };
+            onClick: {
+                type: import("vue").PropType<(e: MouseEvent) => void>;
+            };
+            'onUpdate:checked': import("vue").PropType<(checked: boolean) => void>;
+        }>>, {
+            checked: boolean;
+        }>;
+    };
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    isCustom: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    priority: {
+        type: NumberConstructor;
+        default: number;
+    };
+    desc: {
+        type: StringConstructor;
+        default: string;
+    };
+    copyCallback: {
+        type: FunctionConstructor;
+        default: () => void;
+    };
+    deleteCallback: {
+        type: FunctionConstructor;
+        default: () => void;
+    };
+}>>, {
+    title: string;
+    desc: string;
+    isCustom: boolean;
+    priority: number;
+    copyCallback: Function;
+    deleteCallback: Function;
+}>;
+export default _default;

package/es/components/flow-designer/src/bm-nodes/BmFlowHtmlNode.d.ts

@@ -0,0 +1,19 @@
+import { HtmlNodeModel, HtmlNode } from '@logicflow/core';
+declare class FlowItemModel extends HtmlNodeModel {
+    setAttributes(): void;
+    getDefaultAnchor(): {
+        x: number;
+        y: number;
+        id: string;
+    }[];
+}
+declare class FlowItemNode extends HtmlNode {
+    private vueNode;
+    setHtml(rootEl: HTMLElement): void;
+}
+declare const bmFlowItem: {
+    type: string;
+    view: typeof FlowItemNode;
+    model: typeof FlowItemModel;
+};
+export default bmFlowItem;

package/es/components/flow-designer/src/bm-nodes/BmHtmlNode.vue.d.ts

@@ -0,0 +1,15 @@
+declare const _default: import("vue").DefineComponent<Readonly<import("vue").ComponentPropsOptions<{
+    [x: string]: unknown;
+}>>, {
+    toEditLabel(): void;
+    updateLabel(e: any): void;
+    isEditLabel: import("vue").Ref<boolean>;
+    tempLabel: any;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:label"[], "update:label", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<readonly string[] | import("vue").ExtractPropTypes<Readonly<import("vue").ComponentObjectPropsOptions<{
+    [x: string]: unknown;
+}>>>> & {
+    "onUpdate:label"?: ((...args: any[]) => any) | undefined;
+}, {
+    [x: number]: string;
+} | {}>;
+export default _default;

package/es/components/flow-designer/src/bm-nodes/BmPolyLine.d.ts

@@ -0,0 +1,21 @@
+import { PolylineEdge, PolylineEdgeModel } from '@logicflow/core';
+declare class BmPolyLineModel extends PolylineEdgeModel {
+    private FLOWTYPE;
+    private addConditionItem;
+    initEdgeData(data: any): void;
+    getEdgeStyle(): {
+        [x: string]: any;
+        fill?: string;
+        stroke?: string;
+        strokeWidth?: number;
+    };
+    setAttributes(): void;
+}
+declare class BmPolyLine extends PolylineEdge {
+}
+declare const _default: {
+    type: string;
+    view: typeof BmPolyLine;
+    model: typeof BmPolyLineModel;
+};
+export default _default;

package/es/components/flow-designer/src/bm-nodes/EndCircle.d.ts

@@ -0,0 +1,19 @@
+import { HtmlNodeModel, HtmlNode } from '@logicflow/core';
+declare class EndCircleModel extends HtmlNodeModel {
+    initNodeData(data: any): void;
+    setAttributes(): void;
+    getDefaultAnchor(): {
+        x: number;
+        y: number;
+        id: string;
+    }[];
+}
+declare class EndCircleView extends HtmlNode {
+    setHtml(roolEl: any): void;
+}
+declare const _default: {
+    type: string;
+    view: typeof EndCircleView;
+    model: typeof EndCircleModel;
+};
+export default _default;

package/es/components/flow-designer/src/config.d.ts

@@ -0,0 +1,24 @@
+export declare const BM_NODE_CONFIG: {
+    WIDTH: number;
+    HEIGHT: number;
+    DEFAULTBG: string;
+    DEFAULTCOLOR: string;
+    LINELENGTH: number;
+    ADDNODEOFFSET: number;
+    ENDRADIUS: number;
+    HALFNODEHEIGHT: number;
+    NEXTOFFSET_Y: number;
+    OFFSETDISTANCE: number;
+    PLUSRADIUS: number;
+    ACWIDTH: number;
+    ACHEIGHT: number;
+    CONDIWIDTH: number;
+    CONDIHEIGHT: number;
+    CONDIOFFSET: number;
+    PLUSOFFSET: number;
+    CONDITIONNAME: string;
+    PLUSCONDINAME: string;
+    ACOFFSETDISTANCE: number;
+    CONDITIONPADDING: number;
+    DELETEDEFAULTOFFSET: number;
+};

package/es/components/flow-designer/src/flow-designer-test.d.ts

@@ -0,0 +1,20 @@
+import '@logicflow/core/dist/style/index.css';
+import '@logicflow/extension/lib/style/index.css';
+declare const _default: import("vue").DefineComponent<{
+    lineLength: {
+        type: NumberConstructor;
+        default: number;
+    };
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "nodeCallback"[], "nodeCallback", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    lineLength: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & {
+    onNodeCallback?: ((...args: any[]) => any) | undefined;
+}, {
+    lineLength: number;
+}>;
+export default _default;

package/es/components/flow-designer/src/flow-designer.d.ts

@@ -0,0 +1,11 @@
+export interface createFlowParams {
+    container: HTMLElement | any;
+    width?: number;
+    height?: number;
+}
+export declare class BmLogicFlow {
+    private lf;
+    private eventCenter;
+    constructor(params: createFlowParams);
+    private create;
+}

package/es/components/flow-designer/src/flow-designer.vue.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("vue").DefineComponent<{}, {
+    container: import("vue").Ref<any>;
+    lf: any;
+    init: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+export default _default;

package/es/components/flow-designer/src/utils.d.ts

@@ -0,0 +1,29 @@
+import LogicFlow, { BaseNodeModel, GraphModel } from '@logicflow/core';
+import type { TextConfig } from '@logicflow/core';
+export declare const idGeneratorFunc: () => string;
+export declare function initBasicFlow({ container, ...config }: {
+    [x: string]: any;
+    container: any;
+}): LogicFlow;
+export declare function checkFlowEdge(): void;
+export declare type EdgeParams = {
+    sourceNodeId: string;
+    targetNodeId: string;
+    type: 'bmpolyline' | string;
+    text?: TextConfig | string;
+    pointList?: any[];
+    properties?: any;
+};
+export declare function createFlowEdge(graph: GraphModel, params: EdgeParams): import("@logicflow/core/types/model/edge/BaseEdgeModel").BaseEdgeModel;
+export declare function getFlowRawData(lf: LogicFlow): {
+    json: import("@logicflow/core").GraphConfigData;
+    xml: string;
+};
+export declare function loadFlowData(lf: LogicFlow, json: any): void;
+export declare function findNodeIdsBFC(id: string, getNodesFunc: (_: any) => [], exclude?: string[], end?: string): string[];
+export declare function compuPlusPosition(sourceNode: BaseNodeModel, targetNode: BaseNodeModel): {
+    value: string;
+    x: number;
+    y: number;
+};
+export declare function updateEdgeTextPosition(): void;