@matdata/yasqe 4.6.1

package/src/autocompleters/index.ts

@@ -0,0 +1,346 @@
+import { default as Yasqe, Token, Hint, Position, Config, HintFn, HintConfig } from "../";
+import Trie from "../trie";
+import { EventEmitter } from "events";
+import { take } from "lodash-es";
+const CodeMirror = require("codemirror");
+require("./show-hint.scss");
+export interface CompleterConfig {
+  onInitialize?: (this: CompleterConfig, yasqe: Yasqe) => void; //allows for e.g. registering event listeners in yasqe, like the prefix autocompleter does
+  isValidCompletionPosition: (yasqe: Yasqe) => boolean;
+  get: (yasqe: Yasqe, token?: AutocompletionToken) => Promise<string[]> | string[];
+  preProcessToken?: (yasqe: Yasqe, token: Token) => AutocompletionToken;
+  postProcessSuggestion?: (yasqe: Yasqe, token: AutocompletionToken, suggestedString: string) => string;
+  postprocessHints?: (yasqe: Yasqe, hints: Hint[]) => Hint[];
+  bulk: boolean;
+  autoShow?: boolean;
+  persistenceId?: Config["persistenceId"];
+  name: string;
+}
+const SUGGESTIONS_LIMIT = 100;
+export interface AutocompletionToken extends Token {
+  autocompletionString?: string;
+  tokenPrefix?: string;
+  tokenPrefixUri?: string;
+  from?: Partial<Position>;
+  to?: Partial<Position>;
+}
+export class Completer extends EventEmitter {
+  protected yasqe: Yasqe;
+  private trie?: Trie;
+  private config: CompleterConfig;
+  constructor(yasqe: Yasqe, config: CompleterConfig) {
+    super();
+    this.yasqe = yasqe;
+    this.config = config;
+  }
+
+  // private selectHint(data:EditorChange, completion:any) {
+  //   if (completion.text != this.yasqe.getTokenAt(this.yasqe.getDoc().getCursor()).string) {
+  //     this.yasqe.getDoc().replaceRange(completion.text, data.from, data.to);
+  //   }
+  // };
+  private getStorageId() {
+    return this.yasqe.getStorageId(this.config.persistenceId);
+  }
+
+  /**
+   * Store bulk completion in local storage, and populates the trie
+   */
+  private storeBulkCompletions(completions: string[]) {
+    if (!completions || !(completions instanceof Array)) return;
+    // store array as trie
+    this.trie = new Trie();
+    for (const c of completions) {
+      this.trie.insert(c);
+    }
+
+    // store in localstorage as well
+    var storageId = this.getStorageId();
+    if (storageId)
+      this.yasqe.storage.set(storageId, completions, 60 * 60 * 24 * 30, this.yasqe.handleLocalStorageQuotaFull);
+  }
+
+  /**
+   * Get completion list from `get` function
+   */
+  public getCompletions(token?: AutocompletionToken): Promise<string[]> {
+    if (!this.config.get) return Promise.resolve([]);
+
+    //No token, so probably getting as bulk
+    if (!token) {
+      if (this.config.get instanceof Array) return Promise.resolve(this.config.get);
+      //wrapping call in a promise.resolve, so this when a `get` is both async or sync
+      return Promise.resolve(this.config.get(this.yasqe)).then((suggestions) => {
+        if (suggestions instanceof Array) return suggestions;
+        return [];
+      });
+    }
+
+    //ok, there is a token
+    const stringToAutocomplete = token.autocompletionString || token.string;
+    if (this.trie) return Promise.resolve(take(this.trie.autoComplete(stringToAutocomplete), SUGGESTIONS_LIMIT));
+    if (this.config.get instanceof Array)
+      return Promise.resolve(
+        this.config.get.filter((possibleMatch) => possibleMatch.indexOf(stringToAutocomplete) === 0)
+      );
+    //assuming it's a function
+    return Promise.resolve(this.config.get(this.yasqe, token)).then((r) => {
+      if (r instanceof Array) return r;
+      return [];
+    });
+  }
+
+  /**
+   * Populates completions. Pre-fetches those if bulk is set to true
+   */
+  public initialize(): Promise<void> {
+    if (this.config.onInitialize) this.config.onInitialize(this.yasqe);
+    if (this.config.bulk) {
+      if (this.config.get instanceof Array) {
+        // we don't care whether the completions are already stored in
+        // localstorage. just use this one
+        this.storeBulkCompletions(this.config.get);
+        return Promise.resolve();
+      } else {
+        // if completions are defined in localstorage, use those! (calling the
+        // function may come with overhead (e.g. async calls))
+        var completionsFromStorage: string[] | undefined;
+        var storageId = this.getStorageId();
+        if (storageId) completionsFromStorage = this.yasqe.storage.get<string[]>(storageId);
+        if (completionsFromStorage && completionsFromStorage.length > 0) {
+          this.storeBulkCompletions(completionsFromStorage);
+          return Promise.resolve();
+        } else {
+          return this.getCompletions().then((c) => this.storeBulkCompletions(c));
+        }
+      }
+    }
+    return Promise.resolve();
+  }
+
+  private isValidPosition(): boolean {
+    if (!this.config.isValidCompletionPosition) return false; //no way to check whether we are in a valid position
+    if (!this.config.isValidCompletionPosition(this.yasqe)) {
+      this.emit("invalidPosition", this);
+      this.yasqe.hideNotification(this.config.name);
+      return false;
+    }
+    if (!this.config.autoShow) {
+      this.yasqe.showNotification(this.config.name, "Press CTRL - <spacebar> to autocomplete");
+    }
+    this.emit("validPosition", this);
+    return true;
+  }
+
+  private getHint(autocompletionToken: AutocompletionToken, suggestedString: string): Hint {
+    if (this.config.postProcessSuggestion) {
+      suggestedString = this.config.postProcessSuggestion(this.yasqe, autocompletionToken, suggestedString);
+    }
+    let from: Position | undefined;
+    let to: Position;
+    const cursor = this.yasqe.getDoc().getCursor();
+    if (autocompletionToken.from) {
+      from = { ...cursor, ...autocompletionToken.from };
+    }
+    // Need to set a 'to' part as well, as otherwise we'd be appending the result to the already typed filter
+    const line = this.yasqe.getDoc().getCursor().line;
+    if (autocompletionToken.to) {
+      to = { ch: autocompletionToken?.to?.ch || this.yasqe.getCompleteToken().end, line: line };
+    } else if (autocompletionToken.string.length > 0) {
+      to = { ch: this.yasqe.getCompleteToken().end, line: line };
+    } else {
+      to = <any>autocompletionToken.from;
+    }
+    return {
+      text: suggestedString,
+      displayText: suggestedString,
+      from: from,
+      to: to,
+    };
+  }
+
+  private getHints(token: AutocompletionToken): Promise<Hint[]> {
+    if (this.config.preProcessToken) {
+      token = this.config.preProcessToken(this.yasqe, token);
+    }
+
+    if (token)
+      return this.getCompletions(token)
+        .then((suggestions) => suggestions.map((s) => this.getHint(token, s)))
+        .then((hints) => {
+          if (this.config.postprocessHints) return this.config.postprocessHints(this.yasqe, hints);
+          return hints;
+        });
+    return Promise.resolve([]);
+  }
+  public autocomplete(fromAutoShow: boolean) {
+    //this part goes before the autoshow check, as we _would_ like notification showing to indicate a user can press ctrl-space
+    if (!this.isValidPosition()) return false;
+    const previousCompletionItem = this.yasqe.state.completionActive;
+
+    // Showhint by defaults takes the autocomplete start position (the location of the cursor at the time of starting the autocompletion).
+    const cursor = this.yasqe.getDoc().getCursor();
+    if (
+      // When the cursor goes before current completionItem (e.g. using arrow keys), it would close the autocompletions.
+      // We want the autocompletion to be active at whatever point we are in the token, so let's modify this start pos with the start pos of the token
+      previousCompletionItem &&
+      cursor.sticky && // Is undefined at the end of the token, otherwise it is set as either "before" or "after" (The movement of the cursor)
+      cursor.ch !== previousCompletionItem.startPos.ch
+    ) {
+      this.yasqe.state.completionActive.startPos = cursor;
+    } else if (previousCompletionItem && !cursor.sticky && cursor.ch < previousCompletionItem.startPos.ch) {
+      // A similar thing happens when pressing backspace, CodeMirror will close this autocomplete when 'startLen' changes downward
+      cursor.sticky = previousCompletionItem.startPos.sticky;
+      this.yasqe.state.completionActive.startPos.ch = cursor.ch;
+      this.yasqe.state.completionActive.startLen--;
+    }
+    if (
+      fromAutoShow && // from autoShow, i.e. this gets called each time the editor content changes
+      (!this.config.autoShow || this.yasqe.state.completionActive) // Don't show  and don't create a new instance when its already active
+    ) {
+      return false;
+    }
+
+    const getHints: HintFn = () => {
+      return this.getHints(this.yasqe.getCompleteToken()).then((list) => {
+        const cur = this.yasqe.getDoc().getCursor();
+        const token: AutocompletionToken = this.yasqe.getCompleteToken();
+        const hintResult = {
+          list: list,
+          from: <Position>{
+            line: cur.line,
+            ch: token.start,
+          },
+          to: <Position>{
+            line: cur.line,
+            ch: token.end,
+          },
+        };
+        CodeMirror.on(hintResult, "shown", () => {
+          this.yasqe.emit("autocompletionShown", (this.yasqe as any).state.completionActive.widget);
+        });
+        CodeMirror.on(hintResult, "close", () => {
+          this.yasqe.emit("autocompletionClose");
+        });
+        return hintResult;
+      });
+    };
+
+    getHints.async = false; //in their code, async means using a callback
+    //we always return a promise, which should be properly handled regardless of this val
+    var hintConfig: HintConfig = {
+      closeCharacters: /[\s>"]/,
+      completeSingle: false,
+      hint: getHints,
+      container: this.yasqe.rootEl,
+      // Override these actions back to use their default function
+      // Otherwise these would navigate to the start/end of the suggestion list, while this can also be accomplished with PgUp and PgDn
+      extraKeys: {
+        Home: (yasqe, event) => {
+          yasqe.getDoc().setCursor({ ch: 0, line: event.data.from.line });
+        },
+        End: (yasqe, event) => {
+          yasqe.getDoc().setCursor({ ch: yasqe.getLine(event.data.to.line).length, line: event.data.to.line });
+        },
+      },
+      ...this.yasqe.config.hintConfig,
+    };
+    this.yasqe.showHint(hintConfig);
+    return true;
+  }
+}
+
+/**
+ * Converts rdf:type to http://.../type and converts <http://...> to http://...
+ * Stores additional info such as the used namespace and prefix in the token object
+ */
+export function preprocessIriForCompletion(yasqe: Yasqe, token: AutocompletionToken) {
+  const queryPrefixes = yasqe.getPrefixesFromQuery();
+  const stringToPreprocess = token.string;
+
+  if (stringToPreprocess.indexOf("<") < 0) {
+    token.tokenPrefix = stringToPreprocess.substring(0, stringToPreprocess.indexOf(":") + 1);
+
+    if (queryPrefixes[token.tokenPrefix.slice(0, -1)] != null) {
+      token.tokenPrefixUri = queryPrefixes[token.tokenPrefix.slice(0, -1)];
+    }
+  }
+
+  token.autocompletionString = stringToPreprocess.trim();
+  if (stringToPreprocess.indexOf("<") < 0 && stringToPreprocess.indexOf(":") > -1) {
+    // hmm, the token is prefixed. We still need the complete uri for autocompletions. generate this!
+    for (var prefix in queryPrefixes) {
+      if (token.tokenPrefix === prefix + ":") {
+        token.autocompletionString = queryPrefixes[prefix];
+        token.autocompletionString += stringToPreprocess.substring(prefix.length + 1);
+        break;
+      }
+    }
+  }
+
+  if (token.autocompletionString.indexOf("<") == 0)
+    token.autocompletionString = token.autocompletionString.substring(1);
+  if (token.autocompletionString.indexOf(">", token.autocompletionString.length - 1) > 0)
+    token.autocompletionString = token.autocompletionString.substring(0, token.autocompletionString.length - 1);
+  return token;
+}
+
+export function postprocessIriCompletion(_yasqe: Yasqe, token: AutocompletionToken, suggestedString: string) {
+  if (token.tokenPrefix && token.autocompletionString && token.tokenPrefixUri) {
+    // we need to get the suggested string back to prefixed form
+    suggestedString = token.tokenPrefix + suggestedString.substring(token.tokenPrefixUri.length);
+  } else {
+    // it is a regular uri. add '<' and '>' to string
+    suggestedString = "<" + suggestedString + ">";
+  }
+  return suggestedString;
+}
+
+//Use protocol relative request when served via http[s]*. Otherwise (e.g. file://, fetch via http)
+export const fetchFromLov = (
+  yasqe: Yasqe,
+  type: "class" | "property",
+  token?: AutocompletionToken
+): Promise<string[]> => {
+  var reqProtocol = window.location.protocol.indexOf("http") === 0 ? "https://" : "http://";
+  const notificationKey = "autocomplete_" + type;
+  if (!token || !token.string || token.string.trim().length == 0) {
+    yasqe.showNotification(notificationKey, "Nothing to autocomplete yet!");
+    return Promise.resolve([]);
+  }
+  // //if notification bar is there, show a loader
+  // yasqe.autocompleters.notifications
+  //   .getEl(completer)
+  //   .empty()
+  //   .append($("<span>Fetchting autocompletions &nbsp;</span>"))
+  //   .append($(yutils.svg.getElement(require("../imgs.js").loader)).addClass("notificationLoader"));
+  // doRequests();
+
+  const params = new URLSearchParams();
+  if (token.autocompletionString) params.append("q", token.autocompletionString);
+  params.append("page_size", "50");
+  params.append("type", type);
+  const url = `${reqProtocol}lov.linkeddata.es/dataset/lov/api/v2/autocomplete/terms?${params.toString()}`;
+  return fetch(url)
+    .then((response) => {
+      if (!response.ok) {
+        throw new Error("Failed fetching suggestions from Linked Open Vocabularies");
+      }
+      return response.json();
+    })
+    .then((result) => {
+      if (result.results) {
+        return result.results.map((r: any) => r.uri[0]);
+      }
+      return [];
+    })
+    .catch((_e) => {
+      yasqe.showNotification(notificationKey, "Failed fetching suggestions");
+    });
+};
+
+import variableCompleter from "./variables";
+import prefixCompleter from "./prefixes";
+import propertyCompleter from "./properties";
+import classCompleter from "./classes";
+export var completers: CompleterConfig[] = [variableCompleter, prefixCompleter, propertyCompleter, classCompleter];

package/src/autocompleters/prefixes.ts

@@ -0,0 +1,130 @@
+import * as Autocompleter from "./";
+import { sortBy } from "lodash-es";
+var tokenTypes: { [id: string]: "prefixed" | "var" } = {
+  "string-2": "prefixed",
+  atom: "var",
+};
+
+var conf: Autocompleter.CompleterConfig = {
+  postprocessHints: function (_yasqe, hints) {
+    return sortBy(hints, (hint) => hint.text.split(":")[0]);
+  },
+  onInitialize: function (yasqe) {
+    /**
+     * This event listener makes sure we auto-add prefixes whenever we use them
+     */
+    yasqe.on("change", () => {
+      if (!yasqe.config.autocompleters || yasqe.config.autocompleters.indexOf(this.name) == -1) return; //this autocompleter is disabled
+      var cur = yasqe.getDoc().getCursor();
+
+      var token: Autocompleter.AutocompletionToken = yasqe.getTokenAt(cur);
+      if (token.type && tokenTypes[token.type] == "prefixed") {
+        var colonIndex = token.string.indexOf(":");
+        if (colonIndex !== -1) {
+          // check previous token isnt PREFIX, or a '<'(which would mean we are in a uri)
+          //			var firstTokenString = yasqe.getNextNonWsToken(cur.line).string.toUpperCase();
+          var lastNonWsTokenString = yasqe.getPreviousNonWsToken(cur.line, token).string.toUpperCase();
+          var previousToken = yasqe.getTokenAt({
+            line: cur.line,
+            ch: token.start,
+          }); // needs to be null (beginning of line), or whitespace
+
+          if (
+            lastNonWsTokenString !== "PREFIX" &&
+            (previousToken.type == "ws" ||
+              previousToken.type == null ||
+              (previousToken.type === "punc" &&
+                (previousToken.string === "|" ||
+                  previousToken.string === "/" ||
+                  previousToken.string == "^^" ||
+                  previousToken.string == "{" ||
+                  previousToken.string === "(")))
+          ) {
+            // check whether it isn't defined already (saves us from looping
+            // through the array)
+            var currentPrefix = token.string.substring(0, colonIndex + 1);
+
+            var queryPrefixes = yasqe.getPrefixesFromQuery();
+            if (queryPrefixes[currentPrefix.slice(0, -1)] == null) {
+              // ok, so it isn't added yet!
+              // var completions = yasqe.autocompleters.getTrie(completerName).autoComplete(currentPrefix);
+              token.autocompletionString = currentPrefix;
+              yasqe.autocompleters[this.name]?.getCompletions(token).then((suggestions) => {
+                if (suggestions.length) {
+                  yasqe.addPrefixes(suggestions[0]);
+                  // Re-activate auto-completer after adding prefixes, so another auto-completer can kick in
+                  yasqe.autocomplete();
+                }
+              }, console.warn);
+            }
+          }
+        }
+      }
+    });
+  },
+  isValidCompletionPosition: function (yasqe) {
+    var cur = yasqe.getDoc().getCursor(),
+      token = yasqe.getTokenAt(cur);
+
+    // not at end of line
+    if (yasqe.getDoc().getLine(cur.line).length > cur.ch) return false;
+
+    if (token.type != "ws") {
+      // we want to complete token, e.g. when the prefix starts with an a
+      // (treated as a token in itself..)
+      // but we to avoid including the PREFIX tag. So when we have just
+      // typed a space after the prefix tag, don't get the complete token
+      token = yasqe.getCompleteToken();
+    }
+
+    // we shouldnt be at the uri part the prefix declaration
+    // also check whether current token isnt 'a' (that makes codemirror
+    // thing a namespace is a possiblecurrent
+    if (token.string.indexOf("a") !== 0 && token.state.possibleCurrent.indexOf("PNAME_NS") < 0) return false;
+
+    // First token of line needs to be PREFIX,
+    // there should be no trailing text (otherwise, text is wrongly inserted
+    // in between)
+    var previousToken = yasqe.getPreviousNonWsToken(cur.line, token);
+    if (!previousToken || previousToken.string.toUpperCase() != "PREFIX") return false;
+    return true;
+  },
+  get: function (yasqe) {
+    return fetch(yasqe.config.prefixCcApi)
+      .then((response) => {
+        if (!response.ok) {
+          throw new Error("Failed to fetch prefixes");
+        }
+        return response.json();
+      })
+      .then((resp) => {
+        const prefixArray: string[] = [];
+        for (const prefix in resp) {
+          const completeString = `${prefix}: <${resp[prefix]}>`;
+          prefixArray.push(completeString); // the array we want to store in local storage
+        }
+        return prefixArray.sort();
+      });
+  },
+  preProcessToken: function (yasqe, token) {
+    var previousToken = yasqe.getPreviousNonWsToken(yasqe.getDoc().getCursor().line, token);
+    if (previousToken && previousToken.string && previousToken.string.slice(-1) == ":") {
+      //combine both tokens! In this case we have the cursor at the end of line "PREFIX bla: <".
+      //we want the token to be "bla: <", en not "<"
+      token = {
+        start: previousToken.start,
+        end: token.end,
+        string: previousToken.string + " " + token.string,
+        state: token.state,
+        type: token.type,
+      };
+    }
+    return token;
+  },
+  bulk: true,
+  autoShow: true,
+  persistenceId: "prefixes",
+  name: "prefixes",
+};
+
+export default conf;

package/src/autocompleters/properties.ts

@@ -0,0 +1,28 @@
+import * as Autocompleter from "./";
+
+var conf: Autocompleter.CompleterConfig = {
+  onInitialize: function (_yasqe) {
+    // validPosition: yasqe.autocompleters.notifications.show,
+    // invalidPosition: yasqe.autocompleters.notifications.hide
+  },
+  get: function (yasqe, token) {
+    return Autocompleter.fetchFromLov(yasqe, "property", token);
+  },
+  isValidCompletionPosition: function (yasqe) {
+    const token = yasqe.getCompleteToken();
+    if (token.string.length == 0) return false; //we want -something- to autocomplete
+    if (token.string[0] === "?" || token.string[0] === "$") return false; // we are typing a var
+    if (token.state.possibleCurrent.indexOf("a") >= 0) return true; // predicate pos
+    return false;
+  },
+  preProcessToken: function (yasqe, token) {
+    return Autocompleter.preprocessIriForCompletion(yasqe, token);
+  },
+  postProcessSuggestion: function (yasqe, token, suggestedString) {
+    return Autocompleter.postprocessIriCompletion(yasqe, token, suggestedString);
+  },
+  bulk: false,
+  name: "property",
+};
+
+export default conf;

package/src/autocompleters/show-hint.scss

@@ -0,0 +1,38 @@
+//This is a copy of the codemirror show-hint css
+//Including this ourselves, as we don't want this css to be auto-scoped to yasqe by webpack
+.CodeMirror-hints {
+  position: absolute;
+  z-index: 10;
+  overflow: hidden;
+  list-style: none;
+
+  margin: 0;
+  padding: 2px;
+
+  -webkit-box-shadow: 2px 3px 5px rgba(0, 0, 0, 0.2);
+  -moz-box-shadow: 2px 3px 5px rgba(0, 0, 0, 0.2);
+  box-shadow: 2px 3px 5px rgba(0, 0, 0, 0.2);
+  border-radius: 3px;
+  border: 1px solid silver;
+
+  background: white;
+  font-size: 90%;
+  font-family: monospace;
+
+  max-height: 20em;
+  overflow-y: auto;
+}
+
+.CodeMirror-hint {
+  margin: 0;
+  padding: 0 4px;
+  border-radius: 2px;
+  white-space: pre;
+  color: black;
+  cursor: pointer;
+}
+
+li.CodeMirror-hint-active {
+  background: #08f;
+  color: white;
+}

package/src/autocompleters/variables.ts

@@ -0,0 +1,52 @@
+import * as autocompleter from "./";
+
+var conf: autocompleter.CompleterConfig = {
+  name: "variables",
+  isValidCompletionPosition: function (yasqe) {
+    var token = yasqe.getTokenAt(yasqe.getDoc().getCursor());
+    if (token.type != "ws") {
+      token = yasqe.getCompleteToken(token);
+      if (token && (token.string[0] === "?" || token.string[0] === "$")) {
+        return true;
+      }
+    }
+    return false;
+  },
+  get: function (yasqe, token) {
+    if (!token || token.string.length == 0) return []; //nothing to autocomplete
+    const distinctVars: { [varname: string]: any } = {};
+    const vars: string[] = [];
+    //do this outside of codemirror. I expect jquery to be faster here (just finding dom elements with classnames)
+    //and: this'll still work when the query is incorrect (i.e., when simply typing '?')
+    const atoms = yasqe.getWrapperElement().querySelectorAll(".cm-atom");
+    for (let i = 0; i < atoms.length; i++) {
+      const atom = atoms[i];
+      var variable = atom.innerHTML;
+      if (variable[0] === "?" || variable[0] === "$") {
+        //ok, lets check if the next element in the div is an atom as well. In that case, they belong together (may happen sometimes when query is not syntactically valid)
+        // var nextElClass = nextEl.attr("class");
+        const nextEl: HTMLElement = <any>atom.nextSibling;
+        if (nextEl && nextEl.className && nextEl.className.indexOf("cm-atom") >= 0) {
+          variable += nextEl.innerText;
+        }
+        if (distinctVars[variable]) continue; //already in list
+        //skip single questionmarks
+        if (variable.length <= 1) continue;
+
+        //it should match our token ofcourse
+        if (variable.indexOf(token.string) !== 0) continue;
+
+        //skip exact matches
+        if (variable === token.string) continue;
+
+        //store in map so we have a unique list
+        distinctVars[variable] = true;
+        vars.push(variable);
+      }
+    }
+    return vars.sort();
+  },
+  bulk: false,
+  autoShow: true,
+};
+export default conf;