@matdata/yasr 4.6.1

package/src/jquery/tableToCsv.js

@@ -0,0 +1,88 @@
+"use strict";
+var $ = require("jquery");
+
+$.fn.tableToCsv = function (config) {
+  var csvString = "";
+  config = $.extend(
+    {
+      quote: '"',
+      delimiter: ",",
+      lineBreak: "\n",
+    },
+    config
+  );
+
+  var needToQuoteString = function (value) {
+    //quote when it contains whitespace or the delimiter
+    var needQuoting = false;
+    if (value.match("[\\w|" + config.delimiter + "|" + config.quote + "]")) {
+      needQuoting = true;
+    }
+    return needQuoting;
+  };
+  var addValueToString = function (value) {
+    //Quotes in the string need to be escaped
+    value.replace(config.quote, config.quote + config.quote);
+    if (needToQuoteString(value)) {
+      value = config.quote + value + config.quote;
+    }
+    csvString += " " + value + " " + config.delimiter;
+  };
+
+  var addRowToString = function (rowArray) {
+    rowArray.forEach(function (val) {
+      addValueToString(val);
+    });
+    csvString += config.lineBreak;
+  };
+
+  var tableArrays = [];
+  var $el = $(this);
+  var rowspans = {};
+
+  var totalColCount = 0;
+  $el.find("tr:first *").each(function () {
+    if ($(this).attr("colspan")) {
+      totalColCount += +$(this).attr("colspan");
+    } else {
+      totalColCount++;
+    }
+  });
+
+  $el.find("tr").each(function (rowId, tr) {
+    var $tr = $(tr);
+    var rowArray = [];
+
+    var htmlColId = 0;
+    var actualColId = 0;
+    while (actualColId < totalColCount) {
+      if (rowspans[actualColId]) {
+        rowArray.push(rowspans[actualColId].text);
+        rowspans[actualColId].rowSpan--;
+        if (!rowspans[actualColId].rowSpan) rowspans[actualColId] = null;
+        actualColId++;
+        continue;
+      }
+
+      var $cell = $tr.find(":nth-child(" + (htmlColId + 1) + ")");
+      if (!$cell) break;
+      var colspan = $cell.attr("colspan") || 1;
+      var rowspan = $cell.attr("rowspan") || 1;
+
+      for (var i = 0; i < colspan; i++) {
+        rowArray.push($cell.text());
+        if (rowspan > 1) {
+          rowspans[actualColId] = {
+            rowSpan: rowspan - 1,
+            text: $cell.text(),
+          };
+        }
+        actualColId++;
+      }
+      htmlColId++;
+    }
+    addRowToString(rowArray);
+  });
+
+  return csvString;
+};

package/src/main.scss

