@logilab/sparqlexplorer 0.7.0

package/src/lib/utils/utils.ts

@@ -0,0 +1,131 @@
+import {
+    SPARQL_VIEWS,
+    type SparqlViewConfig,
+} from "@logilab/sparqlexplorer-views";
+import type { SparqlAuth } from "@logilab/sparqlutils";
+import prefix from "./prefixInverted.json";
+
+export interface RDFNode {
+    type: "uri" | "bnode" | "literal";
+    value: string;
+}
+
+export function stringIncludes(a: string, b: string) {
+    return a.toLowerCase().includes(b.toLowerCase());
+}
+
+export function computeRedirect(uri: string, params: string) {
+    return `/#/browse/${encodeURIComponent(uri)}?${params}`;
+}
+
+export function prefixedNameFromUri(uri: string) {
+    const prefixCandidates = Object.entries(prefix).filter(([baseUri]) =>
+        uri.startsWith(baseUri),
+    );
+    if (prefixCandidates.length > 0) {
+        // take the baseUri with the highest length
+        const [bestBaseUri, bestPrefix] = prefixCandidates.sort(
+            ([baseUri1], [baseUri2]) => baseUri2.length - baseUri1.length,
+        )[0];
+        return uri.replace(bestBaseUri, `${bestPrefix}:`);
+    }
+    return uri;
+}
+
+const SAVED_ENDPOINT_KEY = "sparqlexplorer.endpoints";
+
+function stringToStringArray(rawValue: string | null): Array<string> {
+    if (rawValue !== null) {
+        try {
+            const arrayValue = JSON.parse(rawValue);
+            if (
+                Array.isArray(arrayValue) &&
+                arrayValue.every((v) => typeof v === "string")
+            ) {
+                return arrayValue;
+            }
+            return [];
+        } catch {
+            return [];
+        }
+    }
+    return [];
+}
+
+export function getSavedEndpoints(): Array<string> {
+    const rawValue = localStorage.getItem(SAVED_ENDPOINT_KEY);
+    return stringToStringArray(rawValue);
+}
+
+export function addToSavedEndpoints(value: string) {
+    const current = new Set(getSavedEndpoints());
+    current.add(value);
+    const stringValue = JSON.stringify(Array.from(current));
+    localStorage.setItem(SAVED_ENDPOINT_KEY, stringValue);
+}
+
+export function getApplicableViews(
+    uri: string,
+    endpoint: string,
+    auth?: SparqlAuth,
+): Promise<Array<SparqlViewConfig>> {
+    return Promise.all(
+        SPARQL_VIEWS.map((view) => {
+            console.log(view.name);
+            return view.isApplicable(uri, endpoint, auth);
+        }),
+    ).then((viewsApplicablities) => {
+        return SPARQL_VIEWS.filter((_view, idx) => viewsApplicablities[idx]);
+    });
+}
+
+export const DEFAUT_VIEW_NAME = "Default view";
+
+export function isDefaultView(viewName: string | null) {
+    return viewName === DEFAUT_VIEW_NAME;
+}
+
+export function getLabelSparqlClause(
+    uri?: string,
+    onlyRdfsLabel: boolean = false,
+) {
+    const predicates = onlyRdfsLabel
+        ? ["<http://www.w3.org/2000/01/rdf-schema#label>"]
+        : [
+              "<http://www.w3.org/2000/01/rdf-schema#label>",
+              "<http://xmlns.com/foaf/0.1/name>",
+              "<http://purl.org/dc/terms/identifier>",
+              "<http://www.w3.org/2004/02/skos/core#prefLabel>",
+              "<http://www.w3.org/2008/05/skos-xl#prefLabel>/<http://www.w3.org/2008/05/skos-xl#literalForm>",
+              "<http://purl.org/dc/elements/1.1/title>",
+              "<http://purl.org/dc/terms/title>",
+          ];
+    const predicateString = predicates.join("|");
+    const uriSelector = uri ? `<${uri}>` : "?uri";
+    return `OPTIONAL{
+        {
+            ${uriSelector} ${predicateString} ?label
+        }
+    }`;
+}
+
+export interface Label {
+    value: string;
+    lang: string | null;
+}
+
+export interface UriAndLabels {
+    uri: string;
+    labels: Label[];
+}
+
+export function getBestLabel(instance: UriAndLabels) {
+    const filteredLabels = instance.labels
+        .filter((label) => label.lang?.includes("fr"))
+        .map((label) => label.value);
+    const allLabels = instance.labels.map((label) => label.value);
+
+    return (
+        filteredLabels[0] ?? allLabels[0] ?? prefixedNameFromUri(instance.uri)
+    );
+}

package/src/lib/yasgui-utils/Storage.ts

