@matdata/yasr 4.6.1

package/src/parsers/tsv.ts

@@ -0,0 +1,43 @@
+import Parser from "./";
+
+export default function (tsvString: string) {
+  const lines = tsvString.split("\n");
+
+  lines.pop(); //remove the last empty line
+
+  const [headersString, ...sparqlDataStringArr] = lines;
+  const headers = headersString.split("\t").map((header) => header.substring(1));
+
+  const sparqlData = sparqlDataStringArr.map((row) => {
+    const binding: Parser.Binding = {};
+    for (const [index, value] of row.split("\t").entries()) {
+      const bindingName = headers[index];
+      if (value[0] === "<") {
+        binding[bindingName] = { value: value.substring(1, value.length - 1), type: "uri" };
+      } else if (value[0] === '"') {
+        const lastDoubleQuote = value.lastIndexOf('"');
+        const literalValue = value.substring(1, lastDoubleQuote);
+        if (lastDoubleQuote === value.length - 1) binding[bindingName] = { value: literalValue, type: "literal" };
+        else if (lastDoubleQuote < value.lastIndexOf("@")) {
+          const langTag = value.substring(value.lastIndexOf("@") + 1);
+          binding[bindingName] = { value: literalValue, type: "literal", "xml:lang": langTag };
+        } else if (lastDoubleQuote < value.lastIndexOf("^^")) {
+          const dataTag = value.substring(value.lastIndexOf("^^") + 2);
+          binding[bindingName] = { value: literalValue, type: "typed-literal", datatype: dataTag };
+        }
+      }
+    }
+    return binding;
+  });
+
+  const sparqlResults: Parser.SparqlResults = {
+    head: {
+      vars: headers,
+    },
+    results: {
+      bindings: sparqlData,
+    },
+  };
+
+  return sparqlResults;
+}

package/src/parsers/turtleFamily.ts

@@ -0,0 +1,60 @@
+import Parser from "./";
+import * as N3 from "n3";
+
+function n3TermToSparqlBinding(term: N3.Term): Parser.BindingValue {
+  if (term.termType === "NamedNode") {
+    return {
+      value: term.value,
+      type: "uri",
+    };
+  }
+  if (term.termType === "Literal") {
+    const bindingVal: Parser.BindingValue = {
+      value: term.value,
+      type: "literal",
+    };
+    const lang = term.language;
+    if (lang) bindingVal["xml:lang"] = lang;
+    const type = term.datatypeString;
+    if (type) bindingVal.datatype = type;
+
+    return bindingVal;
+  }
+
+  if (term.termType === "BlankNode") {
+    return {
+      value: term.value,
+      type: "bnode",
+    };
+  }
+  return {
+    value: term.value,
+    type: "uri",
+  };
+}
+export default function (queryResponse: any): Parser.SparqlResults {
+  const statements = getTurtleAsStatements(queryResponse);
+  const vars = ["subject", "predicate", "object"];
+  const bindings = statements.map((statement) => {
+    const binding: Parser.Binding = {
+      subject: n3TermToSparqlBinding(statement.subject),
+      predicate: n3TermToSparqlBinding(statement.predicate),
+      object: n3TermToSparqlBinding(statement.object),
+    };
+    return binding;
+  });
+  return {
+    head: {
+      vars: vars,
+    },
+    results: {
+      bindings: bindings,
+    },
+  };
+}
+export function getTurtleAsStatements(queryResponse: any): N3.Quad[] {
+  const parser = new N3.Parser();
+  // When no the response has no body use an empty string
+  const parsed = parser.parse(queryResponse || "");
+  return parsed;
+}

package/src/parsers/xml.ts

