@hpcc-js/eclwatch 3.3.5 → 3.4.0

package/dist/index.js

@@ -1,104 +1,91 @@
-var __defProp = Object.defineProperty;
-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 { BaseScope, Result, WUStateID, Workunit } from "@hpcc-js/comms";
 import { SplitPanel } from "@hpcc-js/phosphor";
 import { DirectoryTree } from "@hpcc-js/tree";
-import { xml2json, hashSum, Subgraph, Vertex as Vertex$1, Edge } from "@hpcc-js/util";
-import { local, select, Icon, Button, ToggleButton, Spacer, Palette } from "@hpcc-js/common";
-import { Table, RowFormatter, domConstruct, Deferred, QueryResults, Common } from "@hpcc-js/dgrid";
-import { Vertex, Subgraph as Subgraph$1, Edge as Edge$1, Graph } from "@hpcc-js/graph";
-import { Legend, ChartPanel, Carousel } from "@hpcc-js/layout";
+import { Edge, Subgraph, Vertex, hashSum, xml2json } from "@hpcc-js/util";
+import { Button, Icon, Palette, Spacer, ToggleButton, local, select } from "@hpcc-js/common";
+import { Common, Deferred, QueryResults, RowFormatter, Table, domConstruct } from "@hpcc-js/dgrid";
+import { Edge as Edge$1, Graph, Subgraph as Subgraph$1, Vertex as Vertex$1 } from "@hpcc-js/graph";
+import { Carousel, ChartPanel, Legend } from "@hpcc-js/layout";
 import { ReactTimelineSeries } from "@hpcc-js/timeline";
+
+//#region src/__package__.ts
 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");
-    this._directoryPane.rowClick = (text) => {
-      this._fileEditorPane.text(text).render();
-    };
-  }
-  transformArchiveTreeData(json) {
-    const ret = {
-      label: json.name,
-      children: json._children.map(transformNode).filter((n) => n)
-    };
-    if (ret.children && ret.children[0] && ret.children[0].label === "html") {
-      return {
-        label: "root",
-        children: [
-          {
-            label: "error",
-            content: JSON.stringify(ret, null, 4)
-          }
-        ]
-      };
-    }
-    return ret;
-    function transformNode(node) {
-      const _node = {};
-      _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 false;
-      }
-      return _node;
-    }
-    __name(transformNode, "transformNode");
-  }
-  updateDirectoryPane(contentStr) {
-    let json;
-    if (contentStr) {
-      try {
-        json = JSON.parse(contentStr);
-      } 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);
-  }
-  update(domNode, element) {
-    super.update(domNode, element);
-    const hash = hashSum({
-      baseUrl: this.baseUrl(),
-      wuid: this.wuid()
-    });
-    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()]);
-  }
+
+//#endregion
+//#region src/ECLArchiveViewer.ts
+var ECLArchiveViewer = class extends SplitPanel {
+	_prevHash;
+	_contentStr;
+	_directoryPane = new DirectoryTree();
+	_fileEditorPane = new Editor().text("");
+	constructor() {
+		super("horizontal");
+		this._directoryPane.rowClick = (text) => {
+			this._fileEditorPane.text(text).render();
+		};
+	}
+	transformArchiveTreeData(json) {
+		const ret = {
+			label: json.name,
+			children: json._children.map(transformNode).filter((n) => n)
+		};
+		if (ret.children && ret.children[0] && ret.children[0].label === "html") return {
+			label: "root",
+			children: [{
+				label: "error",
+				content: JSON.stringify(ret, null, 4)
+			}]
+		};
+		return ret;
+		function transformNode(node) {
+			const _node = {};
+			_node.label = node.name + (node["$"] && node["$"].key ? ` (${node["$"].key})` : "");
+			if (node._children && node._children.length > 0) _node.children = node._children.map((_node$1) => {
+				return transformNode(_node$1);
+			}).filter((n) => n);
+			else if (typeof node.content === "string" && node.content.trim()) _node.content = node.content;
+			else return false;
+			return _node;
+		}
+	}
+	updateDirectoryPane(contentStr) {
+		let json;
+		if (contentStr) try {
+			json = JSON.parse(contentStr);
+		} 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);
+	}
+	update(domNode, element) {
+		super.update(domNode, element);
+		const hash = hashSum({
+			baseUrl: this.baseUrl(),
+			wuid: this.wuid()
+		});
+		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");
-ECLArchiveViewer.prototype.publish("directoryWidthRatio", 0.38, "number", "Default directory panel width ratio relative to the full width");
+ECLArchiveViewer.prototype.publish("directoryWidthRatio", .38, "number", "Default directory panel width ratio relative to the full width");
 ECLArchiveViewer.prototype.publish("contentString", null, "string", "XML/JSON archive content string");
 ECLArchiveViewer.prototype.publishProxy("directoryPaneColor", "_directoryPane", "backgroundColor");
 ECLArchiveViewer.prototype.publishProxy("directoryPaneHoverColor", "_directoryPane", "hoverBackgroundColor");
@@ -111,1072 +98,889 @@ ECLArchiveViewer.prototype.publishProxy("folderIconClosed", "_directoryPane");
 ECLArchiveViewer.prototype.publishProxy("textFileIcon", "_directoryPane");
 ECLArchiveViewer.prototype.publishProxy("codeFileIcon", "_directoryPane");
 ECLArchiveViewer.prototype.publishProxy("verticalScroll", "_directoryPane");
-const _LegendVertex = class _LegendVertex extends Vertex {
-  constructor() {
-    super();
-  }
-  enter(domNode, element) {
-    super.enter(domNode, element);
-    this._icon.on("click", () => {
-      this.click(this.data());
-    });
-  }
-  click(kind) {
-  }
+
+//#endregion
+//#region src/WUGraphLegend.ts
+var LegendVertex = class extends Vertex$1 {
+	constructor() {
+		super();
+	}
+	enter(domNode, element) {
+		super.enter(domNode, element);
+		this._icon.on("click", () => {
+			this.click(this.data());
+		});
+	}
+	click(kind) {}
 };
-__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) {
-        if (this._disabled2[key]) {
-          retVal.push(key);
-        }
-      }
-      return retVal;
-    }
-    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;
-    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);
-        }).on("mouseover", (kind) => {
-          context.mouseover(kind);
-        }).on("mouseout", (kind) => {
-          context.mouseout(kind);
-        })
-      );
-    }).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) {
-      context.icon.get(this).target(null).render();
-    }).remove();
-    const bbox = this.getBBox(true, true);
-    this._g.attr("transform", `translate(16, ${this.height() / 2 - bbox.height / 2})`);
-  }
-  //  Events  ---
-  click(kind) {
-  }
-  mouseover(kind) {
-  }
-  mouseout(kind) {
-  }
+var WUGraphLegend = class extends Legend {
+	icon = local();
+	_disabled2 = {};
+	disabled(_) {
+		if (!arguments.length) {
+			const retVal = [];
+			for (const key in this._disabled2) if (this._disabled2[key]) retVal.push(key);
+			return retVal;
+		}
+		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;
+		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);
+			}).on("mouseover", (kind) => {
+				context.mouseover(kind);
+			}).on("mouseout", (kind) => {
+				context.mouseout(kind);
+			}));
+		}).merge(items).each(function(d, i) {
+			const bbox$1 = context.icon.get(this).icon_shape_colorFill(context._disabled2[d.kind] ? "gray" : null).render().getBBox();
+			select(this).attr("transform", `translate(${+bbox$1.width / 2}, ${i * 30})`);
+		});
+		items.exit().each(function(d) {
+			context.icon.get(this).target(null).render();
+		}).remove();
+		const bbox = this.getBBox(true, true);
+		this._g.attr("transform", `translate(16, ${this.height() / 2 - bbox.height / 2})`);
+	}
+	click(kind) {}
+	mouseover(kind) {}
+	mouseout(kind) {}
 };
