@logicflow/extension 1.2.10 → 1.2.12

package/cjs/bpmn-elements/presets/Event/boundaryEventFactory.js

@@ -0,0 +1,125 @@
+"use strict";
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoundaryEventFactory = void 0;
+/* eslint-disable max-len */
+/* eslint-disable @typescript-eslint/naming-convention */
+var core_1 = require("@logicflow/core");
+var utils_1 = require("../../utils");
+function BoundaryEventFactory(lf) {
+    var _a = __read(lf.useDefinition(), 1), definition = _a[0];
+    var view = /** @class */ (function (_super) {
+        __extends(view, _super);
+        function view() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        view.prototype.getAnchorStyle = function () {
+            return {
+                visibility: 'hidden',
+            };
+        };
+        view.prototype.getShape = function () {
+            var _a;
+            // @ts-ignore
+            var model = this.props.model;
+            var style = model.getNodeStyle();
+            var x = model.x, y = model.y, r = model.r, width = model.width, height = model.height, properties = model.properties;
+            var definitionType = properties.definitionType, cancelActivity = properties.cancelActivity;
+            var icon = (((_a = definition.boundaryEvent) === null || _a === void 0 ? void 0 : _a.get(definitionType)) || {}).icon;
+            var i = Array.isArray(icon)
+                ? core_1.h.apply(void 0, __spread(['g', {
+                        transform: "matrix(1 0 0 1 " + (x - width / 2) + " " + (y - height / 2) + ")",
+                    }], icon)) : core_1.h('path', {
+                transform: "matrix(1 0 0 1 " + (x - width / 2) + " " + (y - height / 2) + ")",
+                d: icon,
+            });
+            return core_1.h('g', {}, core_1.h('circle', __assign(__assign({}, style), { cx: x, cy: y, r: r, strokeDasharray: cancelActivity ? '' : '5,5', strokeWidth: 1.5 })), core_1.h('circle', __assign(__assign({}, style), { cx: x, cy: y, r: r - 3, strokeDasharray: cancelActivity ? '' : '5,5', strokeWidth: 1.5 })), i);
+        };
+        return view;
+    }(core_1.CircleNode));
+    var model = /** @class */ (function (_super) {
+        __extends(model, _super);
+        function model(data, graphModel) {
+            var _a, _b, _c;
+            var _this = this;
+            if (!data.id) {
+                data.id = "Event_" + utils_1.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,
+                };
+            }
+            var _d = (((_a = definition.boundaryEvent) === null || _a === void 0 ? void 0 : _a.get((_b = data.properties) === null || _b === void 0 ? void 0 : _b.definitionType)) || {}).properties, properties = _d === void 0 ? {} : _d;
+            data.properties = __assign(__assign({ attachedToRef: '', cancelActivity: true }, properties), data.properties);
+            ((_c = data.properties) === null || _c === void 0 ? void 0 : _c.definitionType) && (data.properties.definitionId = "Definition_" + utils_1.genBpmnId());
+            _this = _super.call(this, data, graphModel) || this;
+            utils_1.groupRule.call(_this);
+            return _this;
+        }
+        model.prototype.initNodeData = function (data) {
+            _super.prototype.initNodeData.call(this, data);
+            this.r = 20;
+            this.autoToFront = false; // 不自动设置到最顶部，而是使用自己的zIndex
+            this.zIndex = 99999; // 保证边界事件节点用于在最上方
+        };
+        model.prototype.setAttributes = function () {
+            this.r = 18;
+        };
+        return model;
+    }(core_1.CircleNodeModel));
+    return {
+        type: 'bpmn:boundaryEvent',
+        view: view,
+        model: model,
+    };
+}
+exports.BoundaryEventFactory = BoundaryEventFactory;

package/cjs/bpmn-elements/presets/Event/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerEventNodes = void 0;
+var EndEventFactory_1 = require("./EndEventFactory");
+var IntermediateCatchEvent_1 = require("./IntermediateCatchEvent");
+var StartEventFactory_1 = require("./StartEventFactory");
+var boundaryEventFactory_1 = require("./boundaryEventFactory");
+var IntermediateThrowEvent_1 = require("./IntermediateThrowEvent");
+function registerEventNodes(lf) {
+    lf.register(StartEventFactory_1.StartEventFactory(lf));
+    lf.register(EndEventFactory_1.EndEventFactory(lf));
+    lf.register(IntermediateCatchEvent_1.IntermediateCatchEventFactory(lf));
+    lf.register(IntermediateThrowEvent_1.IntermediateThrowEventFactory(lf));
+    lf.register(boundaryEventFactory_1.BoundaryEventFactory(lf));
+}
+exports.registerEventNodes = registerEventNodes;

package/cjs/bpmn-elements/presets/Flow/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerFlows = exports.SequenceFlow = void 0;
+var sequenceFlow_1 = require("./sequenceFlow");
+exports.SequenceFlow = sequenceFlow_1.sequenceFlowFactory();
+function registerFlows(lf) {
+    lf.register(exports.SequenceFlow);
+}
+exports.registerFlows = registerFlows;

package/cjs/bpmn-elements/presets/Flow/sequenceFlow.js