@@ -0,0 +1,229 @@
+@use "scss/variables.scss";
+.yasr {
+  .yasr_btn {
+    border: none;
+    background: inherit;
+  }
+  .svgImg {
+    display: flex;
+    flex-direction: row;
+    svg {
+      max-width: 100%;
+      max-height: 100%;
+      width: 15px;
+      height: 15px;
+      align-self: center;
+    }
+  }
+  .yasr_btn.yasr_external_ref_btn {
+    font-weight: 600;
+    user-select: none;
+    // Active and focus shouldn't color the button since it'll open a new page
+    &:active,
+    &:focus {
+      color: inherit;
+      text-decoration-color: inherit;
+    }
+    .svgImg svg {
+      width: 18px;
+      height: 18px;
+    }
+  }
+  a {
+    color: #428bca;
+    text-decoration: none;
+    &:hover,
+    &:active {
+      outline: 0;
+      color: #2a6496;
+      text-decoration: underline;
+    }
+  }
+  .yasr_btnGroup {
+    margin: 0;
+    padding: 0;
+    list-style: none;
+    display: flex;
+    overflow-x: auto;
+    overflow-y: hidden; // We shouldn't wrap, and therefore never draw a vertical scrollBar
+    .plugin_icon {
+      height: 15px;
+      width: 15px;
+      margin-right: 5px;
+      text-align: center;
+    }
+    .yasr_btn {
+      // redeclared here to target yasr_btns in btnGroup
+      border-bottom: 2px solid transparent;
+      &.selected {
+        border-bottom: 2px solid #337ab7;
+      }
+      padding-left: 6px;
+      padding-right: 6px;
+      margin-left: 6px;
+      margin-right: 6px;
+    }
+  }
+
+  // Default med screen +
+  @media (max-width: 768px) {
+    .yasr_btn {
+      span {
+        display: none;
+      }
+
+      .plugin_icon {
+        margin-right: 0px;
+      }
+    }
+  }
+
+  .yasr_header {
+    display: flex;
+    flex-wrap: wrap;
+  }
+  .yasr_fallback_info:not(:empty) {
+    margin-top: 5px;
+    border: 1px solid #d1d1d1;
+    padding: 0.5rem;
+    background: #f7f7f7;
+    p {
+      margin: 0;
+    }
+  }
+  .yasr_help_variable {
+    background: #dff0ff;
+    color: #428bca;
+  }
+  .yasr_response_chip {
+    color: #505050;
+    background: #f5f5f5;
+    border-radius: 6px;
+    display: flex;
+    font-size: 11pt;
+    max-height: 16pt;
+    align-self: center;
+    align-items: center;
+    justify-content: center;
+    white-space: nowrap;
+    padding: 6px 6px;
+    margin-left: 5px;
+    overflow: visible;
+    box-sizing: border-box;
+    &.empty {
+      display: none;
+    }
+  }
+  .yasr_plugin_control {
+    display: flex;
+    margin-left: auto;
+    align-items: center;
+    &:empty {
+      display: none;
+    }
+  }
+  .yasr_btn {
+    color: #505050;
+    fill: #505050;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+
+    cursor: pointer;
+    white-space: nowrap;
+    padding: 6px 12px;
+    // border-radius: 4px;
+    overflow: visible;
+    box-sizing: border-box;
+    &.btn_icon {
+      padding: 4px 8px;
+    }
+    &[disabled],
+    &.disabled {
+      cursor: default;
+      opacity: 0.5;
+      box-shadow: none;
+    }
+    &:not(.disabled):hover {
+      fill: black;
+      color: black;
+    }
+  }
+
+  .yasr_fullscreenButton {
+    border: none;
+    background: none;
+
+    svg {
+      height: 20px;
+      width: 20px;
+    }
+
+    .fullscreenExitIcon {
+      display: none;
+    }
+  }
+
+  &.fullscreen {
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    z-index: 9999;
+    background: white;
+    margin: 0;
+    display: flex;
+    flex-direction: column;
+
+    .yasr_fullscreenButton {
+      .fullscreenIcon {
+        display: none;
+      }
+      .fullscreenExitIcon {
+        display: block;
+      }
+    }
+
+    .yasr_results {
+      flex: 1;
+      overflow: auto;
+    }
+    &:focus,
+    &.selected {
+      color: #337ab7;
+      fill: #337ab7;
+    }
+  }
+
+  .yasr_loading_indicator {
+    display: none;
+    align-items: center;
+    justify-content: center;
+    padding: 4px 8px;
+    margin-left: 5px;
+
+    .yasr_loading_spinner {
+      width: 20px;
+      height: 20px;
+      border: 3px solid #f3f3f3;
+      border-top: 3px solid #337ab7;
+      border-radius: 50%;
+      animation: yasr_spin 0.8s linear infinite;
+    }
+
+    @keyframes yasr_spin {
+      0% {
+        transform: rotate(0deg);
+      }
+      100% {
+        transform: rotate(360deg);
+      }
+    }
+  }
+
+  .space_element {
+    flex-grow: 1;
+    min-width: 10px;
+  }
+}

package/src/parsers/csv.ts