-__name(_WUGraphLegend, "WUGraphLegend");
-let WUGraphLegend = _WUGraphLegend;
 WUGraphLegend.prototype._class += " eclwatch_WUGraphLegend";
+
+//#endregion
+//#region src/WUScopeController.ts
 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 "";
+	switch (kind) {
+		case "2": return "";
+		case "3": return "";
+		case "5": return "";
+		case "6": return "";
+		case "12": return "";
+		case "15": return "";
+		case "17": return "";
+		case "22": return "";
+		case "23": return "";
+		case "25": return "";
+		case "26": return "";
+		case "29": return "";
+		case "36": return "";
+		case "44": return "";
+		case "47": return "";
+		case "54": return "";
+		case "56": return "";
+		case "59": return "";
+		case "61": return "";
+		case "82": return "";
+		case "88": return "";
+		case "92": return "";
+		case "93": return "";
+		case "99": return "";
+		case "105": return "";
+		case "7": return "";
+		case "9": return "";
+		case "16": return "";
+		case "19": return "";
+		case "21": return "";
+		case "35": return "";
+		case "37": return "";
+		case "71": return "";
+		case "133": return "";
+		case "148": return "";
+		case "168": return "";
+	}
+	return "";
 }
-__name(faCharFactory, "faCharFactory");
-const _WUScopeController = class _WUScopeController {
-  graphDB;
-  subgraphsMap = {};
-  rSubgraphsMap = {};
-  verticesMap = {};
-  rVerticesMap = {};
-  edgesMap = {};
-  rEdgesMap = {};
-  kindMap = {};
-  _disabled = {};
-  constructor() {
-  }
-  clear() {
-    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) ;
-      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) {
-        if (this._disabled[key]) {
-          retVal.push(key);
-        }
-      }
-      return retVal;
-    }
-    this._disabled = {};
-    _.forEach((kind) => this._disabled[kind] = true);
-    return this;
-  }
-  graphGui(graphDB) {
-    const graphGui = {
-      subgraphs: [],
-      vertices: [],
-      edges: [],
-      hierarchy: []
-    };
-    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 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 = "";
-    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 += labelTpl.substring(rpos + 1, labelTpl.length);
-    return retVal.split("\\n").join("\n");
-  }
-  createSubgraph(subgraph) {
-    let sg = this.subgraphsMap[subgraph._.Id];
-    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];
-    if (!v) {
-      const attrs = vertex._.rawAttrs();
-      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);
-        });
-      } else {
-        v = new Vertex().icon_shape_colorFill("#1f77b4").icon_image_colorFill("white").faChar(faCharFactory(attrs["Kind"])).text(attrs["Label"]);
-        const 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;
-    }
-    return v;
-  }
-  isSpill(edge) {
-    const sourceKind = edge.source._.attr("Kind").RawValue;
-    const targetKind = edge.target._.attr("Kind").RawValue;
-    return sourceKind === "2" || targetKind === "71";
-  }
-  spansSubgraph(edge) {
-    return edge.source.parent._.Id !== edge.target.parent._.Id;
-  }
-  createEdge(edge) {
-    let e = this.edgesMap[edge._.Id];
-    if (!e) {
-      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);
-        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;
-  }
-  appendSubgraph(subgraph, hierarchy, subgraphs) {
-    const sg = this.createSubgraph(subgraph);
-    subgraphs.push(sg);
-    const parent = this.subgraphsMap[subgraph.parent._.Id];
-    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];
-    if (parent) {
-      hierarchy.push({ parent, child: v });
-    }
-    return v;
-  }
-  appendEdge(edge, edges) {
-    const e = this.createEdge(edge);
-    if (e) {
-      edges.push(e);
-    }
-    return e;
-  }
-  filterLegend(graphDB) {
-    for (let i = graphDB.vertices.length - 1; i >= 0; --i) {
-      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) {
-      const sg = this.subgraphsMap[subgraph._.Id];
-      switch (sg.minState()) {
-        case "partial":
-          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,
-              Id: subgraph._.Id + ":dummy",
-              ScopeType: "dummy",
-              Properties: {
-                Property: [{
-                  Name: "Activities",
-                  RawValue: "" + vHide.length,
-                  Formatted: "" + vHide.length,
-                  Measure: "count",
-                  Creator: "",
-                  CreatorType: ""
-                }]
-              },
-              Notes: {
-                Note: []
-              },
-              SinkActivity: ""
-            };
-            const dummyScope = new BaseScope(dummyDetails);
-            const dummyVertex = subgraph.createVertex(dummyScope);
-            for (const vertex of vHide) {
-              for (const edge of vertex.inEdges) {
-                if (vShow.indexOf(edge.source) >= 0) {
-                  const dummyEdgeScope = new BaseScope({
-                    ScopeName: edge.source._.ScopeName,
-                    Id: edge.source._.Id + "->" + dummyVertex._.Id,
-                    ScopeType: "dummy-in",
-                    Properties: {
-                      Property: []
-                    },
-                    Notes: {
-                      Note: []
-                    },
-                    SinkActivity: ""
-                  });
-                  subgraph.createEdge(edge.source, dummyVertex, dummyEdgeScope);
-                }
-              }
-              for (const edge of vertex.outEdges) {
-                if (vShow.indexOf(edge.target) >= 0) {
-                  const dummyEdgeScope = new BaseScope({
-                    ScopeName: edge.target._.ScopeName,
-                    Id: dummyVertex._.Id + "->" + edge.target._.Id,
-                    ScopeType: "dummy-out",
-                    Properties: {
-                      Property: []
-                    },
-                    Notes: {
-                      Note: []
-                    },
-                    SinkActivity: ""
-                  });
-                  subgraph.createEdge(dummyVertex, edge.target, dummyEdgeScope);
-                }
-              }
-            }
-            vHide.forEach((vertex) => vertex.remove(true));
-          }
-          break;
-      }
-    }
-  }
-  filterEmptySubgraphs(graphDB) {
-    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(true));
-    }
-  }
-  removeObsoleteSubgraphs(graphDB) {
-    for (const subgraph of [...graphDB.subgraphs]) {
-      if (subgraph.vertices.length === 0) {
-        subgraph.remove(false);
-      }
-    }
-  }
-  graphData() {
-    const graphDB = this.graphDB.clone();
-    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) {
-      retVal.push({
-        kind: parseInt(kind),
-        faChar: faCharFactory(kind),
-        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]) {
-      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);
-      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] = "";
-      }
-    }
-    return row;
-  }
-  activityData() {
-    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"];
-    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"];
-    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;
-    let parentScope;
-    if (item instanceof Subgraph$1) {
-      const subgraph = this.rSubgraphsMap[item.id()];
-      scope = subgraph._;
-      parentScope = subgraph.parent._;
-    } else if (item instanceof Vertex || item instanceof Icon) {
-      const vertex = this.rVerticesMap[item.id()];
-      scope = vertex._;
-      parentScope = vertex.parent._;
-    } else if (item instanceof Edge$1) {
-      const edge = this.rEdgesMap[item.id()];
-      scope = edge._;
-      parentScope = edge.parent._;
-    }
-    if (scope) {
-      return scope.calcTooltip(parentScope);
-    }
-    return "";
-  }
-  subgraph(id) {
-    return this.subgraphsMap[id];
-  }
-  vertex(id) {
-    return this.verticesMap[id];
-  }
-  edge(id) {
-    return this.edgesMap[id];
-  }
-  //  Events  ---
-  minClick(sg) {
-  }
+var WUScopeController = class {
+	graphDB;
+	subgraphsMap = {};
+	rSubgraphsMap = {};
+	verticesMap = {};
+	rVerticesMap = {};
+	edgesMap = {};
+	rEdgesMap = {};
+	kindMap = {};
+	_disabled = {};
+	constructor() {}
+	clear() {
+		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) {} else if (item instanceof Vertex) {
+				const kind = item._.attr("Kind").RawValue;
+				if (!this.kindMap[kind]) this.kindMap[kind] = [];
+				this.kindMap[kind].push(item);
+			} else if (item instanceof Edge) {}
+		});
+	}
+	disabled(_) {
+		if (!arguments.length) {
+			const retVal = [];
+			for (const key in this._disabled) if (this._disabled[key]) retVal.push(key);
+			return retVal;
+		}
+		this._disabled = {};
+		_.forEach((kind) => this._disabled[kind] = true);
+		return this;
+	}
+	graphGui(graphDB) {
+		const graphGui = {
+			subgraphs: [],
+			vertices: [],
+			edges: [],
+			hierarchy: []
+		};
+		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 if (item instanceof Vertex) this.appendVertex(item, graphGui.hierarchy, graphGui.vertices);
+			else if (item instanceof Edge) this.appendEdge(item, graphGui.edges);
+		});
+		return graphGui;
+	}
+	format(labelTpl, obj) {
+		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 += labelTpl.substring(rpos + 1, labelTpl.length);
+		return retVal.split("\\n").join("\n");
+	}
+	createSubgraph(subgraph) {
+		let sg = this.subgraphsMap[subgraph._.Id];
+		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];
+		if (!v) {
+			const attrs = vertex._.rawAttrs();
+			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);
+				});
+			} else {
+				v = new Vertex$1().icon_shape_colorFill("#1f77b4").icon_image_colorFill("white").faChar(faCharFactory(attrs["Kind"])).text(attrs["Label"]);
+				const 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;
+		}
+		return v;
+	}
+	isSpill(edge) {
+		const sourceKind = edge.source._.attr("Kind").RawValue;
+		const targetKind = edge.target._.attr("Kind").RawValue;
+		return sourceKind === "2" || targetKind === "71";
+	}
+	spansSubgraph(edge) {
+		return edge.source.parent._.Id !== edge.target.parent._.Id;
+	}
+	createEdge(edge) {
+		let e = this.edgesMap[edge._.Id];
+		if (!e) {
+			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);
+				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;
+	}
+	appendSubgraph(subgraph, hierarchy, subgraphs) {
+		const sg = this.createSubgraph(subgraph);
+		subgraphs.push(sg);
+		const parent = this.subgraphsMap[subgraph.parent._.Id];
+		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];
+		if (parent) hierarchy.push({
+			parent,
+			child: v
+		});
+		return v;
+	}
+	appendEdge(edge, edges) {
+		const e = this.createEdge(edge);
+		if (e) edges.push(e);
+		return e;
+	}
+	filterLegend(graphDB) {
+		for (let i = graphDB.vertices.length - 1; i >= 0; --i) {
+			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()) {
+			case "partial":
+				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 dummyScope = new BaseScope({
+						ScopeName: subgraph._.ScopeName,
+						Id: subgraph._.Id + ":dummy",
+						ScopeType: "dummy",
+						Properties: { Property: [{
+							Name: "Activities",
+							RawValue: "" + vHide.length,
+							Formatted: "" + vHide.length,
+							Measure: "count",
+							Creator: "",
+							CreatorType: ""
+						}] },
+						Notes: { Note: [] },
+						SinkActivity: ""
+					});
+					const dummyVertex = subgraph.createVertex(dummyScope);
+					for (const vertex of vHide) {
+						for (const edge of vertex.inEdges) if (vShow.indexOf(edge.source) >= 0) {
+							const dummyEdgeScope = new BaseScope({
+								ScopeName: edge.source._.ScopeName,
+								Id: edge.source._.Id + "->" + dummyVertex._.Id,
+								ScopeType: "dummy-in",
+								Properties: { Property: [] },
+								Notes: { Note: [] },
+								SinkActivity: ""
+							});
+							subgraph.createEdge(edge.source, dummyVertex, dummyEdgeScope);
+						}
+						for (const edge of vertex.outEdges) if (vShow.indexOf(edge.target) >= 0) {
+							const dummyEdgeScope = new BaseScope({
+								ScopeName: edge.target._.ScopeName,
+								Id: dummyVertex._.Id + "->" + edge.target._.Id,
+								ScopeType: "dummy-out",
+								Properties: { Property: [] },
+								Notes: { Note: [] },
+								SinkActivity: ""
+							});
+							subgraph.createEdge(dummyVertex, edge.target, dummyEdgeScope);
+						}
+					}
+					vHide.forEach((vertex) => vertex.remove(true));
+				}
+				break;
+		}
+	}
+	filterEmptySubgraphs(graphDB) {
+		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(true));
+		}
+	}
+	removeObsoleteSubgraphs(graphDB) {
+		for (const subgraph of [...graphDB.subgraphs]) if (subgraph.vertices.length === 0) subgraph.remove(false);
+	}
+	graphData() {
+		const graphDB = this.graphDB.clone();
+		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) retVal.push({
+			kind: parseInt(kind),
+			faChar: faCharFactory(kind),
+			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]) retVal.push(this.verticesMap[v._.Id]);
+		return retVal;
+	}
+	formatRow(item, columns$1, row) {
+		const attrs = item._.formattedAttrs();
+		for (const key in attrs) {
+			const idx = columns$1.indexOf(key);
+			if (idx === -1) {
+				columns$1.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] = "";
+		return row;
+	}
+	activityData() {
+		const columns$1 = [
+			"Id",
+			"Kind",
+			"Label"
+		];
+		return {
+			columns: columns$1,
+			data: this.graphDB.vertices.map((v) => {
+				const row = [parseInt(v._.Id.split("a")[1])];
+				return this.formatRow(v, columns$1, row);
+			})
+		};
+	}
+	edgeData() {
+		const columns$1 = ["Id", "Label"];
+		return {
+			columns: columns$1,
+			data: this.graphDB.edges.map((e) => {
+				const row = [e._.Id];
+				return this.formatRow(e, columns$1, row);
+			})
+		};
+	}
+	subgraphData() {
+		const columns$1 = ["Id", "Label"];
+		return {
+			columns: columns$1,
+			data: this.graphDB.subgraphs.map((sg) => {
+				const row = [sg._.Id];
+				return this.formatRow(sg, columns$1, row);
+			})
+		};
+	}
+	calcGraphTooltip(item) {
+		let scope;
+		let parentScope;
+		if (item instanceof Subgraph$1) {
+			const subgraph = this.rSubgraphsMap[item.id()];
+			scope = subgraph._;
+			parentScope = subgraph.parent._;
+		} else if (item instanceof Vertex$1 || item instanceof Icon) {
+			const vertex = this.rVerticesMap[item.id()];
+			scope = vertex._;
+			parentScope = vertex.parent._;
+		} else if (item instanceof Edge$1) {
+			const edge = this.rEdgesMap[item.id()];
+			scope = edge._;
+			parentScope = edge.parent._;
+		}
+		if (scope) return scope.calcTooltip(parentScope);
+		return "";
+	}
+	subgraph(id) {
+		return this.subgraphsMap[id];
+	}
+	vertex(id) {
+		return this.verticesMap[id];
+	}
+	edge(id) {
+		return this.edgesMap[id];
+	}
+	minClick(sg) {}
 };
