@hpcc-js/comms 2.89.0 → 2.90.0

package/dist/index.js

@@ -648,8 +648,8 @@
   }
 
   var PKG_NAME = "@hpcc-js/comms";
-  var PKG_VERSION = "2.89.0";
-  var BUILD_VERSION = "2.104.39";
+  var PKG_VERSION = "2.90.0";
+  var BUILD_VERSION = "2.104.40";
 
   /******************************************************************************
   Copyright (c) Microsoft Corporation.
@@ -5727,6 +5727,13 @@
       }
       return num;
   }
+  function safeDelete(obj, key, prop) {
+      if (obj[key] === undefined || obj[key][prop] === undefined)
+          return;
+      if (key === "__proto__" || key === "constructor" || key === "prototype")
+          return;
+      delete obj[key][prop];
+  }
   var DEFINITION_LIST = "DefinitionList";
   var definitionRegex = /([a-zA-Z]:)?(.*[\\\/])(.*)(\((\d+),(\d+)\))/;
   var PropertyType = ["Avg", "Min", "Max", "Delta", "StdDev"];
@@ -6617,115 +6624,117 @@
           if (request === void 0) { request = {}; }
           return this.WUDetails(request).then(function (response) { return response.Scopes.Scope; });
       };
-      Workunit.prototype.fetchDetailsNormalized = function (request) {
-          if (request === void 0) { request = {}; }
-          return Promise.all([this.fetchDetailsMeta(), this.fetchDetailsRaw(request)]).then(function (promises) {
-              var _a;
-              var meta = promises[0];
-              var scopes = promises[1];
-              var columns = {
-                  id: {
-                      Measure: "label"
-                  },
-                  name: {
-                      Measure: "label"
-                  },
-                  type: {
-                      Measure: "label"
-                  }
-              };
-              var data = [];
-              var _loop_1 = function (scope) {
-                  var props = {};
-                  var formattedProps = {};
-                  if (scope && scope.Id && scope.Properties && scope.Properties.Property) {
-                      for (var key in scope.Properties.Property) {
-                          var scopeProperty = scope.Properties.Property[key];
-                          if (scopeProperty.Measure === "ns") {
-                              scopeProperty.Measure = "s";
-                          }
-                          columns[scopeProperty.Name] = __assign({}, scopeProperty);
-                          delete columns[scopeProperty.Name].RawValue;
-                          delete columns[scopeProperty.Name].Formatted;
-                          switch (scopeProperty.Measure) {
-                              case "bool":
-                                  props[scopeProperty.Name] = !!+scopeProperty.RawValue;
-                                  break;
-                              case "sz":
-                                  props[scopeProperty.Name] = +scopeProperty.RawValue;
-                                  break;
-                              case "s":
-                                  props[scopeProperty.Name] = +scopeProperty.RawValue / 1000000000;
-                                  break;
-                              case "ns":
-                                  props[scopeProperty.Name] = +scopeProperty.RawValue;
-                                  break;
-                              case "ts":
-                                  props[scopeProperty.Name] = new Date(+scopeProperty.RawValue / 1000).toISOString();
-                                  break;
-                              case "cnt":
-                                  props[scopeProperty.Name] = +scopeProperty.RawValue;
-                                  break;
-                              case "cost":
-                                  props[scopeProperty.Name] = +scopeProperty.RawValue / 1000000;
-                                  break;
-                              case "cpu":
-                              case "skw":
-                              case "node":
-                              case "ppm":
-                              case "ip":
-                              case "cy":
-                              case "en":
-                              case "txt":
-                              case "id":
-                              case "fname":
-                              default:
-                                  props[scopeProperty.Name] = scopeProperty.RawValue;
-                          }
-                          formattedProps[scopeProperty.Name] = formatNum((_a = scopeProperty.Formatted) !== null && _a !== void 0 ? _a : props[scopeProperty.Name]);
-                      }
-                      //  Other properties  ---
-                  }
-                  var normalizedScope = __assign({ id: scope.Id, name: scope.ScopeName, type: scope.ScopeType, Kind: scope["Kind"], Label: scope["Label"], __formattedProps: formattedProps, __groupedProps: {} }, props);
-                  if (normalizedScope[DEFINITION_LIST]) {
-                      try {
-                          var definitionList = JSON.parse(normalizedScope[DEFINITION_LIST].split("\\").join("\\\\"));
-                          normalizedScope[DEFINITION_LIST] = [];
-                          definitionList.forEach(function (definition, idx) {
-                              var _a;
-                              var matches = definition.match(definitionRegex);
-                              if (matches) {
-                                  var filePath = ((_a = matches[1]) !== null && _a !== void 0 ? _a : "") + matches[2] + matches[3];
-                                  var line = parseInt(matches[5]);
-                                  var col = parseInt(matches[6]);
-                                  normalizedScope[DEFINITION_LIST].push({ filePath: filePath, line: line, col: col });
-                              }
-                          });
+      Workunit.prototype.normalizeDetails = function (meta, scopes) {
+          var _a;
+          var columns = {
+              id: {
+                  Measure: "label"
+              },
+              name: {
+                  Measure: "label"
+              },
+              type: {
+                  Measure: "label"
+              }
+          };
+          var data = [];
+          var _loop_1 = function (scope) {
+              var props = {};
+              var formattedProps = {};
+              if (scope && scope.Id && scope.Properties && scope.Properties.Property) {
+                  for (var key in scope.Properties.Property) {
+                      var scopeProperty = scope.Properties.Property[key];
+                      if (scopeProperty.Measure === "ns") {
+                          scopeProperty.Measure = "s";
                       }
-                      catch (e) {
-                          logger$2.error("Unexpected \"DefinitionList\":  ".concat(normalizedScope[DEFINITION_LIST]));
+                      columns[scopeProperty.Name] = __assign({}, scopeProperty);
+                      safeDelete(columns, scopeProperty.Name, "RawValue");
+                      safeDelete(columns, scopeProperty.Name, "Formatted");
+                      switch (scopeProperty.Measure) {
+                          case "bool":
+                              props[scopeProperty.Name] = !!+scopeProperty.RawValue;
+                              break;
+                          case "sz":
+                              props[scopeProperty.Name] = +scopeProperty.RawValue;
+                              break;
+                          case "s":
+                              props[scopeProperty.Name] = +scopeProperty.RawValue / 1000000000;
+                              break;
+                          case "ns":
+                              props[scopeProperty.Name] = +scopeProperty.RawValue;
+                              break;
+                          case "ts":
+                              props[scopeProperty.Name] = new Date(+scopeProperty.RawValue / 1000).toISOString();
+                              break;
+                          case "cnt":
+                              props[scopeProperty.Name] = +scopeProperty.RawValue;
+                              break;
+                          case "cost":
+                              props[scopeProperty.Name] = +scopeProperty.RawValue / 1000000;
+                              break;
+                          case "cpu":
+                          case "skw":
+                          case "node":
+                          case "ppm":
+                          case "ip":
+                          case "cy":
+                          case "en":
+                          case "txt":
+                          case "id":
+                          case "fname":
+                          default:
+                              props[scopeProperty.Name] = scopeProperty.RawValue;
                       }
+                      formattedProps[scopeProperty.Name] = formatNum((_a = scopeProperty.Formatted) !== null && _a !== void 0 ? _a : props[scopeProperty.Name]);
                   }
-                  var dedup = {};
-                  for (var key in normalizedScope) {
-                      if (key.indexOf("__") !== 0) {
-                          var row = formatValues(normalizedScope, key, dedup);
-                          if (row) {
-                              normalizedScope.__groupedProps[row.Key] = row;
+                  //  Other properties  ---
+              }
+              var normalizedScope = __assign({ id: scope.Id, name: scope.ScopeName, type: scope.ScopeType, Kind: scope["Kind"], Label: scope["Label"], __formattedProps: formattedProps, __groupedProps: {} }, props);
+              if (normalizedScope[DEFINITION_LIST]) {
+                  try {
+                      var definitionList = JSON.parse(normalizedScope[DEFINITION_LIST].split("\\").join("\\\\"));
+                      normalizedScope[DEFINITION_LIST] = [];
+                      definitionList.forEach(function (definition, idx) {
+                          var _a;
+                          var matches = definition.match(definitionRegex);
+                          if (matches) {
+                              var filePath = ((_a = matches[1]) !== null && _a !== void 0 ? _a : "") + matches[2] + matches[3];
+                              var line = parseInt(matches[5]);
+                              var col = parseInt(matches[6]);
+                              normalizedScope[DEFINITION_LIST].push({ filePath: filePath, line: line, col: col });
                           }
+                      });
+                  }
+                  catch (e) {
+                      logger$2.error("Unexpected \"DefinitionList\":  ".concat(normalizedScope[DEFINITION_LIST]));
+                  }
+              }
+              var dedup = {};
+              for (var key in normalizedScope) {
+                  if (key.indexOf("__") !== 0) {
+                      var row = formatValues(normalizedScope, key, dedup);
+                      if (row) {
+                          normalizedScope.__groupedProps[row.Key] = row;
                       }
                   }
-                  data.push(normalizedScope);
-              };
-              for (var _i = 0, scopes_1 = scopes; _i < scopes_1.length; _i++) {
-                  var scope = scopes_1[_i];
-                  _loop_1(scope);
               }
-              return {
-                  meta: meta,
-                  columns: columns,
-                  data: data
-              };
+              data.push(normalizedScope);
+          };
+          for (var _i = 0, scopes_1 = scopes; _i < scopes_1.length; _i++) {
+              var scope = scopes_1[_i];
+              _loop_1(scope);
+          }
+          return {
+              meta: meta,
+              columns: columns,
+              data: data
+          };
+      };
+      Workunit.prototype.fetchDetailsNormalized = function (request) {
+          var _this = this;
+          if (request === void 0) { request = {}; }
+          return Promise.all([this.fetchDetailsMeta(), this.fetchDetailsRaw(request)]).then(function (promises) {
+              return _this.normalizeDetails(promises[0], promises[1]);
           });
       };
       Workunit.prototype.fetchInfo = function (request) {
@@ -8237,7 +8246,750 @@
       return Topology;
   }(util.StateObject));
 
+  //  Ported from:  https://github.com/hpcc-systems/HPCC-Platform/blob/f0ed9dbeca49c39fb55aa28fec295c89407ac663/esp/src/src/ESPGraph.ts
+  function safeAssign(obj, key, value) {
+      if (key === "__proto__" || key === "constructor" || key === "prototype")
+          return;
+      obj[key] = value;
+  }
+  function xmlEncode(str) {
+      str = "" + str;
+      return str.replace(/&/g, "&amp;")
+          .replace(/"/g, "&quot;")
+          .replace(/'/g, "&apos;")
+          .replace(/</g, "&lt;")
+          .replace(/>/g, "&gt;")
+          .replace(/\n/g, "&#10;")
+          .replace(/\r/g, "&#13;");
+  }
+  function espTime2Seconds(duration) {
+      if (!duration) {
+          return 0;
+      }
+      else if (!isNaN(+duration)) {
+          return parseFloat(duration);
+      }
+      var re = /(?:(?:(\d+).days.)?(?:(\d+)h)?(?:(\d+)m)?(?:(\d+\.\d+|\d+)s))|(?:(\d+\.\d+|\d+)ms|(\d+\.\d+|\d+)us|(\d+\.\d+|\d+)ns)/;
+      var match = re.exec(duration);
+      if (!match)
+          return 0;
+      var days = +match[1] || 0;
+      var hours = +match[2] || 0;
+      var mins = +match[3] || 0;
+      var secs = +match[4] || 0;
+      var ms = +match[5] || 0;
+      var us = +match[6] || 0;
+      var ns = +match[7] || 0;
+      return (days * 24 * 60 * 60) + (hours * 60 * 60) + (mins * 60) + secs + ms / 1000 + us / 1000000 + ns / 1000000000;
+  }
+  function unitTest(size, unit) {
+      var nsIndex = size.indexOf(unit);
+      if (nsIndex !== -1) {
+          return parseFloat(size.substring(0, nsIndex));
+      }
+      return -1;
+  }
+  function espSize2Bytes(size) {
+      if (!size) {
+          return 0;
+      }
+      else if (!isNaN(+size)) {
+          return parseFloat(size);
+      }
+      var retVal = unitTest(size, "Kb");
+      if (retVal >= 0) {
+          return retVal * 1024;
+      }
+      retVal = unitTest(size, "Mb");
+      if (retVal >= 0) {
+          return retVal * Math.pow(1024, 2);
+      }
+      retVal = unitTest(size, "Gb");
+      if (retVal >= 0) {
+          return retVal * Math.pow(1024, 3);
+      }
+      retVal = unitTest(size, "Tb");
+      if (retVal >= 0) {
+          return retVal * Math.pow(1024, 4);
+      }
+      retVal = unitTest(size, "Pb");
+      if (retVal >= 0) {
+          return retVal * Math.pow(1024, 5);
+      }
+      retVal = unitTest(size, "Eb");
+      if (retVal >= 0) {
+          return retVal * Math.pow(1024, 6);
+      }
+      retVal = unitTest(size, "Zb");
+      if (retVal >= 0) {
+          return retVal * Math.pow(1024, 7);
+      }
+      retVal = unitTest(size, "b");
+      if (retVal >= 0) {
+          return retVal;
+      }
+      return 0;
+  }
+  function espSkew2Number(skew) {
+      if (!skew) {
+          return 0;
+      }
+      return parseFloat(skew);
+  }
+  var GRAPH_TYPE;
+  (function (GRAPH_TYPE) {
+      GRAPH_TYPE[GRAPH_TYPE["UNKNOWN"] = 0] = "UNKNOWN";
+      GRAPH_TYPE[GRAPH_TYPE["GRAPH"] = 1] = "GRAPH";
+      GRAPH_TYPE[GRAPH_TYPE["SUBGRAPH"] = 2] = "SUBGRAPH";
+      GRAPH_TYPE[GRAPH_TYPE["VERTEX"] = 3] = "VERTEX";
+      GRAPH_TYPE[GRAPH_TYPE["EDGE"] = 4] = "EDGE";
+      GRAPH_TYPE[GRAPH_TYPE["LAST"] = 5] = "LAST";
+  })(GRAPH_TYPE || (GRAPH_TYPE = {}));
+  var GRAPH_TYPE_STRING;
+  (function (GRAPH_TYPE_STRING) {
+      GRAPH_TYPE_STRING["UNKNOWN"] = "Unknown";
+      GRAPH_TYPE_STRING["GRAPH"] = "Graph";
+      GRAPH_TYPE_STRING["SUBGRAPH"] = "Cluster";
+      GRAPH_TYPE_STRING["VERTEX"] = "Vertex";
+      GRAPH_TYPE_STRING["EDGE"] = "Edge";
+      GRAPH_TYPE_STRING["LAST"] = "Last";
+  })(GRAPH_TYPE_STRING || (GRAPH_TYPE_STRING = {}));
+  var LocalisedXGMMLWriter = /** @class */ (function () {
+      function LocalisedXGMMLWriter(graph) {
+          this.graph = graph;
+          this.m_xgmml = "";
+          this.m_visibleSubgraphs = {};
+          this.m_visibleVertices = {};
+          this.m_semiVisibleVertices = {};
+          this.m_visibleEdges = {};
+      }
+      LocalisedXGMMLWriter.prototype.calcVisibility = function (items, localisationDepth, localisationDistance, noSpills) {
+          var _this = this;
+          this.noSpills = noSpills;
+          items.forEach(function (item) {
+              if (_this.graph.isVertex(item)) {
+                  _this.calcInVertexVisibility(item, localisationDistance);
+                  _this.calcOutVertexVisibility(item, localisationDistance);
+              }
+              else if (_this.graph.isEdge(item)) {
+                  _this.calcInVertexVisibility(item.getSource(), localisationDistance - 1);
+                  _this.calcOutVertexVisibility(item.getTarget(), localisationDistance - 1);
+              }
+              else if (_this.graph.isSubgraph(item)) {
+                  _this.m_visibleSubgraphs[item.__hpcc_id] = item;
+                  _this.calcSubgraphVisibility(item, localisationDepth - 1);
+              }
+          });
+          this.calcVisibility2();
+      };
+      LocalisedXGMMLWriter.prototype.calcInVertexVisibility = function (vertex, localisationDistance) {
+          var _this = this;
+          if (this.noSpills && vertex.isSpill()) {
+              localisationDistance++;
+          }
+          this.m_visibleVertices[vertex.__hpcc_id] = vertex;
+          if (localisationDistance > 0) {
+              vertex.getInEdges().forEach(function (edge) {
+                  _this.calcInVertexVisibility(edge.getSource(), localisationDistance - 1);
+              });
+          }
+      };
+      LocalisedXGMMLWriter.prototype.calcOutVertexVisibility = function (vertex, localisationDistance) {
+          var _this = this;
+          if (this.noSpills && vertex.isSpill()) {
+              localisationDistance++;
+          }
+          this.m_visibleVertices[vertex.__hpcc_id] = vertex;
+          if (localisationDistance > 0) {
+              vertex.getOutEdges().forEach(function (edge) {
+                  _this.calcOutVertexVisibility(edge.getTarget(), localisationDistance - 1);
+              });
+          }
+      };
+      LocalisedXGMMLWriter.prototype.calcSubgraphVisibility = function (subgraph, localisationDepth) {
+          var _this = this;
+          if (localisationDepth < 0) {
+              return;
+          }
+          if (localisationDepth > 0) {
+              subgraph.__hpcc_subgraphs.forEach(function (subgraph, idx) {
+                  _this.calcSubgraphVisibility(subgraph, localisationDepth - 1);
+              });
+          }
+          subgraph.__hpcc_subgraphs.forEach(function (subgraph, idx) {
+              _this.m_visibleSubgraphs[subgraph.__hpcc_id] = subgraph;
+          });
+          subgraph.__hpcc_vertices.forEach(function (vertex, idx) {
+              _this.m_visibleVertices[vertex.__hpcc_id] = vertex;
+          });
+          //  Calculate edges that pass through the subgraph  ---
+          var dedupEdges = {};
+          this.graph.edges.forEach(function (edge, idx) {
+              if (edge.getSource().__hpcc_parent !== edge.getTarget().__hpcc_parent && subgraph === _this.getCommonAncestor(edge)) {
+                  //  Only include one unique edge between subgraphs  ---
+                  if (!dedupEdges[edge.getSource().__hpcc_parent.__hpcc_id + "::" + edge.getTarget().__hpcc_parent.__hpcc_id]) {
+                      dedupEdges[edge.getSource().__hpcc_parent.__hpcc_id + "::" + edge.getTarget().__hpcc_parent.__hpcc_id] = true;
+                      _this.m_visibleEdges[edge.__hpcc_id] = edge;
+                  }
+              }
+          });
+      };
+      LocalisedXGMMLWriter.prototype.buildVertexString = function (vertex, isPoint) {
+          var attrStr = "";
+          var propsStr = "";
+          var props = vertex.getProperties();
+          for (var key in props) {
+              if (isPoint && key.indexOf("_kind") >= 0) {
+                  propsStr += "<att name=\"_kind\" value=\"point\"/>";
+              }
+              else if (key === "id" || key === "label") {
+                  attrStr += " " + key + "=\"" + xmlEncode(props[key]) + "\"";
+              }
+              else {
+                  propsStr += "<att name=\"" + key + "\" value=\"" + xmlEncode(props[key]) + "\"/>";
+              }
+          }
+          return "<node" + attrStr + ">" + propsStr + "</node>";
+      };
+      LocalisedXGMMLWriter.prototype.buildEdgeString = function (edge) {
+          var attrStr = "";
+          var propsStr = "";
+          var props = edge.getProperties();
+          for (var key in props) {
+              if (key.toLowerCase() === "id" ||
+                  key.toLowerCase() === "label" ||
+                  key.toLowerCase() === "source" ||
+                  key.toLowerCase() === "target") {
+                  attrStr += " " + key + "=\"" + xmlEncode(props[key]) + "\"";
+              }
+              else {
+                  propsStr += "<att name=\"" + key + "\" value=\"" + xmlEncode(props[key]) + "\"/>";
+              }
+          }
+          return "<edge" + attrStr + ">" + propsStr + "</edge>";
+      };
+      LocalisedXGMMLWriter.prototype.getAncestors = function (v, ancestors) {
+          var parent = v.__hpcc_parent;
+          while (parent) {
+              ancestors.push(parent);
+              parent = parent.__hpcc_parent;
+          }
+      };
+      LocalisedXGMMLWriter.prototype.getCommonAncestorV = function (v1, v2) {
+          var v1_ancestors = [];
+          var v2_ancestors = [];
+          this.getAncestors(v1, v1_ancestors);
+          this.getAncestors(v2, v2_ancestors);
+          var finger1 = v1_ancestors.length - 1;
+          var finger2 = v2_ancestors.length - 1;
+          var retVal = null;
+          while (finger1 >= 0 && finger2 >= 0 && v1_ancestors[finger1] === v2_ancestors[finger2]) {
+              retVal = v1_ancestors[finger1];
+              --finger1;
+              --finger2;
+          }
+          return retVal;
+      };
+      LocalisedXGMMLWriter.prototype.getCommonAncestor = function (e) {
+          return this.getCommonAncestorV(e.getSource(), e.getTarget());
+      };
+      LocalisedXGMMLWriter.prototype.calcAncestorVisibility = function (vertex) {
+          var _this = this;
+          var ancestors = [];
+          this.getAncestors(vertex, ancestors);
+          ancestors.forEach(function (item, idx) {
+              _this.m_visibleSubgraphs[item.__hpcc_id] = item;
+          });
+      };
+      LocalisedXGMMLWriter.prototype.calcVisibility2 = function () {
+          var _this = this;
+          for (var key in this.m_visibleVertices) {
+              var vertex = this.m_visibleVertices[key];
+              vertex.getInEdges().forEach(function (edge, idx) {
+                  _this.m_visibleEdges[edge.__hpcc_id] = edge;
+              });
+              vertex.getOutEdges().forEach(function (edge, idx) {
+                  _this.m_visibleEdges[edge.__hpcc_id] = edge;
+              });
+              this.calcAncestorVisibility(vertex);
+          }
+          this.calcSemiVisibleVertices();
+      };
+      LocalisedXGMMLWriter.prototype.addSemiVisibleEdge = function (edge) {
+          if (edge && !this.m_visibleEdges[edge.__hpcc_id]) {
+              this.m_visibleEdges[edge.__hpcc_id] = edge;
+          }
+      };
+      LocalisedXGMMLWriter.prototype.addSemiVisibleVertex = function (vertex) {
+          if (!this.m_visibleVertices[vertex.__hpcc_id]) {
+              this.m_semiVisibleVertices[vertex.__hpcc_id] = vertex;
+              this.calcAncestorVisibility(vertex);
+          }
+      };
+      LocalisedXGMMLWriter.prototype.calcSemiVisibleVertices = function () {
+          for (var key in this.m_visibleEdges) {
+              var edge = this.m_visibleEdges[key];
+              var source = edge.getSource();
+              this.addSemiVisibleVertex(source);
+              while (this.noSpills && source.isSpill()) {
+                  var inEdges = source.getInEdges();
+                  if (inEdges.length) {
+                      this.addSemiVisibleEdge(inEdges[0]);
+                      source = inEdges[0].getSource();
+                      this.addSemiVisibleVertex(source);
+                  }
+                  else {
+                      break;
+                  }
+              }
+              var target = edge.getTarget();
+              this.addSemiVisibleVertex(target);
+              while (this.noSpills && target.isSpill()) {
+                  var outEdges = target.getOutEdges();
+                  if (outEdges.length) {
+                      this.addSemiVisibleEdge(outEdges[0]);
+                      target = outEdges[0].getTarget();
+                      this.addSemiVisibleVertex(target);
+                  }
+                  else {
+                      break;
+                  }
+              }
+          }
+      };
+      LocalisedXGMMLWriter.prototype.writeXgmml = function () {
+          var _this = this;
+          this.subgraphVisited(this.graph.subgraphs[0], true);
+          this.graph.edges.forEach(function (edge, idx) {
+              _this.edgeVisited(edge);
+          });
+      };
+      LocalisedXGMMLWriter.prototype.subgraphVisited = function (subgraph, root) {
+          if (root === void 0) { root = false; }
+          if (this.m_visibleSubgraphs[subgraph.__hpcc_id]) {
+              var propsStr = "";
+              this.m_xgmml += root ? "" : "<node id=\"" + subgraph.__hpcc_id + "\"><att><graph>";
+              var xgmmlLen = this.m_xgmml.length;
+              subgraph.walkSubgraphs(this);
+              subgraph.walkVertices(this);
+              if (xgmmlLen === this.m_xgmml.length) {
+                  //  Add at least one child otherwise subgraphs will render as a vertex  ---
+                  var vertex = subgraph.__hpcc_vertices[0];
+                  if (vertex) {
+                      this.m_xgmml += this.buildVertexString(vertex, true);
+                  }
+              }
+              var props = subgraph.getProperties();
+              for (var key in props) {
+                  propsStr += "<att name=\"" + key + "\" value=\"" + xmlEncode(props[key]) + "\"/>";
+              }
+              this.m_xgmml += root ? "" : "</graph></att>" + propsStr + "</node>";
+          }
+          return false;
+      };
+      LocalisedXGMMLWriter.prototype.vertexVisited = function (vertex) {
+          if (this.m_visibleVertices[vertex.__hpcc_id]) {
+              this.m_xgmml += this.buildVertexString(vertex, false);
+          }
+          else if (this.m_semiVisibleVertices[vertex.__hpcc_id]) {
+              this.m_xgmml += this.buildVertexString(vertex, true);
+          }
+      };
+      LocalisedXGMMLWriter.prototype.edgeVisited = function (edge) {
+          if (this.m_visibleEdges[edge.__hpcc_id]) {
+              this.m_xgmml += this.buildEdgeString(edge);
+          }
+      };
+      return LocalisedXGMMLWriter;
+  }());
+  var GraphItem = /** @class */ (function () {
+      function GraphItem(graph, id) {
+          this.__hpcc_graph = graph;
+          this.__hpcc_id = id;
+          this._globalID = id;
+      }
+      GraphItem.prototype.getProperties = function () {
+          var retVal = {};
+          for (var key in this) {
+              if (key.indexOf("__") !== 0 && this.hasOwnProperty(key)) {
+                  retVal[key] = this[key];
+              }
+          }
+          return retVal;
+      };
+      return GraphItem;
+  }());
+  var Subgraph = /** @class */ (function (_super) {
+      __extends(Subgraph, _super);
+      function Subgraph(graph, id) {
+          var _this = _super.call(this, graph, id) || this;
+          _this._globalType = id === "0" ? "Graph" : "Cluster";
+          _this.__hpcc_subgraphs = [];
+          _this.__hpcc_vertices = [];
+          _this.__hpcc_edges = [];
+          _this.id = id;
+          return _this;
+      }
+      Subgraph.prototype.addSubgraph = function (subgraph) {
+          subgraph.__hpcc_parent = this;
+          if (!this.__hpcc_subgraphs.some(function (subgraph2) { return subgraph === subgraph2; })) {
+              this.__hpcc_subgraphs.push(subgraph);
+          }
+      };
+      Subgraph.prototype.addVertex = function (vertex) {
+          vertex.__hpcc_parent = this;
+          if (!this.__hpcc_vertices.some(function (vertex2) { return vertex === vertex2; })) {
+              this.__hpcc_vertices.push(vertex);
+          }
+      };
+      Subgraph.prototype.removeVertex = function (vertex) {
+          this.__hpcc_vertices = this.__hpcc_vertices.filter(function (vertex2) { return vertex !== vertex2; });
+      };
+      Subgraph.prototype.addEdge = function (edge) {
+          edge.__hpcc_parent = this;
+          if (!this.__hpcc_edges.some(function (edge2) { return edge === edge2; })) {
+              this.__hpcc_edges.push(edge);
+          }
+      };
+      Subgraph.prototype.removeEdge = function (edge) {
+          this.__hpcc_edges = this.__hpcc_edges.filter(function (edge2) { return edge !== edge2; });
+      };
+      Subgraph.prototype.remove = function () {
+          var _this = this;
+          this.__hpcc_subgraphs.forEach(function (subgraph) { return subgraph.__hpcc_parent = _this.__hpcc_parent; });
+          this.__hpcc_vertices.forEach(function (vertex) { return vertex.__hpcc_parent = _this.__hpcc_parent; });
+          this.__hpcc_edges.forEach(function (edge) { return edge.__hpcc_parent = _this.__hpcc_parent; });
+          delete this.__hpcc_parent;
+          this.__hpcc_graph.removeItem(this);
+      };
+      Subgraph.prototype.walkSubgraphs = function (visitor) {
+          this.__hpcc_subgraphs.forEach(function (subgraph, idx) {
+              if (visitor.subgraphVisited(subgraph)) {
+                  subgraph.walkSubgraphs(visitor);
+              }
+          });
+      };
+      Subgraph.prototype.walkVertices = function (visitor) {
+          this.__hpcc_vertices.forEach(function (vertex, idx) {
+              visitor.vertexVisited(vertex);
+          });
+      };
+      return Subgraph;
+  }(GraphItem));
+  var Vertex = /** @class */ (function (_super) {
+      __extends(Vertex, _super);
+      function Vertex(graph, id) {
+          var _this = _super.call(this, graph, id) || this;
+          _this._globalType = "Vertex";
+          return _this;
+      }
+      Vertex.prototype.isSpill = function () {
+          return this._isSpill;
+      };
+      Vertex.prototype.remove = function () {
+          var _a;
+          var inVertices = this.getInVertices();
+          if (inVertices.length <= 1) {
+              console.warn(this.__hpcc_id + ":  remove only supports single or zero inputs activities...");
+          }
+          this.getInEdges().forEach(function (edge) {
+              edge.remove();
+          });
+          this.getOutEdges().forEach(function (edge) {
+              edge.setSource(inVertices[0]);
+          });
+          (_a = this.__hpcc_parent) === null || _a === void 0 ? void 0 : _a.removeVertex(this);
+          this.__hpcc_graph.removeItem(this);
+      };
+      Vertex.prototype.getInVertices = function () {
+          return this.getInEdges().map(function (edge) {
+              return edge.getSource();
+          });
+      };
+      Vertex.prototype.getInEdges = function () {
+          var _this = this;
+          return this.__hpcc_graph.edges.filter(function (edge) {
+              return edge.getTarget() === _this;
+          });
+      };
+      Vertex.prototype.getOutVertices = function () {
+          return this.getOutEdges().map(function (edge) {
+              return edge.getTarget();
+          });
+      };
+      Vertex.prototype.getOutEdges = function () {
+          var _this = this;
+          return this.__hpcc_graph.edges.filter(function (edge) {
+              return edge.getSource() === _this;
+          });
+      };
+      return Vertex;
+  }(GraphItem));
+  var Edge = /** @class */ (function (_super) {
+      __extends(Edge, _super);
+      function Edge(graph, id) {
+          var _this = _super.call(this, graph, id) || this;
+          _this._globalType = "Edge";
+          _this._globalType = "Edge";
+          return _this;
+      }
+      Edge.prototype.remove = function () {
+          var _this = this;
+          this.__hpcc_graph.subgraphs.forEach(function (subgraph) {
+              subgraph.removeEdge(_this);
+          });
+          this.__hpcc_graph.removeItem(this);
+      };
+      Edge.prototype.getSource = function () {
+          return this.__hpcc_graph.idx[this._sourceActivity || this.source];
+      };
+      Edge.prototype.setSource = function (source) {
+          if (this._sourceActivity) {
+              this._sourceActivity = source.__hpcc_id;
+          }
+          else if (this.source) {
+              this.source = source.__hpcc_id;
+          }
+          if (this.__widget) {
+              this.__widget.setSource(this.getSource().__widget);
+          }
+      };
+      Edge.prototype.getTarget = function () {
+          return this.__hpcc_graph.idx[this._targetActivity || this.target];
+      };
+      return Edge;
+  }(GraphItem));
+  var QueryGraph = /** @class */ (function () {
+      function QueryGraph() {
+          this.idx = {};
+          this.subgraphs = [];
+          this.vertices = [];
+          this.edges = [];
+          this.xgmml = "";
+          this.clear();
+      }
+      QueryGraph.prototype.clear = function () {
+          this.xgmml = "";
+          this.idx = {};
+          this.subgraphs = [];
+          this.vertices = [];
+          this.edges = [];
+      };
+      QueryGraph.prototype.load = function (xgmml) {
+          this.clear();
+          this.merge(xgmml);
+      };
+      QueryGraph.prototype.merge = function (xgmml) {
+          this.xgmml = xgmml;
+          var parser = new DOMParser();
+          var dom = parser.parseFromString(xgmml, "text/xml");
+          this.walkDocument(dom.documentElement, "0");
+      };
+      QueryGraph.prototype.isSubgraph = function (item) {
+          return item instanceof Subgraph;
+      };
+      QueryGraph.prototype.isVertex = function (item) {
+          return item instanceof Vertex;
+      };
+      QueryGraph.prototype.isEdge = function (item) {
+          return item instanceof Edge;
+      };
+      QueryGraph.prototype.getGlobalType = function (item) {
+          if (item instanceof Vertex) {
+              return GRAPH_TYPE.VERTEX;
+          }
+          else if (item instanceof Edge) {
+              return GRAPH_TYPE.EDGE;
+          }
+          else if (item instanceof Subgraph) {
+              return GRAPH_TYPE.SUBGRAPH;
+          }
+          else if (item instanceof QueryGraph) {
+              return GRAPH_TYPE.GRAPH;
+          }
+          return GRAPH_TYPE.UNKNOWN;
+      };
+      QueryGraph.prototype.getGlobalTypeString = function (item) {
+          if (item instanceof Vertex) {
+              return GRAPH_TYPE_STRING.VERTEX;
+          }
+          else if (item instanceof Edge) {
+              return GRAPH_TYPE_STRING.EDGE;
+          }
+          else if (item instanceof Subgraph) {
+              return GRAPH_TYPE_STRING.SUBGRAPH;
+          }
+          else if (item instanceof QueryGraph) {
+              return GRAPH_TYPE_STRING.GRAPH;
+          }
+          return GRAPH_TYPE_STRING.UNKNOWN;
+      };
+      QueryGraph.prototype.getItem = function (docNode, id) {
+          if (!this.idx[id]) {
+              switch (docNode.tagName) {
+                  case "graph":
+                      var subgraph = new Subgraph(this, id);
+                      this.subgraphs.push(subgraph);
+                      this.idx[id] = subgraph;
+                      break;
+                  case "node":
+                      var vertex = new Vertex(this, id);
+                      this.vertices.push(vertex);
+                      this.idx[id] = vertex;
+                      break;
+                  case "edge":
+                      var edge = new Edge(this, id);
+                      this.edges.push(edge);
+                      this.idx[id] = edge;
+                      break;
+                  default:
+                      console.warn("Graph.getItem - Unknown Node Type!");
+                      break;
+              }
+          }
+          var retVal = this.idx[id];
+          Array.from(docNode.attributes).forEach(function (attr) {
+              safeAssign(retVal, attr.name, attr.value);
+          });
+          return retVal;
+      };
+      QueryGraph.prototype.removeItem = function (item) {
+          delete this.idx[item.__hpcc_id];
+          if (item instanceof Subgraph) {
+              this.subgraphs = this.subgraphs.filter(function (subgraph) {
+                  return item !== subgraph;
+              });
+          }
+          else if (item instanceof Vertex) {
+              this.vertices = this.vertices.filter(function (vertex) {
+                  return item !== vertex;
+              });
+          }
+          else if (item instanceof Edge) {
+              this.edges = this.edges.filter(function (edge) {
+                  return item !== edge;
+              });
+          }
+      };
+      QueryGraph.prototype.getChildByTagName = function (docNode, tagName) {
+          var retVal = null;
+          Array.from(docNode.childNodes).some(function (childNode, idx) {
+              if (childNode.tagName === tagName) {
+                  retVal = childNode;
+                  return true;
+              }
+          });
+          return retVal;
+      };
+      QueryGraph.prototype.walkDocument = function (docNode, id) {
+          var _this = this;
+          var retVal = this.getItem(docNode, id);
+          docNode.childNodes.forEach(function (childNode, idx) {
+              switch (childNode.nodeType) {
+                  case 1: // 	ELEMENT_NODE
+                      switch (childNode.tagName) {
+                          case "graph":
+                              break;
+                          case "node":
+                              var isSubgraph = false;
+                              var attNode = _this.getChildByTagName(childNode, "att");
+                              if (attNode) {
+                                  var graphNode = _this.getChildByTagName(attNode, "graph");
+                                  if (graphNode) {
+                                      isSubgraph = true;
+                                      var subgraph = _this.walkDocument(graphNode, childNode.getAttribute("id"));
+                                      retVal.addSubgraph(subgraph);
+                                  }
+                              }
+                              if (!isSubgraph) {
+                                  var vertex = _this.walkDocument(childNode, childNode.getAttribute("id"));
+                                  retVal.addVertex(vertex);
+                              }
+                              break;
+                          case "att":
+                              var name_1 = childNode.getAttribute("name");
+                              var uname = "_" + name_1;
+                              var value = childNode.getAttribute("value");
+                              if (name_1.indexOf("Time") === 0) {
+                                  safeAssign(retVal, uname, value);
+                                  safeAssign(retVal, name_1, "" + espTime2Seconds(value));
+                              }
+                              else if (name_1.indexOf("Size") === 0) {
+                                  safeAssign(retVal, uname, value);
+                                  safeAssign(retVal, name_1, "" + espSize2Bytes(value));
+                              }
+                              else if (name_1.indexOf("Skew") === 0) {
+                                  safeAssign(retVal, uname, value);
+                                  safeAssign(retVal, name_1, "" + espSkew2Number(value));
+                              }
+                              else {
+                                  safeAssign(retVal, name_1, value);
+                              }
+                              break;
+                          case "edge":
+                              var edge = _this.walkDocument(childNode, childNode.getAttribute("id"));
+                              if (edge.NumRowsProcessed !== undefined) {
+                                  edge._eclwatchCount = edge.NumRowsProcessed.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+                              }
+                              else if (edge.Count !== undefined) {
+                                  edge._eclwatchCount = edge.Count.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+                              }
+                              else if (edge.count !== undefined) {
+                                  edge._eclwatchCount = edge.count.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+                              }
+                              if (edge.inputProgress) {
+                                  edge._eclwatchInputProgress = "[" + edge.inputProgress.replace(/\B(?=(\d{3})+(?!\d))/g, ",") + "]";
+                              }
+                              if (edge.SkewMaxRowsProcessed && edge.SkewMinRowsProcessed) {
+                                  edge._eclwatchSkew = "+" + edge.SkewMaxRowsProcessed + ", " + edge.SkewMinRowsProcessed;
+                              }
+                              if (edge._dependsOn) ;
+                              else if (edge._childGraph) ;
+                              else if (edge._sourceActivity || edge._targetActivity) {
+                                  edge._isSpill = true;
+                                  var source = edge.getSource();
+                                  source._isSpill = true;
+                                  var target = edge.getTarget();
+                                  target._isSpill = true;
+                              }
+                              retVal.addEdge(edge);
+                              break;
+                      }
+                      break;
+              }
+          });
+          return retVal;
+      };
+      QueryGraph.prototype.removeSubgraphs = function () {
+          var subgraphs = __spreadArray([], this.subgraphs, true);
+          subgraphs.forEach(function (subgraph) {
+              if (subgraph.__hpcc_parent instanceof Subgraph) {
+                  subgraph.remove();
+              }
+          });
+      };
+      QueryGraph.prototype.removeSpillVertices = function () {
+          var vertices = __spreadArray([], this.vertices, true);
+          vertices.forEach(function (vertex) {
+              if (vertex.isSpill()) {
+                  vertex.remove();
+              }
+          });
+      };
+      QueryGraph.prototype.getLocalisedXGMML = function (items, localisationDepth, localisationDistance, noSpills) {
+          var xgmmlWriter = new LocalisedXGMMLWriter(this);
+          xgmmlWriter.calcVisibility(items, localisationDepth, localisationDistance, noSpills);
+          xgmmlWriter.writeXgmml();
+          return "<graph>" + xgmmlWriter.m_xgmml + "</graph>";
+      };
+      return QueryGraph;
+  }());
+
   var logger$1 = util.scopedLogger("@hpcc-js/comms/ecl/query.ts");
