service-flow-designer 0.0.1-beta.1 → 0.0.1-beta.4

package/dist/lib/node_modules/.pnpm/@logicflow_extension@1.2.27/node_modules/@logicflow/extension/es/bpmn-adapter/index.js

@@ -0,0 +1,521 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const bpmnIds = require("./bpmnIds.js");
+const json2xml = require("./json2xml.js");
+const xml2json = require("./xml2json.js");
+const constant = require("../bpmn/constant.js");
+var __extends = /* @__PURE__ */ function() {
+  var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+      d2.__proto__ = b2;
+    } || function(d2, b2) {
+      for (var p in b2) if (b2.hasOwnProperty(p)) d2[p] = b2[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 = 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 = 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 };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+  return ar;
+};
+var BpmnElements;
+(function(BpmnElements2) {
+  BpmnElements2["START"] = "bpmn:startEvent";
+  BpmnElements2["END"] = "bpmn:endEvent";
+  BpmnElements2["GATEWAY"] = "bpmn:exclusiveGateway";
+  BpmnElements2["USER"] = "bpmn:userTask";
+  BpmnElements2["SYSTEM"] = "bpmn:serviceTask";
+  BpmnElements2["FLOW"] = "bpmn:sequenceFlow";
+})(BpmnElements || (BpmnElements = {}));
+var defaultAttrs = [
+  "-name",
+  "-id",
+  "bpmn:incoming",
+  "bpmn:outgoing",
+  "-sourceRef",
+  "-targetRef"
+];
+var defaultRetainedFields = ["properties", "startPoint", "endPoint", "pointsList"];
+function toXmlJson(retainedFields) {
+  var fields = retainedFields ? defaultRetainedFields.concat(retainedFields) : defaultRetainedFields;
+  return function(json) {
+    function ToXmlJson(obj) {
+      var xmlJson = {};
+      if (typeof obj === "string") {
+        return obj;
+      }
+      if (Array.isArray(obj)) {
+        return obj.map(function(j) {
+          return ToXmlJson(j);
+        });
+      }
+      Object.entries(obj).forEach(function(_a) {
+        var _b = __read(_a, 2), key = _b[0], value = _b[1];
+        if (typeof value !== "object") {
+          if (key.indexOf("-") === 0 || ["#text", "#cdata-section", "#comment"].includes(key)) {
+            xmlJson[key] = value;
+          } else {
+            xmlJson["-" + key] = value;
+          }
+        } else if (fields.includes(key)) {
+          xmlJson["-" + key] = ToXmlJson(value);
+        } else {
+          xmlJson[key] = ToXmlJson(value);
+        }
+      });
+      return xmlJson;
+    }
+    return ToXmlJson(json);
+  };
+}
+function toNormalJson(xmlJson) {
+  var json = {};
+  Object.entries(xmlJson).forEach(function(_a) {
+    var _b = __read(_a, 2), key = _b[0], value = _b[1];
+    if (key.indexOf("-") === 0) {
+      json[key.substring(1)] = json2xml.handleAttributes(value);
+    } else if (typeof value === "string") {
+      json[key] = value;
+    } else if (Object.prototype.toString.call(value) === "[object Object]") {
+      json[key] = toNormalJson(value);
+    } else if (Array.isArray(value)) {
+      json[key] = value.map(function(v) {
+        return toNormalJson(v);
+      });
+    } else {
+      json[key] = value;
+    }
+  });
+  return json;
+}
+function convertLf2ProcessData(bpmnProcessData, data, retainedFields) {
+  var nodeMap = /* @__PURE__ */ new Map();
+  data.nodes.forEach(function(node) {
+    var _a;
+    var processNode = {
+      "-id": node.id
+    };
+    if ((_a = node.text) === null || _a === void 0 ? void 0 : _a.value) {
+      processNode["-name"] = node.text.value;
+    }
+    if (node.properties) {
+      var properties = toXmlJson(retainedFields)(node.properties);
+      Object.assign(processNode, properties);
+    }
+    nodeMap.set(node.id, processNode);
+    if (!bpmnProcessData[node.type]) {
+      bpmnProcessData[node.type] = processNode;
+    } else if (Array.isArray(bpmnProcessData[node.type])) {
+      bpmnProcessData[node.type].push(processNode);
+    } else {
+      bpmnProcessData[node.type] = [bpmnProcessData[node.type], processNode];
+    }
+  });
+  var sequenceFlow = data.edges.map(function(edge) {
+    var _a, _b;
+    var targetNode = nodeMap.get(edge.targetNodeId);
+    if (!targetNode["bpmn:incoming"]) {
+      targetNode["bpmn:incoming"] = edge.id;
+    } else if (Array.isArray(targetNode["bpmn:incoming"])) {
+      targetNode["bpmn:incoming"].push(edge.id);
+    } else {
+      targetNode["bpmn:incoming"] = [targetNode["bpmn:incoming"], edge.id];
+    }
+    var edgeConfig = {
+      "-id": edge.id,
+      "-sourceRef": edge.sourceNodeId,
+      "-targetRef": edge.targetNodeId
+    };
+    if ((_a = edge.text) === null || _a === void 0 ? void 0 : _a.value) {
+      edgeConfig["-name"] = (_b = edge.text) === null || _b === void 0 ? void 0 : _b.value;
+    }
+    if (edge.properties) {
+      var properties = toXmlJson(retainedFields)(edge.properties);
+      Object.assign(edgeConfig, properties);
+    }
+    return edgeConfig;
+  });
+  data.edges.forEach(function(edge) {
+    var sourceNode = nodeMap.get(edge.sourceNodeId);
+    if (!sourceNode["bpmn:outgoing"]) {
+      sourceNode["bpmn:outgoing"] = edge.id;
+    } else if (Array.isArray(sourceNode["bpmn:outgoing"])) {
+      sourceNode["bpmn:outgoing"].push(edge.id);
+    } else {
+      sourceNode["bpmn:outgoing"] = [sourceNode["bpmn:outgoing"], edge.id];
+    }
+  });
+  bpmnProcessData[BpmnElements.FLOW] = sequenceFlow;
+}
+function convertLf2DiagramData(bpmnDiagramData, data) {
+  bpmnDiagramData["bpmndi:BPMNEdge"] = data.edges.map(function(edge) {
+    var _a;
+    var edgeId = edge.id;
+    var pointsList = edge.pointsList.map(function(_a2) {
+      var x = _a2.x, y = _a2.y;
+      return {
+        "-x": x,
+        "-y": y
+      };
+    });
+    var diagramData = {
+      "-id": edgeId + "_di",
+      "-bpmnElement": edgeId,
+      "di:waypoint": pointsList
+    };
+    if ((_a = edge.text) === null || _a === void 0 ? void 0 : _a.value) {
+      diagramData["bpmndi:BPMNLabel"] = {
+        "dc:Bounds": {
+          "-x": edge.text.x - edge.text.value.length * 10 / 2,
+          "-y": edge.text.y - 7,
+          "-width": edge.text.value.length * 10,
+          "-height": 14
+        }
+      };
+    }
+    return diagramData;
+  });
+  bpmnDiagramData["bpmndi:BPMNShape"] = data.nodes.map(function(node) {
+    var _a;
+    var nodeId = node.id;
+    var width = 100;
+    var height = 80;
+    var x = node.x, y = node.y;
+    var shapeConfig = BpmnAdapter.shapeConfigMap.get(node.type);
+    if (shapeConfig) {
+      width = shapeConfig.width;
+      height = shapeConfig.height;
+    }
+    x -= width / 2;
+    y -= height / 2;
+    var diagramData = {
+      "-id": nodeId + "_di",
+      "-bpmnElement": nodeId,
+      "dc:Bounds": {
+        "-x": x,
+        "-y": y,
+        "-width": width,
+        "-height": height
+      }
+    };
+    if ((_a = node.text) === null || _a === void 0 ? void 0 : _a.value) {
+      diagramData["bpmndi:BPMNLabel"] = {
+        "dc:Bounds": {
+          "-x": node.text.x - node.text.value.length * 10 / 2,
+          "-y": node.text.y - 7,
+          "-width": node.text.value.length * 10,
+          "-height": 14
+        }
+      };
+    }
+    return diagramData;
+  });
+}
+function convertBpmn2LfData(bpmnData) {
+  var nodes = [];
+  var edges = [];
+  var definitions = bpmnData["bpmn:definitions"];
+  if (definitions) {
+    var process_1 = definitions["bpmn:process"];
+    Object.keys(process_1).forEach(function(key) {
+      if (key.indexOf("bpmn:") === 0) {
+        var value = process_1[key];
+        if (key === BpmnElements.FLOW) {
+          var bpmnEdges = definitions["bpmndi:BPMNDiagram"]["bpmndi:BPMNPlane"]["bpmndi:BPMNEdge"];
+          edges = getLfEdges(value, bpmnEdges);
+        } else {
+          var shapes = definitions["bpmndi:BPMNDiagram"]["bpmndi:BPMNPlane"]["bpmndi:BPMNShape"];
+          nodes = nodes.concat(getLfNodes(value, shapes, key));
+        }
+      }
+    });
+  }
+  return {
+    nodes,
+    edges
+  };
+}
+function getLfNodes(value, shapes, key) {
+  var nodes = [];
+  if (Array.isArray(value)) {
+    value.forEach(function(val) {
+      var shapeValue2;
+      if (Array.isArray(shapes)) {
+        shapeValue2 = shapes.find(function(shape) {
+          return shape["-bpmnElement"] === val["-id"];
+        });
+      } else {
+        shapeValue2 = shapes;
+      }
+      var node2 = getNodeConfig(shapeValue2, key, val);
+      nodes.push(node2);
+    });
+  } else {
+    var shapeValue = void 0;
+    if (Array.isArray(shapes)) {
+      shapeValue = shapes.find(function(shape) {
+        return shape["-bpmnElement"] === value["-id"];
+      });
+    } else {
+      shapeValue = shapes;
+    }
+    var node = getNodeConfig(shapeValue, key, value);
+    nodes.push(node);
+  }
+  return nodes;
+}
+function getNodeConfig(shapeValue, type, processValue) {
+  var x = Number(shapeValue["dc:Bounds"]["-x"]);
+  var y = Number(shapeValue["dc:Bounds"]["-y"]);
+  var name = processValue["-name"];
+  var shapeConfig = BpmnAdapter.shapeConfigMap.get(type);
+  if (shapeConfig) {
+    x += shapeConfig.width / 2;
+    y += shapeConfig.height / 2;
+  }
+  var properties;
+  Object.entries(processValue).forEach(function(_a) {
+    var _b = __read(_a, 2), key = _b[0], value = _b[1];
+    if (defaultAttrs.indexOf(key) === -1) {
+      if (!properties)
+        properties = {};
+      properties[key] = value;
+    }
+  });
+  if (properties) {
+    properties = toNormalJson(properties);
+  }
+  var text;
+  if (name) {
+    text = {
+      x,
+      y,
+      value: name
+    };
+    if (shapeValue["bpmndi:BPMNLabel"] && shapeValue["bpmndi:BPMNLabel"]["dc:Bounds"]) {
+      var textBounds = shapeValue["bpmndi:BPMNLabel"]["dc:Bounds"];
+      text.x = Number(textBounds["-x"]) + Number(textBounds["-width"]) / 2;
+      text.y = Number(textBounds["-y"]) + Number(textBounds["-height"]) / 2;
+    }
+  }
+  var nodeConfig = {
+    id: shapeValue["-bpmnElement"],
+    type,
+    x,
+    y,
+    properties
+  };
+  if (text) {
+    nodeConfig.text = text;
+  }
+  return nodeConfig;
+}
+function getLfEdges(value, bpmnEdges) {
+  var edges = [];
+  if (Array.isArray(value)) {
+    value.forEach(function(val) {
+      var edgeValue2;
+      if (Array.isArray(bpmnEdges)) {
+        edgeValue2 = bpmnEdges.find(function(edge) {
+          return edge["-bpmnElement"] === val["-id"];
+        });
+      } else {
+        edgeValue2 = bpmnEdges;
+      }
+      edges.push(getEdgeConfig(edgeValue2, val));
+    });
+  } else {
+    var edgeValue = void 0;
+    if (Array.isArray(bpmnEdges)) {
+      edgeValue = bpmnEdges.find(function(edge) {
+        return edge["-bpmnElement"] === value["-id"];
+      });
+    } else {
+      edgeValue = bpmnEdges;
+    }
+    edges.push(getEdgeConfig(edgeValue, value));
+  }
+  return edges;
+}
+function getEdgeConfig(edgeValue, processValue) {
+  var text;
+  var textVal = processValue["-name"];
+  if (textVal) {
+    var textBounds = edgeValue["bpmndi:BPMNLabel"]["dc:Bounds"];
+    var textLength_1 = 0;
+    textVal.split("\n").forEach(function(textSpan) {
+      if (textLength_1 < textSpan.length) {
+        textLength_1 = textSpan.length;
+      }
+    });
+    text = {
+      value: textVal,
+      x: Number(textBounds["-x"]) + textLength_1 * 10 / 2,
+      y: Number(textBounds["-y"]) + 7
+    };
+  }
+  var properties;
+  Object.entries(processValue).forEach(function(_a) {
+    var _b = __read(_a, 2), key = _b[0], value = _b[1];
+    if (defaultAttrs.indexOf(key) === -1) {
+      if (!properties)
+        properties = {};
+      properties[key] = value;
+    }
+  });
+  if (properties) {
+    properties = toNormalJson(properties);
+  }
+  var edge = {
+    id: processValue["-id"],
+    type: BpmnElements.FLOW,
+    pointsList: edgeValue["di:waypoint"].map(function(point) {
+      return {
+        x: Number(point["-x"]),
+        y: Number(point["-y"])
+      };
+    }),
+    sourceNodeId: processValue["-sourceRef"],
+    targetNodeId: processValue["-targetRef"],
+    properties
+  };
+  if (text) {
+    edge.text = text;
+  }
+  return edge;
+}
+var BpmnAdapter = (
+  /** @class */
+  function() {
+    function BpmnAdapter2(_a) {
+      var _this = this;
+      var lf = _a.lf;
+      this.adapterOut = function(data, retainedFields) {
+        var bpmnProcessData = __assign({}, _this.processAttributes);
+        convertLf2ProcessData(bpmnProcessData, data, retainedFields);
+        var bpmnDiagramData = {
+          "-id": "BPMNPlane_1",
+          "-bpmnElement": bpmnProcessData["-id"]
+        };
+        convertLf2DiagramData(bpmnDiagramData, data);
+        var definitions = _this.definitionAttributes;
+        definitions["bpmn:process"] = bpmnProcessData;
+        definitions["bpmndi:BPMNDiagram"] = {
+          "-id": "BPMNDiagram_1",
+          "bpmndi:BPMNPlane": bpmnDiagramData
+        };
+        var bpmnData = {
+          "bpmn:definitions": definitions
+        };
+        return bpmnData;
+      };
+      this.adapterIn = function(bpmnData) {
+        if (bpmnData) {
+          return convertBpmn2LfData(bpmnData);
+        }
+      };
+      lf.adapterIn = function(data) {
+        return _this.adapterIn(data);
+      };
+      lf.adapterOut = function(data, retainedFields) {
+        return _this.adapterOut(data, retainedFields);
+      };
+      this.processAttributes = {
+        "-isExecutable": "true",
+        "-id": "Process_" + bpmnIds.getBpmnId()
+      };
+      this.definitionAttributes = {
+        "-id": "Definitions_" + bpmnIds.getBpmnId(),
+        "-xmlns:xsi": "http://www.w3.org/2001/XMLSchema-instance",
+        "-xmlns:bpmn": "http://www.omg.org/spec/BPMN/20100524/MODEL",
+        "-xmlns:bpmndi": "http://www.omg.org/spec/BPMN/20100524/DI",
+        "-xmlns:dc": "http://www.omg.org/spec/DD/20100524/DC",
+        "-xmlns:di": "http://www.omg.org/spec/DD/20100524/DI",
+        "-targetNamespace": "http://logic-flow.org",
+        "-exporter": "logicflow",
+        "-exporterVersion": "1.2.0"
+      };
+    }
+    BpmnAdapter2.prototype.setCustomShape = function(key, val) {
+      BpmnAdapter2.shapeConfigMap.set(key, val);
+    };
+    BpmnAdapter2.pluginName = "bpmn-adapter";
+    BpmnAdapter2.shapeConfigMap = /* @__PURE__ */ new Map();
+    return BpmnAdapter2;
+  }()
+);
+BpmnAdapter.shapeConfigMap.set(BpmnElements.START, {
+  width: constant.StartEventConfig.width,
+  height: constant.StartEventConfig.height
+});
+BpmnAdapter.shapeConfigMap.set(BpmnElements.END, {
+  width: constant.EndEventConfig.width,
+  height: constant.EndEventConfig.height
+});
+BpmnAdapter.shapeConfigMap.set(BpmnElements.GATEWAY, {
+  width: constant.ExclusiveGatewayConfig.width,
+  height: constant.ExclusiveGatewayConfig.height
+});
+BpmnAdapter.shapeConfigMap.set(BpmnElements.SYSTEM, {
+  width: constant.ServiceTaskConfig.width,
+  height: constant.ServiceTaskConfig.height
+});
+BpmnAdapter.shapeConfigMap.set(BpmnElements.USER, {
+  width: constant.UserTaskConfig.width,
+  height: constant.UserTaskConfig.height
+});
+(function(_super) {
+  __extends(BpmnXmlAdapter, _super);
+  function BpmnXmlAdapter(data) {
+    var _this = _super.call(this, data) || this;
+    _this.adapterXmlIn = function(bpmnData) {
+      var json = xml2json.lfXml2Json(bpmnData);
+      return _this.adapterIn(json);
+    };
+    _this.adapterXmlOut = function(data2, retainedFields) {
+      var outData = _this.adapterOut(data2, retainedFields);
+      return json2xml.lfJson2Xml(outData);
+    };
+    var lf = data.lf;
+    lf.adapterIn = _this.adapterXmlIn;
+    lf.adapterOut = _this.adapterXmlOut;
+    return _this;
+  }
+  BpmnXmlAdapter.pluginName = "bpmnXmlAdapter";
+  return BpmnXmlAdapter;
+})(BpmnAdapter);
+exports.BpmnAdapter = BpmnAdapter;
+exports.default = BpmnAdapter;
+exports.toNormalJson = toNormalJson;
+exports.toXmlJson = toXmlJson;

