@logicflow/extension 1.2.9 → 1.2.11

package/es/bpmn-elements/presets/Gateway/gateway.js

@@ -0,0 +1,105 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+/* eslint-disable @typescript-eslint/naming-convention */
+import { PolygonNode, PolygonNodeModel, h, } from '@logicflow/core';
+import { genBpmnId, groupRule } from '../../utils';
+var gateway = {
+    exclusive: 0,
+    inclusive: 1,
+    parallel: 2,
+};
+/**
+ * index 0 排他网关
+ * index 1 包容网关
+ * index 2 并行网关
+ */
+export var gatewayComposable = [
+    [1, 1, 0],
+    [0, 0, 1],
+    [0, 1, 1],
+];
+/**
+ * @param type 网关节点的type, 对应其XML定义中的节点名，如<bpmn:inclusiveGateway /> 其type为bpmn:inclusiveGateway
+ * @param icon 网关节点左上角的图标，可以是svg path，也可以是h函数生成的svg
+ * @param props (可选) 网关节点的属性
+ * @returns { type: string, model: any, view: any }
+ */
+export function GatewayNodeFactory(type, icon, props) {
+    var view = /** @class */ (function (_super) {
+        __extends(view, _super);
+        function view() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        view.prototype.getShape = function () {
+            // @ts-ignore
+            var model = this.props.model;
+            var x = model.x, y = model.y, width = model.width, height = model.height, points = model.points;
+            var style = model.getNodeStyle();
+            return h('g', {
+                transform: "matrix(1 0 0 1 " + (x - width / 2) + " " + (y - height / 2) + ")",
+            }, h('polygon', __assign(__assign({}, style), { x: x,
+                y: y,
+                points: points })), typeof icon === 'string'
+                ? h('path', __assign(__assign({ d: icon }, style), { fill: 'rgb(34, 36, 42)', strokeWidth: 1 }))
+                : icon);
+        };
+        return view;
+    }(PolygonNode));
+    var model = /** @class */ (function (_super) {
+        __extends(model, _super);
+        function model(data, graphModel) {
+            var _this = this;
+            if (!data.id) {
+                data.id = "Gateway_" + genBpmnId();
+            }
+            if (!data.text) {
+                data.text = '';
+            }
+            if (data.text && typeof data.text === 'string') {
+                data.text = {
+                    value: data.text,
+                    x: data.x,
+                    y: data.y + 40,
+                };
+            }
+            data.properties = __assign(__assign({}, (props || {})), data.properties);
+            _this = _super.call(this, data, graphModel) || this;
+            _this.points = [
+                [25, 0],
+                [50, 25],
+                [25, 50],
+                [0, 25],
+            ];
+            groupRule.call(_this);
+            return _this;
+        }
+        return model;
+    }(PolygonNodeModel));
+    return {
+        type: type,
+        view: view,
+        model: model,
+    };
+}

package/es/bpmn-elements/presets/Gateway/index.d.ts

@@ -0,0 +1,2 @@
+import LogicFlow from '@logicflow/core';
+export declare function registerGatewayNodes(lf: LogicFlow): void;

package/es/bpmn-elements/presets/Gateway/index.js

@@ -0,0 +1,10 @@
+import { exclusiveIcon, parallelIcon, inclusiveIcon } from '../icons';
+import { GatewayNodeFactory } from './gateway';
+export function registerGatewayNodes(lf) {
+    var ExclusiveGateway = GatewayNodeFactory('bpmn:exclusiveGateway', exclusiveIcon);
+    var ParallelGateway = GatewayNodeFactory('bpmn:parallelGateway', parallelIcon);
+    var InclusiveGateway = GatewayNodeFactory('bpmn:inclusiveGateway', inclusiveIcon);
+    lf.register(ExclusiveGateway);
+    lf.register(InclusiveGateway);
+    lf.register(ParallelGateway);
+}

package/es/bpmn-elements/presets/Task/index.d.ts

@@ -0,0 +1,2 @@
+import LogicFlow from '@logicflow/core';
+export declare function registerTaskNodes(lf: LogicFlow): void;

package/es/bpmn-elements/presets/Task/index.js

