@matdata/yasqe 4.6.1

package/src/sparql.ts

@@ -0,0 +1,215 @@
+import { default as Yasqe, Config, RequestConfig } from "./";
+import { merge, isFunction } from "lodash-es";
+import * as queryString from "query-string";
+export type YasqeAjaxConfig = Config["requestConfig"];
+export interface PopulatedAjaxConfig {
+  url: string;
+  reqMethod: "POST" | "GET";
+  headers: { [key: string]: string };
+  accept: string;
+  args: RequestArgs;
+  withCredentials: boolean;
+}
+function getRequestConfigSettings(yasqe: Yasqe, conf?: Partial<Config["requestConfig"]>): RequestConfig<Yasqe> {
+  if (isFunction(conf)) {
+    return conf(yasqe) as RequestConfig<Yasqe>;
+  }
+  return (conf ?? {}) as RequestConfig<Yasqe>;
+}
+// type callback = AjaxConfig.callbacks['complete'];
+export function getAjaxConfig(
+  yasqe: Yasqe,
+  _config: Partial<Config["requestConfig"]> = {},
+): PopulatedAjaxConfig | undefined {
+  const config: RequestConfig<Yasqe> = merge(
+    {},
+    getRequestConfigSettings(yasqe, yasqe.config.requestConfig),
+    getRequestConfigSettings(yasqe, _config),
+  );
+  if (!config.endpoint || config.endpoint.length == 0) return; // nothing to query!
+
+  var queryMode = yasqe.getQueryMode();
+  /**
+   * initialize ajax config
+   */
+  const endpoint = isFunction(config.endpoint) ? config.endpoint(yasqe) : config.endpoint;
+  var reqMethod: "GET" | "POST" =
+    queryMode == "update" ? "POST" : isFunction(config.method) ? config.method(yasqe) : config.method;
+  const headers = isFunction(config.headers) ? config.headers(yasqe) : config.headers;
+  // console.log({headers})
+  const withCredentials = isFunction(config.withCredentials) ? config.withCredentials(yasqe) : config.withCredentials;
+  return {
+    reqMethod,
+    url: endpoint,
+    args: getUrlArguments(yasqe, config),
+    headers: headers,
+    accept: getAcceptHeader(yasqe, config),
+    withCredentials,
+  };
+  /**
+   * merge additional request headers
+   */
+}
+
+export async function executeQuery(yasqe: Yasqe, config?: YasqeAjaxConfig): Promise<any> {
+  const queryStart = Date.now();
+  try {
+    yasqe.emit("queryBefore", yasqe, config);
+    const populatedConfig = getAjaxConfig(yasqe, config);
+    if (!populatedConfig) {
+      return; // Nothing to query
+    }
+    const abortController = new AbortController();
+
+    const fetchOptions: RequestInit = {
+      method: populatedConfig.reqMethod,
+      headers: {
+        Accept: populatedConfig.accept,
+        ...(populatedConfig.headers || {}),
+      },
+      credentials: populatedConfig.withCredentials ? "include" : "same-origin",
+      signal: abortController.signal,
+    };
+    if (fetchOptions?.headers && populatedConfig.reqMethod === "POST") {
+      (fetchOptions.headers as Record<string, string>)["Content-Type"] = "application/x-www-form-urlencoded";
+    }
+    const searchParams = new URLSearchParams();
+    for (const key in populatedConfig.args) {
+      const value = populatedConfig.args[key];
+      if (Array.isArray(value)) {
+        value.forEach((v) => searchParams.append(key, v));
+      } else {
+        searchParams.append(key, value);
+      }
+    }
+    if (populatedConfig.reqMethod === "POST") {
+      fetchOptions.body = searchParams.toString();
+    } else {
+      const url = new URL(populatedConfig.url);
+      searchParams.forEach((value, key) => {
+        url.searchParams.append(key, value);
+      });
+      populatedConfig.url = url.toString();
+    }
+    const request = new Request(populatedConfig.url, fetchOptions);
+    yasqe.emit("query", request, abortController);
+    const response = await fetch(request);
+    if (!response.ok) {
+      throw new Error((await response.text()) || response.statusText);
+    }
+    // Await the response content and merge with the `Response` object
+    const queryResponse = {
+      ok: response.ok,
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers,
+      type: response.type,
+      content: await response.text(),
+    };
+    yasqe.emit("queryResponse", queryResponse, Date.now() - queryStart);
+    yasqe.emit("queryResults", queryResponse.content, Date.now() - queryStart);
+    return queryResponse;
+  } catch (e) {
+    if (e instanceof Error && e.message === "Aborted") {
+      // The query was aborted. We should not do or draw anything
+    } else {
+      yasqe.emit("queryResponse", e, Date.now() - queryStart);
+    }
+    yasqe.emit("error", e);
+    throw e;
+  }
+}
+
+export type RequestArgs = { [argName: string]: string | string[] };
+export function getUrlArguments(yasqe: Yasqe, _config: Config["requestConfig"]): RequestArgs {
+  var queryMode = yasqe.getQueryMode();
+
+  var data: RequestArgs = {};
+  const config: RequestConfig<Yasqe> = getRequestConfigSettings(yasqe, _config);
+  var queryArg = isFunction(config.queryArgument) ? config.queryArgument(yasqe) : config.queryArgument;
+  if (!queryArg) queryArg = yasqe.getQueryMode();
+  data[queryArg] = config.adjustQueryBeforeRequest ? config.adjustQueryBeforeRequest(yasqe) : yasqe.getValue();
+  /**
+   * add named graphs to ajax config
+   */
+  const namedGraphs = isFunction(config.namedGraphs) ? config.namedGraphs(yasqe) : config.namedGraphs;
+  if (namedGraphs && namedGraphs.length > 0) {
+    let argName = queryMode === "query" ? "named-graph-uri" : "using-named-graph-uri ";
+    data[argName] = namedGraphs;
+  }
+  /**
+   * add default graphs to ajax config
+   */
+  const defaultGraphs = isFunction(config.defaultGraphs) ? config.defaultGraphs(yasqe) : config.defaultGraphs;
+  if (defaultGraphs && defaultGraphs.length > 0) {
+    let argName = queryMode == "query" ? "default-graph-uri" : "using-graph-uri ";
+    data[argName] = namedGraphs;
+  }
+
+  /**
+   * add additional request args
+   */
+  const args = isFunction(config.args) ? config.args(yasqe) : config.args;
+  if (args && args.length > 0)
+    merge(
+      data,
+      args.reduce((argsObject: { [key: string]: string[] }, arg) => {
+        argsObject[arg.name] ? argsObject[arg.name].push(arg.value) : (argsObject[arg.name] = [arg.value]);
+        return argsObject;
+      }, {}),
+    );
+
+  return data;
+}
+export function getAcceptHeader(yasqe: Yasqe, _config: Config["requestConfig"]) {
+  const config: RequestConfig<Yasqe> = getRequestConfigSettings(yasqe, _config);
+  var acceptHeader = null;
+  if (yasqe.getQueryMode() == "update") {
+    acceptHeader = isFunction(config.acceptHeaderUpdate) ? config.acceptHeaderUpdate(yasqe) : config.acceptHeaderUpdate;
+  } else {
+    var qType = yasqe.getQueryType();
+    if (qType == "DESCRIBE" || qType == "CONSTRUCT") {
+      acceptHeader = isFunction(config.acceptHeaderGraph) ? config.acceptHeaderGraph(yasqe) : config.acceptHeaderGraph;
+    } else {
+      acceptHeader = isFunction(config.acceptHeaderSelect)
+        ? config.acceptHeaderSelect(yasqe)
+        : config.acceptHeaderSelect;
+    }
+  }
+  return acceptHeader;
+}
+export function getAsCurlString(yasqe: Yasqe, _config?: Config["requestConfig"]) {
+  let ajaxConfig = getAjaxConfig(yasqe, getRequestConfigSettings(yasqe, _config));
+  if (!ajaxConfig) return "";
+  let url = ajaxConfig.url;
+  if (ajaxConfig.url.indexOf("http") !== 0) {
+    //this is either a relative or absolute url, which is not supported by CURL.
+    //Add domain, schema, etc etc
+    url = `${window.location.protocol}//${window.location.host}`;
+    if (ajaxConfig.url.indexOf("/") === 0) {
+      //its an absolute path
+      url += ajaxConfig.url;
+    } else {
+      //relative, so append current location to url first
+      url += window.location.pathname + ajaxConfig.url;
+    }
+  }
+  const segments: string[] = ["curl"];
+
+  if (ajaxConfig.reqMethod === "GET") {
+    url += `?${queryString.stringify(ajaxConfig.args)}`;
+    segments.push(url);
+  } else if (ajaxConfig.reqMethod === "POST") {
+    segments.push(url);
+    segments.push("--data", queryString.stringify(ajaxConfig.args));
+  } else {
+    // I don't expect to get here but let's be sure
+    console.warn("Unexpected request-method", ajaxConfig.reqMethod);
+    segments.push(url);
+  }
+  segments.push("-X", ajaxConfig.reqMethod);
+  for (const header in ajaxConfig.headers) {
+    segments.push(`-H  '${header}: ${ajaxConfig.headers[header]}'`);
+  }
+  return segments.join(" ");
+}