@@ -0,0 +1,78 @@
+"use strict";
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sequenceFlowFactory = void 0;
+/* eslint-disable @typescript-eslint/naming-convention */
+var core_1 = require("@logicflow/core");
+var utils_1 = require("../../utils");
+function sequenceFlowFactory(props) {
+    var model = /** @class */ (function (_super) {
+        __extends(model, _super);
+        function model(data, graphModel) {
+            var _this = this;
+            if (!data.id) {
+                data.id = "Flow_" + utils_1.genBpmnId();
+            }
+            var properties = __assign(__assign(__assign({}, (props || {})), data.properties), { 
+                // panels: ['condition'],
+                isDefaultFlow: false });
+            data.properties = properties;
+            _this = _super.call(this, data, graphModel) || this;
+            return _this;
+        }
+        model.extendKey = 'SequenceFlowModel';
+        return model;
+    }(core_1.PolylineEdgeModel));
+    var view = /** @class */ (function (_super) {
+        __extends(view, _super);
+        function view() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        view.prototype.getStartArrow = function () {
+            // eslint-disable-next-line no-shadow
+            var model = this.props.model;
+            var isDefaultFlow = model.properties.isDefaultFlow;
+            return isDefaultFlow
+                ? core_1.h('path', {
+                    refX: 15,
+                    stroke: '#000000',
+                    strokeWidth: 2,
+                    d: 'M 20 5 10 -5 z',
+                })
+                : core_1.h('path', {
+                    d: '',
+                });
+        };
+        view.extendKey = 'SequenceFlowEdge';
+        return view;
+    }(core_1.PolylineEdge));
+    return {
+        type: 'bpmn:sequenceFlow',
+        view: view,
+        model: model,
+    };
+}
+exports.sequenceFlowFactory = sequenceFlowFactory;

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

@@ -0,0 +1,109 @@
+"use strict";
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GatewayNodeFactory = exports.gatewayComposable = void 0;
+/* eslint-disable @typescript-eslint/naming-convention */
+var core_1 = require("@logicflow/core");
+var utils_1 = require("../../utils");
+var gateway = {
+    exclusive: 0,
+    inclusive: 1,
+    parallel: 2,
+};
+/**
+ * index 0 排他网关
+ * index 1 包容网关
+ * index 2 并行网关
+ */
+exports.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 }
+ */
+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 core_1.h('g', {
+                transform: "matrix(1 0 0 1 " + (x - width / 2) + " " + (y - height / 2) + ")",
+            }, core_1.h('polygon', __assign(__assign({}, style), { x: x,
+                y: y,
+                points: points })), typeof icon === 'string'
+                ? core_1.h('path', __assign(__assign({ d: icon }, style), { fill: 'rgb(34, 36, 42)', strokeWidth: 1 }))
+                : icon);
+        };
+        return view;
+    }(core_1.PolygonNode));
+    var model = /** @class */ (function (_super) {
+        __extends(model, _super);
+        function model(data, graphModel) {
+            var _this = this;
+            if (!data.id) {
+                data.id = "Gateway_" + utils_1.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],
+            ];
+            utils_1.groupRule.call(_this);
+            return _this;
+        }
+        return model;
+    }(core_1.PolygonNodeModel));
+    return {
+        type: type,
+        view: view,
+        model: model,
+    };
+}
+exports.GatewayNodeFactory = GatewayNodeFactory;

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerGatewayNodes = void 0;
+var icons_1 = require("../icons");
+var gateway_1 = require("./gateway");
+function registerGatewayNodes(lf) {
+    var ExclusiveGateway = gateway_1.GatewayNodeFactory('bpmn:exclusiveGateway', icons_1.exclusiveIcon);
+    var ParallelGateway = gateway_1.GatewayNodeFactory('bpmn:parallelGateway', icons_1.parallelIcon);
+    var InclusiveGateway = gateway_1.GatewayNodeFactory('bpmn:inclusiveGateway', icons_1.inclusiveIcon);
+    lf.register(ExclusiveGateway);
+    lf.register(InclusiveGateway);
+    lf.register(ParallelGateway);
+}
+exports.registerGatewayNodes = registerGatewayNodes;

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

@@ -0,0 +1,134 @@
+"use strict";
+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.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTaskNodes = void 0;
+var icons_1 = require("../icons");
+var task_1 = require("./task");
+var subProcess_1 = require("./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;
+    }
+}
+function registerTaskNodes(lf) {
+    var ServiceTask = task_1.TaskNodeFactory('bpmn:serviceTask', icons_1.serviceTaskIcon);
+    var UserTask = task_1.TaskNodeFactory('bpmn:userTask', icons_1.userTaskIcon);
+    lf.register(ServiceTask);
+    lf.register(UserTask);
+    lf.register(subProcess_1.SubProcessFactory());
+    boundaryEvent(lf);
+}
+exports.registerTaskNodes = registerTaskNodes;

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

@@ -0,0 +1,190 @@
+"use strict";
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubProcessFactory = void 0;
+/* eslint-disable no-shadow */
+/* eslint-disable @typescript-eslint/naming-convention */
+var core_1 = require("@logicflow/core");
+var index_1 = require("../../../materials/group/index");
+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 = core_1.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 core_1.h('g', {}, [
+                core_1.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 core_1.h('g', {}, [
+                // this.getAddAbleShape(),
+                core_1.h('rect', __assign({}, foldRectAttrs)),
+                this.getFoldIcon(),
+            ]);
+        };
+        return view;
+    }(index_1.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;
+    }(index_1.GroupNode.model));
+    return {
+        type: 'bpmn:subProcess',
+        view: view,
+        model: model,
+    };
+}
+exports.SubProcessFactory = SubProcessFactory;