@@ -0,0 +1,79 @@
+import Parser from "./";
+import { unescape, isEmpty } from "lodash-es";
+function parseHead(node: ChildNode): Parser.SparqlResults["head"] {
+  const head: Parser.SparqlResults["head"] = {
+    vars: [],
+  };
+  for (let headNodeIt = 0; headNodeIt < node.childNodes.length; headNodeIt++) {
+    const headNode = node.childNodes[headNodeIt] as Element;
+    if (headNode.nodeName == "variable") {
+      const name = headNode.getAttribute("name");
+      if (name) head.vars.push(name);
+    }
+  }
+  return head;
+}
+
+const allowedBindingValueTypes: Array<Parser.BindingValue["type"]> = ["uri", "literal", "bnode", "typed-literal"];
+function parseResults(node: ChildNode, postProcessBinding: Parser.PostProcessBinding): Parser.SparqlResults["results"] {
+  const results: Parser.SparqlResults["results"] = {
+    bindings: [],
+  };
+
+  for (let resultIt = 0; resultIt < node.childNodes.length; resultIt++) {
+    const resultNode = node.childNodes[resultIt];
+    const binding: Parser.Binding = {};
+
+    for (let bindingIt = 0; bindingIt < resultNode.childNodes.length; bindingIt++) {
+      const bindingNode = resultNode.childNodes[bindingIt] as Element;
+      if (bindingNode.nodeName == "binding") {
+        const varName = bindingNode.getAttribute("name");
+        if (varName) {
+          for (let bindingInfIt = 0; bindingInfIt < bindingNode.childNodes.length; bindingInfIt++) {
+            const bindingInf = bindingNode.childNodes[bindingInfIt] as Element;
+            if (bindingInf.nodeName === "#text") continue;
+            if (allowedBindingValueTypes.indexOf(bindingInf.nodeName as any) < 0) continue;
+            const bindingValue: Parser.BindingValue = {
+              type: bindingInf.nodeName as Parser.BindingValue["type"],
+              value: unescape(bindingInf.innerHTML),
+            };
+            const dataType = bindingInf.getAttribute("datatype");
+            if (dataType) bindingValue.datatype = dataType;
+            binding[varName] = bindingValue;
+          }
+        }
+      }
+    }
+
+    if (!isEmpty) {
+    }
+    if (!isEmpty(binding)) results.bindings.push(postProcessBinding(binding));
+  }
+  return results;
+}
+
+function parseBoolean(node: Element) {
+  return node.innerHTML === "true";
+}
+export default function (
+  xmlString: string,
+  postProcessBinding: Parser.PostProcessBinding
+): Parser.SparqlResults | undefined {
+  if (typeof xmlString !== "string") return;
+  const domParser = new DOMParser();
+  let mainXml = domParser.parseFromString(xmlString, "text/xml");
+  if (!mainXml.childNodes.length) return;
+
+  const xml = mainXml.childNodes[0];
+
+  const json: Partial<Parser.SparqlResults> = {};
+
+  for (let i = 0; i < xml.childNodes.length; i++) {
+    const node = xml.childNodes[i];
+    if (node.nodeName == "head") json.head = parseHead(node as Element);
+    if (node.nodeName == "results") json.results = parseResults(node as Element, postProcessBinding);
+    if (node.nodeName == "boolean") json.boolean = parseBoolean(node as Element);
+  }
+
+  return json as Parser.SparqlResults;
+}

package/src/plugins/boolean/index.scss

@@ -0,0 +1,11 @@
+.yasr {
+  .booleanResult {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    svg {
+      margin-bottom: -10px;
+      margin-right: 7px;
+    }
+  }
+}

package/src/plugins/boolean/index.ts

