@hpcc-js/eclwatch 3.2.19 → 3.3.0

package/dist/index.js

@@ -1,6 +1,5 @@
 var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key != "symbol" ? key + "" : key, value);
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 import { Editor } from "@hpcc-js/codemirror";
 import { Workunit, BaseScope, Result, WUStateID } from "@hpcc-js/comms";
 import { SplitPanel } from "@hpcc-js/phosphor";
@@ -11,14 +10,16 @@ import { Table, RowFormatter, domConstruct, Deferred, QueryResults, Common } fro
 import { Vertex, Subgraph as Subgraph$1, Edge as Edge$1, Graph } from "@hpcc-js/graph";
 import { Legend, ChartPanel, Carousel } from "@hpcc-js/layout";
 import { ReactTimelineSeries } from "@hpcc-js/timeline";
-const PKG_NAME = "@hpcc-js/eclwatch", PKG_VERSION = "3.1.1", BUILD_VERSION = "3.2.1";
-class ECLArchiveViewer extends SplitPanel {
+const PKG_NAME = "@hpcc-js/eclwatch";
+const PKG_VERSION = "3.1.1";
+const BUILD_VERSION = "3.2.1";
+const _ECLArchiveViewer = class _ECLArchiveViewer extends SplitPanel {
+  _prevHash;
+  _contentStr;
+  _directoryPane = new DirectoryTree();
+  _fileEditorPane = new Editor().text("");
   constructor() {
     super("horizontal");
-    __publicField(this, "_prevHash");
-    __publicField(this, "_contentStr");
-    __publicField(this, "_directoryPane", new DirectoryTree());
-    __publicField(this, "_fileEditorPane", new Editor().text(""));
     this._directoryPane.rowClick = (text) => {
       this._fileEditorPane.text(text).render();
     };
@@ -28,7 +29,7 @@ class ECLArchiveViewer extends SplitPanel {
       label: json.name,
       children: json._children.map(transformNode).filter((n) => n)
     };
-    if (ret.children && ret.children[0] && ret.children[0].label === "html")
+    if (ret.children && ret.children[0] && ret.children[0].label === "html") {
       return {
         label: "root",
         children: [
@@ -38,33 +39,41 @@ class ECLArchiveViewer extends SplitPanel {
           }
         ]
       };
+    }
     return ret;
     function transformNode(node) {
       const _node = {};
-      if (_node.label = node.name + (node.$ && node.$.key ? ` (${node.$.key})` : ""), node._children && node._children.length > 0)
-        _node.children = node._children.map((_node2) => transformNode(_node2)).filter((n) => n);
-      else if (typeof node.content == "string" && node.content.trim())
+      _node.label = node.name + (node["$"] && node["$"].key ? ` (${node["$"].key})` : "");
+      if (node._children && node._children.length > 0) {
+        _node.children = node._children.map((_node2) => {
+          return transformNode(_node2);
+        }).filter((n) => n);
+      } else if (typeof node.content === "string" && node.content.trim()) {
         _node.content = node.content;
-      else
-        return !1;
+      } else {
+        return false;
+      }
       return _node;
     }
+    __name(transformNode, "transformNode");
   }
   updateDirectoryPane(contentStr) {
     let json;
-    if (contentStr)
+    if (contentStr) {
       try {
         json = JSON.parse(contentStr);
-      } catch {
+      } catch (e) {
         json = xml2json(contentStr);
       }
+    }
     if (json) {
       const _data = this.transformArchiveTreeData(json);
       this._directoryPane.data(_data).render();
     }
   }
   enter(domNode, element) {
-    super.enter(domNode, element), this.addWidget(this._directoryPane).addWidget(this._fileEditorPane);
+    super.enter(domNode, element);
+    this.addWidget(this._directoryPane).addWidget(this._fileEditorPane);
   }
   update(domNode, element) {
     super.update(domNode, element);
@@ -72,11 +81,20 @@ class ECLArchiveViewer extends SplitPanel {
       baseUrl: this.baseUrl(),
       wuid: this.wuid()
     });
-    this._prevHash !== hash || typeof this._contentStr > "u" ? Workunit.attach({ baseUrl: this.baseUrl() }, this.wuid()).fetchArchive().then((resp) => {
-      this._contentStr = resp, this.updateDirectoryPane(this._contentStr), this._prevHash = hash;
-    }) : this.updateDirectoryPane(this._contentStr), this.relativeSizes([this.directoryWidthRatio(), 1 - this.directoryWidthRatio()]);
+    if (this._prevHash !== hash || typeof this._contentStr === "undefined") {
+      Workunit.attach({ baseUrl: this.baseUrl() }, this.wuid()).fetchArchive().then((resp) => {
+        this._contentStr = resp;
+        this.updateDirectoryPane(this._contentStr);
+        this._prevHash = hash;
+      });
+    } else {
+      this.updateDirectoryPane(this._contentStr);
+    }
+    this.relativeSizes([this.directoryWidthRatio(), 1 - this.directoryWidthRatio()]);
   }
-}
+};
+__name(_ECLArchiveViewer, "ECLArchiveViewer");
+let ECLArchiveViewer = _ECLArchiveViewer;
 ECLArchiveViewer.prototype._class += " eclwatch_ECLArchiveViewer";
 ECLArchiveViewer.prototype.publish("baseUrl", "", "string", "HPCC Platform Base URL");
 ECLArchiveViewer.prototype.publish("wuid", "", "string", "Workunit ID");
@@ -93,51 +111,59 @@ ECLArchiveViewer.prototype.publishProxy("folderIconClosed", "_directoryPane");
 ECLArchiveViewer.prototype.publishProxy("textFileIcon", "_directoryPane");
 ECLArchiveViewer.prototype.publishProxy("codeFileIcon", "_directoryPane");
 ECLArchiveViewer.prototype.publishProxy("verticalScroll", "_directoryPane");