package/src/tokenUtils.ts

@@ -0,0 +1,121 @@
+import { default as Yasqe, Token, Position } from "./";
+
+/**
+ * When typing a query, this query is sometimes syntactically invalid, causing
+ * the current tokens to be incorrect This causes problem for autocompletion.
+ * http://bla might result in two tokens: http:// and bla. We'll want to combine
+ * these
+ */
+
+export function getCompleteToken(yasqe: Yasqe, token?: Token, cur?: Position): Token {
+  if (!cur) {
+    cur = yasqe.getDoc().getCursor() as Position;
+  }
+  if (!token) {
+    token = yasqe.getTokenAt(cur) as Token;
+  }
+
+  return expandTokenToEnd(yasqe, expandTokenToStart(yasqe, token, cur), cur);
+}
+function expandTokenToStart(yasqe: Yasqe, token: Token, cur: Position): Token {
+  var prevToken: Token = yasqe.getTokenAt({
+    line: cur.line,
+    ch: token.start,
+  });
+
+  if ((token.type === "punc" || token.type === "error") && !token.state.possibleFullIri && !token.state.inPrefixDecl) {
+    token.state.possibleCurrent = token.state.possibleNext;
+    return token;
+  }
+  if (prevToken.type === "punc" && !prevToken.state.possibleFullIri && !prevToken.state.inPrefixDecl) {
+    //assuming this is a path expression. Should not expand the token anymore
+    //Also checking whether current token isnt an error, to avoid stopping on iri path delimiters
+    return token;
+  }
+  // not start of line, and not whitespace
+  if (prevToken.type != null && prevToken.type != "ws" && token.type != null && token.type != "ws") {
+    token.start = prevToken.start;
+    token.string = prevToken.string + token.string;
+    return expandTokenToStart(yasqe, token, {
+      line: cur.line,
+      ch: prevToken.start,
+    }); // recursively, might have multiple tokens which it should include
+  } else if (token.type != null && token.type == "ws") {
+    //always keep 1 char of whitespace between tokens. Otherwise, autocompletions might end up next to the previous node, without whitespace between them
+    token.start = token.start + 1;
+    token.string = token.string.substring(1);
+    return token;
+  } else {
+    return token;
+  }
+}
+
+function expandTokenToEnd(yasqe: Yasqe, token: Token, cur: Position): Token {
+  if (token.string.indexOf(" ") >= 0) {
+    /**
+     * This is most likely a query ending with `<http://www.opengis.net/ont/geosparql# ?a`
+     *                                                                                ^ cursor
+     * In this case, separate by whitespace, and assume we're finished
+     */
+    const whitespaceIndex = token.string.indexOf(" ");
+    token.string = token.string.substr(0, whitespaceIndex);
+    token.end = token.start + token.string.length;
+    return token;
+  }
+  if (!token.type) return token;
+
+  var nextToken: Token = yasqe.getTokenAt({
+    line: cur.line,
+    ch: token.end + 1,
+  });
+
+  if (
+    // not end of line
+    nextToken.type !== "ws" &&
+    //not a punctuation (for eg '?subject}', we dont want to include '}')
+    token.state.possibleFullIri &&
+    //not whitespace
+    token.type !== null &&
+    token.type !== "ws" &&
+    // Avoid infinite loops as CM will give back the last token of in a line when requesting something larger then the lines length
+    nextToken.end !== token.end
+  ) {
+    token.end = nextToken.end;
+    token.string = token.string + nextToken.string;
+    return expandTokenToEnd(yasqe, token, {
+      line: cur.line,
+      ch: nextToken.end,
+    }); // recursively, might have multiple tokens which it should include
+  } else if (token.type === "ws") {
+    //always keep 1 char of whitespace between tokens. Otherwise, autocompletions might end up next to the previous node, without whitespace between them
+    token.end = token.end + 1;
+    token.string = token.string.substring(token.string.length - 1);
+    return token;
+  } else {
+    return token;
+  }
+}
+export function getPreviousNonWsToken(yasqe: Yasqe, line: number, token: Token): Token {
+  var previousToken = yasqe.getTokenAt({
+    line: line,
+    ch: token.start,
+  });
+  if (previousToken != null && previousToken.type == "ws") {
+    previousToken = getPreviousNonWsToken(yasqe, line, previousToken);
+  }
+  return previousToken;
+}
+export function getNextNonWsToken(yasqe: Yasqe, lineNumber: number, charNumber?: number): Token | undefined {
+  if (charNumber == undefined) charNumber = 1;
+  var token = yasqe.getTokenAt({
+    line: lineNumber,
+    ch: charNumber,
+  });
+  if (token == null || token == undefined || token.end < charNumber) {
+    return undefined;
+  }
+  if (token.type == "ws") {
+    return getNextNonWsToken(yasqe, lineNumber, token.end + 1);
+  }
+  return token;
+}

