@matdata/yasqe 4.7.4 → 4.8.0

package/build/ts/src/index.js

@@ -0,0 +1,775 @@
+import "./scss/yasqe.scss";
+import "./scss/buttons.scss";
+import { findFirstPrefixLine } from "./prefixFold";
+import { getPrefixesFromQuery, addPrefixes, removePrefixes } from "./prefixUtils";
+import { getPreviousNonWsToken, getNextNonWsToken, getCompleteToken } from "./tokenUtils";
+import { Storage as YStorage } from "@matdata/yasgui-utils";
+import * as queryString from "query-string";
+import tooltip from "./tooltip";
+import { drawSvgStringAsElement, addClass, removeClass } from "@matdata/yasgui-utils";
+import * as Sparql from "./sparql";
+import * as imgs from "./imgs";
+import * as Autocompleter from "./autocompleters";
+import { merge, escape } from "lodash-es";
+import getDefaults from "./defaults";
+import CodeMirror from "./CodeMirror";
+export class Yasqe extends CodeMirror {
+    constructor(parent, conf = {}) {
+        super();
+        this.autocompleters = {};
+        this.prevQueryValid = false;
+        this.queryValid = true;
+        this.isFullscreen = false;
+        this.handleHashChange = () => {
+            var _a, _b;
+            (_b = (_a = this.config).consumeShareLink) === null || _b === void 0 ? void 0 : _b.call(_a, this);
+        };
+        this.notificationEls = {};
+        if (!parent)
+            throw new Error("No parent passed as argument. Dont know where to draw YASQE");
+        this.rootEl = document.createElement("div");
+        this.rootEl.className = "yasqe";
+        parent.appendChild(this.rootEl);
+        this.config = merge({}, Yasqe.defaults, conf);
+        const cm = CodeMirror(this.rootEl, this.config);
+        for (const key of Object.getOwnPropertyNames(Yasqe.prototype)) {
+            cm[key] = Yasqe.prototype[key].bind(this);
+        }
+        Object.assign(this, CodeMirror.prototype, cm);
+        this.storage = new YStorage(Yasqe.storageNamespace);
+        this.drawButtons();
+        const storageId = this.getStorageId();
+        if (storageId) {
+            const persConf = this.storage.get(storageId);
+            if (persConf && typeof persConf === "string") {
+                this.persistentConfig = { query: persConf, editorHeight: this.config.editorHeight };
+            }
+            else {
+                this.persistentConfig = persConf;
+            }
+            if (!this.persistentConfig)
+                this.persistentConfig = { query: this.getValue(), editorHeight: this.config.editorHeight };
+            if (this.persistentConfig && this.persistentConfig.query)
+                this.setValue(this.persistentConfig.query);
+        }
+        this.config.autocompleters.forEach((c) => this.enableCompleter(c).then(() => { }, console.warn));
+        if (this.config.consumeShareLink) {
+            this.config.consumeShareLink(this);
+            window.addEventListener("hashchange", this.handleHashChange);
+        }
+        this.checkSyntax();
+        if (this.persistentConfig && this.persistentConfig.editorHeight) {
+            this.getWrapperElement().style.height = this.persistentConfig.editorHeight;
+        }
+        else if (this.config.editorHeight) {
+            this.getWrapperElement().style.height = this.config.editorHeight;
+        }
+        if (this.config.resizeable)
+            this.drawResizer();
+        if (this.config.collapsePrefixesOnLoad)
+            this.collapsePrefixes(true);
+        this.registerEventListeners();
+    }
+    handleChange() {
+        this.checkSyntax();
+        this.updateQueryButton();
+    }
+    handleBlur() {
+        this.saveQuery();
+    }
+    handleChanges() {
+        this.checkSyntax();
+        this.updateQueryButton();
+    }
+    handleCursorActivity() {
+        this.autocomplete(true);
+    }
+    handleQuery(_yasqe, req, abortController) {
+        this.req = req;
+        this.abortController = abortController;
+        this.updateQueryButton();
+    }
+    handleQueryResponse(_yasqe, _response, duration) {
+        this.lastQueryDuration = duration;
+        this.req = undefined;
+        this.updateQueryButton();
+    }
+    handleQueryAbort(_yasqe, _req) {
+        this.req = undefined;
+        this.updateQueryButton();
+    }
+    registerEventListeners() {
+        this.on("change", this.handleChange);
+        this.on("blur", this.handleBlur);
+        this.on("changes", this.handleChanges);
+        this.on("cursorActivity", this.handleCursorActivity);
+        this.on("query", this.handleQuery);
+        this.on("queryResponse", this.handleQueryResponse);
+        this.on("queryAbort", this.handleQueryAbort);
+    }
+    unregisterEventListeners() {
+        this.off("change", this.handleChange);
+        this.off("blur", this.handleBlur);
+        this.off("changes", this.handleChanges);
+        this.off("cursorActivity", this.handleCursorActivity);
+        this.off("query", this.handleQuery);
+        this.off("queryResponse", this.handleQueryResponse);
+        this.off("queryAbort", this.handleQueryAbort);
+    }
+    emit(event, ...data) {
+        CodeMirror.signal(this, event, this, ...data);
+    }
+    getStorageId(getter) {
+        const persistenceId = getter || this.config.persistenceId;
+        if (!persistenceId)
+            return undefined;
+        if (typeof persistenceId === "string")
+            return persistenceId;
+        return persistenceId(this);
+    }
+    drawButtons() {
+        const buttons = document.createElement("div");
+        buttons.className = "yasqe_buttons";
+        this.getWrapperElement().appendChild(buttons);
+        if (this.config.pluginButtons) {
+            const pluginButtons = this.config.pluginButtons();
+            if (!pluginButtons)
+                return;
+            if (Array.isArray(pluginButtons)) {
+                for (const button of pluginButtons) {
+                    buttons.append(button);
+                }
+            }
+            else {
+                buttons.appendChild(pluginButtons);
+            }
+        }
+        if (this.config.createShareableLink) {
+            var svgShare = drawSvgStringAsElement(imgs.share);
+            const shareLinkWrapper = document.createElement("button");
+            shareLinkWrapper.className = "yasqe_share";
+            shareLinkWrapper.title = "Share query";
+            shareLinkWrapper.setAttribute("aria-label", "Share query");
+            shareLinkWrapper.appendChild(svgShare);
+            buttons.appendChild(shareLinkWrapper);
+            shareLinkWrapper.addEventListener("click", (event) => showSharePopup(event));
+            shareLinkWrapper.addEventListener("keydown", (event) => {
+                if (event.code === "Enter") {
+                    showSharePopup(event);
+                }
+            });
+            const showSharePopup = (event) => {
+                event.stopPropagation();
+                let popup = document.createElement("div");
+                popup.className = "yasqe_sharePopup";
+                buttons.appendChild(popup);
+                document.body.addEventListener("click", (event) => {
+                    if (popup && event.target !== popup && !popup.contains(event.target)) {
+                        popup.remove();
+                        popup = undefined;
+                    }
+                }, true);
+                var input = document.createElement("input");
+                input.type = "text";
+                input.value = this.config.createShareableLink(this);
+                input.onfocus = function () {
+                    input.select();
+                };
+                input.onmouseup = function () {
+                    return false;
+                };
+                popup.innerHTML = "";
+                var inputWrapper = document.createElement("div");
+                inputWrapper.className = "inputWrapper";
+                inputWrapper.appendChild(input);
+                popup.appendChild(inputWrapper);
+                const popupInputButtons = [];
+                const createShortLink = this.config.createShortLink;
+                if (createShortLink) {
+                    popup.className = popup.className += " enableShort";
+                    const shortBtn = document.createElement("button");
+                    popupInputButtons.push(shortBtn);
+                    shortBtn.innerHTML = "Shorten";
+                    shortBtn.className = "yasqe_btn yasqe_btn-sm shorten";
+                    popup.appendChild(shortBtn);
+                    shortBtn.onclick = () => {
+                        popupInputButtons.forEach((button) => (button.disabled = true));
+                        createShortLink(this, input.value).then((value) => {
+                            input.value = value;
+                            input.focus();
+                        }, (err) => {
+                            const errSpan = document.createElement("span");
+                            errSpan.className = "shortlinkErr";
+                            let textContent = "An error has occurred";
+                            if (typeof err === "string" && err.length !== 0) {
+                                textContent = err;
+                            }
+                            else if (err.message && err.message.length !== 0) {
+                                textContent = err.message;
+                            }
+                            errSpan.textContent = textContent;
+                            input.replaceWith(errSpan);
+                        });
+                    };
+                }
+                const curlBtn = document.createElement("button");
+                popupInputButtons.push(curlBtn);
+                curlBtn.innerText = "cURL";
+                curlBtn.className = "yasqe_btn yasqe_btn-sm curl";
+                popup.appendChild(curlBtn);
+                curlBtn.onclick = () => {
+                    popupInputButtons.forEach((button) => (button.disabled = true));
+                    input.value = this.getAsCurlString();
+                    input.focus();
+                    popup === null || popup === void 0 ? void 0 : popup.appendChild(curlBtn);
+                };
+                const svgPos = svgShare.getBoundingClientRect();
+                popup.style.top = svgShare.offsetTop + svgPos.height + "px";
+                popup.style.left = svgShare.offsetLeft + svgShare.clientWidth - popup.clientWidth + "px";
+                input.focus();
+            };
+        }
+        if (this.config.showQueryButton) {
+            this.queryBtn = document.createElement("button");
+            addClass(this.queryBtn, "yasqe_queryButton");
+            const queryEl = drawSvgStringAsElement(imgs.query);
+            addClass(queryEl, "queryIcon");
+            this.queryBtn.appendChild(queryEl);
+            const warningIcon = drawSvgStringAsElement(imgs.warning);
+            addClass(warningIcon, "warningIcon");
+            this.queryBtn.appendChild(warningIcon);
+            this.queryBtn.onclick = () => {
+                if (this.config.queryingDisabled)
+                    return;
+                if (this.req) {
+                    this.abortQuery();
+                }
+                else {
+                    this.query().catch(() => { });
+                }
+            };
+            this.queryBtn.title = "Run query";
+            this.queryBtn.setAttribute("aria-label", "Run query");
+            buttons.appendChild(this.queryBtn);
+            this.updateQueryButton();
+        }
+        this.fullscreenBtn = document.createElement("button");
+        addClass(this.fullscreenBtn, "yasqe_fullscreenButton");
+        const fullscreenIcon = drawSvgStringAsElement(imgs.fullscreen);
+        addClass(fullscreenIcon, "fullscreenIcon");
+        this.fullscreenBtn.appendChild(fullscreenIcon);
+        const fullscreenExitIcon = drawSvgStringAsElement(imgs.fullscreenExit);
+        addClass(fullscreenExitIcon, "fullscreenExitIcon");
+        this.fullscreenBtn.appendChild(fullscreenExitIcon);
+        this.fullscreenBtn.onclick = () => {
+            this.toggleFullscreen();
+        };
+        this.fullscreenBtn.title = "Toggle fullscreen (F11)";
+        this.fullscreenBtn.setAttribute("aria-label", "Toggle fullscreen");
+        buttons.appendChild(this.fullscreenBtn);
+    }
+    toggleFullscreen() {
+        var _a, _b;
+        this.isFullscreen = !this.isFullscreen;
+        if (this.isFullscreen) {
+            addClass(this.rootEl, "fullscreen");
+            (_a = this.fullscreenBtn) === null || _a === void 0 ? void 0 : _a.setAttribute("title", "Exit fullscreen (F11)");
+        }
+        else {
+            removeClass(this.rootEl, "fullscreen");
+            (_b = this.fullscreenBtn) === null || _b === void 0 ? void 0 : _b.setAttribute("title", "Toggle fullscreen (F11)");
+        }
+        this.refresh();
+    }
+    getIsFullscreen() {
+        return this.isFullscreen;
+    }
+    drawResizer() {
+        if (this.resizeWrapper)
+            return;
+        this.resizeWrapper = document.createElement("div");
+        addClass(this.resizeWrapper, "resizeWrapper");
+        const chip = document.createElement("div");
+        addClass(chip, "resizeChip");
+        this.resizeWrapper.appendChild(chip);
+        this.resizeWrapper.addEventListener("mousedown", this.initDrag, false);
+        this.resizeWrapper.addEventListener("dblclick", this.expandEditor);
+        this.rootEl.appendChild(this.resizeWrapper);
+    }
+    initDrag() {
+        document.documentElement.addEventListener("mousemove", this.doDrag, false);
+        document.documentElement.addEventListener("mouseup", this.stopDrag, false);
+    }
+    calculateDragOffset(event, rootEl) {
+        let parentOffset = 0;
+        if (rootEl.offsetParent)
+            parentOffset = rootEl.offsetParent.offsetTop;
+        let scrollOffset = 0;
+        let parentElement = rootEl.parentElement;
+        while (parentElement) {
+            scrollOffset += parentElement.scrollTop;
+            parentElement = parentElement.parentElement;
+        }
+        return event.clientY - parentOffset - this.rootEl.offsetTop + scrollOffset;
+    }
+    doDrag(event) {
+        this.getWrapperElement().style.height = this.calculateDragOffset(event, this.rootEl) + "px";
+    }
+    stopDrag() {
+        document.documentElement.removeEventListener("mousemove", this.doDrag, false);
+        document.documentElement.removeEventListener("mouseup", this.stopDrag, false);
+        this.emit("resize", this.getWrapperElement().style.height);
+        if (this.getStorageId() && this.persistentConfig) {
+            this.persistentConfig.editorHeight = this.getWrapperElement().style.height;
+            this.saveQuery();
+        }
+        this.refresh();
+    }
+    duplicateLine() {
+        const cur = this.getDoc().getCursor();
+        if (cur) {
+            const line = this.getDoc().getLine(cur.line);
+            this.getDoc().replaceRange(line + "\n" + line, { ch: 0, line: cur.line }, { ch: line.length, line: cur.line });
+        }
+    }
+    updateQueryButton(status) {
+        if (!this.queryBtn)
+            return;
+        if (this.config.queryingDisabled) {
+            addClass(this.queryBtn, "query_disabled");
+            this.queryBtn.title = this.config.queryingDisabled;
+        }
+        else {
+            removeClass(this.queryBtn, "query_disabled");
+            this.queryBtn.title = "Run query";
+            this.queryBtn.setAttribute("aria-label", "Run query");
+        }
+        if (!status) {
+            status = this.queryValid ? "valid" : "error";
+        }
+        if (status != this.queryStatus) {
+            removeClass(this.queryBtn, "query_" + this.queryStatus);
+            addClass(this.queryBtn, "query_" + status);
+            this.queryStatus = status;
+        }
+        if (this.req && this.queryBtn.className.indexOf("busy") < 0) {
+            this.queryBtn.className = this.queryBtn.className += " busy";
+        }
+        if (!this.req && this.queryBtn.className.indexOf("busy") >= 0) {
+            this.queryBtn.className = this.queryBtn.className.replace("busy", "");
+        }
+    }
+    handleLocalStorageQuotaFull(_e) {
+        console.warn("Localstorage quota exceeded. Clearing all queries");
+        Yasqe.clearStorage();
+    }
+    saveQuery() {
+        const storageId = this.getStorageId();
+        if (!storageId || !this.persistentConfig)
+            return;
+        this.persistentConfig.query = this.getValue();
+        this.storage.set(storageId, this.persistentConfig, this.config.persistencyExpire, this.handleLocalStorageQuotaFull);
+    }
+    getQueryType() {
+        return this.getOption("queryType");
+    }
+    getQueryMode() {
+        switch (this.getQueryType()) {
+            case "INSERT":
+            case "DELETE":
+            case "LOAD":
+            case "CLEAR":
+            case "CREATE":
+            case "DROP":
+            case "COPY":
+            case "MOVE":
+            case "ADD":
+                return "update";
+            default:
+                return "query";
+        }
+    }
+    getVariablesFromQuery() {
+        const token = this.getTokenAt({ line: this.getDoc().lastLine(), ch: this.getDoc().getLine(this.getDoc().lastLine()).length }, true);
+        const vars = [];
+        for (var v in token.state.variables) {
+            vars.push(v);
+        }
+        return vars.sort();
+    }
+    autoformatSelection(start, end) {
+        var text = this.getValue();
+        text = text.substring(start, end);
+        return Yasqe.autoformatString(text);
+    }
+    static autoformatString(text) {
+        var breakAfterArray = [
+            ["keyword", "ws", "string-2", "ws", "variable-3"],
+            ["keyword", "ws", "variable-3"],
+        ];
+        var breakBeforeCharacters = ["}"];
+        var getBreakType = function (stringVal) {
+            if (stringVal === "{")
+                return 1;
+            if (stringVal === ".")
+                return 1;
+            if (stringVal === ";") {
+                if (stackTrace.length > 2 && stackTrace[stackTrace.length - 2] === "punc")
+                    return 0;
+                return 1;
+            }
+            for (var i = 0; i < breakAfterArray.length; i++) {
+                if (stackTrace.valueOf().toString() === breakAfterArray[i].valueOf().toString()) {
+                    return 1;
+                }
+            }
+            for (var i = 0; i < breakBeforeCharacters.length; i++) {
+                if (currentLine.trim() !== "" && stringVal == breakBeforeCharacters[i]) {
+                    return -1;
+                }
+            }
+            return 0;
+        };
+        var formattedQuery = "";
+        var currentLine = "";
+        var stackTrace = [];
+        Yasqe.runMode(text, "sparql11", function (stringVal, type) {
+            stackTrace.push(type);
+            var breakType = getBreakType(stringVal);
+            if (breakType != 0) {
+                if (breakType == 1) {
+                    formattedQuery += stringVal + "\n";
+                    currentLine = "";
+                }
+                else {
+                    formattedQuery += "\n" + stringVal;
+                    currentLine = stringVal;
+                }
+                stackTrace = [];
+            }
+            else {
+                currentLine += stringVal;
+                formattedQuery += stringVal;
+            }
+            if (stackTrace.length == 1 && stackTrace[0] == "sp-ws")
+                stackTrace = [];
+        });
+        return formattedQuery.replace(/\n\s*\n/g, "\n").trim();
+    }
+    commentLines() {
+        var startLine = this.getDoc().getCursor("start").line;
+        var endLine = this.getDoc().getCursor("end").line;
+        var min = Math.min(startLine, endLine);
+        var max = Math.max(startLine, endLine);
+        var linesAreCommented = true;
+        for (var i = min; i <= max; i++) {
+            var line = this.getDoc().getLine(i);
+            if (line.length == 0 || line.substring(0, 1) != "#") {
+                linesAreCommented = false;
+                break;
+            }
+        }
+        for (var i = min; i <= max; i++) {
+            if (linesAreCommented) {
+                this.getDoc().replaceRange("", {
+                    line: i,
+                    ch: 0,
+                }, {
+                    line: i,
+                    ch: 1,
+                });
+            }
+            else {
+                this.getDoc().replaceRange("#", {
+                    line: i,
+                    ch: 0,
+                });
+            }
+        }
+    }
+    autoformat() {
+        if (!this.getDoc().somethingSelected())
+            this.execCommand("selectAll");
+        const from = this.getDoc().getCursor("start");
+        var to = {
+            line: this.getDoc().getCursor("end").line,
+            ch: this.getDoc().getSelection().length,
+        };
+        var absStart = this.getDoc().indexFromPos(from);
+        var absEnd = this.getDoc().indexFromPos(to);
+        const res = this.autoformatSelection(absStart, absEnd);
+        this.operation(() => {
+            this.getDoc().replaceRange(res, from, to);
+            var startLine = this.getDoc().posFromIndex(absStart).line;
+            var endLine = this.getDoc().posFromIndex(absStart + res.length).line;
+            for (var i = startLine; i <= endLine; i++) {
+                this.indentLine(i, "smart");
+            }
+        });
+    }
+    getQueryWithValues(values) {
+        if (!values)
+            return this.getValue();
+        var injectString;
+        if (typeof values === "string") {
+            injectString = values;
+        }
+        else {
+            if (!(values instanceof Array))
+                values = [values];
+            var variables = values.reduce(function (vars, valueObj) {
+                for (var v in valueObj) {
+                    vars[v] = v;
+                }
+                return vars;
+            }, {});
+            var varArray = [];
+            for (var v in variables) {
+                varArray.push(v);
+            }
+            if (!varArray.length)
+                return this.getValue();
+            injectString = "VALUES (" + varArray.join(" ") + ") {\n";
+            values.forEach(function (valueObj) {
+                injectString += "( ";
+                varArray.forEach(function (variable) {
+                    injectString += valueObj[variable] || "UNDEF";
+                });
+                injectString += " )\n";
+            });
+            injectString += "}\n";
+        }
+        if (!injectString)
+            return this.getValue();
+        var newQuery = "";
+        var injected = false;
+        var gotSelect = false;
+        Yasqe.runMode(this.getValue(), "sparql11", function (stringVal, className, _row, _col, _state) {
+            if (className === "keyword" && stringVal.toLowerCase() === "select")
+                gotSelect = true;
+            newQuery += stringVal;
+            if (gotSelect && !injected && className === "punc" && stringVal === "{") {
+                injected = true;
+                newQuery += "\n" + injectString;
+            }
+        });
+        return newQuery;
+    }
+    getValueWithoutComments() {
+        var cleanedQuery = "";
+        Yasqe.runMode(this.getValue(), "sparql11", function (stringVal, className) {
+            if (className != "comment") {
+                cleanedQuery += stringVal;
+            }
+        });
+        return cleanedQuery;
+    }
+    setCheckSyntaxErrors(isEnabled) {
+        this.config.syntaxErrorCheck = isEnabled;
+        this.checkSyntax();
+    }
+    checkSyntax() {
+        this.queryValid = true;
+        this.clearGutter("gutterErrorBar");
+        var state;
+        for (var l = 0; l < this.getDoc().lineCount(); ++l) {
+            var precise = false;
+            if (!this.prevQueryValid) {
+                precise = true;
+            }
+            var token = this.getTokenAt({
+                line: l,
+                ch: this.getDoc().getLine(l).length,
+            }, precise);
+            var state = token.state;
+            this.setOption("queryType", state.queryType);
+            if (state.OK == false) {
+                if (!this.config.syntaxErrorCheck) {
+                    const els = this.getWrapperElement().querySelectorAll(".sp-error");
+                    for (let i = 0; i < els.length; i++) {
+                        var el = els[i];
+                        if (el.style)
+                            el.style.color = "black";
+                    }
+                    return;
+                }
+                const warningEl = drawSvgStringAsElement(imgs.warning);
+                if (state.errorMsg) {
+                    tooltip(this, warningEl, escape(token.state.errorMsg));
+                }
+                else if (state.possibleCurrent && state.possibleCurrent.length > 0) {
+                    var expectedEncoded = [];
+                    state.possibleCurrent.forEach(function (expected) {
+                        expectedEncoded.push("<strong style='text-decoration:underline'>" + escape(expected) + "</strong>");
+                    });
+                    tooltip(this, warningEl, "This line is invalid. Expected: " + expectedEncoded.join(", "));
+                }
+                warningEl.className = "parseErrorIcon";
+                this.setGutterMarker(l, "gutterErrorBar", warningEl);
+                this.queryValid = false;
+                break;
+            }
+        }
+    }
+    getCompleteToken(token, cur) {
+        return getCompleteToken(this, token, cur);
+    }
+    getPreviousNonWsToken(line, token) {
+        return getPreviousNonWsToken(this, line, token);
+    }
+    getNextNonWsToken(lineNumber, charNumber) {
+        return getNextNonWsToken(this, lineNumber, charNumber);
+    }
+    showNotification(key, message) {
+        if (!this.notificationEls[key]) {
+            const notificationContainer = document.createElement("div");
+            addClass(notificationContainer, "notificationContainer");
+            this.getWrapperElement().appendChild(notificationContainer);
+            this.notificationEls[key] = document.createElement("div");
+            addClass(this.notificationEls[key], "notification", "notif_" + key);
+            notificationContainer.appendChild(this.notificationEls[key]);
+        }
+        for (const notificationId in this.notificationEls) {
+            if (notificationId !== key)
+                this.hideNotification(notificationId);
+        }
+        const el = this.notificationEls[key];
+        addClass(el, "active");
+        el.innerText = message;
+    }
+    hideNotification(key) {
+        if (this.notificationEls[key]) {
+            removeClass(this.notificationEls[key], "active");
+        }
+    }
+    enableCompleter(name) {
+        if (!Yasqe.Autocompleters[name])
+            return Promise.reject(new Error("Autocompleter " + name + " is not a registered autocompleter"));
+        if (this.config.autocompleters.indexOf(name) < 0)
+            this.config.autocompleters.push(name);
+        const autocompleter = (this.autocompleters[name] = new Autocompleter.Completer(this, Yasqe.Autocompleters[name]));
+        return autocompleter.initialize();
+    }
+    disableCompleter(name) {
+        this.config.autocompleters = this.config.autocompleters.filter((a) => a !== name);
+        this.autocompleters[name] = undefined;
+    }
+    autocomplete(fromAutoShow = false) {
+        if (this.getDoc().somethingSelected())
+            return;
+        for (let i in this.config.autocompleters) {
+            const autocompleter = this.autocompleters[this.config.autocompleters[i]];
+            if (!autocompleter || !autocompleter.autocomplete(fromAutoShow))
+                continue;
+        }
+    }
+    collapsePrefixes(collapse = true) {
+        const firstPrefixLine = findFirstPrefixLine(this);
+        if (firstPrefixLine === undefined)
+            return;
+        this.foldCode(firstPrefixLine, CodeMirror.fold.prefix, collapse ? "fold" : "unfold");
+    }
+    getPrefixesFromQuery() {
+        return getPrefixesFromQuery(this);
+    }
+    addPrefixes(prefixes) {
+        return addPrefixes(this, prefixes);
+    }
+    removePrefixes(prefixes) {
+        return removePrefixes(this, prefixes);
+    }
+    updateWidget() {
+        if (this.cursorCoords &&
+            this.state.completionActive &&
+            this.state.completionActive.widget) {
+            const newTop = this.cursorCoords(null).bottom;
+            this.state.completionActive.widget.hints.style.top = newTop + "px";
+        }
+    }
+    query(config) {
+        if (this.config.queryingDisabled)
+            return Promise.reject("Querying is disabled.");
+        this.abortQuery();
+        return Sparql.executeQuery(this, config);
+    }
+    getUrlParams() {
+        let urlParams = {};
+        if (window.location.hash.length > 1) {
+            urlParams = queryString.parse(location.hash);
+        }
+        if ((!urlParams || !("query" in urlParams)) && window.location.search.length > 1) {
+            urlParams = queryString.parse(window.location.search);
+        }
+        return urlParams;
+    }
+    configToQueryParams() {
+        var urlParams = {};
+        if (window.location.hash.length > 1)
+            urlParams = queryString.parse(window.location.hash);
+        urlParams["query"] = this.getValue();
+        return urlParams;
+    }
+    queryParamsToConfig(params) {
+        if (params && params.query && typeof params.query === "string") {
+            this.setValue(params.query);
+        }
+    }
+    getAsCurlString(config) {
+        return Sparql.getAsCurlString(this, config);
+    }
+    abortQuery() {
+        if (this.req) {
+            if (this.abortController) {
+                this.abortController.abort();
+            }
+            this.emit("queryAbort", this, this.req);
+        }
+    }
+    expandEditor() {
+        this.setSize(null, "100%");
+    }
+    destroy() {
+        var _a, _b;
+        this.abortQuery();
+        this.unregisterEventListeners();
+        (_a = this.resizeWrapper) === null || _a === void 0 ? void 0 : _a.removeEventListener("mousedown", this.initDrag, false);
+        (_b = this.resizeWrapper) === null || _b === void 0 ? void 0 : _b.removeEventListener("dblclick", this.expandEditor);
+        for (const autocompleter in this.autocompleters) {
+            this.disableCompleter(autocompleter);
+        }
+        window.removeEventListener("hashchange", this.handleHashChange);
+        this.rootEl.remove();
+    }
+    static clearStorage() {
+        const storage = new YStorage(Yasqe.storageNamespace);
+        storage.removeNamespace();
+    }
+    static registerAutocompleter(value, enable = true) {
+        const name = value.name;
+        Yasqe.Autocompleters[name] = value;
+        if (enable && Yasqe.defaults.autocompleters.indexOf(name) < 0)
+            Yasqe.defaults.autocompleters.push(name);
+    }
+    static forkAutocompleter(fromCompleter, newCompleter, enable = true) {
+        if (!Yasqe.Autocompleters[fromCompleter])
+            throw new Error("Autocompleter " + fromCompleter + " does not exist");
+        if (!(newCompleter === null || newCompleter === void 0 ? void 0 : newCompleter.name)) {
+            throw new Error("Expected a name for newly registered autocompleter");
+        }
+        const name = newCompleter.name;
+        Yasqe.Autocompleters[name] = Object.assign(Object.assign({}, Yasqe.Autocompleters[fromCompleter]), newCompleter);
+        if (enable && Yasqe.defaults.autocompleters.indexOf(name) < 0)
+            Yasqe.defaults.autocompleters.push(name);
+    }
+}
+Yasqe.storageNamespace = "triply";
+Yasqe.Sparql = Sparql;
+Yasqe.runMode = CodeMirror.runMode;
+Yasqe.Autocompleters = {};
+Yasqe.defaults = getDefaults();
+Object.assign(CodeMirror.prototype, Yasqe.prototype);
+Autocompleter.completers.forEach((c) => {
+    Yasqe.registerAutocompleter(c);
+});
+export default Yasqe;
+//# sourceMappingURL=index.js.map