@@ -0,0 +1,117 @@
+// FIXME this seems shady
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const store = require("store");
+
+export interface ItemWrapper<V = Record<string, unknown>> {
+    exp: number;
+    val: V;
+    namespace: string;
+    time: number;
+}
+
+interface QuotaExceededError extends Error {
+    quotaExceeded?: boolean;
+}
+export default class Storage {
+    private namespace: string;
+    constructor(namespace: string) {
+        this.namespace = namespace;
+    }
+    public set<V = Record<string, unknown>>(
+        key: string | undefined,
+        // biome-ignore lint/suspicious/noExplicitAny: any is ok
+        val: any,
+        expInSeconds: number,
+        // biome-ignore lint/suspicious/noExplicitAny: any is ok
+        onQuotaExceeded: (e: any) => void,
+    ) {
+        if (!store.enabled) return; //this is probably in private mode. Don't run, as we might get Js errors
+        this.removeExpiredKeys();
+        if (key && val !== undefined) {
+            //try to store string for dom objects (e.g. XML result). Otherwise, we might get a circular reference error when stringifying this
+            if (val.documentElement)
+                val = new XMLSerializer().serializeToString(
+                    val.documentElement,
+                );
+            try {
+                store.set(key, {
+                    namespace: this.namespace,
+                    val: val,
+                    exp: expInSeconds,
+                    time: Date.now() / 1000,
+                } as ItemWrapper<V>);
+            } catch (e) {
+                if (e instanceof Error) {
+                    const quotaExceededError = e as QuotaExceededError;
+                    quotaExceededError.quotaExceeded = isQuotaExceeded(e);
+                    if (quotaExceededError.quotaExceeded && onQuotaExceeded) {
+                        onQuotaExceeded(e);
+                    } else {
+                        throw quotaExceededError;
+                    }
+                }
+                throw e;
+            }
+        }
+    }
+    remove(key: string) {
+        if (!store.enabled) return; //this is probably in private mode. Don't run, as we might get Js errors
+        if (key) store.remove(key);
+    }
+    removeExpiredKeys() {
+        if (!store.enabled) return;
+        store.each((value: ItemWrapper, key: string) => {
+            if (value?.exp && Date.now() / 1000 - value.time > value.exp) {
+                this.remove(key);
+            }
+        });
+    }
+    removeAll() {
+        if (!store.enabled) return; //this is probably in private mode. Don't run, as we might get Js errors
+    }
+    removeNamespace() {
+        // biome-ignore lint/suspicious/noExplicitAny: any is ok
+        store.each((value: ItemWrapper<any>, key: string) => {
+            if (value.namespace && value.namespace === this.namespace)
+                this.remove(key);
+        });
+    }
+    get<V>(key?: string): V | undefined {
+        if (!store.enabled) return; //this is probably in private mode. Don't run, as we might get Js errors
+        if (!key) return;
+        this.removeExpiredKeys();
+        if (key) {
+            const info: ItemWrapper<V> = store.get(key);
+            if (!info) {
+                return;
+            }
+            return info.val;
+        } else {
+            return;
+        }
+    }
+}
+
+// biome-ignore lint/suspicious/noExplicitAny: any is ok
+function isQuotaExceeded(e: any) {
+    let quotaExceeded = false;
+    if (e) {
+        if (e.code) {
+            switch (e.code) {
+                case 22:
+                    quotaExceeded = true;
+                    break;
+                case 1014:
+                    // Firefox
+                    if (e.name === "NS_ERROR_DOM_QUOTA_REACHED") {
+                        quotaExceeded = true;
+                    }
+                    break;
+            }
+        } else if (e.number === -2147024882) {
+            // Internet Explorer 8
+            quotaExceeded = true;
+        }
+    }
+    return quotaExceeded;
+}

package/src/lib/yasgui-utils/index.ts

@@ -0,0 +1,66 @@
+export function drawSvgStringAsElement(svgString: string) {
+    if (svgString && svgString.trim().indexOf("<svg") === 0) {
+        //no style passed via config. guess own styles
+        const parser = new DOMParser();
+        const dom = parser.parseFromString(svgString, "text/xml");
+        const svg = dom.documentElement;
+        svg.setAttribute("aria-hidden", "true");
+
+        const svgContainer = document.createElement("div");
+        svgContainer.className = "svgImg";
+        svgContainer.appendChild(svg);
+        return svgContainer;
+    }
+    throw new Error("No svg string given. Cannot draw");
+}
+export interface FaIcon {
+    width: number;
+    height: number;
+    svgPathData: string;
+}
+
+/**
+ * Draws font fontawesome icon as svg. This is a lot more lightweight then the option that is offered by fontawesome
+ * @param faIcon
+ * @returns
+ */
+export function drawFontAwesomeIconAsSvg(faIcon: FaIcon) {
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${faIcon.width} ${faIcon.height}" aria-hidden="true"><path fill="currentColor" d="${faIcon.svgPathData}"></path></svg>`;
+}
+
+export function hasClass(el: Element | undefined, className: string) {
+    if (!el) return;
+    if (el.classList) return el.classList.contains(className);
+    else
+        return !!el.className.match(
+            new RegExp("(\\s|^)" + className + "(\\s|$)"),
+        );
+}
+
+export function addClass(
+    el: Element | undefined | null,
+    ...classNames: string[]
+) {
+    if (!el) return;
+    for (const className of classNames) {
+        if (el.classList) el.classList.add(className);
+        else if (!hasClass(el, className)) el.className += " " + className;
+    }
+}
+
+export function removeClass(el: Element | undefined | null, className: string) {
+    if (!el) return;
+    if (el.classList) el.classList.remove(className);
+    else if (hasClass(el, className)) {
+        const reg = new RegExp("(\\s|^)" + className + "(\\s|$)");
+        el.className = el.className.replace(reg, " ");
+    }
+}
+
+export function getAsValue<E, A>(valueOrFn: E | ((arg: A) => E), arg: A): E {
+    if (typeof valueOrFn === "function") {
+        // biome-ignore lint/suspicious/noExplicitAny: any is ok
+        return (valueOrFn as any)(arg);
+    }
+    return valueOrFn;
+}