@@ -0,0 +1,130 @@
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+import { serviceTaskIcon, userTaskIcon } from '../icons';
+import { TaskNodeFactory } from './task';
+import { SubProcessFactory } from './subProcess';
+function boundaryEvent(lf) {
+    lf.on('node:drag,node:dnd-drag', checkAppendBoundaryEvent);
+    lf.on('node:drop,node:dnd-add', appendBoundaryEvent);
+    lf.graphModel.addNodeMoveRules(function (model, deltaX, deltaY) {
+        if (model.isTaskNode) {
+            // 如果移动的是分组，那么分组的子节点也跟着移动。
+            var nodeIds = model.boundaryEvents;
+            lf.graphModel.moveNodes(nodeIds, deltaX, deltaY, true);
+            return true;
+        }
+        return true;
+    });
+    function appendBoundaryEvent(_a) {
+        var e_1, _b;
+        var data = _a.data;
+        var type = data.type, id = data.id;
+        if (type !== 'bpmn:boundaryEvent') {
+            return;
+        }
+        var nodes = lf.graphModel.nodes;
+        try {
+            for (var nodes_1 = __values(nodes), nodes_1_1 = nodes_1.next(); !nodes_1_1.done; nodes_1_1 = nodes_1.next()) {
+                var node = nodes_1_1.value;
+                if (node.isTaskNode) {
+                    var nodeId = null;
+                    if ((nodeId = isBoundaryEventCloseToTask(node, data)) !== null) {
+                        var eventModel = lf.graphModel.getNodeModelById(id);
+                        var nodeModel = lf.graphModel.getNodeModelById(nodeId);
+                        var attachedToRef = eventModel.properties.attachedToRef;
+                        if (attachedToRef && attachedToRef !== nodeId) {
+                            lf.graphModel.getNodeModelById(attachedToRef).deleteBoundaryEvent(id);
+                        }
+                        nodeModel.addBoundaryEvent(id);
+                        return;
+                    }
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (nodes_1_1 && !nodes_1_1.done && (_b = nodes_1.return)) _b.call(nodes_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    }
+    // 判断此节点是否在某个节点的边界上
+    // 如果在，且这个节点model存在属性isTaskNode，则调用这个方法
+    function checkAppendBoundaryEvent(_a) {
+        var e_2, _b;
+        var data = _a.data;
+        var type = data.type;
+        if (type !== 'bpmn:boundaryEvent') {
+            return;
+        }
+        var nodes = lf.graphModel.nodes;
+        try {
+            for (var nodes_2 = __values(nodes), nodes_2_1 = nodes_2.next(); !nodes_2_1.done; nodes_2_1 = nodes_2.next()) {
+                var node = nodes_2_1.value;
+                if (node.isTaskNode) {
+                    if (isBoundaryEventCloseToTask(node, data)) {
+                        // 同时只允许在一个节点的边界上
+                        node.setTouching(true);
+                    }
+                    else {
+                        node.setTouching(false);
+                    }
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (nodes_2_1 && !nodes_2_1.done && (_b = nodes_2.return)) _b.call(nodes_2);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    }
+    function isBoundaryEventCloseToTask(task, event) {
+        var offset = 5;
+        var tx = task.x, ty = task.y, twidth = task.width, theight = task.height, id = task.id;
+        var bbox = {
+            minX: tx - twidth / 2,
+            maxX: tx + twidth / 2,
+            minY: ty - theight / 2,
+            maxY: ty + theight / 2,
+        };
+        var bx = event.x, by = event.y;
+        var outerBBox = {
+            minX: bbox.minX - offset,
+            maxX: bbox.maxX + offset,
+            minY: bbox.minY - offset,
+            maxY: bbox.maxY + offset,
+        };
+        var innerBBox = {
+            minX: bbox.minX + offset,
+            maxX: bbox.maxX - offset,
+            minY: bbox.minY + offset,
+            maxY: bbox.maxX - offset,
+        };
+        if (bx > outerBBox.minX && bx < outerBBox.maxX && by > outerBBox.minY && by < outerBBox.maxY) {
+            if (!(bx > innerBBox.minX && bx < innerBBox.maxX && by > innerBBox.minY && by < innerBBox.maxY)) {
+                return id;
+            }
+        }
+        return null;
+    }
+}
+export function registerTaskNodes(lf) {
+    var ServiceTask = TaskNodeFactory('bpmn:serviceTask', serviceTaskIcon);
+    var UserTask = TaskNodeFactory('bpmn:userTask', userTaskIcon);
+    lf.register(ServiceTask);
+    lf.register(UserTask);
+    lf.register(SubProcessFactory());
+    boundaryEvent(lf);
+}

package/es/bpmn-elements/presets/Task/subProcess.d.ts

@@ -0,0 +1,5 @@
+export declare function SubProcessFactory(): {
+    type: string;
+    model: any;
+    view: any;
+};

package/es/bpmn-elements/presets/Task/subProcess.js

@@ -0,0 +1,186 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+/* eslint-disable no-shadow */
+/* eslint-disable @typescript-eslint/naming-convention */
+import { h } from '@logicflow/core';
+import { GroupNode } from '../../../materials/group/index';
+export function SubProcessFactory() {
+    var view = /** @class */ (function (_super) {
+        __extends(view, _super);
+        function view() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        view.prototype.getFoldIcon = function () {
+            var model = this.props.model;
+            var x = model.x, y = model.y, width = model.width, height = model.height, properties = model.properties, foldable = model.foldable;
+            var foldX = model.x - model.width / 2 + 5;
+            var foldY = model.y - model.height / 2 + 5;
+            if (!foldable)
+                return null;
+            var iconIcon = h('path', {
+                fill: 'none',
+                stroke: '#818281',
+                strokeWidth: 2,
+                'pointer-events': 'none',
+                d: properties.isFolded
+                    ? "M " + (foldX + 3) + "," + (foldY + 6) + " " + (foldX + 11) + "," + (foldY + 6) + " M" + (foldX + 7) + "," + (foldY + 2) + " " + (foldX + 7) + "," + (foldY + 10)
+                    : "M " + (foldX + 3) + "," + (foldY + 6) + " " + (foldX + 11) + "," + (foldY + 6) + " ",
+            });
+            return h('g', {}, [
+                h('rect', {
+                    height: 12,
+                    width: 14,
+                    rx: 2,
+                    ry: 2,
+                    strokeWidth: 1,
+                    fill: '#F4F5F6',
+                    stroke: '#CECECE',
+                    cursor: 'pointer',
+                    x: x - width / 2 + 5,
+                    y: y - height / 2 + 5,
+                    onClick: function (e) {
+                        e.stopPropagation();
+                        model.foldGroup(!properties.isFolded);
+                    },
+                }),
+                iconIcon,
+            ]);
+        };
+        view.prototype.getResizeShape = function () {
+            var model = this.props.model;
+            var x = model.x, y = model.y, width = model.width, height = model.height;
+            var style = model.getNodeStyle();
+            var foldRectAttrs = __assign(__assign({}, style), { x: x - width / 2, y: y - height / 2, width: width,
+                height: height, stroke: 'black', strokeWidth: 2, strokeDasharray: '0 0' });
+            return h('g', {}, [
+                // this.getAddAbleShape(),
+                h('rect', __assign({}, foldRectAttrs)),
+                this.getFoldIcon(),
+            ]);
+        };
+        return view;
+    }(GroupNode.view));
+    var model = /** @class */ (function (_super) {
+        __extends(model, _super);
+        function model() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        model.prototype.initNodeData = function (data) {
+            _super.prototype.initNodeData.call(this, data);
+            this.foldable = true;
+            // this.isFolded = true;
+            this.resizable = true;
+            this.width = 400;
+            this.height = 200;
+            // 根据 properties中的配置重设 宽高
+            this.resetWidthHeight();
+            this.isTaskNode = true; // 标识此节点是任务节点，可以被附件边界事件
+            this.boundaryEvents = []; // 记录自己附加的边界事件
+        };
+        // 自定义根据properties.iniProp
+        model.prototype.resetWidthHeight = function () {
+            var _a, _b;
+            var width = (_a = this.properties.iniProp) === null || _a === void 0 ? void 0 : _a.width;
+            var height = (_b = this.properties.iniProp) === null || _b === void 0 ? void 0 : _b.height;
+            width && (this.width = width);
+            height && (this.height = height);
+        };
+        model.prototype.getNodeStyle = function () {
+            var style = _super.prototype.getNodeStyle.call(this);
+            style.stroke = '#989891';
+            style.strokeWidth = 1;
+            style.strokeDasharray = '3 3';
+            if (this.isSelected) {
+                style.stroke = 'rgb(124, 15, 255)';
+            }
+            // isBoundaryEventTouchingTask属性用于标识拖动边界节点是否靠近此节点
+            // 如果靠近，则高亮提示
+            // style.fill = 'rgb(255, 230, 204)';
+            var isBoundaryEventTouchingTask = this.properties.isBoundaryEventTouchingTask;
+            if (isBoundaryEventTouchingTask) {
+                style.stroke = '#00acff';
+                style.strokeWidth = 2;
+            }
+            return style;
+        };
+        model.prototype.addChild = function (id) {
+            var model = this.graphModel.getElement(id);
+            model.setProperties({
+                parent: this.id,
+            });
+            _super.prototype.addChild.call(this, id);
+        };
+        // 隐藏锚点而不是设置锚点数为0
+        // 因为分组内部节点与外部节点相连时，
+        // 如果折叠分组，需要分组代替内部节点与外部节点相连。
+        model.prototype.getAnchorStyle = function () {
+            var style = _super.prototype.getAnchorStyle.call(this, {});
+            style.stroke = '#000';
+            style.fill = '#fff';
+            style.hover.stroke = 'transparent';
+            return style;
+        };
+        model.prototype.getOutlineStyle = function () {
+            var style = _super.prototype.getOutlineStyle.call(this);
+            style.stroke = 'transparent';
+            !style.hover && (style.hover = {});
+            style.hover.stroke = 'transparent';
+            return style;
+        };
+        /**
+         * 提供方法给插件在判断此节点被拖动边界事件节点靠近时调用，从而触发高亮
+         */
+        model.prototype.setTouching = function (flag) {
+            this.setProperty('isBoundaryEventTouchingTask', flag);
+        };
+        /**
+         * 附加后记录被附加的边界事件节点Id
+         */
+        model.prototype.addBoundaryEvent = function (nodeId) {
+            this.setTouching(false);
+            if (this.boundaryEvents.find(function (item) { return item === nodeId; })) {
+                return false;
+            }
+            var boundaryEvent = this.graphModel.getNodeModelById(nodeId);
+            boundaryEvent === null || boundaryEvent === void 0 ? void 0 : boundaryEvent.setProperties({
+                attachedToRef: this.id,
+            });
+            this.boundaryEvents.push(nodeId);
+            return true;
+        };
+        /**
+         * 被附加的边界事件节点被删除时，移除记录
+         */
+        model.prototype.deleteBoundaryEvent = function (nodeId) {
+            this.boundaryEvents = this.boundaryEvents.filter(function (item) { return item !== nodeId; });
+        };
+        return model;
+    }(GroupNode.model));
+    return {
+        type: 'bpmn:subProcess',
+        view: view,
+        model: model,
+    };
+}

package/es/bpmn-elements/presets/Task/task.d.ts

@@ -0,0 +1,12 @@
+export declare const multiInstanceIcon: any;
+/**
+ * @param type 任务节点的type, 对应其XML定义中的节点名，如<bpmn:userTask /> 其type为bpmn:userTask
+ * @param icon 任务节点左上角的图标，可以是svg path，也可以是h函数生成的svg
+ * @param props (可选) 任务节点的属性
+ * @returns { type: string, model: any, view: any }
+ */
+export declare function TaskNodeFactory(type: string, icon: string | any[], props?: any): {
+    type: string;
+    model: any;
+    view: any;
+};

package/es/bpmn-elements/presets/Task/task.js

@@ -0,0 +1,186 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+/* eslint-disable @typescript-eslint/naming-convention */
+import { RectNode, RectNodeModel, h, } from '@logicflow/core';
+import { parallelMarker, sequentialMarker, loopMarker } from '../icons';
+import { genBpmnId, groupRule } from '../../utils';
+export var multiInstanceIcon = {
+    parallel: parallelMarker,
+    sequential: sequentialMarker,
+    loop: loopMarker,
+};
+/**
+ * @param type 任务节点的type, 对应其XML定义中的节点名，如<bpmn:userTask /> 其type为bpmn:userTask
+ * @param icon 任务节点左上角的图标，可以是svg path，也可以是h函数生成的svg
+ * @param props (可选) 任务节点的属性
+ * @returns { type: string, model: any, view: any }
+ */
+export function TaskNodeFactory(type, icon, props) {
+    var view = /** @class */ (function (_super) {
+        __extends(view, _super);
+        function view() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        view.prototype.getLabelShape = function () {
+            // @ts-ignore
+            var model = this.props.model;
+            var x = model.x, y = model.y, width = model.width, height = model.height;
+            var style = model.getNodeStyle();
+            var i = Array.isArray(icon)
+                ? h.apply(void 0, __spread(['g', {
+                        transform: "matrix(1 0 0 1 " + (x - width / 2) + " " + (y - height / 2) + ")",
+                    }], icon)) : h('path', {
+                fill: style.stroke,
+                d: icon,
+            });
+            return h('svg', {
+                x: x - width / 2 + 5,
+                y: y - height / 2 + 5,
+                width: 25,
+                height: 25,
+                viewBox: '0 0 1274 1024',
+            }, i);
+        };
+        view.prototype.getShape = function () {
+            // @ts-ignore
+            var model = this.props.model;
+            var x = model.x, y = model.y, width = model.width, height = model.height, radius = model.radius, properties = model.properties;
+            var style = model.getNodeStyle();
+            return h('g', {}, [
+                h('rect', __assign(__assign({}, style), { x: x - width / 2, y: y - height / 2, rx: radius, ry: radius, width: width,
+                    height: height, opacity: 0.95 })),
+                this.getLabelShape(),
+                h('g', {
+                    transform: "matrix(1 0 0 1 " + (x - width / 2) + " " + (y - height / 2) + ")",
+                }, h('path', {
+                    fill: 'white',
+                    strokeLinecap: 'round',
+                    strokeLinejoin: 'round',
+                    stroke: 'rgb(34, 36, 42)',
+                    strokeWidth: '2',
+                    d: multiInstanceIcon[properties.multiInstanceType] || '',
+                })),
+            ]);
+        };
+        return view;
+    }(RectNode));
+    var model = /** @class */ (function (_super) {
+        __extends(model, _super);
+        function model(data, graphModel) {
+            var _a;
+            var _this = this;
+            if (!data.id) {
+                data.id = "Activity_" + genBpmnId();
+            }
+            var properties = __assign(__assign({}, (props || {})), data.properties);
+            data.properties = properties;
+            _this = _super.call(this, data, graphModel) || this;
+            (_a = properties === null || properties === void 0 ? void 0 : properties.boundaryEvents) === null || _a === void 0 ? void 0 : _a.forEach(function (id) {
+                _this.addBoundaryEvent(id);
+            });
+            _this.deleteProperty('boundaryEvents');
+            groupRule.call(_this);
+            return _this;
+        }
+        model.prototype.initNodeData = function (data) {
+            _super.prototype.initNodeData.call(this, data);
+            this.isTaskNode = true; // 标识此节点是任务节点，可以被附件边界事件
+            this.boundaryEvents = []; // 记录自己附加的边界事件
+        };
+        model.prototype.getNodeStyle = function () {
+            var style = _super.prototype.getNodeStyle.call(this);
+            // isBoundaryEventTouchingTask属性用于标识拖动边界节点是否靠近此节点
+            // 如果靠近，则高亮提示
+            // style.fill = 'rgb(255, 230, 204)';
+            var isBoundaryEventTouchingTask = this.properties.isBoundaryEventTouchingTask;
+            if (isBoundaryEventTouchingTask) {
+                style.stroke = '#00acff';
+                style.strokeWidth = 2;
+            }
+            return style;
+        };
+        model.prototype.getOutlineStyle = function () {
+            var style = _super.prototype.getOutlineStyle.call(this);
+            style.stroke = 'transparent';
+            !style.hover && (style.hover = {});
+            style.hover.stroke = 'transparent';
+            return style;
+        };
+        /**
+           * 提供方法给插件在判断此节点被拖动边界事件节点靠近时调用，从而触发高亮
+           */
+        model.prototype.setTouching = function (flag) {
+            this.setProperty('isBoundaryEventTouchingTask', flag);
+        };
+        /**
+           * 附加后记录被附加的边界事件节点Id
+           */
+        model.prototype.addBoundaryEvent = function (nodeId) {
+            this.setTouching(false);
+            if (this.boundaryEvents.find(function (item) { return item === nodeId; })) {
+                return false;
+            }
+            var boundaryEvent = this.graphModel.getNodeModelById(nodeId);
+            boundaryEvent === null || boundaryEvent === void 0 ? void 0 : boundaryEvent.setProperties({
+                attachedToRef: this.id,
+            });
+            this.boundaryEvents.push(nodeId);
+            return true;
+        };
+        /**
+           * 被附加的边界事件节点被删除时，移除记录
+           */
+        model.prototype.deleteBoundaryEvent = function (nodeId) {
+            this.boundaryEvents = this.boundaryEvents.filter(function (item) { return item !== nodeId; });
+        };
+        return model;
+    }(RectNodeModel));
+    // @ts-ignore
+    return {
+        type: type,
+        view: view,
+        model: model,
+    };
+}