-__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();
-    this.topOverlay(false);
-    this.widget(this._view);
-    const buttons = [
-      this._toggleGraph,
-      this._toggleActivities,
-      this._toggleEdges,
-      this._toggleSubgraphs,
-      new Spacer(),
-      this._partialAll,
-      this._maxAll,
-      new Spacer(),
-      ...this._graph.iconBarButtons(),
-      new Spacer()
-    ];
-    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) => {
-      return this._gc.calcGraphTooltip(v);
-    });
-  }
-  stateClick(sourceB) {
-    switch (sourceB) {
-      case this._partialAll:
-        this._graph.data().subgraphs.forEach((sg) => {
-          sg.minState("partial");
-        });
-        break;
-      case this._maxAll:
-        this._graph.data().subgraphs.forEach((sg) => {
-          sg.minState("normal");
-        });
-        break;
-    }
-    this.render();
-  }
-  viewClick(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;
-      case this._toggleActivities:
-        this._view.active(1);
-        break;
-      case this._toggleEdges:
-        this._view.active(2);
-        break;
-      case this._toggleSubgraphs:
-        this._view.active(3);
-        break;
-    }
-    this.render((w) => {
-    });
-  }
-  _prevHashSum;
-  _prevScopeGraph;
-  fetchScopeGraph() {
-    const hash = hashSum({
-      baseUrl: this.baseUrl(),
-      wuid: this.wuid(),
-      graphID: this.graphID(),
-      subgraphID: this.subgraphID()
-    });
-    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);
-  }
-  update(domNode, element) {
-    super.update(domNode, element);
-  }
-  exit(domNode, element) {
-    super.exit(domNode, element);
-  }
-  loadGraph() {
-    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);
-    }
-    {
-      const { columns: columns2, data } = this._gc.edgeData();
-      this._edges.columns(columns2).data(data);
-    }
-    {
-      const { columns: columns2, data } = this._gc.subgraphData();
-      this._subgraphs.columns(columns2).data(data);
-    }
-  }
-  render(callback) {
-    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(_);
-    if (item) {
-      this._graph.selection([item]);
-    }
-    return this;
-  }
+
+//#endregion
+//#region src/WUGraph.ts
+var WUGraph = class 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();
+		this.topOverlay(false);
+		this.widget(this._view);
+		const buttons = [
+			this._toggleGraph,
+			this._toggleActivities,
+			this._toggleEdges,
+			this._toggleSubgraphs,
+			new Spacer(),
+			this._partialAll,
+			this._maxAll,
+			new Spacer(),
+			...this._graph.iconBarButtons(),
+			new Spacer()
+		];
+		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) => {
+			return this._gc.calcGraphTooltip(v);
+		});
+	}
+	stateClick(sourceB) {
+		switch (sourceB) {
+			case this._partialAll:
+				this._graph.data().subgraphs.forEach((sg) => {
+					sg.minState("partial");
+				});
+				break;
+			case this._maxAll:
+				this._graph.data().subgraphs.forEach((sg) => {
+					sg.minState("normal");
+				});
+				break;
+		}
+		this.render();
+	}
+	viewClick(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;
+			case this._toggleActivities:
+				this._view.active(1);
+				break;
+			case this._toggleEdges:
+				this._view.active(2);
+				break;
+			case this._toggleSubgraphs:
+				this._view.active(3);
+				break;
+		}
+		this.render((w) => {});
+	}
+	_prevHashSum;
+	_prevScopeGraph;
+	fetchScopeGraph() {
+		const hash = hashSum({
+			baseUrl: this.baseUrl(),
+			wuid: this.wuid(),
+			graphID: this.graphID(),
+			subgraphID: this.subgraphID()
+		});
+		if (!this._prevScopeGraph || this._prevHashSum !== hash) {
+			this.startProgress();
+			this._prevHashSum = hash;
+			this._gc.clear();
+			return Workunit.attach({ baseUrl: this.baseUrl() }, this.wuid()).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);
+	}
+	update(domNode, element) {
+		super.update(domNode, element);
+	}
+	exit(domNode, element) {
+		super.exit(domNode, element);
+	}
+	loadGraph() {
+		this._gc.disabled(this._legend.disabled());
+		this._graph.data(this._gc.graphData(), true);
+		{
+			const { columns: columns$1, data } = this._gc.activityData();
+			this._activities.columns(columns$1).data(data);
+		}
+		{
+			const { columns: columns$1, data } = this._gc.edgeData();
+			this._edges.columns(columns$1).data(data);
+		}
+		{
+			const { columns: columns$1, data } = this._gc.subgraphData();
+			this._subgraphs.columns(columns$1).data(data);
+		}
+	}
+	render(callback) {
+		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(_);
+		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");
 WUGraph.prototype.publish("graphID", "", "string", "Graph ID");
 WUGraph.prototype.publish("subgraphID", "", "string", "Subgraph ID");
+
+//#endregion
+//#region src/WUResultStore.ts
 function entitiesEncode(str) {
-  return String(str).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+	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]":
-    case "[object Boolean]":
-    case "[object Number]":
-      return item;
-    case "[object String]":
-      return entitiesEncode(item);
-    default:
-      console.warn("Unknown cell type:  " + Object.prototype.toString.call(item));
-  }
-  return item;
+	switch (Object.prototype.toString.call(item)) {
+		case "[object Undefined]":
+		case "[object Boolean]":
+		case "[object Number]": return item;
+		case "[object String]": return entitiesEncode(item);
+		default: console.warn("Unknown cell type:  " + Object.prototype.toString.call(item));
+	}
+	return item;
 }