+  var siFormatter = format("~s");
+  function isNumber(n) {
+      return !isNaN(parseFloat(n)) && !isNaN(n - 0);
+  }
   var QueryCache = /** @class */ (function (_super) {
       __extends(QueryCache, _super);
       function QueryCache() {
@@ -8513,6 +9265,66 @@
       Query.prototype.fetchSummaryStats = function () {
           return this.wsWorkunitsService.WUQueryGetSummaryStats({ Target: this.QuerySet, QueryId: this.QueryId });
       };
+      Query.prototype.fetchGraph = function (GraphName, SubGraphId) {
+          if (GraphName === void 0) { GraphName = ""; }
+          if (SubGraphId === void 0) { SubGraphId = ""; }
+          return this.wsWorkunitsService.WUQueryGetGraph({ Target: this.QuerySet, QueryId: this.QueryId, GraphName: GraphName, SubGraphId: SubGraphId }).then(function (response) {
+              var _a;
+              var graph = new QueryGraph();
+              var first = true;
+              for (var _i = 0, _b = ((_a = response === null || response === void 0 ? void 0 : response.Graphs) === null || _a === void 0 ? void 0 : _a.ECLGraphEx) || []; _i < _b.length; _i++) {
+                  var graphItem = _b[_i];
+                  if (first) {
+                      graph.load(graphItem.Graph);
+                      first = false;
+                  }
+                  else {
+                      graph.merge(graphItem.Graph);
+                  }
+              }
+              return graph;
+          });
+      };
+      Query.prototype.fetchDetailsNormalized = function (request) {
+          if (request === void 0) { request = {}; }
+          var wu = Workunit.attach(this.wsWorkunitsService, this.Wuid);
+          if (wu) {
+              return Promise.all([this.fetchGraph(), wu.fetchDetailsMeta(), wu.fetchDetailsRaw(request)]).then(function (promises) {
+                  var graph = promises[0];
+                  var meta = promises[1];
+                  var metrics = promises[2];
+                  var data = metrics.map(function (metric) {
+                      if (metric.Id[0] === "a" || metric.Id[0] === "e") {
+                          var item = graph.idx[metric.Id.substring(1)];
+                          var _loop_1 = function (key) {
+                              if (key.charAt(0) !== "_" && key.charAt(0) === key.charAt(0).toUpperCase() && (typeof item[key] === "string" || typeof item[key] === "number" || typeof item[key] === "boolean")) {
+                                  if (!metric.Properties.Property.some(function (row) { return row.Name === key; })) {
+                                      var isNum = isNumber(item[key]);
+                                      var rawValue = isNum ? parseFloat(item[key]) : item[key];
+                                      var formatted = item[key];
+                                      if (key.indexOf("Time") >= 0) {
+                                          rawValue = rawValue / 1000000000;
+                                          formatted = siFormatter(rawValue) + "s";
+                                      }
+                                      metric.Properties.Property.push({
+                                          Name: key,
+                                          RawValue: rawValue,
+                                          Formatted: formatted
+                                      });
+                                  }
+                              }
+                          };
+                          for (var key in item) {
+                              _loop_1(key);
+                          }
+                      }
+                      return metric;
+                  });
+                  return wu.normalizeDetails(meta, data);
+              });
+          }
+          return Promise.resolve({ meta: undefined, columns: undefined, data: undefined });
+      };
       Query.prototype.submit = function (request) {
           var _a;
           return __awaiter(this, void 0, void 0, function () {
@@ -9351,6 +10163,7 @@
   exports.PackageProcessService = PackageProcessService;
   exports.PropertyType = PropertyType;
   exports.Query = Query;
+  exports.QueryGraph = QueryGraph;
   exports.RelatedProperty = RelatedProperty;
   exports.Resource = Resource;
   exports.ResourcesService = ResourcesService;