@@ -0,0 +1,42 @@
+/**
+ * Make sure not to include any deps from our main index file. That way, we can easily publish the publin as standalone build
+ */
+import Yasr from "../../";
+import { Plugin } from "../";
+require("./index.scss");
+export interface PluginConfig {}
+import { drawSvgStringAsElement } from "@matdata/yasgui-utils";
+const cross =
+  '<svg xmlns="http://www.w3.org/2000/svg" version="1.1" x="0" y="0" width="30" height="30" viewBox="0 0 100 100" enable-background="new 0 0 100 100" xml:space="preserve"><g><path d="M83.288,88.13c-2.114,2.112-5.575,2.112-7.689,0L53.659,66.188c-2.114-2.112-5.573-2.112-7.687,0L24.251,87.907 c-2.113,2.114-5.571,2.114-7.686,0l-4.693-4.691c-2.114-2.114-2.114-5.573,0-7.688l21.719-21.721c2.113-2.114,2.113-5.573,0-7.686 L11.872,24.4c-2.114-2.113-2.114-5.571,0-7.686l4.842-4.842c2.113-2.114,5.571-2.114,7.686,0L46.12,33.591 c2.114,2.114,5.572,2.114,7.688,0l21.721-21.719c2.114-2.114,5.573-2.114,7.687,0l4.695,4.695c2.111,2.113,2.111,5.571-0.003,7.686 L66.188,45.973c-2.112,2.114-2.112,5.573,0,7.686L88.13,75.602c2.112,2.111,2.112,5.572,0,7.687L83.288,88.13z"/></g></svg>';
+const check =
+  '<svg xmlns="http://www.w3.org/2000/svg" version="1.1" x="0" y="0" width="30" height="30" viewBox="0 0 100 100" enable-background="new 0 0 100 100" xml:space="preserve"><path d="M14.301,49.982l22.606,17.047L84.361,4.903c2.614-3.733,7.76-4.64,11.493-2.026l0.627,0.462 c3.732,2.614,4.64,7.758,2.025,11.492l-51.783,79.77c-1.955,2.791-3.896,3.762-7.301,3.988c-3.405,0.225-5.464-1.039-7.508-3.084 L2.447,61.814c-3.263-3.262-3.263-8.553,0-11.814l0.041-0.019C5.75,46.718,11.039,46.718,14.301,49.982z"/></svg>';
+
+export default class Boolean implements Plugin<PluginConfig> {
+  private yasr: Yasr;
+  public priority = 10;
+  hideFromSelection = true;
+  constructor(yasr: Yasr) {
+    this.yasr = yasr;
+  }
+  draw() {
+    const el = document.createElement("div");
+    el.className = "booleanResult";
+
+    const boolVal = this.yasr.results?.getBoolean();
+    el.appendChild(drawSvgStringAsElement(boolVal ? check : cross));
+    const textEl = document.createElement("span");
+    textEl.textContent = boolVal ? "True" : "False";
+    el.appendChild(textEl);
+
+    this.yasr.resultsEl.appendChild(el);
+  }
+  canHandleResults() {
+    return (
+      !!this.yasr.results?.getBoolean &&
+      (this.yasr.results.getBoolean() === true || this.yasr.results.getBoolean() == false)
+    );
+  }
+  getIcon() {
+    return document.createElement("");
+  }
+}

package/src/plugins/error/index.scss

@@ -0,0 +1,57 @@
+.yasr {
+  .errorResult {
+    padding: 10px;
+    .errorHeader {
+      // display:flex;
+      overflow: hidden;
+      .yasr_tryQuery {
+        float: right;
+        // color: #428bca;
+        text-decoration: none;
+        padding-top: 3px;
+        padding-bottom: 3px;
+      }
+      span.status {
+        display: inline-block;
+        padding: 0.35em 0.5rem;
+        font-size: 75%;
+        font-weight: 600;
+        line-height: 1.35;
+        text-align: center;
+        white-space: nowrap;
+        vertical-align: baseline;
+        border-radius: 0.25em;
+        color: #fff;
+        background-color: #dc3545;
+      }
+    }
+    .errorMessageContainer {
+      display: flex;
+      .errorMessage {
+        flex-grow: 1;
+        width: 0;
+        min-width: 100px;
+        overflow: auto;
+        display: block;
+        padding: 10px;
+        margin: 10px 0 10px;
+        font-size: 13px;
+        line-height: 1.42857;
+        word-break: break-all;
+        word-wrap: break-word;
+        color: #333;
+        background-color: #f5f5f5;
+        border: 1px solid #ccc;
+        border-radius: 4px;
+      }
+    }
+    .redOutline {
+      color: #a94442;
+      background-color: #f2dede;
+      margin-top: 10px;
+      padding: 5px 1em;
+      border: 1px solid #ebccd1;
+      border-radius: 4px;
+    }
+  }
+}

package/src/plugins/error/index.ts