-__name(safeEncode, "safeEncode");
-const _Store = class _Store {
-  wuResult;
-  schema;
-  _columns;
-  _cache = {};
-  rowFormatter;
-  _filter = {};
-  onError;
-  constructor(wuResult, schema, renderHtml, filter = {}, 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 = "") {
-    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: false,
-        width: keyed ? 16 : 0,
-        isSet: node.isSet
-      };
-      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 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) {
-        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) {
-          domConstruct.create("th", { innerHTML: safeEncode(key) }, tr);
-        }
-        tr = domConstruct.create("tr", null, table);
-        for (const key in cell) {
-          switch (Object.prototype.toString.call(cell[key])) {
-            case "[object Object]":
-            case "[object Array]":
-              this.rowToTable(cell[key], __row, node);
-              break;
-            default:
-              domConstruct.create("td", { innerHTML: safeEncode(cell[key]) }, tr);
-              break;
-          }
-        }
-        break;
-      case "[object Array]":
-        for (let i = 0; i < cell.length; ++i) {
-          switch (Object.prototype.toString.call(cell[i])) {
-            case "[object Boolean]":
-            case "[object Number]":
-            case "[object String]":
-              const tr1 = domConstruct.create("tr", null, table);
-              domConstruct.create("td", { innerHTML: safeEncode(cell[i]) }, tr1);
-              break;
-            default:
-              if (i === 0) {
-                const tr2 = domConstruct.create("tr", null, table);
-                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]) {
-                  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 - "__html".length) !== -1) {
-                    domConstruct.create("td", { innerHTML: cell[i][key] }, tr1);
-                  } else if (key.indexOf("__javascript", key.length - "__javascript".length) !== -1) {
-                    domConstruct.create("td", null, tr1);
-                  } else {
-                    const val = cell[i][key];
-                    domConstruct.create("td", { innerHTML: safeEncode(val) }, tr1);
-                  }
-                } else {
-                  domConstruct.create("td", { innerHTML: "" }, tr1);
-                }
-              }
-          }
-        }
-        break;
-    }
-  }
-  getIdentity(row) {
-    return row.__hpcc_id;
-  }
-  _request(start, end) {
-    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, 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();
-    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)
-    });
-  }
+var Store = class {
+	wuResult;
+	schema;
+	_columns;
+	_cache = {};
+	rowFormatter;
+	_filter = {};
+	onError;
+	constructor(wuResult, schema, renderHtml, filter = {}, 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 = "") {
+		if (!parentNode) return [];
+		return parentNode.children().filter((node) => node.name.indexOf("__hidden", node.name.length - 8) === -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: false,
+				width: keyed ? 16 : 0,
+				isSet: node.isSet
+			};
+			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 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) 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) domConstruct.create("th", { innerHTML: safeEncode(key) }, tr);
+				tr = domConstruct.create("tr", null, table);
+				for (const key in cell) switch (Object.prototype.toString.call(cell[key])) {
+					case "[object Object]":
+					case "[object Array]":
+						this.rowToTable(cell[key], __row, node);
+						break;
+					default:
+						domConstruct.create("td", { innerHTML: safeEncode(cell[key]) }, tr);
+						break;
+				}
+				break;
+			case "[object Array]":
+				for (let i = 0; i < cell.length; ++i) switch (Object.prototype.toString.call(cell[i])) {
+					case "[object Boolean]":
+					case "[object Number]":
+					case "[object String]":
+						const tr1 = domConstruct.create("tr", null, table);
+						domConstruct.create("td", { innerHTML: safeEncode(cell[i]) }, tr1);
+						break;
+					default:
+						if (i === 0) {
+							const tr2 = domConstruct.create("tr", null, table);
+							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]) 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) domConstruct.create("td", { innerHTML: cell[i][key] }, tr1);
+						else if (key.indexOf("__javascript", key.length - 12) !== -1) domConstruct.create("td", null, tr1);
+						else {
+							const val = cell[i][key];
+							domConstruct.create("td", { innerHTML: safeEncode(val) }, tr1);
+						}
+						else domConstruct.create("td", { innerHTML: "" }, tr1);
+				}
+				break;
+		}
+	}
+	getIdentity(row) {
+		return row.__hpcc_id;
+	}
+	_request(start, end) {
+		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, 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();
+		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) });
+	}
 };