@@ -0,0 +1,30 @@
+import Parser from "./";
+import * as Papa from "papaparse";
+
+export default function (csvString: string) {
+  const csvStringToJsonObject = Papa.parse(csvString, { header: true, skipEmptyLines: true });
+  if (csvStringToJsonObject.meta.fields === undefined) {
+    throw new Error("Could not parse CSV, no headers found!");
+  }
+  const header = csvStringToJsonObject.meta.fields;
+  const lines = csvStringToJsonObject.data as Record<string, string>[];
+
+  const sparqlData = lines.map((row) => {
+    const bindingObject: Parser.Binding = {};
+    for (const variable in row) {
+      bindingObject[variable] = { value: row[variable], type: "literal" };
+    }
+    return bindingObject;
+  });
+
+  const sparqlResults: Parser.SparqlResults = {
+    head: {
+      vars: header,
+    },
+    results: {
+      bindings: sparqlData,
+    },
+  };
+
+  return sparqlResults;
+}

package/src/parsers/index.ts

@@ -0,0 +1,311 @@
+import SparqlJsonParser from "./json";
+import TurtleParser, { getTurtleAsStatements } from "./turtleFamily";
+import SparqlXmlParser from "./xml";
+import SparqlCsvParser from "./csv";
+import SparqlTsvParser from "./tsv";
+import bindingsToCsv from "../bindingsToCsv";
+import { cloneDeep } from "lodash-es";
+import N3 from "n3";
+
+namespace Parser {
+  export interface ErrorSummary {
+    status?: number;
+    text: string;
+    statusText?: string;
+  }
+  export interface BindingValue {
+    value: string;
+    type: "uri" | "literal" | "typed-literal" | "bnode";
+    datatype?: string;
+    "xml:lang"?: string;
+  }
+  export interface Binding {
+    [varname: string]: BindingValue;
+  }
+  export interface SparqlResults {
+    head: {
+      vars: string[];
+    };
+    boolean?: boolean;
+    results?: {
+      bindings: Binding[];
+    };
+  }
+  //a json response summary, that we can store in localstorage
+  export interface ResponseSummary {
+    data?: any;
+    error?: ErrorSummary;
+    status?: number;
+    contentType?: string;
+    executionTime?: number;
+  }
+  export type PostProcessBinding = (binding: Binding) => Binding;
+}
+const applyMustacheToLiterals: Parser.PostProcessBinding = (binding: Parser.Binding) => {
+  for (const lit in binding) {
+    if (binding[lit].type === "uri") continue;
+    binding[lit].value = binding[lit].value.replace(/{{(.*?)}}/g, (variable) => {
+      variable = variable.substring(2, variable.length - 2).trim();
+      if (binding[variable]) {
+        return binding[variable].value;
+      } else {
+        return variable;
+      }
+    });
+  }
+  return binding;
+};
+
+/**
+ * Response object from a fetch request with an additional `.content` property containing the awaited response content
+ */
+type QueryResponse = Response & {
+  content: string;
+};
+
+/**
+ * Parser class for handling query responses from various formats.
+ *
+ * This class processes responses from SPARQL endpoints and converts them into standardized formats for further processing.
+ * It can handle JSON, XML, CSV, TSV, and Turtle responses, detecting the format either from content-type headers
+ * or by attempting to parse the content.
+ *
+ * The parser can process:
+ * - Direct `QueryResponse` objects (regular fetch response with additional content property with the awaited response content)
+ * - ResponseSummary objects
+ * - Error objects
+ * - Raw response data
+ *
+ * It provides methods to access parsed data in standardized formats, error information,
+ * and utilities to convert the data for storage or export.
+ */
+class Parser {
+  private res: QueryResponse | undefined;
+  private summary: Parser.ResponseSummary | undefined;
+  private errorSummary: Parser.ErrorSummary | undefined;
+  private error: Error | undefined;
+  private type: "json" | "xml" | "csv" | "tsv" | "ttl" | undefined;
+  private executionTime: number | undefined;
+
+  constructor(responseOrObject: Parser.ResponseSummary | QueryResponse | Error | any, executionTime?: number) {
+    if (responseOrObject.executionTime) this.executionTime = responseOrObject.executionTime;
+    if (executionTime) this.executionTime = executionTime; // Parameter has priority
+    if (responseOrObject instanceof Error) {
+      this.error = responseOrObject;
+    } else if ((<any>responseOrObject).content) {
+      this.setResponse(<QueryResponse>responseOrObject);
+    } else {
+      this.setSummary(<Parser.ResponseSummary>responseOrObject);
+    }
+  }
+  public setResponse(res: QueryResponse) {
+    this.res = res;
+  }
+  public setSummary(summary: Parser.ResponseSummary | any) {
+    if (!summary.data && !summary.error) {
+      //This isnt a summary object, just try to recreate a summary object ourselves (assuming we're just passed a sparql-result object directly)
+      this.summary = {
+        data: summary,
+      };
+    } else {
+      this.summary = summary;
+    }
+  }
+
+  public hasError() {
+    if (this.res && this.res.status >= 400) return true;
+    if (this.errorSummary) return true;
+    if (this.error) return true;
+    if (this.summary && this.summary.error) return true;
+    return false;
+  }
+  public getError() {
+    if (!this.errorSummary) {
+      if (this.res && this.res.status >= 400) {
+        this.errorSummary = {
+          text: this.res.statusText,
+          status: this.res.status,
+          statusText: !this.res.ok ? this.res.statusText : undefined,
+        };
+      }
+      if (this.summary && this.summary.error) {
+        this.errorSummary = this.summary.error;
+      }
+      if (this.error) {
+        this.errorSummary = {
+          text: this.error.message,
+        };
+      }
+    }
+    return this.errorSummary;
+  }
+  public getContentType() {
+    if (this.res) return this.res.headers.get("content-type") || undefined;
+    if (this.summary) return this.summary.contentType;
+  }
+  private json: false | Parser.SparqlResults | undefined;
+  getAsJson() {
+    if (this.json) return this.json;
+    if (this.json === false || this.hasError()) return; //already tried parsing this, and failed. do not try again...
+    if (this.getParserFromContentType()) return this.json;
+    if (this.doLuckyGuess()) return this.json;
+
+    if (!this.json) this.json = false; //explicitly set to false, so we don't try to parse this thing again..
+    return this.json;
+  }
+  private getData(): any {
+    if (this.res) {
+      if (this.res.content) return this.res.content;
+      if (this.res.body) return this.res.body;
+      if (this.res.text) return this.res.text; //probably a construct or something
+    }
+    if (this.summary) return this.summary.data;
+  }
+  public getResponseTime() {
+    return this.executionTime;
+  }
+  private getParserFromContentType(): boolean {
+    const contentType = this.getContentType();
+    if (contentType) {
+      const data = cloneDeep(this.getData());
+      try {
+        if (contentType.indexOf("json") > -1) {
+          if (contentType.indexOf("sparql-results+json") >= 0) {
+            this.json = SparqlJsonParser(data, applyMustacheToLiterals);
+            this.type = "json";
+            return true;
+          } else if (contentType.indexOf("application/rdf+json") > -1) {
+            this.type = "json";
+            return true;
+          }
+          this.type = "json";
+        } else if (contentType.indexOf("xml") > -1) {
+          this.json = SparqlXmlParser(data, applyMustacheToLiterals);
+          this.type = "xml";
+          return true;
+        } else if (contentType.indexOf("csv") > -1) {
+          this.json = SparqlCsvParser(data);
+          this.type = "csv";
+          return true;
+        } else if (contentType.indexOf("tab-separated") > -1) {
+          this.json = SparqlTsvParser(data);
+          this.type = "tsv";
+          return true;
+        } else if (
+          contentType.indexOf("turtle") > 0 ||
+          contentType.indexOf("trig") > 0 ||
+          contentType.indexOf("triple") > 0 ||
+          contentType.indexOf("quad") > 0
+        ) {
+          this.json = TurtleParser(data);
+          this.type = "ttl";
+          return true;
+        }
+      } catch (e) {
+        if (e instanceof Error) {
+          this.errorSummary = { text: e.message };
+        } else {
+          this.errorSummary = { text: e as any };
+        }
+      }
+    }
+    return false;
+  }
+  private doLuckyGuess(): boolean {
+    const data = cloneDeep(this.getData());
+    try {
+      this.json = SparqlJsonParser(data, applyMustacheToLiterals);
+      this.type = "json";
+      return true;
+    } catch {}
+    try {
+      this.json = SparqlXmlParser(data, applyMustacheToLiterals);
+      this.type = "xml";
+      return true;
+    } catch {}
+    return false;
+  }
+
+  public getVariables(): string[] {
+    const json = this.getAsJson();
+
+    if (json && json.head) return json.head.vars;
+
+    return [];
+  }
+
+  public getBoolean(): boolean | undefined {
+    const json = this.getAsJson();
+    if (json && "boolean" in json) return json.boolean;
+  }
+
+  public getBindings() {
+    const json = this.getAsJson();
+    if (json && json.results) return json.results.bindings;
+    else return null;
+  }
+  private statements: false | N3.Quad[] | undefined;
+  public getStatements() {
+    if (!this.statements && this.type === "ttl") {
+      this.statements = getTurtleAsStatements(this.getData());
+    }
+    if (this.statements) return this.statements;
+    return null;
+  }
+  getOriginalResponseAsString(): string {
+    const data = this.getData();
+    if (typeof data === "string") {
+      return data;
+    } else if (this.type === "json") {
+      return JSON.stringify(data, undefined, 2);
+    }
+    return data;
+  }
+
+  getType() {
+    if (!this.type) this.getAsJson(); //detects type as well
+    return this.type;
+  }
+  getStatus(): number | undefined {
+    if (this.res) return this.res.status;
+    if (this.summary) return this.summary.status;
+  }
+
+  //process the input parameters in such a way that we can store it in local storage (i.e., no function)
+  //and, make sure we can easily pass it on back to this wrapper function when loading it again from storage
+  //When an object is too large to store, this method returns undefined
+  public getAsStoreObject(maxResponseSize: number): Parser.ResponseSummary | undefined {
+    let summary = this.summary;
+    if (!summary && this.res) {
+      summary = {
+        contentType: this.getContentType(),
+        data: this.getOriginalResponseAsString(),
+        error: this.getError(),
+        status: this.getStatus(),
+        executionTime: this.getResponseTime(),
+      };
+    }
+    if (summary) {
+      //if data is set, it should be less than max limit. If not set, it's probably a response error that we'd like to store as well
+      if (summary.data && summary.data.length > maxResponseSize) {
+        return undefined;
+      }
+      return summary;
+    }
+    if (this.error) {
+      return {
+        error: this.getError(),
+        executionTime: this.getResponseTime(),
+      };
+    }
+  }
+
+  public asCsv() {
+    const json = this.getAsJson();
+    if (this.type === "csv") return this.getOriginalResponseAsString();
+    if (json && json.results) {
+      return bindingsToCsv(json);
+    }
+  }
+}
+export default Parser;

package/src/parsers/json.ts

@@ -0,0 +1,22 @@
+import Parser from "./";
+export default function (queryResponse: any, postProcessBinding: Parser.PostProcessBinding): Parser.SparqlResults {
+  if (typeof queryResponse == "string") {
+    const json = JSON.parse(queryResponse);
+    if (postProcessBinding) {
+      for (const binding in json.results.bindings) {
+        json.results.bindings[binding] = postProcessBinding(json.results.bindings[binding]);
+      }
+    }
+    return json;
+  }
+  if (typeof queryResponse == "object" && queryResponse.constructor === {}.constructor) {
+    // an ASK-query only returns a "boolean" field so we should check if are undefined here
+    if (postProcessBinding && queryResponse.results) {
+      for (const binding in queryResponse.results.bindings) {
+        queryResponse.results.bindings[binding] = postProcessBinding(queryResponse.results.bindings[binding]);
+      }
+    }
+    return queryResponse;
+  }
+  throw new Error("Could not parse json");
+}