package/src/tooltip.ts

@@ -0,0 +1,31 @@
+/**
+ * Write our own tooltip, to avoid loading another library for just this functionality. For now, we only use tooltip for showing parse errors, so this is quite a tailored solution
+ * Requirements:
+ * 		position tooltip within codemirror frame as much as possible, to avoid z-index issues with external things on page
+ * 		use html as content
+ */
+import Yasqe from "./";
+
+export default function tooltip(_yasqe: Yasqe, parent: HTMLDivElement, html: string) {
+  var tooltip: HTMLDivElement;
+  parent.onmouseover = function () {
+    if (!tooltip) {
+      tooltip = document.createElement("div");
+      tooltip.className = "yasqe_tooltip";
+    }
+    // if ($(yasqe.getWrapperElement()).offset().top >= tooltip.offset().top) {
+    //shit, move the tooltip down. The tooltip now hovers over the top edge of the yasqe instance
+    // tooltip.css("bottom", "auto");
+    // tooltip.css("top", "26px");
+    // }
+    tooltip.style.display = "block";
+    tooltip.innerHTML = html;
+    parent.appendChild(tooltip);
+  };
+  parent.onmouseout = function () {
+    if (tooltip) {
+      tooltip.style.display = "none";
+    }
+    tooltip.innerHTML = html;
+  };
+}