-__name(_Store, "Store");
-let Store = _Store;
-const _WUResult = class _WUResult extends Common {
-  _result;
-  _localStore;
-  constructor() {
-    super();
-    this.renderHtml(false);
-  }
-  hashSum(opts = {}) {
-    return hashSum({
-      baseUrl: this.baseUrl(),
-      wuid: this.wuid(),
-      resultName: this.resultName(),
-      sequence: this.sequence(),
-      nodeGroup: this.nodeGroup(),
-      logicalFile: this.logicalFile(),
-      userID: this.user(),
-      password: this.password(),
-      bypassCache: this.bypassCache(),
-      ...opts
-    });
-  }
-  _prevResultHash;
-  calcResult() {
-    const resultHash = this.hashSum();
-    if (this._prevResultHash !== resultHash) {
-      this._prevResultHash = resultHash;
-      const opts = {
-        baseUrl: this.baseUrl(),
-        userID: this.user(),
-        password: this.password()
-      };
-      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();
-    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({
-      renderHtml: this.renderHtml(),
-      filter: this.filter()
-    });
-    if (this._prevStoreHash !== storeHash) {
-      this._prevStoreHash = storeHash;
-      const result = this.calcResult();
-      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) {
-  }
+
+//#endregion
+//#region src/WUResult.ts
+var WUResult = class extends Common {
+	_result;
+	_localStore;
+	constructor() {
+		super();
+		this.renderHtml(false);
+	}
+	hashSum(opts = {}) {
+		return hashSum({
+			baseUrl: this.baseUrl(),
+			wuid: this.wuid(),
+			resultName: this.resultName(),
+			sequence: this.sequence(),
+			nodeGroup: this.nodeGroup(),
+			logicalFile: this.logicalFile(),
+			userID: this.user(),
+			password: this.password(),
+			bypassCache: this.bypassCache(),
+			...opts
+		});
+	}
+	_prevResultHash;
+	calcResult() {
+		const resultHash = this.hashSum();
+		if (this._prevResultHash !== resultHash) {
+			this._prevResultHash = resultHash;
+			const opts = {
+				baseUrl: this.baseUrl(),
+				userID: this.user(),
+				password: this.password()
+			};
+			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();
+		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({
+			renderHtml: this.renderHtml(),
+			filter: this.filter()
+		});
+		if (this._prevStoreHash !== storeHash) {
+			this._prevStoreHash = storeHash;
+			const result = this.calcResult();
+			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");
@@ -1188,286 +992,267 @@ WUResult.prototype.publish("nodeGroup", "", "string", "NodeGroup");
 WUResult.prototype.publish("logicalFile", "", "string", "Logical File Name");
 WUResult.prototype.publish("filter", {}, "object", "Filter");
 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();
-    this.zoomable(false).zoomToFitLimit(1).layout("Hierarchy").hierarchyRankDirection("LR").showToolbar(false).allowDragging(false);
-  }
-  _prevHash;
-  attachWorkunit() {
-    const hash = hashSum({
-      baseUrl: this.baseUrl(),
-      wuid: this.wuid()
-    });
-    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);
-  }
-  updateVertex(vertex, color) {
-    vertex.icon_image_colorFill(color).textbox_text_colorFill(color);
-  }
-  updateVertexStatus(level, active = false) {
-    const completeColor = this._wu.isFailed() ? "darkred" : "darkgreen";
-    this._create.text(
-      "Created"
-      /* CREATE */
-    );
-    this._compile.text(
-      "Compiled"
-      /* COMPILE */
-    );
-    this._execute.text(
-      "Executed"
-      /* EXECUTE */
-    );
-    this._complete.text(
-      "Completed"
-      /* COMPLETE */
-    );
-    switch (level) {
-      case 0:
-        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");
-        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");
-        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");
-        break;
-      case 4:
-        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(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);
-    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) {
-    this.attachWorkunit();
-    switch (this._wu.StateID) {
-      case WUStateID.Blocked:
-      case WUStateID.Wait:
-      case WUStateID.Scheduled:
-      case WUStateID.UploadingFiled:
-        this.updateVertexStatus(1);
-        break;
-      case WUStateID.Compiling:
-        this.updateVertexStatus(2, true);
-        break;
-      case WUStateID.Submitted:
-        this.updateVertexStatus(1, true);
-        break;
-      case WUStateID.Compiled:
-        this.updateVertexStatus(2);
-        break;
-      case WUStateID.Aborting:
-      case WUStateID.Running:
-        this.updateVertexStatus(3, true);
-        break;
-      case WUStateID.Aborted:
-      case WUStateID.Archived:
-      case WUStateID.Completed:
-        this.updateVertexStatus(4);
-        break;
-      case WUStateID.Failed:
-        this.updateVertexStatus(4, false);
-        break;
-      case WUStateID.DebugPaused:
-      case WUStateID.DebugRunning:
-      case WUStateID.Paused:
-      case WUStateID.Unknown:
-      default:
-        this.updateVertexStatus(0);
-        break;
-    }
-    super.update(domNode, element);
-    this.zoomToFit();
-  }
-  exit(domNode, element) {
-    if (this._wuHandle) {
-      this._wuHandle.release();
-    }
-    super.exit(domNode, element);
-  }
+
+//#endregion
+//#region src/WUStatus.ts
+let STATUS = /* @__PURE__ */ function(STATUS$1) {
+	STATUS$1["CREATE"] = "Created";
+	STATUS$1["COMPILE"] = "Compiled";
+	STATUS$1["EXECUTE"] = "Executed";
+	STATUS$1["COMPLETE"] = "Completed";
+	return STATUS$1;
+}({});
+let STATUS_ACTIVE = /* @__PURE__ */ function(STATUS_ACTIVE$1) {
+	STATUS_ACTIVE$1["CREATE"] = "Creating";
+	STATUS_ACTIVE$1["COMPILE"] = "Compiling";
+	STATUS_ACTIVE$1["EXECUTE"] = "Executing";
+	STATUS_ACTIVE$1["COMPLETE"] = "Completed";
+	return STATUS_ACTIVE$1;
+}({});
+var WUStatus = class extends Graph {
+	_wu;
+	_wuHandle;
+	_create;
+	_compile;
+	_execute;
+	_complete;
+	constructor() {
+		super();
+		this.zoomable(false).zoomToFitLimit(1).layout("Hierarchy").hierarchyRankDirection("LR").showToolbar(false).allowDragging(false);
+	}
+	_prevHash;
+	attachWorkunit() {
+		const hash = hashSum({
+			baseUrl: this.baseUrl(),
+			wuid: this.wuid()
+		});
+		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$1().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);
+	}
+	updateVertex(vertex, color) {
+		vertex.icon_image_colorFill(color).textbox_text_colorFill(color);
+	}
+	updateVertexStatus(level, active = false) {
+		const completeColor = this._wu.isFailed() ? "darkred" : "darkgreen";
+		this._create.text(STATUS.CREATE);
+		this._compile.text(STATUS.COMPILE);
+		this._execute.text(STATUS.EXECUTE);
+		this._complete.text(STATUS.COMPLETE);
+		switch (level) {
+			case 0:
+				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(STATUS_ACTIVE.CREATE);
+				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(STATUS_ACTIVE.COMPILE);
+				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(STATUS_ACTIVE.EXECUTE);
+				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);
+				break;
+		}
+	}
+	createEdge(source, target) {
+		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);
+		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) {
+		this.attachWorkunit();
+		switch (this._wu.StateID) {
+			case WUStateID.Blocked:
+			case WUStateID.Wait:
+			case WUStateID.Scheduled:
+			case WUStateID.UploadingFiled:
+				this.updateVertexStatus(1);
+				break;
+			case WUStateID.Compiling:
+				this.updateVertexStatus(2, true);
+				break;
+			case WUStateID.Submitted:
+				this.updateVertexStatus(1, true);
+				break;
+			case WUStateID.Compiled:
+				this.updateVertexStatus(2);
+				break;
+			case WUStateID.Aborting:
+			case WUStateID.Running:
+				this.updateVertexStatus(3, true);
+				break;
+			case WUStateID.Aborted:
+			case WUStateID.Archived:
+			case WUStateID.Completed:
+				this.updateVertexStatus(4);
+				break;
+			case WUStateID.Failed:
+				this.updateVertexStatus(4, false);
+				break;
+			case WUStateID.DebugPaused:
+			case WUStateID.DebugRunning:
+			case WUStateID.Paused:
+			case WUStateID.Unknown:
+			default:
+				this.updateVertexStatus(0);
+				break;
+		}
+		super.update(domNode, element);
+		this.zoomToFit();
+	}
+	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"];
-const _WUTimeline = class _WUTimeline extends ReactTimelineSeries {
-  _palette = Palette.ordinal("default");
-  constructor() {
-    super();
-    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() {
-    delete this._prevHashSum;
-    return this;
-  }
-  fetchScopes() {
-    const hash = hashSum({
-      baseUrl: this.baseUrl(),
-      wuid: this.wuid(),
-      request: this.request()
-    });
-    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);
-  }
-  exit(domNode, element) {
-    super.exit(domNode, element);
-  }
+
+//#endregion
+//#region src/WUTimeline.ts
+var columns = [
+	"label",
+	"start",
+	"end",
+	"icon",
+	"color",
+	"series"
+];
+var WUTimeline = class extends ReactTimelineSeries {
+	_palette = Palette.ordinal("default");
+	constructor() {
+		super();
+		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() {
+		delete this._prevHashSum;
+		return this;
+	}
+	fetchScopes() {
+		const hash = hashSum({
+			baseUrl: this.baseUrl(),
+			wuid: this.wuid(),
+			request: this.request()
+		});
+		if (this._prevHashSum !== hash) {
+			this._prevHashSum = hash;
+			Workunit.attach({ baseUrl: this.baseUrl() }, this.wuid()).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);
+	}
+	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");
 WUTimeline.prototype.publish("request", {
-  ScopeFilter: {
-    MaxDepth: 3,
-    ScopeTypes: ["graph", "subgraph"]
-  },
-  NestedFilter: {
-    Depth: 0,
-    ScopeTypes: []
-  },
-  PropertiesToReturn: {
-    AllProperties: false,
-    AllStatistics: true,
-    AllHints: false,
-    Properties: ["WhenStarted", "TimeElapsed"]
-  },
-  ScopeOptions: {
-    IncludeId: true,
-    IncludeScope: true,
-    IncludeScopeType: true
-  },
-  PropertyOptions: {
-    IncludeName: true,
-    IncludeRawValue: true,
-    IncludeFormatted: true,
-    IncludeMeasure: true,
-    IncludeCreator: false,
-    IncludeCreatorType: false
-  }
+	ScopeFilter: {
+		MaxDepth: 3,
+		ScopeTypes: ["graph", "subgraph"]
+	},
+	NestedFilter: {
+		Depth: 0,
+		ScopeTypes: []
+	},
+	PropertiesToReturn: {
+		AllProperties: false,
+		AllStatistics: true,
+		AllHints: false,
+		Properties: ["WhenStarted", "TimeElapsed"]
+	},
+	ScopeOptions: {
+		IncludeId: true,
+		IncludeScope: true,
+		IncludeScopeType: true
+	},
+	PropertyOptions: {
+		IncludeName: true,
+		IncludeRawValue: true,
+		IncludeFormatted: true,
+		IncludeMeasure: true,
+		IncludeCreator: false,
+		IncludeCreatorType: false
+	}
 }, "object", "WUDetails Request");
-export {
-  BUILD_VERSION,
-  ECLArchiveViewer,
-  PKG_NAME,
-  PKG_VERSION,
-  STATUS,
-  STATUS_ACTIVE,
-  WUGraph,
-  WUResult,
-  WUScopeController,
-  WUStatus,
-  WUTimeline
-};
-//# sourceMappingURL=index.js.map
-!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)}}();
+
+//#endregion
+export { BUILD_VERSION, ECLArchiveViewer, PKG_NAME, PKG_VERSION, STATUS, STATUS_ACTIVE, WUGraph, WUResult, WUScopeController, WUStatus, WUTimeline };
+//# sourceMappingURL=index.js.map!function(){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}\n/*$vite$:1*/")),document.head.appendChild(e)}}catch(t){console.error("vite-plugin-css-injected-by-js",t)}}();