-class LegendVertex extends Vertex {
+const _LegendVertex = class _LegendVertex extends Vertex {
   constructor() {
     super();
   }
   enter(domNode, element) {
-    super.enter(domNode, element), this._icon.on("click", () => {
+    super.enter(domNode, element);
+    this._icon.on("click", () => {
       this.click(this.data());
     });
   }
   click(kind) {
   }
-}
-class WUGraphLegend extends Legend {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "icon", local());
-    __publicField(this, "_disabled2", {
-      /*  TODO:  Default some to disabled?
-      43: true,
-      71: true,
-      82: true,
-      88: true
-      */
-    });
-  }
+};
+__name(_LegendVertex, "LegendVertex");
+let LegendVertex = _LegendVertex;
+const _WUGraphLegend = class _WUGraphLegend extends Legend {
+  icon = local();
+  _disabled2 = {
+    /*  TODO:  Default some to disabled?
+    43: true,
+    71: true,
+    82: true,
+    88: true
+    */
+  };
   disabled(_) {
     if (!arguments.length) {
       const retVal = [];
-      for (const key in this._disabled2)
-        this._disabled2[key] && retVal.push(key);
+      for (const key in this._disabled2) {
+        if (this._disabled2[key]) {
+          retVal.push(key);
+        }
+      }
       return retVal;
     }
-    return this._disabled2 = {}, _.forEach((kind) => this._disabled2[kind] = !0), this;
+    this._disabled2 = {};
+    _.forEach((kind) => this._disabled2[kind] = true);
+    return this;
   }
   toggle(kind) {
     this._disabled2[kind] = !this._disabled2[kind];
   }
   update(domNode, element) {
     super.update(domNode, element);
-    const context = this, items = this._g.selectAll(".legendItem").data(this.data(), (d) => d.kind);
+    const context = this;
+    const items = this._g.selectAll(".legendItem").data(this.data(), (d) => d.kind);
     items.enter().append("g").attr("class", "legendItem").each(function(d) {
       context.icon.set(
         this,
         new LegendVertex().target(this).data(d.kind).textbox_shape_colorStroke("none").textbox_shape_colorFill("none").iconAnchor("left").faChar(d.faChar).text(`${d.label} (${d.count})`).tooltip(`${d.kind} - ${d.label}`).on("click", (kind) => {
-          context.toggle(kind), context.render(), context.click(kind);
+          context.toggle(kind);
+          context.render();
+          context.click(kind);
         }).on("mouseover", (kind) => {
           context.mouseover(kind);
         }).on("mouseout", (kind) => {
@@ -147,10 +173,11 @@ class WUGraphLegend extends Legend {
     }).merge(items).each(function(d, i) {
       const bbox2 = context.icon.get(this).icon_shape_colorFill(context._disabled2[d.kind] ? "gray" : null).render().getBBox();
       select(this).attr("transform", `translate(${+bbox2.width / 2}, ${i * 30})`);
-    }), items.exit().each(function(d) {
+    });
+    items.exit().each(function(d) {
       context.icon.get(this).target(null).render();
     }).remove();
-    const bbox = this.getBBox(!0, !0);
+    const bbox = this.getBBox(true, true);
     this._g.attr("transform", `translate(16, ${this.height() / 2 - bbox.height / 2})`);
   }
   //  Events  ---
@@ -160,118 +187,171 @@ class WUGraphLegend extends Legend {
   }
   mouseout(kind) {
   }
-}
+};
+__name(_WUGraphLegend, "WUGraphLegend");
+let WUGraphLegend = _WUGraphLegend;
 WUGraphLegend.prototype._class += " eclwatch_WUGraphLegend";
 function faCharFactory(kind) {
   switch (kind) {
     case "2":
       return "";
+    //  Disk Write
     case "3":
       return "";
+    //  sort
     case "5":
       return "";
+    //  Filter
     case "6":
       return "";
+    //  Split
     case "12":
       return "";
+    //  First N
     case "15":
       return "";
+    //  Lightweight Join
     case "17":
       return "";
+    //  Lookup Join
     case "22":
       return "";
+    //  Pipe Output
     case "23":
       return "";
+    //  Funnel
     case "25":
       return "";
+    //  Inline Dataset
     case "26":
       return "";
+    //  distribute
     case "29":
       return "";
+    //  Store Internal Result
     case "36":
       return "";
+    //  If
     case "44":
       return "";
+    //  write csv
     case "47":
       return "";
+    //  write
     case "54":
       return "";
+    //  Workunit Read
     case "56":
       return "";
+    //  Spill
     case "59":
       return "";
+    //  Merge
     case "61":
       return "";
+    //  write xml
     case "82":
       return "";
+    //  Projected Disk Read Spill
     case "88":
       return "";
+    //  Projected Disk Read Spill
     case "92":
       return "";
+    //  Limted Index Read
     case "93":
       return "";
+    //  Limted Index Read
     case "99":
       return "";
+    //  CSV Read
     case "105":
       return "";
+    //  CSV Read
     case "7":
       return "";
+    //  Project
     case "9":
       return "";
+    //  Local Iterate
     case "16":
       return "";
+    //  Output Internal
     case "19":
       return "";
+    //  Hash Distribute
     case "21":
       return "";
+    //  Normalize
     case "35":
       return "";
+    //  CSV Write
     case "37":
       return "";
+    //  Index Write
     case "71":
       return "";
+    //  Disk Read Spill
     case "133":
       return "";
+    //  Inline Dataset
     case "148":
       return "";
+    //  Inline Dataset
     case "168":
       return "";
   }
   return "";
 }
-class WUScopeController {
+__name(faCharFactory, "faCharFactory");
+const _WUScopeController = class _WUScopeController {
+  graphDB;
+  subgraphsMap = {};
+  rSubgraphsMap = {};
+  verticesMap = {};
+  rVerticesMap = {};
+  edgesMap = {};
+  rEdgesMap = {};
+  kindMap = {};
+  _disabled = {};
   constructor() {
-    __publicField(this, "graphDB");
-    __publicField(this, "subgraphsMap", {});
-    __publicField(this, "rSubgraphsMap", {});
-    __publicField(this, "verticesMap", {});
-    __publicField(this, "rVerticesMap", {});
-    __publicField(this, "edgesMap", {});
-    __publicField(this, "rEdgesMap", {});
-    __publicField(this, "kindMap", {});
-    __publicField(this, "_disabled", {});
   }
   clear() {
-    this.subgraphsMap = {}, this.rSubgraphsMap = {}, this.verticesMap = {}, this.rVerticesMap = {}, this.edgesMap = {}, this.rEdgesMap = {};
+    this.subgraphsMap = {};
+    this.rSubgraphsMap = {};
+    this.verticesMap = {};
+    this.rVerticesMap = {};
+    this.edgesMap = {};
+    this.rEdgesMap = {};
   }
   set(masterGraph) {
-    this.graphDB = masterGraph, this.graphGui(this.graphDB), this.kindMap = {}, this.graphDB.walk((item) => {
-      if (!(item instanceof Subgraph)) {
-        if (item instanceof Vertex$1) {
-          const kind = item._.attr("Kind").RawValue;
-          this.kindMap[kind] || (this.kindMap[kind] = []), this.kindMap[kind].push(item);
+    this.graphDB = masterGraph;
+    this.graphGui(this.graphDB);
+    this.kindMap = {};
+    this.graphDB.walk((item) => {
+      if (item instanceof Subgraph) ;
+      else if (item instanceof Vertex$1) {
+        const kind = item._.attr("Kind").RawValue;
+        if (!this.kindMap[kind]) {
+          this.kindMap[kind] = [];
         }
-      }
+        this.kindMap[kind].push(item);
+      } else ;
     });
   }
   disabled(_) {
     if (!arguments.length) {
       const retVal = [];
-      for (const key in this._disabled)
-        this._disabled[key] && retVal.push(key);
+      for (const key in this._disabled) {
+        if (this._disabled[key]) {
+          retVal.push(key);
+        }
+      }
       return retVal;
     }
-    return this._disabled = {}, _.forEach((kind) => this._disabled[kind] = !0), this;
+    this._disabled = {};
+    _.forEach((kind) => this._disabled[kind] = true);
+    return this;
   }
   graphGui(graphDB) {
     const graphGui = {
@@ -280,31 +360,46 @@ class WUScopeController {
       edges: [],
       hierarchy: []
     };
-    return graphDB.walk((item) => {
+    graphDB.walk((item) => {
       if (item instanceof Subgraph) {
         const subgraph = this.appendSubgraph(item, graphGui.hierarchy, graphGui.subgraphs);
         subgraph.showMinMax(item.vertices.length > 3 || subgraph.minState() !== "normal");
-      } else item instanceof Vertex$1 ? this.appendVertex(item, graphGui.hierarchy, graphGui.vertices) : item instanceof Edge && this.appendEdge(item, graphGui.edges);
-    }), graphGui;
+      } else if (item instanceof Vertex$1) {
+        this.appendVertex(item, graphGui.hierarchy, graphGui.vertices);
+      } else if (item instanceof Edge) {
+        this.appendEdge(item, graphGui.edges);
+      }
+    });
+    return graphGui;
   }
   format(labelTpl, obj) {
-    let retVal = "", lpos = labelTpl.indexOf("%"), rpos = -1;
-    for (; lpos >= 0; ) {
-      if (retVal += labelTpl.substring(rpos + 1, lpos), rpos = labelTpl.indexOf("%", lpos + 1), rpos < 0) {
+    let retVal = "";
+    let lpos = labelTpl.indexOf("%");
+    let rpos = -1;
+    while (lpos >= 0) {
+      retVal += labelTpl.substring(rpos + 1, lpos);
+      rpos = labelTpl.indexOf("%", lpos + 1);
+      if (rpos < 0) {
         console.warn("Invalid Label Template");
         break;
       }
       const key = labelTpl.substring(lpos + 1, rpos);
-      retVal += key ? obj[labelTpl.substring(lpos + 1, rpos)] || "" : "%", lpos = labelTpl.indexOf("%", rpos + 1);
+      retVal += !key ? "%" : obj[labelTpl.substring(lpos + 1, rpos)] || "";
+      lpos = labelTpl.indexOf("%", rpos + 1);
     }
-    return retVal += labelTpl.substring(rpos + 1, labelTpl.length), retVal.split("\\n").join(`
-`);
+    retVal += labelTpl.substring(rpos + 1, labelTpl.length);
+    return retVal.split("\\n").join("\n");
   }
   createSubgraph(subgraph) {
     let sg = this.subgraphsMap[subgraph._.Id];
-    return sg || (sg = new Subgraph$1().title(subgraph._.Id).on("minClick", () => {
-      this.minClick(sg);
-    }), this.subgraphsMap[subgraph._.Id] = sg, this.rSubgraphsMap[sg.id()] = subgraph), sg;
+    if (!sg) {
+      sg = new Subgraph$1().title(subgraph._.Id).on("minClick", () => {
+        this.minClick(sg);
+      });
+      this.subgraphsMap[subgraph._.Id] = sg;
+      this.rSubgraphsMap[sg.id()] = subgraph;
+    }
+    return sg;
   }
   createVertex(vertex) {
     let v = this.verticesMap[vertex._.Id];
@@ -313,31 +408,40 @@ class WUScopeController {
       if (vertex._.ScopeType === "dummy") {
         const parent = this.subgraphsMap[vertex.parent._.Id];
         v = new Icon().shape_colorFill("darkred").shape_colorStroke("darkred").image_colorFill("white").faChar("").on("click", () => {
-          parent.minState("normal"), this.minClick(parent);
+          parent.minState("normal");
+          this.minClick(parent);
         });
       } else {
-        v = new Vertex().icon_shape_colorFill("#1f77b4").icon_image_colorFill("white").faChar(faCharFactory(attrs.Kind)).text(attrs.Label);
+        v = new Vertex().icon_shape_colorFill("#1f77b4").icon_image_colorFill("white").faChar(faCharFactory(attrs["Kind"])).text(attrs["Label"]);
         const annotations = [];
-        vertex._.hasAttr("Definition") && annotations.push({
-          faChar: "",
-          tooltip: "Definition",
-          shape_colorFill: "lightgray",
-          shape_colorStroke: "lightgray",
-          image_colorFill: "black"
-        }), vertex._.hasAttr("IsInternal") && annotations.push({
-          faChar: "",
-          tooltip: "IsInternal",
-          shape_colorFill: "red",
-          shape_colorStroke: "red",
-          image_colorFill: "white"
-        }), v.annotationIcons(annotations);
+        if (vertex._.hasAttr("Definition")) {
+          annotations.push({
+            faChar: "",
+            tooltip: "Definition",
+            shape_colorFill: "lightgray",
+            shape_colorStroke: "lightgray",
+            image_colorFill: "black"
+          });
+        }
+        if (vertex._.hasAttr("IsInternal")) {
+          annotations.push({
+            faChar: "",
+            tooltip: "IsInternal",
+            shape_colorFill: "red",
+            shape_colorStroke: "red",
+            image_colorFill: "white"
+          });
+        }
+        v.annotationIcons(annotations);
       }
-      this.verticesMap[vertex._.Id] = v, this.rVerticesMap[v.id()] = vertex;
+      this.verticesMap[vertex._.Id] = v;
+      this.rVerticesMap[v.id()] = vertex;
     }
     return v;
   }
   isSpill(edge) {
-    const sourceKind = edge.source._.attr("Kind").RawValue, targetKind = edge.target._.attr("Kind").RawValue;
+    const sourceKind = edge.source._.attr("Kind").RawValue;
+    const targetKind = edge.target._.attr("Kind").RawValue;
     return sourceKind === "2" || targetKind === "71";
   }
   spansSubgraph(edge) {
@@ -346,12 +450,30 @@ class WUScopeController {
   createEdge(edge) {
     let e = this.edgesMap[edge._.Id];
     if (!e) {
-      const attrs = edge._.rawAttrs(), sourceV = this.verticesMap[edge.source._.Id], targetV = this.verticesMap[edge.target._.Id];
+      const attrs = edge._.rawAttrs();
+      const sourceV = this.verticesMap[edge.source._.Id];
+      const targetV = this.verticesMap[edge.target._.Id];
       if (sourceV && targetV) {
-        const isSpill = this.isSpill(edge), spansSubgraph = this.spansSubgraph(edge), label = this.format(`%Label%
-%NumRowsProcessed%`, attrs);
-        let strokeDasharray = null, weight = 100;
-        attrs.IsDependency ? (weight = 10, strokeDasharray = "1,5") : attrs._childGraph ? strokeDasharray = "5,5" : isSpill ? (weight = 25, strokeDasharray = "5,5,10,5") : spansSubgraph && (weight = 5, strokeDasharray = "5,5"), e = new Edge$1().sourceVertex(sourceV).targetVertex(targetV).sourceMarker("circle").targetMarker("arrow").weight(weight).strokeDasharray(strokeDasharray).text(label), this.edgesMap[edge._.Id] = e, this.rEdgesMap[e.id()] = edge;
+        const isSpill = this.isSpill(edge);
+        const spansSubgraph = this.spansSubgraph(edge);
+        const label = this.format("%Label%\n%NumRowsProcessed%", attrs);
+        let strokeDasharray = null;
+        let weight = 100;
+        if (attrs["IsDependency"]) {
+          weight = 10;
+          strokeDasharray = "1,5";
+        } else if (attrs["_childGraph"]) {
+          strokeDasharray = "5,5";
+        } else if (isSpill) {
+          weight = 25;
+          strokeDasharray = "5,5,10,5";
+        } else if (spansSubgraph) {
+          weight = 5;
+          strokeDasharray = "5,5";
+        }
+        e = new Edge$1().sourceVertex(sourceV).targetVertex(targetV).sourceMarker("circle").targetMarker("arrow").weight(weight).strokeDasharray(strokeDasharray).text(label);
+        this.edgesMap[edge._.Id] = e;
+        this.rEdgesMap[e.id()] = edge;
       }
     }
     return e;
@@ -360,42 +482,64 @@ class WUScopeController {
     const sg = this.createSubgraph(subgraph);
     subgraphs.push(sg);
     const parent = this.subgraphsMap[subgraph.parent._.Id];
-    return parent && hierarchy.push({ parent, child: sg }), sg;
+    if (parent) {
+      hierarchy.push({ parent, child: sg });
+    }
+    return sg;
   }
   appendVertex(vertex, hierarchy, vertices) {
     const v = this.createVertex(vertex);
     vertices.push(v);
     const parent = this.subgraphsMap[vertex.parent._.Id];
-    return parent && hierarchy.push({ parent, child: v }), v;
+    if (parent) {
+      hierarchy.push({ parent, child: v });
+    }
+    return v;
   }
   appendEdge(edge, edges) {
     const e = this.createEdge(edge);
-    return e && edges.push(e), e;
+    if (e) {
+      edges.push(e);
+    }
+    return e;
   }
   filterLegend(graphDB) {
     for (let i = graphDB.vertices.length - 1; i >= 0; --i) {
-      const vertex = graphDB.vertices[i], kind = vertex._.attr("Kind").RawValue;
-      this._disabled[kind] && vertex.remove(!1, (source, target) => new BaseScope({
-        ScopeName: vertex._.ScopeName + ":in",
-        Id: source.Id + "->" + target.Id,
-        ScopeType: "dummy-edge",
-        Properties: {
-          Property: [vertex._.attr("Label")]
-        },
-        Notes: {
-          Note: []
-        },
-        SinkActivity: ""
-      }));
+      const vertex = graphDB.vertices[i];
+      const kind = vertex._.attr("Kind").RawValue;
+      if (this._disabled[kind]) {
+        vertex.remove(false, (source, target) => {
+          return new BaseScope({
+            ScopeName: vertex._.ScopeName + ":in",
+            Id: source.Id + "->" + target.Id,
+            ScopeType: "dummy-edge",
+            Properties: {
+              Property: [vertex._.attr("Label")]
+            },
+            Notes: {
+              Note: []
+            },
+            SinkActivity: ""
+          });
+        });
+      }
     }
   }
   filterPartial(graphDB) {
-    for (const subgraph of graphDB.subgraphs)
-      switch (this.subgraphsMap[subgraph._.Id].minState()) {
+    for (const subgraph of graphDB.subgraphs) {
+      const sg = this.subgraphsMap[subgraph._.Id];
+      switch (sg.minState()) {
         case "partial":
-          const childVertices = subgraph.vertices, vShow = [], vHide = [];
-          for (const vertex of childVertices)
-            vertex.inEdges.length === 0 || vertex.inEdges.some((edge) => edge.source.parent !== edge.target.parent) || vertex.outEdges.length === 0 || vertex.outEdges.some((edge) => edge.source.parent !== edge.target.parent) ? vShow.push(vertex) : vHide.push(vertex);
+          const childVertices = subgraph.vertices;
+          const vShow = [];
+          const vHide = [];
+          for (const vertex of childVertices) {
+            if (vertex.inEdges.length === 0 || vertex.inEdges.some((edge) => edge.source.parent !== edge.target.parent) || vertex.outEdges.length === 0 || vertex.outEdges.some((edge) => edge.source.parent !== edge.target.parent)) {
+              vShow.push(vertex);
+            } else {
+              vHide.push(vertex);
+            }
+          }
           if (vHide.length > 1) {
             const dummyDetails = {
               ScopeName: subgraph._.ScopeName,
@@ -415,9 +559,11 @@ class WUScopeController {
                 Note: []
               },
               SinkActivity: ""
-            }, dummyScope = new BaseScope(dummyDetails), dummyVertex = subgraph.createVertex(dummyScope);
+            };
+            const dummyScope = new BaseScope(dummyDetails);
+            const dummyVertex = subgraph.createVertex(dummyScope);
             for (const vertex of vHide) {
-              for (const edge of vertex.inEdges)
+              for (const edge of vertex.inEdges) {
                 if (vShow.indexOf(edge.source) >= 0) {
                   const dummyEdgeScope = new BaseScope({
                     ScopeName: edge.source._.ScopeName,
@@ -433,7 +579,8 @@ class WUScopeController {
                   });
                   subgraph.createEdge(edge.source, dummyVertex, dummyEdgeScope);
                 }
-              for (const edge of vertex.outEdges)
+              }
+              for (const edge of vertex.outEdges) {
                 if (vShow.indexOf(edge.target) >= 0) {
                   const dummyEdgeScope = new BaseScope({
                     ScopeName: edge.target._.ScopeName,
@@ -449,89 +596,117 @@ class WUScopeController {
                   });
                   subgraph.createEdge(dummyVertex, edge.target, dummyEdgeScope);
                 }
+              }
             }
-            vHide.forEach((vertex) => vertex.remove(!0));
+            vHide.forEach((vertex) => vertex.remove(true));
           }
           break;
       }
+    }
   }
   filterEmptySubgraphs(graphDB) {
-    for (; ; ) {
+    while (true) {
       const emptySubgraphs = graphDB.subgraphs.filter((subgraph) => subgraph.subgraphs.length === 0 && subgraph.vertices.length === 0);
       if (emptySubgraphs.length === 0) break;
-      emptySubgraphs.forEach((subgraph) => subgraph.remove(!0));
+      emptySubgraphs.forEach((subgraph) => subgraph.remove(true));
     }
   }
   removeObsoleteSubgraphs(graphDB) {
-    for (const subgraph of [...graphDB.subgraphs])
-      subgraph.vertices.length === 0 && subgraph.remove(!1);
+    for (const subgraph of [...graphDB.subgraphs]) {
+      if (subgraph.vertices.length === 0) {
+        subgraph.remove(false);
+      }
+    }
   }
   graphData() {
     const graphDB = this.graphDB.clone();
-    return this.filterLegend(graphDB), this.filterPartial(graphDB), this.filterEmptySubgraphs(graphDB), this.removeObsoleteSubgraphs(graphDB), this.graphGui(graphDB);
+    this.filterLegend(graphDB);
+    this.filterPartial(graphDB);
+    this.filterEmptySubgraphs(graphDB);
+    this.removeObsoleteSubgraphs(graphDB);
+    return this.graphGui(graphDB);
   }
   calcLegend() {
     const retVal = [];
-    for (const kind in this.kindMap)
+    for (const kind in this.kindMap) {
       retVal.push({
         kind: parseInt(kind),
         faChar: faCharFactory(kind),
-        label: this.kindMap[kind][0]._.attr("Label").RawValue.split(`
-`)[0],
+        label: this.kindMap[kind][0]._.attr("Label").RawValue.split("\n")[0],
         count: this.kindMap[kind].length
       });
+    }
     return retVal;
   }
   vertices(kind) {
     const retVal = [];
-    for (const v of this.kindMap[kind])
+    for (const v of this.kindMap[kind]) {
       retVal.push(this.verticesMap[v._.Id]);
+    }
     return retVal;
   }
   formatRow(item, columns2, row) {
     const attrs = item._.formattedAttrs();
     for (const key in attrs) {
       const idx = columns2.indexOf(key);
-      idx === -1 ? (columns2.push(key), row.push(attrs[key])) : row[idx] = attrs[key];
+      if (idx === -1) {
+        columns2.push(key);
+        row.push(attrs[key]);
+      } else {
+        row[idx] = attrs[key];
+      }
+    }
+    for (let i = 0; i < 100; ++i) {
+      if (row[i] === void 0) {
+        row[i] = "";
+      }
     }
-    for (let i = 0; i < 100; ++i)
-      row[i] === void 0 && (row[i] = "");
     return row;
   }
   activityData() {
-    const columns2 = ["Id", "Kind", "Label"], data = this.graphDB.vertices.map((v) => {
+    const columns2 = ["Id", "Kind", "Label"];
+    const data = this.graphDB.vertices.map((v) => {
       const row = [parseInt(v._.Id.split("a")[1])];
       return this.formatRow(v, columns2, row);
     });
     return { columns: columns2, data };
   }
   edgeData() {
-    const columns2 = ["Id", "Label"], data = this.graphDB.edges.map((e) => {
+    const columns2 = ["Id", "Label"];
+    const data = this.graphDB.edges.map((e) => {
       const row = [e._.Id];
       return this.formatRow(e, columns2, row);
     });
     return { columns: columns2, data };
   }
   subgraphData() {
-    const columns2 = ["Id", "Label"], data = this.graphDB.subgraphs.map((sg) => {
+    const columns2 = ["Id", "Label"];
+    const data = this.graphDB.subgraphs.map((sg) => {
       const row = [sg._.Id];
       return this.formatRow(sg, columns2, row);
     });
     return { columns: columns2, data };
   }
   calcGraphTooltip(item) {
-    let scope, parentScope;
+    let scope;
+    let parentScope;
     if (item instanceof Subgraph$1) {
       const subgraph = this.rSubgraphsMap[item.id()];
-      scope = subgraph._, parentScope = subgraph.parent._;
+      scope = subgraph._;
+      parentScope = subgraph.parent._;
     } else if (item instanceof Vertex || item instanceof Icon) {
       const vertex = this.rVerticesMap[item.id()];
-      scope = vertex._, parentScope = vertex.parent._;
+      scope = vertex._;
+      parentScope = vertex.parent._;
     } else if (item instanceof Edge$1) {
       const edge = this.rEdgesMap[item.id()];
-      scope = edge._, parentScope = edge.parent._;
+      scope = edge._;
+      parentScope = edge.parent._;
+    }
+    if (scope) {
+      return scope.calcTooltip(parentScope);
     }
-    return scope ? scope.calcTooltip(parentScope) : "";
+    return "";
   }
   subgraph(id) {
     return this.subgraphsMap[id];
@@ -545,47 +720,49 @@ class WUScopeController {
   //  Events  ---
   minClick(sg) {
   }
-}
-class WUGraph extends ChartPanel {
+};
+__name(_WUScopeController, "WUScopeController");
+let WUScopeController = _WUScopeController;
+const _WUGraph = class _WUGraph extends ChartPanel {
+  _partialAll = new Button().faChar("fa-window-restore").tooltip("Partial All").on("click", () => {
+    this.stateClick(this._partialAll);
+  });
+  _maxAll = new Button().faChar("fa-window-maximize").tooltip("Max All").on("click", () => {
+    this.stateClick(this._maxAll);
+  });
+  _toggleGraph = new ToggleButton().faChar("fa-chain").tooltip("Graph").selected(true).on("click", () => {
+    this.viewClick(this._toggleGraph);
+  });
+  _toggleActivities = new ToggleButton().faChar("fa-table").tooltip("Activitiies").selected(false).on("click", () => {
+    this.viewClick(this._toggleActivities);
+  });
+  _toggleEdges = new ToggleButton().faChar("fa-table").tooltip("Edges").selected(false).on("click", () => {
+    this.viewClick(this._toggleEdges);
+  });
+  _toggleSubgraphs = new ToggleButton().faChar("fa-table").tooltip("Subgraphs").selected(false).on("click", () => {
+    this.viewClick(this._toggleSubgraphs);
+  });
+  _graph = new Graph().layout("Hierarchy").applyScaleOnLayout(true).showToolbar(false).allowDragging(false);
+  _activities = new Table().pagination(false);
+  _edges = new Table().pagination(false);
+  _subgraphs = new Table().pagination(false);
+  _legend = new WUGraphLegend(this).on("click", (kind) => {
+    this.render();
+  }).on("mouseover", (kind) => {
+    const verticesMap = {};
+    for (const vertex of this._gc.vertices(kind)) {
+      verticesMap[vertex.id()] = true;
+    }
+    this._graph.highlightVerticies(verticesMap);
+  }).on("mouseout", (kind) => {
+    this._graph.highlightVerticies();
+  });
+  _view = new Carousel().widgets([this._graph, this._activities, this._edges, this._subgraphs]);
+  _gc = new WUScopeController();
   constructor() {
     super();
-    __publicField(this, "_partialAll", new Button().faChar("fa-window-restore").tooltip("Partial All").on("click", () => {
-      this.stateClick(this._partialAll);
-    }));
-    __publicField(this, "_maxAll", new Button().faChar("fa-window-maximize").tooltip("Max All").on("click", () => {
-      this.stateClick(this._maxAll);
-    }));
-    __publicField(this, "_toggleGraph", new ToggleButton().faChar("fa-chain").tooltip("Graph").selected(!0).on("click", () => {
-      this.viewClick(this._toggleGraph);
-    }));
-    __publicField(this, "_toggleActivities", new ToggleButton().faChar("fa-table").tooltip("Activitiies").selected(!1).on("click", () => {
-      this.viewClick(this._toggleActivities);
-    }));
-    __publicField(this, "_toggleEdges", new ToggleButton().faChar("fa-table").tooltip("Edges").selected(!1).on("click", () => {
-      this.viewClick(this._toggleEdges);
-    }));
-    __publicField(this, "_toggleSubgraphs", new ToggleButton().faChar("fa-table").tooltip("Subgraphs").selected(!1).on("click", () => {
-      this.viewClick(this._toggleSubgraphs);
-    }));
-    __publicField(this, "_graph", new Graph().layout("Hierarchy").applyScaleOnLayout(!0).showToolbar(!1).allowDragging(!1));
-    __publicField(this, "_activities", new Table().pagination(!1));
-    __publicField(this, "_edges", new Table().pagination(!1));
-    __publicField(this, "_subgraphs", new Table().pagination(!1));
-    __publicField(this, "_legend", new WUGraphLegend(this).on("click", (kind) => {
-      this.render();
-    }).on("mouseover", (kind) => {
-      const verticesMap = {};
-      for (const vertex of this._gc.vertices(kind))
-        verticesMap[vertex.id()] = !0;
-      this._graph.highlightVerticies(verticesMap);
-    }).on("mouseout", (kind) => {
-      this._graph.highlightVerticies();
-    }));
-    __publicField(this, "_view", new Carousel().widgets([this._graph, this._activities, this._edges, this._subgraphs]));
-    __publicField(this, "_gc", new WUScopeController());
-    __publicField(this, "_prevHashSum");
-    __publicField(this, "_prevScopeGraph");
-    this.topOverlay(!1), this.widget(this._view);
+    this.topOverlay(false);
+    this.widget(this._view);
     const buttons = [
       this._toggleGraph,
       this._toggleActivities,
@@ -598,11 +775,16 @@ class WUGraph extends ChartPanel {
       ...this._graph.iconBarButtons(),
       new Spacer()
     ];
-    this.buttons(buttons.concat(this.buttons())), this._gc.minClick = (sg) => {
-      this.loadGraph(), this._graph.render((w) => {
+    this.buttons(buttons.concat(this.buttons()));
+    this._gc.minClick = (sg) => {
+      this.loadGraph();
+      this._graph.render((w) => {
         this._graph.selection([sg]).centerOnItem(sg);
       });
-    }, this._graph.tooltipHTML((v) => this._gc.calcGraphTooltip(v));
+    };
+    this._graph.tooltipHTML((v) => {
+      return this._gc.calcGraphTooltip(v);
+    });
   }
   stateClick(sourceB) {
     switch (sourceB) {
@@ -620,7 +802,11 @@ class WUGraph extends ChartPanel {
     this.render();
   }
   viewClick(sourceTB) {
-    switch (this._toggleGraph.selected(sourceTB === this._toggleGraph), this._toggleActivities.selected(sourceTB === this._toggleActivities), this._toggleEdges.selected(sourceTB === this._toggleEdges), this._toggleSubgraphs.selected(sourceTB === this._toggleSubgraphs), sourceTB) {
+    this._toggleGraph.selected(sourceTB === this._toggleGraph);
+    this._toggleActivities.selected(sourceTB === this._toggleActivities);
+    this._toggleEdges.selected(sourceTB === this._toggleEdges);
+    this._toggleSubgraphs.selected(sourceTB === this._toggleSubgraphs);
+    switch (sourceTB) {
       case this._toggleGraph:
         this._view.active(0);
         break;
@@ -637,6 +823,8 @@ class WUGraph extends ChartPanel {
     this.render((w) => {
     });
   }
+  _prevHashSum;
+  _prevScopeGraph;
   fetchScopeGraph() {
     const hash = hashSum({
       baseUrl: this.baseUrl(),
@@ -644,11 +832,24 @@ class WUGraph extends ChartPanel {
       graphID: this.graphID(),
       subgraphID: this.subgraphID()
     });
-    return !this._prevScopeGraph || this._prevHashSum !== hash ? (this.startProgress(), this._prevHashSum = hash, this._gc.clear(), Workunit.attach({ baseUrl: this.baseUrl() }, this.wuid()).fetchGraphs().then((graphs) => {
-      for (const graph of graphs)
-        if (graph.Name === this.graphID())
-          return this.finishProgress(), graph.fetchScopeGraph(this.subgraphID());
-    }).then((scopeGraph) => (this._prevScopeGraph = scopeGraph, this._prevScopeGraph))) : Promise.resolve(this._prevScopeGraph);
+    if (!this._prevScopeGraph || this._prevHashSum !== hash) {
+      this.startProgress();
+      this._prevHashSum = hash;
+      this._gc.clear();
+      const wu = Workunit.attach({ baseUrl: this.baseUrl() }, this.wuid());
+      return wu.fetchGraphs().then((graphs) => {
+        for (const graph of graphs) {
+          if (graph.Name === this.graphID()) {
+            this.finishProgress();
+            return graph.fetchScopeGraph(this.subgraphID());
+          }
+        }
+      }).then((scopeGraph) => {
+        this._prevScopeGraph = scopeGraph;
+        return this._prevScopeGraph;
+      });
+    }
+    return Promise.resolve(this._prevScopeGraph);
   }
   enter(domNode, _element) {
     super.enter(domNode, _element);
@@ -660,7 +861,8 @@ class WUGraph extends ChartPanel {
     super.exit(domNode, element);
   }
   loadGraph() {
-    this._gc.disabled(this._legend.disabled()), this._graph.data(this._gc.graphData(), !0);
+    this._gc.disabled(this._legend.disabled());
+    this._graph.data(this._gc.graphData(), true);
     {
       const { columns: columns2, data } = this._gc.activityData();
       this._activities.columns(columns2).data(data);
@@ -675,16 +877,29 @@ class WUGraph extends ChartPanel {
     }
   }
   render(callback) {
-    return this.wuid() && this.graphID() ? this.fetchScopeGraph().then((scopedGraph) => {
-      this._gc.set(scopedGraph), this._legend.data(this._gc.calcLegend()), this.loadGraph(), super.render(callback);
-    }) : super.render(callback), this;
+    if (this.wuid() && this.graphID()) {
+      this.fetchScopeGraph().then((scopedGraph) => {
+        this._gc.set(scopedGraph);
+        this._legend.data(this._gc.calcLegend());
+        this.loadGraph();
+        super.render(callback);
+      });
+    } else {
+      super.render(callback);
+    }
+    return this;
   }
   selection(_) {
     if (!arguments.length) return this._graph.selection();
     const item = this._gc.vertex(_) || this._gc.edge(_) || this._gc.subgraph(_);
-    return item && this._graph.selection([item]), this;
+    if (item) {
+      this._graph.selection([item]);
+    }
+    return this;
   }
-}
+};
+__name(_WUGraph, "WUGraph");
+let WUGraph = _WUGraph;
 WUGraph.prototype._class += " eclwatch_WUGraph";
 WUGraph.prototype.publish("baseUrl", "", "string", "HPCC Platform Base URL");
 WUGraph.prototype.publish("wuid", "", "string", "Workunit ID");
@@ -693,6 +908,7 @@ WUGraph.prototype.publish("subgraphID", "", "string", "Subgraph ID");
 function entitiesEncode(str) {
   return String(str).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
+__name(entitiesEncode, "entitiesEncode");
 function safeEncode(item) {
   switch (Object.prototype.toString.call(item)) {
     case "[object Undefined]":
@@ -706,67 +922,94 @@ function safeEncode(item) {
   }
   return item;
 }
-class Store {
+__name(safeEncode, "safeEncode");
+const _Store = class _Store {
+  wuResult;
+  schema;
+  _columns;
+  _cache = {};
+  rowFormatter;
+  _filter = {};
+  onError;
   constructor(wuResult, schema, renderHtml, filter = {}, onError) {
-    __publicField(this, "wuResult");
-    __publicField(this, "schema");
-    __publicField(this, "_columns");
-    __publicField(this, "_cache", {});
-    __publicField(this, "rowFormatter");
-    __publicField(this, "_filter", {});
-    __publicField(this, "onError");
-    this.wuResult = wuResult, this.schema = schema, this._columns = this.schema2Columns(this.schema.root), this.rowFormatter = new RowFormatter(this._columns, renderHtml), this._filter = filter, this.onError = onError;
+    this.wuResult = wuResult;
+    this.schema = schema;
+    this._columns = this.schema2Columns(this.schema.root);
+    this.rowFormatter = new RowFormatter(this._columns, renderHtml);
+    this._filter = filter;
+    this.onError = onError;
   }
   columns() {
     return this._columns;
   }
   schema2Columns(parentNode, prefix = "") {
-    return parentNode ? parentNode.children().filter((node) => node.name.indexOf("__hidden", node.name.length - 8) === -1).map((node, idx) => {
-      const label = node.name, keyed = node.attrs["hpcc:keyed"], column = {
+    if (!parentNode) return [];
+    return parentNode.children().filter((node) => node.name.indexOf("__hidden", node.name.length - "__hidden".length) === -1).map((node, idx) => {
+      const label = node.name;
+      const keyed = node.attrs["hpcc:keyed"];
+      const column = {
         field: prefix + label,
         leafID: label,
         idx,
         label: label + (keyed ? " (i)" : ""),
         className: "resultGridCell",
-        sortable: !1,
+        sortable: false,
         width: keyed ? 16 : 0,
         isSet: node.isSet
-      }, children = this.schema2Columns(node, prefix + label + "_");
-      return children.length ? (column.width += 10 + children.reduce((prev, childNode) => prev + childNode.width, 0), column.children = children) : (column.width += node.charWidth() * 9, column.formatter = (cell, row) => {
-        switch (typeof cell) {
-          case "string":
-            return {
-              html: cell.replace(/\t/g, "&nbsp;&nbsp;&nbsp;&nbsp;").trim()
-            };
-          case "undefined":
-            return "";
-        }
-        return cell;
-      }), column;
-    }) : [];
+      };
+      const children = this.schema2Columns(node, prefix + label + "_");
+      if (children.length) {
+        column.width += 10 + children.reduce((prev, childNode) => {
+          return prev + childNode.width;
+        }, 0);
+        column.children = children;
+      } else {
+        column.width += node.charWidth() * 9;
+        column.formatter = (cell, row) => {
+          switch (typeof cell) {
+            case "string":
+              return {
+                html: cell.replace(/\t/g, "&nbsp;&nbsp;&nbsp;&nbsp;").trim()
+              };
+            case "undefined":
+              return "";
+          }
+          return cell;
+        };
+      }
+      return column;
+    });
   }
   isChildDataset(cell) {
-    if (Object.prototype.toString.call(cell) !== "[object Object]")
-      return !1;
-    let propCount = 0, firstPropType = null;
-    for (const key in cell)
-      firstPropType || (firstPropType = Object.prototype.toString.call(cell[key])), propCount++;
+    if (Object.prototype.toString.call(cell) !== "[object Object]") {
+      return false;
+    }
+    let propCount = 0;
+    let firstPropType = null;
+    for (const key in cell) {
+      if (!firstPropType) {
+        firstPropType = Object.prototype.toString.call(cell[key]);
+      }
+      propCount++;
+    }
     return propCount === 1 && firstPropType === "[object Array]";
   }
   rowToTable(cell, __row, node) {
     if (this.isChildDataset(cell)) {
-      for (const key in cell)
+      for (const key in cell) {
         this.rowToTable(cell[key], __row, node);
+      }
       return;
     }
     const table = domConstruct.create("table", { border: 1, cellspacing: 0, width: "100%" }, node);
     switch (Object.prototype.toString.call(cell)) {
       case "[object Object]":
         let tr = domConstruct.create("tr", null, table);
-        for (const key in cell)
+        for (const key in cell) {
           domConstruct.create("th", { innerHTML: safeEncode(key) }, tr);
+        }
         tr = domConstruct.create("tr", null, table);
-        for (const key in cell)
+        for (const key in cell) {
           switch (Object.prototype.toString.call(cell[key])) {
             case "[object Object]":
             case "[object Array]":
@@ -776,9 +1019,10 @@ class Store {
               domConstruct.create("td", { innerHTML: safeEncode(cell[key]) }, tr);
               break;
           }
+        }
         break;
       case "[object Array]":
-        for (let i = 0; i < cell.length; ++i)
+        for (let i = 0; i < cell.length; ++i) {
           switch (Object.prototype.toString.call(cell[i])) {
             case "[object Boolean]":
             case "[object Number]":
@@ -789,26 +1033,30 @@ class Store {
             default:
               if (i === 0) {
                 const tr2 = domConstruct.create("tr", null, table);
-                for (const key in cell[i])
+                for (const key in cell[i]) {
                   domConstruct.create("th", { innerHTML: safeEncode(key) }, tr2);
+                }
               }
               domConstruct.create("tr", null, table);
-              for (const key in cell[i])
-                if (cell[i][key])
+              for (const key in cell[i]) {
+                if (cell[i][key]) {
                   if (Object.prototype.toString.call(cell[i][key]) === "[object Object]" || Object.prototype.toString.call(cell[i][key]) === "[object Array]") {
                     const td = domConstruct.create("td", null, tr1);
                     this.rowToTable(cell[i][key], cell[i], td);
-                  } else if (key.indexOf("__html", key.length - 6) !== -1)
+                  } else if (key.indexOf("__html", key.length - "__html".length) !== -1) {
                     domConstruct.create("td", { innerHTML: cell[i][key] }, tr1);
-                  else if (key.indexOf("__javascript", key.length - 12) !== -1)
+                  } else if (key.indexOf("__javascript", key.length - "__javascript".length) !== -1) {
                     domConstruct.create("td", null, tr1);
-                  else {
+                  } else {
                     const val = cell[i][key];
                     domConstruct.create("td", { innerHTML: safeEncode(val) }, tr1);
                   }
-                else
+                } else {
                   domConstruct.create("td", { innerHTML: "" }, tr1);
+                }
+              }
           }
+        }
         break;
     }
   }
@@ -819,31 +1067,39 @@ class Store {
     if (!this.wuResult) return Promise.resolve({ totalLength: 0, data: [] });
     const cacheKey = `${start}->${end}`;
     if (this._cache[cacheKey]) return this._cache[cacheKey];
-    const retVal = this.wuResult.fetchRows(start, end - start, !1, this._filter).then((rows) => ({
-      totalLength: this.wuResult.Total,
-      data: rows.map((row, idx) => {
-        const formattedRow = this.rowFormatter.format(row);
-        return formattedRow.__hpcc_id = start + idx, formattedRow.__hpcc_orig = row, formattedRow;
-      })
-    })).catch((err) => (this.onError(err.Message || "An exception has occurred"), { totalLength: 0, data: [] }));
-    return this._cache[cacheKey] = retVal, retVal;
+    const retVal = this.wuResult.fetchRows(start, end - start, false, this._filter).then((rows) => {
+      return {
+        totalLength: this.wuResult.Total,
+        data: rows.map((row, idx) => {
+          const formattedRow = this.rowFormatter.format(row);
+          formattedRow.__hpcc_id = start + idx;
+          formattedRow.__hpcc_orig = row;
+          return formattedRow;
+        })
+      };
+    }).catch((err) => {
+      this.onError(err.Message || "An exception has occurred");
+      return { totalLength: 0, data: [] };
+    });
+    this._cache[cacheKey] = retVal;
+    return retVal;
   }
   fetchRange(options) {
     const retVal = new Deferred();
-    return this._request(options.start, options.end).then((response) => retVal.resolve(response)), new QueryResults(retVal.then((response) => response.data), {
+    this._request(options.start, options.end).then((response) => retVal.resolve(response));
+    return new QueryResults(retVal.then((response) => response.data), {
       totalLength: retVal.then((response) => response.totalLength)
     });
   }
-}
-class WUResult extends Common {
+};
+__name(_Store, "Store");
+let Store = _Store;
+const _WUResult = class _WUResult extends Common {
+  _result;
+  _localStore;
   constructor() {
     super();
-    __publicField(this, "_result");
-    __publicField(this, "_localStore");
-    __publicField(this, "_prevResultHash");
-    __publicField(this, "_prevStoreHash");
-    __publicField(this, "_prevQueryHash");
-    this.renderHtml(!1);
+    this.renderHtml(false);
   }
   hashSum(opts = {}) {
     return hashSum({
@@ -855,9 +1111,11 @@ class WUResult extends Common {
       logicalFile: this.logicalFile(),
       userID: this.user(),
       password: this.password(),
+      bypassCache: this.bypassCache(),
       ...opts
     });
   }
+  _prevResultHash;
   calcResult() {
     const resultHash = this.hashSum();
     if (this._prevResultHash !== resultHash) {
@@ -867,14 +1125,30 @@ class WUResult extends Common {
         userID: this.user(),
         password: this.password()
       };
-      this.wuid() && this.resultName() ? this._result = Result.attach(opts, this.wuid(), this.resultName()) : this.wuid() && this.sequence() !== void 0 ? this._result = Result.attach(opts, this.wuid(), this.sequence()) : this.logicalFile() && this.nodeGroup() ? this._result = Result.attachLogicalFile(opts, this.nodeGroup(), this.logicalFile()) : this.logicalFile() && (this._result = Result.attachLogicalFile(opts, "", this.logicalFile()));
+      if (this.wuid() && this.resultName()) {
+        this._result = Result.attach(opts, this.wuid(), this.resultName());
+      } else if (this.wuid() && this.sequence() !== void 0) {
+        this._result = Result.attach(opts, this.wuid(), this.sequence());
+      } else if (this.logicalFile() && this.nodeGroup()) {
+        this._result = Result.attachLogicalFile(opts, this.nodeGroup(), this.logicalFile());
+      } else if (this.logicalFile()) {
+        this._result = Result.attachLogicalFile(opts, "", this.logicalFile());
+      }
+      if (this._result && this.bypassCache()) {
+        this._result.bypassCache(this.bypassCache());
+      }
     }
     return this._result;
   }
   fetch(row, count, abortController = new AbortController()) {
     const result = this.calcResult();
-    return result ? result.fetchRows(row, count, !1, {}, abortController.signal) : Promise.resolve([]);
+    if (result) {
+      return result.fetchRows(row, count, false, {}, abortController.signal);
+    }
+    return Promise.resolve([]);
   }
+  _prevStoreHash;
+  _prevQueryHash;
   update(domNode, element) {
     super.update(domNode, element);
     const storeHash = this.hashSum({
@@ -884,17 +1158,25 @@ class WUResult extends Common {
     if (this._prevStoreHash !== storeHash) {
       this._prevStoreHash = storeHash;
       const result = this.calcResult();
-      result && result.fetchXMLSchema().then((schema) => {
-        var _a, _b;
-        this._localStore = new Store(result, schema, this.renderHtml(), this.filter(), (msg) => {
-          this._dgrid && (this._dgrid.noDataMessage = `<span class='dojoxGridNoData'>${msg}</span>`, this._dgrid.refresh());
-        }), (_a = this._dgrid) == null || _a.set("columns", this._localStore.columns()), (_b = this._dgrid) == null || _b.set("collection", this._localStore);
-      });
+      if (result) {
+        result.fetchXMLSchema().then((schema) => {
+          this._localStore = new Store(result, schema, this.renderHtml(), this.filter(), (msg) => {
+            if (this._dgrid) {
+              this._dgrid.noDataMessage = `<span class='dojoxGridNoData'>${msg}</span>`;
+              this._dgrid.refresh();
+            }
+          });
+          this._dgrid?.set("columns", this._localStore.columns());
+          this._dgrid?.set("collection", this._localStore);
+        });
+      }
     }
   }
   click(row, col, sel) {
   }
-}
+};
+__name(_WUResult, "WUResult");
+let WUResult = _WUResult;
 WUResult.prototype._class += " eclwatch_WUResult";
 WUResult.prototype.publish("baseUrl", "", "string", "URL to WsWorkunits");
 WUResult.prototype.publish("user", "", "string", "User ID");
@@ -905,27 +1187,48 @@ WUResult.prototype.publish("sequence", void 0, "number", "Sequence Number");
 WUResult.prototype.publish("nodeGroup", "", "string", "NodeGroup");
 WUResult.prototype.publish("logicalFile", "", "string", "Logical File Name");
 WUResult.prototype.publish("filter", {}, "object", "Filter");
-var STATUS = /* @__PURE__ */ ((STATUS2) => (STATUS2.CREATE = "Created", STATUS2.COMPILE = "Compiled", STATUS2.EXECUTE = "Executed", STATUS2.COMPLETE = "Completed", STATUS2))(STATUS || {}), STATUS_ACTIVE = /* @__PURE__ */ ((STATUS_ACTIVE2) => (STATUS_ACTIVE2.CREATE = "Creating", STATUS_ACTIVE2.COMPILE = "Compiling", STATUS_ACTIVE2.EXECUTE = "Executing", STATUS_ACTIVE2.COMPLETE = "Completed", STATUS_ACTIVE2))(STATUS_ACTIVE || {});
-class WUStatus extends Graph {
+WUResult.prototype.publish("bypassCache", false, "boolean", "Bypass cached results");
+var STATUS = /* @__PURE__ */ ((STATUS2) => {
+  STATUS2["CREATE"] = "Created";
+  STATUS2["COMPILE"] = "Compiled";
+  STATUS2["EXECUTE"] = "Executed";
+  STATUS2["COMPLETE"] = "Completed";
+  return STATUS2;
+})(STATUS || {});
+var STATUS_ACTIVE = /* @__PURE__ */ ((STATUS_ACTIVE2) => {
+  STATUS_ACTIVE2["CREATE"] = "Creating";
+  STATUS_ACTIVE2["COMPILE"] = "Compiling";
+  STATUS_ACTIVE2["EXECUTE"] = "Executing";
+  STATUS_ACTIVE2["COMPLETE"] = "Completed";
+  return STATUS_ACTIVE2;
+})(STATUS_ACTIVE || {});
+const _WUStatus = class _WUStatus extends Graph {
+  _wu;
+  _wuHandle;
+  _create;
+  _compile;
+  _execute;
+  _complete;
   constructor() {
     super();
-    __publicField(this, "_wu");
-    __publicField(this, "_wuHandle");
-    __publicField(this, "_create");
-    __publicField(this, "_compile");
-    __publicField(this, "_execute");
-    __publicField(this, "_complete");
-    __publicField(this, "_prevHash");
-    this.zoomable(!1).zoomToFitLimit(1).layout("Hierarchy").hierarchyRankDirection("LR").showToolbar(!1).allowDragging(!1);
+    this.zoomable(false).zoomToFitLimit(1).layout("Hierarchy").hierarchyRankDirection("LR").showToolbar(false).allowDragging(false);
   }
+  _prevHash;
   attachWorkunit() {
     const hash = hashSum({
       baseUrl: this.baseUrl(),
       wuid: this.wuid()
     });
-    this._prevHash !== hash && (this._prevHash = hash, this._wu = Workunit.attach({ baseUrl: this.baseUrl() }, this.wuid()), this._wuHandle && this._wuHandle.release(), this._wuHandle = this._wu.watch((changes) => {
-      this.lazyRender();
-    }));
+    if (this._prevHash !== hash) {
+      this._prevHash = hash;
+      this._wu = Workunit.attach({ baseUrl: this.baseUrl() }, this.wuid());
+      if (this._wuHandle) {
+        this._wuHandle.release();
+      }
+      this._wuHandle = this._wu.watch((changes) => {
+        this.lazyRender();
+      });
+    }
   }
   createVertex(faChar) {
     return new Vertex().icon_diameter(32).icon_shape_colorFill("none").icon_shape_colorStroke("none").icon_image_colorFill("darkgray").iconAnchor("middle").textbox_shape_colorFill("none").textbox_shape_colorStroke("none").textbox_text_colorFill("darkgray").faChar(faChar);
@@ -933,60 +1236,89 @@ class WUStatus extends Graph {
   updateVertex(vertex, color) {
     vertex.icon_image_colorFill(color).textbox_text_colorFill(color);
   }
-  updateVertexStatus(level, active = !1) {
+  updateVertexStatus(level, active = false) {
     const completeColor = this._wu.isFailed() ? "darkred" : "darkgreen";
-    switch (this._create.text(
+    this._create.text(
       "Created"
       /* CREATE */
-    ), this._compile.text(
+    );
+    this._compile.text(
       "Compiled"
       /* COMPILE */
-    ), this._execute.text(
+    );
+    this._execute.text(
       "Executed"
       /* EXECUTE */
-    ), this._complete.text(
+    );
+    this._complete.text(
       "Completed"
       /* COMPLETE */
-    ), level) {
+    );
+    switch (level) {
       case 0:
-        this.updateVertex(this._create, "darkgray"), this.updateVertex(this._compile, "darkgray"), this.updateVertex(this._execute, "darkgray"), this.updateVertex(this._complete, "darkgray");
+        this.updateVertex(this._create, "darkgray");
+        this.updateVertex(this._compile, "darkgray");
+        this.updateVertex(this._execute, "darkgray");
+        this.updateVertex(this._complete, "darkgray");
         break;
       case 1:
         this._create.text(
           "Creating"
           /* CREATE */
-        ), this.updateVertex(this._create, active ? "orange" : completeColor), this.updateVertex(this._compile, "darkgray"), this.updateVertex(this._execute, "darkgray"), this.updateVertex(this._complete, "darkgray");
+        );
+        this.updateVertex(this._create, active ? "orange" : completeColor);
+        this.updateVertex(this._compile, "darkgray");
+        this.updateVertex(this._execute, "darkgray");
+        this.updateVertex(this._complete, "darkgray");
         break;
       case 2:
         this._compile.text(
           "Compiling"
           /* COMPILE */
-        ), this.updateVertex(this._create, completeColor), this.updateVertex(this._compile, active ? "orange" : completeColor), this.updateVertex(this._execute, completeColor), this.updateVertex(this._complete, "darkgray");
+        );
+        this.updateVertex(this._create, completeColor);
+        this.updateVertex(this._compile, active ? "orange" : completeColor);
+        this.updateVertex(this._execute, completeColor);
+        this.updateVertex(this._complete, "darkgray");
         break;
       case 3:
         this._execute.text(
           "Executing"
           /* EXECUTE */
-        ), this.updateVertex(this._create, completeColor), this.updateVertex(this._compile, completeColor), this.updateVertex(this._execute, active ? "orange" : completeColor), this.updateVertex(this._complete, "darkgray");
+        );
+        this.updateVertex(this._create, completeColor);
+        this.updateVertex(this._compile, completeColor);
+        this.updateVertex(this._execute, active ? "orange" : completeColor);
+        this.updateVertex(this._complete, "darkgray");
         break;
       case 4:
-        this.updateVertex(this._create, completeColor), this.updateVertex(this._compile, completeColor), this.updateVertex(this._execute, completeColor), this.updateVertex(this._complete, completeColor);
+        this.updateVertex(this._create, completeColor);
+        this.updateVertex(this._compile, completeColor);
+        this.updateVertex(this._execute, completeColor);
+        this.updateVertex(this._complete, completeColor);
         break;
     }
   }
   createEdge(source, target) {
-    return new Edge$1().sourceVertex(source).targetVertex(target).strokeColor("black").showArc(!1);
+    return new Edge$1().sourceVertex(source).targetVertex(target).strokeColor("black").showArc(false);
   }
   enter(domNode, element) {
-    super.enter(domNode, element), this._create = this.createVertex(""), this._compile = this.createVertex(""), this._execute = this.createVertex(""), this._complete = this.createVertex("");
-    const e1 = this.createEdge(this._create, this._compile), e2 = this.createEdge(this._compile, this._execute), e3 = this.createEdge(this._execute, this._complete);
+    super.enter(domNode, element);
+    this._create = this.createVertex("");
+    this._compile = this.createVertex("");
+    this._execute = this.createVertex("");
+    this._complete = this.createVertex("");
+    const e1 = this.createEdge(this._create, this._compile);
+    const e2 = this.createEdge(this._compile, this._execute);
+    const e3 = this.createEdge(this._execute, this._complete);
     this.data({
       vertices: [this._create, this._compile, this._execute, this._complete],
       edges: [e1, e2, e3]
     });
   }
   update(domNode, element) {
-    switch (this.attachWorkunit(), this._wu.StateID) {
+    this.attachWorkunit();
+    switch (this._wu.StateID) {
       case WUStateID.Blocked:
       case WUStateID.Wait:
       case WUStateID.Scheduled:
@@ -994,17 +1326,17 @@ class WUStatus extends Graph {
         this.updateVertexStatus(1);
         break;
       case WUStateID.Compiling:
-        this.updateVertexStatus(2, !0);
+        this.updateVertexStatus(2, true);
         break;
       case WUStateID.Submitted:
-        this.updateVertexStatus(1, !0);
+        this.updateVertexStatus(1, true);
         break;
       case WUStateID.Compiled:
         this.updateVertexStatus(2);
         break;
       case WUStateID.Aborting:
       case WUStateID.Running:
-        this.updateVertexStatus(3, !0);
+        this.updateVertexStatus(3, true);
         break;
       case WUStateID.Aborted:
       case WUStateID.Archived:
@@ -1012,7 +1344,7 @@ class WUStatus extends Graph {
         this.updateVertexStatus(4);
         break;
       case WUStateID.Failed:
-        this.updateVertexStatus(4, !1);
+        this.updateVertexStatus(4, false);
         break;
       case WUStateID.DebugPaused:
       case WUStateID.DebugRunning:
@@ -1022,25 +1354,34 @@ class WUStatus extends Graph {
         this.updateVertexStatus(0);
         break;
     }
-    super.update(domNode, element), this.zoomToFit();
+    super.update(domNode, element);
+    this.zoomToFit();
   }
   exit(domNode, element) {
-    this._wuHandle && this._wuHandle.release(), super.exit(domNode, element);
+    if (this._wuHandle) {
+      this._wuHandle.release();
+    }
+    super.exit(domNode, element);
   }
-}
+};
+__name(_WUStatus, "WUStatus");
+let WUStatus = _WUStatus;
 WUStatus.prototype._class += " eclwatch_WUStatus";
 WUStatus.prototype.publish("baseUrl", "", "string", "HPCC Platform Base URL");
 WUStatus.prototype.publish("wuid", "", "string", "Workunit ID");
 const columns = ["label", "start", "end", "icon", "color", "series"];
-class WUTimeline extends ReactTimelineSeries {
+const _WUTimeline = class _WUTimeline extends ReactTimelineSeries {
+  _palette = Palette.ordinal("default");
   constructor() {
     super();
-    __publicField(this, "_palette", Palette.ordinal("default"));
-    __publicField(this, "_prevHashSum");
-    this.columns(columns).titleColumn("label").iconColumn("icon").colorColumn("color").seriesColumn("series").timePattern("%Y-%m-%dT%H:%M:%S.%LZ").tickFormat("%H:%M").tooltipTimeFormat("%H:%M:%S.%L").tooltipHTML((d) => d[columns.length].calcTooltip());
+    this.columns(columns).titleColumn("label").iconColumn("icon").colorColumn("color").seriesColumn("series").timePattern("%Y-%m-%dT%H:%M:%S.%LZ").tickFormat("%H:%M").tooltipTimeFormat("%H:%M:%S.%L").tooltipHTML((d) => {
+      return d[columns.length].calcTooltip();
+    });
   }
+  _prevHashSum;
   clear() {
-    return delete this._prevHashSum, this;
+    delete this._prevHashSum;
+    return this;
   }
   fetchScopes() {
     const hash = hashSum({
@@ -1048,31 +1389,41 @@ class WUTimeline extends ReactTimelineSeries {
       wuid: this.wuid(),
       request: this.request()
     });
-    this._prevHashSum !== hash && (this._prevHashSum = hash, Workunit.attach({ baseUrl: this.baseUrl() }, this.wuid()).fetchDetails(this.request()).then((scopes) => scopes.filter((scope) => scope.Id && scope.attr("WhenStarted").RawValue).map((scope) => {
-      const whenStarted = +scope.attr("WhenStarted").RawValue / 1e3, timeElapsed = +scope.attr("TimeElapsed").RawValue / 1e6;
-      return [
-        scope.Id,
-        new Date(whenStarted).toISOString(),
-        timeElapsed ? new Date(whenStarted + timeElapsed).toISOString() : void 0,
-        null,
-        this._palette(scope.ScopeType),
-        scope.ScopeName.split("::").join(":").split(":").slice(0, 1),
-        scope
-      ];
-    })).then((scopes) => {
-      this.data(scopes).render();
-    }));
+    if (this._prevHashSum !== hash) {
+      this._prevHashSum = hash;
+      const wu = Workunit.attach({ baseUrl: this.baseUrl() }, this.wuid());
+      wu.fetchDetails(this.request()).then((scopes) => {
+        return scopes.filter((scope) => scope.Id && scope.attr("WhenStarted").RawValue).map((scope) => {
+          const whenStarted = +scope.attr("WhenStarted").RawValue / 1e3;
+          const timeElapsed = +scope.attr("TimeElapsed").RawValue / 1e6;
+          return [
+            scope.Id,
+            new Date(whenStarted).toISOString(),
+            timeElapsed ? new Date(whenStarted + timeElapsed).toISOString() : void 0,
+            null,
+            this._palette(scope.ScopeType),
+            scope.ScopeName.split("::").join(":").split(":").slice(0, 1),
+            scope
+          ];
+        });
+      }).then((scopes) => {
+        this.data(scopes).render();
+      });
+    }
   }
   enter(domNode, _element) {
     super.enter(domNode, _element);
   }
   update(domNode, element) {
-    this.fetchScopes(), super.update(domNode, element);
+    this.fetchScopes();
+    super.update(domNode, element);
   }
   exit(domNode, element) {
     super.exit(domNode, element);
   }
-}
+};
+__name(_WUTimeline, "WUTimeline");
+let WUTimeline = _WUTimeline;
 WUTimeline.prototype._class += " eclwatch_WUTimeline";
 WUTimeline.prototype.publish("baseUrl", "", "string", "HPCC Platform Base URL");
 WUTimeline.prototype.publish("wuid", "", "string", "Workunit ID");
@@ -1086,23 +1437,23 @@ WUTimeline.prototype.publish("request", {
     ScopeTypes: []
   },
   PropertiesToReturn: {
-    AllProperties: !1,
-    AllStatistics: !0,
-    AllHints: !1,
+    AllProperties: false,
+    AllStatistics: true,
+    AllHints: false,
     Properties: ["WhenStarted", "TimeElapsed"]
   },
   ScopeOptions: {
-    IncludeId: !0,
-    IncludeScope: !0,
-    IncludeScopeType: !0
+    IncludeId: true,
+    IncludeScope: true,
+    IncludeScopeType: true
   },
   PropertyOptions: {
-    IncludeName: !0,
-    IncludeRawValue: !0,
-    IncludeFormatted: !0,
-    IncludeMeasure: !0,
-    IncludeCreator: !1,
-    IncludeCreatorType: !1
+    IncludeName: true,
+    IncludeRawValue: true,
+    IncludeFormatted: true,
+    IncludeMeasure: true,
+    IncludeCreator: false,
+    IncludeCreatorType: false
   }
 }, "object", "WUDetails Request");
 export {
@@ -1119,4 +1470,4 @@ export {
   WUTimeline
 };
 //# sourceMappingURL=index.js.map
-(function(){"use strict";try{if(typeof document<"u"){var e=document.createElement("style");e.appendChild(document.createTextNode(".eclwatch_WUGraphLegend .graph_Vertex{cursor:auto}.eclwatch_WUGraphLegend .graph_Vertex .common_Icon{cursor:pointer}.eclwatch_WUGraph .graph_Vertex{cursor:auto}.eclwatch_WUGraph .marker{fill:#656565;stroke:none;stroke-width:1px}.eclwatch_WUGraph .zoom{fill:none;pointer-events:all}.eclwatch_WUGraph .selectionBrush{fill:none;stroke:#a9a9a9}.d3-tip .eclwatch_WUGraph_Tooltip h3,.d3-tip .eclwatch_WUGraph_Tooltip h4{margin:0}.d3-tip .eclwatch_WUGraph_Tooltip table{border-collapse:separate;border-spacing:5px}.d3-tip .eclwatch_WUGraph_Tooltip table .key{font-weight:700}.d3-tip .eclwatch_WUGraph_Tooltip table .value{font-weight:400}")),document.head.appendChild(e)}}catch(t){console.error("vite-plugin-css-injected-by-js",t)}})();
+!function(){"use strict";try{if("undefined"!=typeof document){var e=document.createElement("style");e.appendChild(document.createTextNode(".eclwatch_WUGraphLegend .graph_Vertex{cursor:auto}.eclwatch_WUGraphLegend .graph_Vertex .common_Icon{cursor:pointer}.eclwatch_WUGraph .graph_Vertex{cursor:auto}.eclwatch_WUGraph .marker{fill:#656565;stroke:none;stroke-width:1px}.eclwatch_WUGraph .zoom{fill:none;pointer-events:all}.eclwatch_WUGraph .selectionBrush{fill:none;stroke:#a9a9a9}.d3-tip .eclwatch_WUGraph_Tooltip h3,.d3-tip .eclwatch_WUGraph_Tooltip h4{margin:0}.d3-tip .eclwatch_WUGraph_Tooltip table{border-collapse:separate;border-spacing:5px}.d3-tip .eclwatch_WUGraph_Tooltip table .key{font-weight:700}.d3-tip .eclwatch_WUGraph_Tooltip table .value{font-weight:400}")),document.head.appendChild(e)}}catch(t){console.error("vite-plugin-css-injected-by-js",t)}}();