package/dist/lib/node_modules/.pnpm/@logicflow_extension@1.2.27/node_modules/@logicflow/extension/es/bpmn-adapter/json2xml.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function type(obj) {
+  return Object.prototype.toString.call(obj);
+}
+function addSpace(depth) {
+  return "  ".repeat(depth);
+}
+function handleAttributes(o) {
+  var t = o;
+  if (type(o) === "[object Object]") {
+    t = {};
+    Object.keys(o).forEach(function(k) {
+      var tk = k;
+      if (k.charAt(0) === "-") {
+        tk = k.substring(1);
+      }
+      t[tk] = handleAttributes(o[k]);
+    });
+  } else if (Array.isArray(o)) {
+    t = [];
+    o.forEach(function(item, index) {
+      t[index] = handleAttributes(item);
+    });
+  }
+  return t;
+}
+function getAttributes(obj) {
+  var tmp = obj;
+  try {
+    if (typeof tmp !== "string") {
+      tmp = JSON.parse(obj);
+    }
+  } catch (error) {
+    tmp = JSON.stringify(handleAttributes(obj)).replace(/"/g, "'");
+  }
+  return tmp;
+}
+var tn = "	\n";
+function toXml(obj, name, depth) {
+  var frontSpace = addSpace(depth);
+  var str = "";
+  if (name === "#text") {
+    return tn + frontSpace + obj;
+  } else if (name === "#cdata-section") {
+    return tn + frontSpace + "<![CDATA[" + obj + "]]>";
+  } else if (name === "#comment") {
+    return tn + frontSpace + "<!--" + obj + "-->";
+  }
+  if (("" + name).charAt(0) === "-") {
+    return " " + name.substring(1) + '="' + getAttributes(obj) + '"';
+  } else {
+    if (Array.isArray(obj)) {
+      obj.forEach(function(item) {
+        str += toXml(item, name, depth + 1);
+      });
+    } else if (type(obj) === "[object Object]") {
+      var keys = Object.keys(obj);
+      var attributes_1 = "";
+      var children_1 = "";
+      str += (depth === 0 ? "" : tn + frontSpace) + "<" + name;
+      keys.forEach(function(k) {
+        k.charAt(0) === "-" ? attributes_1 += toXml(obj[k], k, depth + 1) : children_1 += toXml(obj[k], k, depth + 1);
+      });
+      str += attributes_1 + (children_1 !== "" ? ">" + children_1 + (tn + frontSpace) + "</" + name + ">" : " />");
+    } else {
+      str += tn + frontSpace + ("<" + name + ">" + obj.toString() + "</" + name + ">");
+    }
+  }
+  return str;
+}
+function lfJson2Xml(o) {
+  var xmlStr = "";
+  for (var m in o) {
+    xmlStr += toXml(o[m], m, 0);
+  }
+  return xmlStr;
+}
+exports.handleAttributes = handleAttributes;
+exports.lfJson2Xml = lfJson2Xml;