@oxilite/common 0.1.0

package/README.md

@@ -0,0 +1,5 @@
+# @oxilite/common
+
+RDF/JS terms (`DataFactory`, `NamedNode`, `Literal`, `Quad`…), JSON conversions and result types shared by [`@oxilite/node`](https://www.npmjs.com/package/@oxilite/node) and [`@oxilite/d1`](https://www.npmjs.com/package/@oxilite/d1). You normally get it through one of those packages.
+
+See the [oxilite repository](https://github.com/Volland/oxilite) for documentation.

package/dist/index.d.ts

@@ -0,0 +1,150 @@
+/** Any RDF/JS term (from any library: @rdfjs/data-model, N3.js, oxigraph, …). */
+export interface TermLike {
+    termType: string;
+    value: string;
+    language?: string;
+    direction?: string;
+    datatype?: TermLike;
+    subject?: TermLike;
+    predicate?: TermLike;
+    object?: TermLike;
+    graph?: TermLike;
+}
+declare abstract class BaseTerm {
+    abstract readonly termType: string;
+    abstract readonly value: string;
+    equals(other: TermLike | null | undefined): boolean;
+}
+export declare class NamedNode extends BaseTerm {
+    readonly value: string;
+    readonly termType: "NamedNode";
+    constructor(value: string);
+    toString(): string;
+}
+export declare class BlankNode extends BaseTerm {
+    readonly value: string;
+    readonly termType: "BlankNode";
+    constructor(value: string);
+    toString(): string;
+}
+export declare class Literal extends BaseTerm {
+    readonly value: string;
+    readonly language: string;
+    readonly direction: "" | "ltr" | "rtl";
+    readonly termType: "Literal";
+    readonly datatype: NamedNode;
+    constructor(value: string, language?: string, datatype?: NamedNode, direction?: "" | "ltr" | "rtl");
+    toString(): string;
+}
+export declare class DefaultGraph extends BaseTerm {
+    readonly termType: "DefaultGraph";
+    readonly value: "";
+    toString(): string;
+}
+export declare class Variable extends BaseTerm {
+    readonly value: string;
+    readonly termType: "Variable";
+    constructor(value: string);
+    toString(): string;
+}
+export type Subject = NamedNode | BlankNode | Quad | Variable;
+export type Object_ = NamedNode | BlankNode | Literal | Quad | Variable;
+export type Graph = NamedNode | BlankNode | DefaultGraph | Variable;
+export type Term = NamedNode | BlankNode | Literal | DefaultGraph | Variable | Quad;
+export declare class Quad extends BaseTerm {
+    readonly subject: Subject;
+    readonly predicate: NamedNode | Variable;
+    readonly object: Object_;
+    readonly graph: Graph;
+    readonly termType: "Quad";
+    readonly value: "";
+    constructor(subject: Subject, predicate: NamedNode | Variable, object: Object_, graph?: Graph);
+    toString(): string;
+}
+/** RDF/JS DataFactory. */
+export declare const DataFactory: {
+    namedNode: (value: string) => NamedNode;
+    blankNode: (value?: string) => BlankNode;
+    literal: (value: string, languageOrDatatype?: string | TermLike) => Literal;
+    defaultGraph: () => DefaultGraph;
+    variable: (value: string) => Variable;
+    quad: (subject: Subject, predicate: NamedNode | Variable, object: Object_, graph?: Graph) => Quad;
+    triple: (subject: Subject, predicate: NamedNode | Variable, object: Object_) => Quad;
+    fromTerm: (t: TermLike) => Term;
+    fromQuad: (q: TermLike) => Quad;
+};
+export declare const namedNode: (value: string) => NamedNode;
+export declare const blankNode: (value?: string) => BlankNode;
+export declare const literal: (value: string, languageOrDatatype?: string | TermLike) => Literal;
+export declare const defaultGraph: () => DefaultGraph;
+export declare const variable: (value: string) => Variable;
+export declare const quad: (subject: Subject, predicate: NamedNode | Variable, object: Object_, graph?: Graph) => Quad;
+export declare const triple: (subject: Subject, predicate: NamedNode | Variable, object: Object_) => Quad;
+/** JSON term as produced by the oxilite core. */
+export type TermJson = {
+    termType: string;
+    value: string;
+    language?: string;
+    direction?: string;
+    datatype?: TermJson;
+    subject?: TermJson;
+    predicate?: TermJson;
+    object?: TermJson;
+    graph?: TermJson;
+};
+/** Converts any RDF/JS term to the core's JSON form. */
+export declare function toJson(t: TermLike): TermJson;
+/** Builds a term from the core's JSON form. */
+export declare function fromJson(j: TermJson): Term;
+/** Output of the core (see `oxilite_core::json::output_to_json`). */
+export type Output = {
+    kind: "solutions";
+    variables: string[];
+    rows: (TermJson | null)[][];
+} | {
+    kind: "boolean";
+    value: boolean;
+} | {
+    kind: "quads";
+    quads: TermJson[];
+} | {
+    kind: "number";
+    value: number;
+} | {
+    kind: "text";
+    value: string;
+} | {
+    kind: "ok";
+};
+/** SELECT solutions (like Oxigraph's JS API: one Map per solution), ASK boolean, or quads. */
+export type QueryResult = Map<string, Term>[] | boolean | Quad[] | string;
+export declare function outputToResult(out: Output): QueryResult;
+/** Query options accepted by both packages (Oxigraph's JS option names). */
+export interface QueryOptions {
+    base_iri?: string;
+    use_default_graph_as_union?: boolean;
+    default_graph?: TermLike | TermLike[];
+    named_graphs?: TermLike[];
+    results_format?: string;
+    /** Query-time entailment (oxilite extension): `"none"` (default), `"rdfs"` or `"owl-ql"`. */
+    reasoning?: "none" | "rdfs" | "owl-ql";
+    /** Also match inferences stored by `materialize()` (oxilite extension). */
+    include_inferred?: boolean;
+}
+/** Load options (Oxigraph's JS option names). */
+export interface LoadOptions {
+    format: string;
+    base_iri?: string;
+    to_graph_name?: TermLike;
+    unchecked?: boolean;
+    no_transaction?: boolean;
+}
+/** Dump options (Oxigraph's JS option names). */
+export interface DumpOptions {
+    format: string;
+    from_graph_name?: TermLike;
+}
+/** Content of `load()`: a string, bytes, or a list of them (like Oxigraph's JS API). */
+export type LoadData = string | Uint8Array | (string | Uint8Array)[];
+export declare function loadDataToString(data: LoadData): string;
+export {};

package/dist/index.js

@@ -0,0 +1,211 @@
+// RDF/JS-compatible terms and conversions shared by @oxilite/node and @oxilite/d1.
+//
+// The JSON forms exchanged with the oxilite core are defined in
+// crates/oxilite-core/src/json.rs.
+class BaseTerm {
+    equals(other) {
+        return other != null && termEquals(this, other);
+    }
+}
+export class NamedNode extends BaseTerm {
+    value;
+    termType = "NamedNode";
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    toString() {
+        return `<${this.value}>`;
+    }
+}
+export class BlankNode extends BaseTerm {
+    value;
+    termType = "BlankNode";
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    toString() {
+        return `_:${this.value}`;
+    }
+}
+const XSD_STRING = "http://www.w3.org/2001/XMLSchema#string";
+const RDF_LANG_STRING = "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString";
+const RDF_DIR_LANG_STRING = "http://www.w3.org/1999/02/22-rdf-syntax-ns#dirLangString";
+function escape(s) {
+    return s.replace(/[\\"\n\r]/g, (c) => ({ "\\": "\\\\", '"': '\\"', "\n": "\\n", "\r": "\\r" })[c]);
+}
+export class Literal extends BaseTerm {
+    value;
+    language;
+    direction;
+    termType = "Literal";
+    datatype;
+    constructor(value, language = "", datatype, direction = "") {
+        super();
+        this.value = value;
+        this.language = language;
+        this.direction = direction;
+        this.datatype =
+            datatype ?? new NamedNode(language ? (direction ? RDF_DIR_LANG_STRING : RDF_LANG_STRING) : XSD_STRING);
+    }
+    toString() {
+        const v = `"${escape(this.value)}"`;
+        if (this.language)
+            return `${v}@${this.language}${this.direction ? `--${this.direction}` : ""}`;
+        if (this.datatype.value === XSD_STRING)
+            return v;
+        return `${v}^^${this.datatype.toString()}`;
+    }
+}
+export class DefaultGraph extends BaseTerm {
+    termType = "DefaultGraph";
+    value = "";
+    toString() {
+        return "DEFAULT";
+    }
+}
+export class Variable extends BaseTerm {
+    value;
+    termType = "Variable";
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    toString() {
+        return `?${this.value}`;
+    }
+}
+export class Quad extends BaseTerm {
+    subject;
+    predicate;
+    object;
+    graph;
+    termType = "Quad";
+    value = "";
+    constructor(subject, predicate, object, graph = new DefaultGraph()) {
+        super();
+        this.subject = subject;
+        this.predicate = predicate;
+        this.object = object;
+        this.graph = graph;
+    }
+    toString() {
+        const inner = (t) => (t instanceof Quad ? `<<( ${t.subject} ${t.predicate} ${t.object} )>>` : t.toString());
+        const g = this.graph.termType === "DefaultGraph" ? "" : ` ${this.graph}`;
+        return `${inner(this.subject)} ${this.predicate} ${inner(this.object)}${g}`;
+    }
+}
+function termEquals(a, b) {
+    if (a.termType !== b.termType || a.value !== b.value)
+        return false;
+    if (a.termType === "Literal") {
+        return ((a.language ?? "") === (b.language ?? "") &&
+            (a.direction ?? "") === (b.direction ?? "") &&
+            (a.datatype?.value ?? XSD_STRING) === (b.datatype?.value ?? XSD_STRING));
+    }
+    if (a.termType === "Quad") {
+        const parts = ["subject", "predicate", "object", "graph"];
+        return parts.every((p) => {
+            const x = a[p];
+            const y = b[p];
+            if (!x || !y)
+                return (x?.termType ?? "DefaultGraph") === (y?.termType ?? "DefaultGraph");
+            return termEquals(x, y);
+        });
+    }
+    return true;
+}
+/** RDF/JS DataFactory. */
+export const DataFactory = {
+    namedNode: (value) => new NamedNode(value),
+    blankNode: (value) => new BlankNode(value ?? `b${Math.random().toString(36).slice(2)}`),
+    literal: (value, languageOrDatatype) => {
+        if (typeof languageOrDatatype === "string") {
+            const [lang, dir] = languageOrDatatype.split("--");
+            return new Literal(value, lang, undefined, dir ?? "");
+        }
+        if (languageOrDatatype)
+            return new Literal(value, "", new NamedNode(languageOrDatatype.value));
+        return new Literal(value);
+    },
+    defaultGraph: () => new DefaultGraph(),
+    variable: (value) => new Variable(value),
+    quad: (subject, predicate, object, graph) => new Quad(subject, predicate, object, graph ?? new DefaultGraph()),
+    triple: (subject, predicate, object) => new Quad(subject, predicate, object, new DefaultGraph()),
+    fromTerm: (t) => fromJson(toJson(t)),
+    fromQuad: (q) => fromJson(toJson(q)),
+};
+export const namedNode = DataFactory.namedNode;
+export const blankNode = DataFactory.blankNode;
+export const literal = DataFactory.literal;
+export const defaultGraph = DataFactory.defaultGraph;
+export const variable = DataFactory.variable;
+export const quad = DataFactory.quad;
+export const triple = DataFactory.triple;
+/** Converts any RDF/JS term to the core's JSON form. */
+export function toJson(t) {
+    switch (t.termType) {
+        case "Literal":
+            return {
+                termType: "Literal",
+                value: t.value,
+                language: t.language ?? "",
+                direction: t.direction ?? "",
+                datatype: { termType: "NamedNode", value: t.datatype?.value ?? XSD_STRING },
+            };
+        case "Quad":
+            return {
+                termType: "Quad",
+                value: "",
+                subject: toJson(t.subject),
+                predicate: toJson(t.predicate),
+                object: toJson(t.object),
+                graph: t.graph ? toJson(t.graph) : { termType: "DefaultGraph", value: "" },
+            };
+        default:
+            return { termType: t.termType, value: t.value };
+    }
+}
+/** Builds a term from the core's JSON form. */
+export function fromJson(j) {
+    switch (j.termType) {
+        case "NamedNode":
+            return new NamedNode(j.value);
+        case "BlankNode":
+            return new BlankNode(j.value);
+        case "Literal":
+            return new Literal(j.value, j.language ?? "", j.datatype ? new NamedNode(j.datatype.value) : undefined, j.direction ?? "");
+        case "DefaultGraph":
+            return new DefaultGraph();
+        case "Quad":
+            return new Quad(fromJson(j.subject), fromJson(j.predicate), fromJson(j.object), j.graph ? fromJson(j.graph) : new DefaultGraph());
+        default:
+            throw new Error(`Unsupported termType ${j.termType}`);
+    }
+}
+export function outputToResult(out) {
+    switch (out.kind) {
+        case "solutions":
+            return out.rows.map((row) => {
+                const m = new Map();
+                row.forEach((t, i) => {
+                    if (t)
+                        m.set(out.variables[i], fromJson(t));
+                });
+                return m;
+            });
+        case "boolean":
+            return out.value;
+        case "quads":
+            return out.quads.map((q) => fromJson(q));
+        case "text":
+            return out.value;
+        default:
+            throw new Error(`Unexpected output ${out.kind}`);
+    }
+}
+export function loadDataToString(data) {
+    const one = (d) => (typeof d === "string" ? d : new TextDecoder().decode(d));
+    return Array.isArray(data) ? data.map(one).join("\n") : one(data);
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@oxilite/common",
+  "version": "0.1.0",
+  "description": "RDF/JS terms and result conversion shared by the oxilite JavaScript packages",
+  "license": "MIT OR Apache-2.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p ."
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Volland/oxilite.git",
+    "directory": "packages/common"
+  },
+  "homepage": "https://github.com/Volland/oxilite#readme",
+  "bugs": "https://github.com/Volland/oxilite/issues",
+  "author": "Volodymyr Pavlyshyn",
+  "keywords": [
+    "rdf",
+    "sparql",
+    "sqlite",
+    "oxigraph",
+    "rdfjs"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}