package/src/trie.ts

@@ -0,0 +1,238 @@
+export default class Trie {
+  private words = 0;
+  private prefixes = 0;
+  private children: { [char: string]: Trie } = {};
+
+  /*
+   * Insert a word into the dictionary.
+   * Recursively traverse through the trie nodes, and create new node if does not already exist.
+   *
+   * @method insert
+   * @param {String} str Word to insert in the dictionary
+   * @param {Integer} pos Current index of the string to be inserted
+   * @return {Void}
+   */
+  insert(str: string, pos?: number) {
+    if (str.length == 0) {
+      //blank string cannot be inserted
+      return;
+    }
+
+    var T = this,
+      k,
+      child;
+
+    if (pos === undefined) {
+      pos = 0;
+    }
+    if (pos === str.length) {
+      T.words++;
+      return;
+    }
+    T.prefixes++;
+    k = str[pos];
+    if (T.children[k] === undefined) {
+      //if node for this char doesn't exist, create one
+      T.children[k] = new Trie();
+    }
+    child = T.children[k];
+    child.insert(str, pos + 1);
+  }
+  /*
+   * Remove a word from the dictionary.
+   *
+   * @method remove
+   * @param {String} str Word to be removed
+   * @param {Integer} pos Current index of the string to be removed
+   * @return {Void}
+   */
+  remove(str: string, pos?: number) {
+    if (str.length == 0) {
+      return;
+    }
+    var T = this,
+      k,
+      child;
+
+    if (pos === undefined) {
+      pos = 0;
+    }
+    if (T === undefined) {
+      return;
+    }
+    if (pos === str.length) {
+      T.words--;
+      return;
+    }
+    T.prefixes--;
+    k = str[pos];
+    child = T.children[k];
+    child.remove(str, pos + 1);
+  }
+
+  /*
+   * Update an existing word in the dictionary.
+   * This method removes the old word from the dictionary and inserts the new word.
+   *
+   * @method update
+   * @param {String} strOld The old word to be replaced
+   * @param {String} strNew The new word to be inserted
+   * @return {Void}
+   */
+  update(strOld: string, strNew: string) {
+    if (strOld.length == 0 || strNew.length == 0) {
+      return;
+    }
+    this.remove(strOld);
+    this.insert(strNew);
+  }
+
+  /*
+   * Count the number of times a given word has been inserted into the dictionary
+   *
+   * @method countWord
+   * @param {String} str Word to get count of
+   * @param {Integer} pos Current index of the given word
+   * @return {Integer} The number of times a given word exists in the dictionary
+   */
+  countWord(str: string, pos?: number) {
+    if (str.length == 0) {
+      return 0;
+    }
+
+    var T = this,
+      k,
+      child,
+      ret = 0;
+
+    if (pos === undefined) {
+      pos = 0;
+    }
+    if (pos === str.length) {
+      return T.words;
+    }
+    k = str[pos];
+    child = T.children[k];
+    if (child !== undefined) {
+      //node exists
+      ret = child.countWord(str, pos + 1);
+    }
+    return ret;
+  }
+
+  /*
+   * Count the number of times a given prefix exists in the dictionary
+   *
+   * @method countPrefix
+   * @param {String} str Prefix to get count of
+   * @param {Integer} pos Current index of the given prefix
+   * @return {Integer} The number of times a given prefix exists in the dictionary
+   */
+  countPrefix(str: string, pos: number) {
+    if (str.length == 0) {
+      return 0;
+    }
+
+    var T = this,
+      k: string,
+      child,
+      ret = 0;
+
+    if (pos === undefined) {
+      pos = 0;
+    }
+    if (pos === str.length) {
+      return T.prefixes;
+    }
+    var k = str[pos];
+    child = T.children[k];
+    if (child !== undefined) {
+      //node exists
+      ret = child.countPrefix(str, pos + 1);
+    }
+    return ret;
+  }
+
+  /*
+   * Find a word in the dictionary
+   *
+   * @method find
+   * @param {String} str The word to find in the dictionary
+   * @return {Boolean} True if the word exists in the dictionary, else false
+   */
+  find(str: string) {
+    if (str.length == 0) {
+      return false;
+    }
+
+    if (this.countWord(str) > 0) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  /*
+   * Get all words in the dictionary
+   *
+   * @method getAllWords
+   * @param {String} str Prefix of current word
+   * @return {Array} Array of words in the dictionary
+   */
+  getAllWords(str: string): string[] {
+    var T = this,
+      k,
+      child,
+      ret = [];
+    if (str === undefined) {
+      str = "";
+    }
+    if (T === undefined) {
+      return [];
+    }
+    if (T.words > 0) {
+      ret.push(str);
+    }
+    for (k in T.children) {
+      if (T.children.hasOwnProperty(k)) {
+        child = T.children[k];
+        ret = ret.concat(child.getAllWords(str + k));
+      }
+    }
+    return ret;
+  }
+
+  /*
+   * Autocomplete a given prefix
+   *
+   * @method autoComplete
+   * @param {String} str Prefix to be completed based on dictionary entries
+   * @param {Integer} pos Current index of the prefix
+   * @return {Array} Array of possible suggestions
+   */
+  autoComplete(str: string, pos?: number): string[] {
+    var T = this,
+      k,
+      child;
+    if (str.length == 0) {
+      if (pos === undefined) {
+        return T.getAllWords(str);
+      } else {
+        return [];
+      }
+    }
+    if (pos === undefined) {
+      pos = 0;
+    }
+    k = str[pos];
+    child = T.children[k];
+    if (child === undefined) {
+      //node doesn't exist
+      return [];
+    }
+    if (pos === str.length - 1) {
+      return child.getAllWords(str);
+    }
+    return child.autoComplete(str, pos + 1);
+  }
+}