@@ -0,0 +1,124 @@
+/**
+ * Make sure not to include any deps from our main index file. That way, we can easily publish the publin as standalone build
+ */
+import { Plugin } from "../";
+import Yasr from "../../";
+import { addClass } from "@matdata/yasgui-utils";
+require("./index.scss");
+
+export default class Error implements Plugin<never> {
+  private yasr: Yasr;
+  constructor(yasr: Yasr) {
+    this.yasr = yasr;
+  }
+  canHandleResults() {
+    return !!this.yasr.results && !!this.yasr.results.getError();
+  }
+  private getTryBtn(link: string) {
+    const tryBtn = document.createElement("a");
+    tryBtn.href = link;
+    tryBtn.rel = "noopener noreferrer";
+    tryBtn.target = "_blank";
+    tryBtn.className = "yasr_tryQuery";
+    tryBtn.textContent = "Try query in a new browser window";
+    return tryBtn;
+  }
+  private getCorsMessage() {
+    const corsEl = document.createElement("div");
+    corsEl.className = "redOutline";
+    const mainMsg = document.createElement("p");
+    mainMsg.textContent = "Unable to get response from endpoint. Possible reasons:";
+    corsEl.appendChild(mainMsg);
+
+    const list = document.createElement("ul");
+    const incorrectEndpoint = document.createElement("li");
+    incorrectEndpoint.textContent = "Incorrect endpoint URL";
+    list.appendChild(incorrectEndpoint);
+
+    const endpointDown = document.createElement("li");
+    endpointDown.textContent = "Endpoint is down";
+    list.appendChild(endpointDown);
+
+    const cors = document.createElement("li");
+    const firstPart = document.createElement("span");
+    firstPart.textContent = "Endpoint is not accessible from the YASGUI server and website, and the endpoint is not ";
+    cors.appendChild(firstPart);
+    const secondPart = document.createElement("a");
+    secondPart.textContent = "CORS-enabled";
+    secondPart.href = "http://enable-cors.org/";
+    secondPart.target = "_blank";
+    secondPart.rel = "noopener noreferrer";
+    cors.appendChild(secondPart);
+    list.appendChild(cors);
+
+    corsEl.appendChild(list);
+    return corsEl;
+  }
+  async draw() {
+    const el = document.createElement("div");
+    el.className = "errorResult";
+    this.yasr.resultsEl.appendChild(el);
+
+    const error = this.yasr.results?.getError();
+    if (!error) return;
+    const header = document.createElement("div");
+    header.className = "errorHeader";
+    el.appendChild(header);
+
+    // Try whether a custom rendering of the error exists
+    const newMessage = await this.yasr.renderError(error);
+    if (newMessage) {
+      const customMessage = document.createElement("div");
+      customMessage.className = "redOutline";
+      customMessage.appendChild(newMessage);
+      el.appendChild(customMessage);
+      return;
+    }
+
+    // No custom rendering? Let's render it ourselves!
+    if (error.status) {
+      var statusText = "Error";
+      if (error.statusText && error.statusText.length < 100) {
+        //use a max: otherwise the alert span will look ugly
+        statusText = error.statusText;
+      }
+      statusText += ` (#${error.status})`;
+      const statusTextEl = document.createElement("span");
+      statusTextEl.className = "status";
+      statusTextEl.textContent = statusText;
+
+      header.appendChild(statusTextEl);
+      if (this.yasr.config.getPlainQueryLinkToEndpoint) {
+        const link = this.yasr.config.getPlainQueryLinkToEndpoint();
+        if (link) header.appendChild(this.getTryBtn(link));
+      }
+
+      if (error.text) {
+        const textContainer = document.createElement("div");
+        addClass(textContainer, "errorMessageContainer");
+        el.appendChild(textContainer);
+        const errTextEl = document.createElement("pre");
+        addClass(errTextEl, "errorMessage");
+        errTextEl.textContent = error.text;
+        textContainer.appendChild(errTextEl);
+      }
+    } else {
+      if (this.yasr.config.getPlainQueryLinkToEndpoint) {
+        const link = this.yasr.config.getPlainQueryLinkToEndpoint();
+        if (link) header.appendChild(this.getTryBtn(link));
+      }
+      if (!error.text || error.text.indexOf("Request has been terminated") >= 0) {
+        el.appendChild(this.getCorsMessage());
+      } else {
+        const errTextEl = document.createElement("pre");
+        errTextEl.textContent = error.text;
+        el.appendChild(errTextEl);
+      }
+    }
+  }
+  getIcon() {
+    return document.createElement("");
+  }
+  priority = 20;
+  hideFromSelection = true;
+}

package/src/plugins/index.ts

@@ -0,0 +1,24 @@
+export interface Plugin<Opts extends any> {
+  priority: number;
+  canHandleResults(): boolean;
+  hideFromSelection?: boolean;
+  // getPersistentSettings?: () => any;
+  label?: string;
+  options?: Opts;
+
+  initialize?(): Promise<void>;
+  destroy?(): void;
+  draw(persistentConfig: any, runtimeConfig?: any): Promise<void> | void;
+  getIcon(): Element | undefined;
+  download?(filename?: string): DownloadInfo | undefined;
+  helpReference?: string;
+}
+export interface DownloadInfo {
+  contentType: string;
+  /**
+   * File contents as a string or a data url
+   */
+  getData: () => string;
+  filename: string;
+  title: string;
+}

package/src/plugins/response/index.scss

@@ -0,0 +1,63 @@
+.yasr {
+  .yasr_results {
+    position: relative;
+    .CodeMirror {
+      border: 1px solid #d1d1d1;
+      margin-top: 5px;
+      height: 100%;
+      &.overflow::before {
+        background: linear-gradient(transparent 0%, #ffffffaa 75%, white 100%);
+        content: "";
+        width: 100%;
+        height: 100%;
+        z-index: 1200;
+        position: absolute;
+        pointer-events: none;
+      }
+    }
+    .overlay {
+      width: 100%;
+      position: absolute;
+      bottom: 0;
+      z-index: 1201;
+      display: flex;
+      pointer-events: none;
+      &::before,
+      &::after {
+        content: "";
+        flex-grow: 1;
+      }
+    }
+
+    .overlay_content {
+      display: flex;
+      align-content: center;
+      justify-content: center;
+      align-items: center;
+      background: white;
+      pointer-events: all;
+      background: linear-gradient(to right, transparent, white 5%, white 95%, transparent 100%);
+    }
+    .yasr_btn.overlay_btn {
+      border: 1px solid #337ab7;
+      background: white;
+      color: #337ab7;
+      padding: 10px;
+      margin: 10px;
+      svg {
+        margin-left: 0.5rem;
+        fill: #337ab7;
+        color: #337ab7;
+      }
+      &:hover {
+        color: #255681;
+        border-color: #337ab7;
+        fill: #255681;
+        svg {
+          color: #255681;
+          fill: #255681;
+        }
+      }
+    }
+  }
+}

package/src/plugins/response/index.ts

@@ -0,0 +1,170 @@
+/**
+ * Make sure not to include any deps from our main index file. That way, we can easily publish the publin as standalone build
+ */
+import { Plugin } from "../";
+import Yasr from "../../";
+require("./index.scss");
+const CodeMirror = require("codemirror");
+require("codemirror/addon/fold/foldcode.js");
+require("codemirror/addon/fold/foldgutter.js");
+require("codemirror/addon/fold/xml-fold.js");
+require("codemirror/addon/fold/brace-fold.js");
+
+require("codemirror/addon/edit/matchbrackets.js");
+require("codemirror/mode/xml/xml.js");
+
+require("codemirror/mode/javascript/javascript.js");
+require("codemirror/lib/codemirror.css");
+import { drawSvgStringAsElement, addClass, removeClass, drawFontAwesomeIconAsSvg } from "@matdata/yasgui-utils";
+import * as faAlignIcon from "@fortawesome/free-solid-svg-icons/faAlignLeft";
+import { DeepReadonly } from "ts-essentials";
+import * as imgs from "../../imgs";
+
+export interface PluginConfig {
+  maxLines: number;
+}
+export default class Response implements Plugin<PluginConfig> {
+  private yasr: Yasr;
+  label = "Response";
+  priority = 2;
+  helpReference = "https://docs.triply.cc/yasgui/#response";
+  private config: DeepReadonly<PluginConfig>;
+  private overLay: HTMLDivElement | undefined;
+  private cm: CodeMirror.Editor | undefined;
+  constructor(yasr: Yasr) {
+    this.yasr = yasr;
+    this.config = Response.defaults;
+    if (yasr.config.plugins["response"] && yasr.config.plugins["response"].dynamicConfig) {
+      this.config = {
+        ...this.config,
+        ...yasr.config.plugins["response"].dynamicConfig,
+      };
+    }
+  }
+  // getDownloadInfo: getDownloadInfo
+  canHandleResults() {
+    if (!this.yasr.results) return false;
+    if (!this.yasr.results.getOriginalResponseAsString) return false;
+    var response = this.yasr.results.getOriginalResponseAsString();
+    if ((!response || response.length == 0) && this.yasr.results.getError()) return false; //in this case, show exception instead, as we have nothing to show anyway
+    return true;
+  }
+  public getIcon() {
+    return drawSvgStringAsElement(drawFontAwesomeIconAsSvg(faAlignIcon));
+  }
+  download(filename?: string) {
+    if (!this.yasr.results) return;
+    const contentType = this.yasr.results.getContentType();
+    const type = this.yasr.results.getType();
+    const extension = type === "xml" ? "rdf" : type;
+    return {
+      getData: () => {
+        return this.yasr.results?.getOriginalResponseAsString() || "";
+      },
+      filename: `${filename || "queryResults"}${extension ? "." + extension : ""}`,
+      contentType: contentType ? contentType : "text/plain",
+      title: "Download result",
+    };
+  }
+  draw(persistentConfig: PluginConfig) {
+    const config: DeepReadonly<PluginConfig> = {
+      ...this.config,
+      ...persistentConfig,
+    };
+    // When the original response is empty, use an empty string
+    let value = this.yasr.results?.getOriginalResponseAsString() || "";
+    const lines = value.split("\n");
+    if (lines.length > config.maxLines) {
+      value = lines.slice(0, config.maxLines).join("\n");
+    }
+
+    const codemirrorOpts: Partial<CodeMirror.EditorConfiguration> = {
+      readOnly: true,
+      lineNumbers: true,
+      lineWrapping: true,
+      foldGutter: true,
+      gutters: ["CodeMirror-linenumbers", "CodeMirror-foldgutter"],
+      value: value,
+      extraKeys: { Tab: false },
+    };
+    const mode = this.yasr.results?.getType();
+    if (mode === "json") {
+      codemirrorOpts.mode = { name: "javascript", json: true };
+    }
+
+    this.cm = CodeMirror(this.yasr.resultsEl, codemirrorOpts);
+    // Don't show less originally we've already set the value in the codemirrorOpts
+    if (lines.length > config.maxLines) this.showLess(false);
+  }
+  private limitData(value: string) {
+    const lines = value.split("\n");
+    if (lines.length > this.config.maxLines) {
+      value = lines.slice(0, this.config.maxLines).join("\n");
+    }
+    return value;
+  }
+  /**
+   *
+   * @param setValue Optional, if set to false the string will not update
+   */
+  showLess(setValue = true) {
+    if (!this.cm) return;
+    // Add overflow
+    addClass(this.cm.getWrapperElement(), "overflow");
+
+    // Remove old instance
+    if (this.overLay) {
+      this.overLay.remove();
+      this.overLay = undefined;
+    }
+
+    // Wrapper
+    this.overLay = document.createElement("div");
+    addClass(this.overLay, "overlay");
+
+    // overlay content
+    const overlayContent = document.createElement("div");
+    addClass(overlayContent, "overlay_content");
+
+    const showMoreButton = document.createElement("button");
+    showMoreButton.title = "Show all";
+    addClass(showMoreButton, "yasr_btn", "overlay_btn");
+    showMoreButton.textContent = "Show all";
+    showMoreButton.addEventListener("click", () => this.showMore());
+    overlayContent.append(showMoreButton);
+
+    const downloadButton = document.createElement("button");
+    downloadButton.title = "Download result";
+    addClass(downloadButton, "yasr_btn", "overlay_btn");
+
+    const text = document.createElement("span");
+    text.innerText = "Download result";
+    downloadButton.appendChild(text);
+    downloadButton.appendChild(drawSvgStringAsElement(imgs.download));
+    downloadButton.addEventListener("click", () => this.yasr.download());
+    downloadButton.addEventListener("keydown", (event) => {
+      if (event.code === "Space" || event.code === "Enter") this.yasr.download();
+    });
+
+    overlayContent.appendChild(downloadButton);
+    this.overLay.appendChild(overlayContent);
+    this.cm.getWrapperElement().appendChild(this.overLay);
+    if (setValue) {
+      this.cm.setValue(this.limitData(this.yasr.results?.getOriginalResponseAsString() || ""));
+    }
+  }
+  /**
+   * Render the raw response full length
+   */
+  showMore() {
+    if (!this.cm) return;
+    removeClass(this.cm.getWrapperElement(), "overflow");
+    this.overLay?.remove();
+    this.overLay = undefined;
+    this.cm.setValue(this.yasr.results?.getOriginalResponseAsString() || "");
+    this.cm.refresh();
+  }
+  public static defaults: PluginConfig = {
+    maxLines: 30,
+  };
+}