ldkit 0.7.0 → 1.1.0

package/esm/library/engine/query_engine.js

@@ -1,5 +1,4 @@
-import { BindingsFactory, QuadFactory, } from "../rdf.js";
-import { ArrayIterator, MappingIterator, TreeIterator, } from "../asynciterator.js";
+import { getResponseTypes, resolve, } from "./query_resolvers.js";
 export class QueryEngine {
     getSparqlEndpoint(context) {
         if (!context) {
@@ -30,10 +29,10 @@ export class QueryEngine {
     getFetch(context) {
         return context && context.fetch ? context.fetch : fetch;
     }
-    async query(query, responseType, context) {
+    query(query, responseType, context) {
         const endpoint = this.getSparqlEndpoint(context);
         const fetchFn = this.getFetch(context);
-        const response = await fetchFn(endpoint, {
+        return fetchFn(endpoint, {
             method: "POST",
             headers: {
                 "accept": responseType,
@@ -43,35 +42,24 @@ export class QueryEngine {
                 query,
             }),
         });
-        const json = await response.json();
-        return json;
     }
-    async queryBindings(query, context) {
-        const json = await this.query(query, "application/sparql-results+json", context);
-        if (!Array.isArray(json.results?.bindings)) {
-            throw new Error("Bindings SPARQL query result not found");
+    async queryAndResolve(type, query, context) {
+        const responseType = getResponseTypes(type).join(", ");
+        const response = await this.query(query, responseType, context);
+        if (!response.ok) {
+            await response.body?.cancel();
+            throw new Error(`Invalid query response status '${response.status} ${response.statusText}'`);
         }
-        const bindingsFactory = new BindingsFactory();
-        const bindingsIterator = new ArrayIterator(json.results.bindings);
-        // TODO: review the unknown type cast
-        return new MappingIterator(bindingsIterator, (i) => bindingsFactory.fromJson(i));
+        return resolve(type, response);
     }
-    async queryBoolean(query, context) {
-        const json = await this.query(query, "application/sparql-results+json", context);
-        if ("boolean" in json) {
-            return Boolean(json.boolean);
-        }
-        throw new Error("Boolean SPARQL query result not found");
+    queryBindings(query, context) {
+        return this.queryAndResolve("bindings", query, context);
     }
-    async queryQuads(query, context) {
-        const json = await this.query(query, "application/rdf+json", context);
-        if (!(json?.constructor === Object)) {
-            throw new Error("Quads SPARQL query result not found");
-        }
-        const quadFactory = new QuadFactory();
-        const treeIterator = new TreeIterator(json);
-        // TODO: review the unknown type cast
-        return new MappingIterator(treeIterator, (i) => quadFactory.fromJson(i));
+    queryBoolean(query, context) {
+        return this.queryAndResolve("boolean", query, context);
+    }
+    queryQuads(query, context) {
+        return this.queryAndResolve("quads", query, context);
     }
     async queryVoid(query, context) {
         await this.query(query, "application/sparql-results+json", context);

package/esm/library/engine/query_resolvers.js

@@ -0,0 +1,72 @@
+import { BindingsFactory, N3, QuadFactory } from "../rdf.js";
+import { ArrayIterator, MappingIterator, TreeIterator, } from "../asynciterator.js";
+class QueryResolver {
+}
+class BooleanJsonResolver extends QueryResolver {
+    async resolve(response) {
+        const json = await response.json();
+        if ("boolean" in json) {
+            return Boolean(json.boolean);
+        }
+        throw new Error("Boolean SPARQL query result not found");
+    }
+}
+class BindingsJsonResolver extends QueryResolver {
+    async resolve(response) {
+        const json = await response.json();
+        if (!Array.isArray(json.results?.bindings)) {
+            throw new Error("Bindings SPARQL query result not found");
+        }
+        const bindingsFactory = new BindingsFactory();
+        const bindingsIterator = new ArrayIterator(json.results.bindings);
+        // TODO: review the unknown type cast
+        return new MappingIterator(bindingsIterator, (i) => bindingsFactory.fromJson(i));
+    }
+}
+class QuadsJsonResolver extends QueryResolver {
+    async resolve(response) {
+        const json = await response.json();
+        if (!(json?.constructor === Object)) {
+            throw new Error("Quads SPARQL query result not found");
+        }
+        const quadFactory = new QuadFactory();
+        const treeIterator = new TreeIterator(json);
+        // TODO: review the unknown type cast
+        return new MappingIterator(treeIterator, (i) => quadFactory.fromJson(i));
+    }
+}
+class QuadsTurtleResolver extends QueryResolver {
+    async resolve(response) {
+        const text = await response.text();
+        const quads = new N3.Parser({ format: "turtle" }).parse(text);
+        return new ArrayIterator(quads);
+    }
+}
+const resolvers = {
+    "boolean": {
+        "application/sparql-results+json": new BooleanJsonResolver(),
+    },
+    "bindings": {
+        "application/sparql-results+json": new BindingsJsonResolver(),
+    },
+    "quads": {
+        "application/rdf+json": new QuadsJsonResolver(),
+        "text/turtle": new QuadsTurtleResolver(),
+    },
+};
+export const getResponseTypes = (resolverType) => Object.keys(resolvers[resolverType]);
+export const resolve = (resolverType, response) => {
+    const contentType = response.headers.get("Content-type");
+    if (!contentType) {
+        throw new Error(`Content-type header was not found in response`);
+    }
+    const separatorPosition = contentType.indexOf(";");
+    const mime = separatorPosition > 0
+        ? contentType.substring(0, separatorPosition)
+        : contentType;
+    const resolver = resolvers[resolverType][mime];
+    if (!resolver) {
+        throw new Error(`No resolver exists for response type '${mime}'`);
+    }
+    return resolver.resolve(response);
+};

package/esm/library/rdf.js

@@ -1,6 +1,7 @@
 export { fromRdf, toRdf } from "rdf-literal";
-import { DataFactory, DefaultGraph, } from "rdf-data-factory";
+import { DataFactory, DefaultGraph } from "rdf-data-factory";
 export { DataFactory, DefaultGraph };
+export * as N3 from "n3";
 export const quadsToGraph = (quads) => {
     const graph = new Map();
     for (const quad of quads) {
@@ -29,8 +30,8 @@ export class TermFactory {
         if (jsonTerm.type === "bnode") {
             return this.dataFactory.blankNode(jsonTerm.value);
         }
-        if ("xml:lang" in jsonTerm) {
-            return this.dataFactory.literal(jsonTerm.value, jsonTerm["xml:lang"]);
+        if ("lang" in jsonTerm) {
+            return this.dataFactory.literal(jsonTerm.value, jsonTerm["lang"]);
         }
         if ("datatype" in jsonTerm) {
             return this.dataFactory.literal(jsonTerm.value, this.dataFactory.namedNode(jsonTerm.datatype));

package/esm/mod.js

@@ -1,3 +1,4 @@
 export { setDefaultContext, setDefaultEngine } from "./library/global.js";
 export { createLens, createResource } from "./library/lens/mod.js";
 export { createNamespace } from "./library/namespaces/namespace.js";
+export { QueryEngine } from "./library/engine/mod.js";

package/package.json

@@ -3,7 +3,7 @@
   "main": "./script/mod.js",
   "types": "./types/mod.d.ts",
   "name": "ldkit",
-  "version": "0.7.0",
+  "version": "1.1.0",
   "description": "LDkit, a Linked Data query toolkit for TypeScript developers",
   "homepage": "https://ldkit.io",
   "author": "Karel Klima <karelklima@gmail.com> (https://karelklima.com)",
@@ -23,31 +23,53 @@
   },
   "exports": {
     ".": {
-      "import": "./esm/mod.js",
-      "require": "./script/mod.js",
-      "types": "./types/mod.d.ts"
+      "import": {
+        "types": "./types/mod.d.ts",
+        "default": "./esm/mod.js"
+      },
+      "require": {
+        "types": "./types/mod.d.ts",
+        "default": "./script/mod.js"
+      }
     },
     "./namespaces": {
-      "import": "./esm/namespaces.js",
-      "require": "./script/namespaces.js",
-      "types": "./types/namespaces.d.ts"
+      "import": {
+        "types": "./types/namespaces.d.ts",
+        "default": "./esm/namespaces.js"
+      },
+      "require": {
+        "types": "./types/namespaces.d.ts",
+        "default": "./script/namespaces.js"
+      }
     },
     "./rdf": {
-      "import": "./esm/rdf.js",
-      "require": "./script/rdf.js",
-      "types": "./types/rdf.d.ts"
+      "import": {
+        "types": "./types/rdf.d.ts",
+        "default": "./esm/rdf.js"
+      },
+      "require": {
+        "types": "./types/rdf.d.ts",
+        "default": "./script/rdf.js"
+      }
     },
     "./sparql": {
-      "import": "./esm/sparql.js",
-      "require": "./script/sparql.js",
-      "types": "./types/sparql.d.ts"
+      "import": {
+        "types": "./types/sparql.d.ts",
+        "default": "./esm/sparql.js"
+      },
+      "require": {
+        "types": "./types/sparql.d.ts",
+        "default": "./script/sparql.js"
+      }
     }
   },
   "dependencies": {
-    "@comunica/types": "2.4.0",
-    "asynciterator": "3.7.0",
+    "@comunica/types": "2.6.8",
+    "@types/n3": "*",
+    "asynciterator": "3.8.0",
+    "n3": "1.17.2",
     "rdf-data-factory": "1.1.1",
     "rdf-js": "4.0.2",
-    "rdf-literal": "1.3.0"
+    "rdf-literal": "1.3.1"
   }
 }

package/script/library/engine/query_engine.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryEngine = void 0;
-const rdf_js_1 = require("../rdf.js");
-const asynciterator_js_1 = require("../asynciterator.js");
+const query_resolvers_js_1 = require("./query_resolvers.js");
 class QueryEngine {
     getSparqlEndpoint(context) {
         if (!context) {
@@ -33,10 +32,10 @@ class QueryEngine {
     getFetch(context) {
         return context && context.fetch ? context.fetch : fetch;
     }
-    async query(query, responseType, context) {
+    query(query, responseType, context) {
         const endpoint = this.getSparqlEndpoint(context);
         const fetchFn = this.getFetch(context);
-        const response = await fetchFn(endpoint, {
+        return fetchFn(endpoint, {
             method: "POST",
             headers: {
                 "accept": responseType,
@@ -46,35 +45,24 @@ class QueryEngine {
                 query,
             }),
         });
-        const json = await response.json();
-        return json;
     }
-    async queryBindings(query, context) {
-        const json = await this.query(query, "application/sparql-results+json", context);
-        if (!Array.isArray(json.results?.bindings)) {
-            throw new Error("Bindings SPARQL query result not found");
+    async queryAndResolve(type, query, context) {
+        const responseType = (0, query_resolvers_js_1.getResponseTypes)(type).join(", ");
+        const response = await this.query(query, responseType, context);
+        if (!response.ok) {
+            await response.body?.cancel();
+            throw new Error(`Invalid query response status '${response.status} ${response.statusText}'`);
         }
-        const bindingsFactory = new rdf_js_1.BindingsFactory();
-        const bindingsIterator = new asynciterator_js_1.ArrayIterator(json.results.bindings);
-        // TODO: review the unknown type cast
-        return new asynciterator_js_1.MappingIterator(bindingsIterator, (i) => bindingsFactory.fromJson(i));
+        return (0, query_resolvers_js_1.resolve)(type, response);
     }
-    async queryBoolean(query, context) {
-        const json = await this.query(query, "application/sparql-results+json", context);
-        if ("boolean" in json) {
-            return Boolean(json.boolean);
-        }
-        throw new Error("Boolean SPARQL query result not found");
+    queryBindings(query, context) {
+        return this.queryAndResolve("bindings", query, context);
     }
-    async queryQuads(query, context) {
-        const json = await this.query(query, "application/rdf+json", context);
-        if (!(json?.constructor === Object)) {
-            throw new Error("Quads SPARQL query result not found");
-        }
-        const quadFactory = new rdf_js_1.QuadFactory();
-        const treeIterator = new asynciterator_js_1.TreeIterator(json);
-        // TODO: review the unknown type cast
-        return new asynciterator_js_1.MappingIterator(treeIterator, (i) => quadFactory.fromJson(i));
+    queryBoolean(query, context) {
+        return this.queryAndResolve("boolean", query, context);
+    }
+    queryQuads(query, context) {
+        return this.queryAndResolve("quads", query, context);
     }
     async queryVoid(query, context) {
         await this.query(query, "application/sparql-results+json", context);

package/script/library/engine/query_resolvers.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolve = exports.getResponseTypes = void 0;
+const rdf_js_1 = require("../rdf.js");
+const asynciterator_js_1 = require("../asynciterator.js");
+class QueryResolver {
+}
+class BooleanJsonResolver extends QueryResolver {
+    async resolve(response) {
+        const json = await response.json();
+        if ("boolean" in json) {
+            return Boolean(json.boolean);
+        }
+        throw new Error("Boolean SPARQL query result not found");
+    }
+}
+class BindingsJsonResolver extends QueryResolver {
+    async resolve(response) {
+        const json = await response.json();
+        if (!Array.isArray(json.results?.bindings)) {
+            throw new Error("Bindings SPARQL query result not found");
+        }
+        const bindingsFactory = new rdf_js_1.BindingsFactory();
+        const bindingsIterator = new asynciterator_js_1.ArrayIterator(json.results.bindings);
+        // TODO: review the unknown type cast
+        return new asynciterator_js_1.MappingIterator(bindingsIterator, (i) => bindingsFactory.fromJson(i));
+    }
+}
+class QuadsJsonResolver extends QueryResolver {
+    async resolve(response) {
+        const json = await response.json();
+        if (!(json?.constructor === Object)) {
+            throw new Error("Quads SPARQL query result not found");
+        }
+        const quadFactory = new rdf_js_1.QuadFactory();
+        const treeIterator = new asynciterator_js_1.TreeIterator(json);
+        // TODO: review the unknown type cast
+        return new asynciterator_js_1.MappingIterator(treeIterator, (i) => quadFactory.fromJson(i));
+    }
+}
+class QuadsTurtleResolver extends QueryResolver {
+    async resolve(response) {
+        const text = await response.text();
+        const quads = new rdf_js_1.N3.Parser({ format: "turtle" }).parse(text);
+        return new asynciterator_js_1.ArrayIterator(quads);
+    }
+}
+const resolvers = {
+    "boolean": {
+        "application/sparql-results+json": new BooleanJsonResolver(),
+    },
+    "bindings": {
+        "application/sparql-results+json": new BindingsJsonResolver(),
+    },
+    "quads": {
+        "application/rdf+json": new QuadsJsonResolver(),
+        "text/turtle": new QuadsTurtleResolver(),
+    },
+};
+const getResponseTypes = (resolverType) => Object.keys(resolvers[resolverType]);
+exports.getResponseTypes = getResponseTypes;
+const resolve = (resolverType, response) => {
+    const contentType = response.headers.get("Content-type");
+    if (!contentType) {
+        throw new Error(`Content-type header was not found in response`);
+    }
+    const separatorPosition = contentType.indexOf(";");
+    const mime = separatorPosition > 0
+        ? contentType.substring(0, separatorPosition)
+        : contentType;
+    const resolver = resolvers[resolverType][mime];
+    if (!resolver) {
+        throw new Error(`No resolver exists for response type '${mime}'`);
+    }
+    return resolver.resolve(response);
+};
+exports.resolve = resolve;

package/script/library/rdf.js

@@ -1,12 +1,36 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QuadFactory = exports.BindingsFactory = exports.ReadOnlyBindings = exports.TermFactory = exports.quadsToGraph = exports.DefaultGraph = exports.DataFactory = exports.toRdf = exports.fromRdf = void 0;
+exports.QuadFactory = exports.BindingsFactory = exports.ReadOnlyBindings = exports.TermFactory = exports.quadsToGraph = exports.N3 = exports.DefaultGraph = exports.DataFactory = exports.toRdf = exports.fromRdf = void 0;
 var rdf_literal_1 = require("rdf-literal");
 Object.defineProperty(exports, "fromRdf", { enumerable: true, get: function () { return rdf_literal_1.fromRdf; } });
 Object.defineProperty(exports, "toRdf", { enumerable: true, get: function () { return rdf_literal_1.toRdf; } });
 const rdf_data_factory_1 = require("rdf-data-factory");
 Object.defineProperty(exports, "DataFactory", { enumerable: true, get: function () { return rdf_data_factory_1.DataFactory; } });
 Object.defineProperty(exports, "DefaultGraph", { enumerable: true, get: function () { return rdf_data_factory_1.DefaultGraph; } });
+exports.N3 = __importStar(require("n3"));
 const quadsToGraph = (quads) => {
     const graph = new Map();
     for (const quad of quads) {
@@ -36,8 +60,8 @@ class TermFactory {
         if (jsonTerm.type === "bnode") {
             return this.dataFactory.blankNode(jsonTerm.value);
         }
-        if ("xml:lang" in jsonTerm) {
-            return this.dataFactory.literal(jsonTerm.value, jsonTerm["xml:lang"]);
+        if ("lang" in jsonTerm) {
+            return this.dataFactory.literal(jsonTerm.value, jsonTerm["lang"]);
         }
         if ("datatype" in jsonTerm) {
             return this.dataFactory.literal(jsonTerm.value, this.dataFactory.namedNode(jsonTerm.datatype));

package/script/mod.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNamespace = exports.createResource = exports.createLens = exports.setDefaultEngine = exports.setDefaultContext = void 0;
+exports.QueryEngine = exports.createNamespace = exports.createResource = exports.createLens = exports.setDefaultEngine = exports.setDefaultContext = void 0;
 var global_js_1 = require("./library/global.js");
 Object.defineProperty(exports, "setDefaultContext", { enumerable: true, get: function () { return global_js_1.setDefaultContext; } });
 Object.defineProperty(exports, "setDefaultEngine", { enumerable: true, get: function () { return global_js_1.setDefaultEngine; } });
@@ -9,3 +9,5 @@ Object.defineProperty(exports, "createLens", { enumerable: true, get: function (
 Object.defineProperty(exports, "createResource", { enumerable: true, get: function () { return mod_js_1.createResource; } });
 var namespace_js_1 = require("./library/namespaces/namespace.js");
 Object.defineProperty(exports, "createNamespace", { enumerable: true, get: function () { return namespace_js_1.createNamespace; } });
+var mod_js_2 = require("./library/engine/mod.js");
+Object.defineProperty(exports, "QueryEngine", { enumerable: true, get: function () { return mod_js_2.QueryEngine; } });

package/types/library/asynciterator.d.ts

@@ -1,10 +1,10 @@
 import { AsyncIterator } from "asynciterator";
 export { ArrayIterator, type AsyncIterator, MappingIterator, } from "asynciterator";
-declare type TreeNode<T> = {
+type TreeNode<T> = {
     [property: string]: T[] | TreeNode<T>;
 };
-export declare type Tree<T> = T[] | TreeNode<T>;
-declare type Subtree<T> = {
+export type Tree<T> = T[] | TreeNode<T>;
+type Subtree<T> = {
     type: "node";
     tree: TreeNode<T>;
     parent?: Subtree<T>;

package/types/library/decoder.d.ts

@@ -1,5 +1,5 @@
 import { type Context, Graph } from "./rdf.js";
 import type { Schema } from "./schema/mod.js";
-declare type DecodedNode = Record<string, unknown>;
+type DecodedNode = Record<string, unknown>;
 export declare const decode: (graph: Graph, schema: Schema, context: Context) => DecodedNode[];
 export {};

package/types/library/encoder.d.ts

@@ -1,5 +1,5 @@
 import { type Context, type RDF } from "./rdf.js";
 import type { Schema } from "./schema/mod.js";
-declare type DecodedNode = Record<string, unknown>;
+type DecodedNode = Record<string, unknown>;
 export declare const encode: (node: DecodedNode, schema: Schema, context: Context, variableInitCounter?: number) => RDF.Quad[];
 export {};

package/types/library/engine/query_engine.d.ts

@@ -1,15 +1,16 @@
-import { type Context, type IQueryEngine, type RDF, RDFJSON } from "../rdf.js";
-declare type QueryResponseFormat = {
-    "application/sparql-results+json": RDFJSON.SparqlResultsJsonFormat;
-    "application/rdf+json": RDFJSON.RdfJsonFormat;
-};
+import { type Context, type IQueryEngine, type RDF } from "../rdf.js";
+import { type ResolverType } from "./query_resolvers.js";
 export declare class QueryEngine implements IQueryEngine {
     protected getSparqlEndpoint(context?: Context): string;
     protected getFetch(context?: Context): typeof fetch;
-    query<ResponseType extends keyof QueryResponseFormat, ResponseFormat = QueryResponseFormat[ResponseType]>(query: string, responseType: ResponseType, context?: Context): Promise<ResponseFormat>;
+    query(query: string, responseType: string, context?: Context): Promise<Response>;
+    queryAndResolve<T extends ResolverType>(type: T, query: string, context?: Context): Promise<{
+        boolean: boolean;
+        bindings: RDF.ResultStream<RDF.Bindings>;
+        quads: RDF.ResultStream<RDF.Quad>;
+    }[T]>;
     queryBindings(query: string, context?: Context): Promise<RDF.ResultStream<RDF.Bindings>>;
     queryBoolean(query: string, context?: Context): Promise<boolean>;
     queryQuads(query: string, context?: Context): Promise<RDF.ResultStream<RDF.Quad>>;
     queryVoid(query: string, context?: Context): Promise<void>;
 }
-export {};

package/types/library/engine/query_resolvers.d.ts

@@ -0,0 +1,10 @@
+import { type RDF } from "../rdf.js";
+type ResolveFormat = {
+    "boolean": boolean;
+    "bindings": RDF.ResultStream<RDF.Bindings>;
+    "quads": RDF.ResultStream<RDF.Quad>;
+};
+export type ResolverType = keyof ResolveFormat;
+export declare const getResponseTypes: (resolverType: ResolverType) => string[];
+export declare const resolve: <T extends keyof ResolveFormat>(resolverType: T, response: Response) => Promise<ResolveFormat[T]>;
+export {};

package/types/library/lens/types.d.ts

@@ -1,5 +1,5 @@
 import type { SchemaInterfaceIdentity } from "../schema/mod.js";
-export declare type Entity<T extends unknown = Record<string, unknown>> = DeepPartial<T> & SchemaInterfaceIdentity;
-export declare type DeepPartial<T> = T extends Record<string, unknown> ? {
+export type Entity<T extends unknown = Record<string, unknown>> = DeepPartial<T> & SchemaInterfaceIdentity;
+export type DeepPartial<T> = T extends Record<string, unknown> ? {
     [P in keyof T]?: DeepPartial<T[P]>;
 } : T;

package/types/library/namespaces/dbo.d.ts

@@ -2,11 +2,12 @@ declare const _default: {
     number: "dbo:number";
     symbol: "dbo:symbol";
     tree: "dbo:tree";
-    value: "dbo:value";
-    type: "dbo:type";
     closed: "dbo:closed";
     map: "dbo:map";
     range: "dbo:range";
+    format: "dbo:format";
+    value: "dbo:value";
+    type: "dbo:type";
     prefix: "dbo:prefix";
     length: "dbo:length";
     Name: "dbo:Name";
@@ -1742,7 +1743,6 @@ declare const _default: {
     footedness: "dbo:footedness";
     forces: "dbo:forces";
     foresterDistrict: "dbo:foresterDistrict";
-    format: "dbo:format";
     formationDate: "dbo:formationDate";
     formationYear: "dbo:formationYear";
     formerBandMember: "dbo:formerBandMember";

package/types/library/namespaces/dc.d.ts

@@ -1,11 +1,11 @@
 declare const _default: {
     subject: "dc:subject";
+    format: "dc:format";
     type: "dc:type";
     date: "dc:date";
     language: "dc:language";
     description: "dc:description";
     creator: "dc:creator";
-    format: "dc:format";
     publisher: "dc:publisher";
     relation: "dc:relation";
     source: "dc:source";

package/types/library/namespaces/dcterms.d.ts

@@ -1,5 +1,6 @@
 declare const _default: {
     subject: "dcterms:subject";
+    format: "dcterms:format";
     type: "dcterms:type";
     date: "dcterms:date";
     language: "dcterms:language";
@@ -9,7 +10,6 @@ declare const _default: {
     abstract: "dcterms:abstract";
     created: "dcterms:created";
     creator: "dcterms:creator";
-    format: "dcterms:format";
     isPartOf: "dcterms:isPartOf";
     license: "dcterms:license";
     publisher: "dcterms:publisher";

package/types/library/namespaces/namespace.d.ts

@@ -1,11 +1,11 @@
-declare type NamespacePrototype = {
+type NamespacePrototype = {
     iri: string;
     prefix: string;
     terms: readonly string[];
 };
-declare type NamespacePrefix<Namespace extends NamespacePrototype> = Namespace["prefix"];
-declare type NamespaceIri<Namespace extends NamespacePrototype> = Namespace["iri"];
-declare type NamespaceObject<Namespace extends NamespacePrototype> = {
+type NamespacePrefix<Namespace extends NamespacePrototype> = Namespace["prefix"];
+type NamespaceIri<Namespace extends NamespacePrototype> = Namespace["iri"];
+type NamespaceObject<Namespace extends NamespacePrototype> = {
     [Term in Namespace["terms"][number]]: `${NamespacePrefix<Namespace>}${Term}`;
 };
 export declare const createNamespace: <N extends NamespacePrototype, I = NamespaceIri<N>, P = NamespacePrefix<N>, O = NamespaceObject<N>>(namespaceSpec: N) => O & {

package/types/library/namespaces/schema.d.ts

@@ -1,8 +1,10 @@
 declare const _default: {
     object: "schema:object";
+    map: "schema:map";
+    application: "schema:application";
+    text: "schema:text";
     value: "schema:value";
     query: "schema:query";
-    map: "schema:map";
     duration: "schema:duration";
     language: "schema:language";
     Property: "schema:Property";
@@ -1560,7 +1562,6 @@ declare const _default: {
     antagonist: "schema:antagonist";
     applicableLocation: "schema:applicableLocation";
     applicantLocationRequirements: "schema:applicantLocationRequirements";
-    application: "schema:application";
     applicationCategory: "schema:applicationCategory";
     applicationContact: "schema:applicationContact";
     applicationDeadline: "schema:applicationDeadline";
@@ -2577,7 +2578,6 @@ declare const _default: {
     termDuration: "schema:termDuration";
     termsOfService: "schema:termsOfService";
     termsPerYear: "schema:termsPerYear";
-    text: "schema:text";
     textValue: "schema:textValue";
     thumbnailUrl: "schema:thumbnailUrl";
     tickerSymbol: "schema:tickerSymbol";

package/types/library/namespaces/skos.d.ts

@@ -1,4 +1,5 @@
 declare const _default: {
+    example: "skos:example";
     definition: "skos:definition";
     member: "skos:member";
     note: "skos:note";
@@ -15,7 +16,6 @@ declare const _default: {
     closeMatch: "skos:closeMatch";
     editorialNote: "skos:editorialNote";
     exactMatch: "skos:exactMatch";
-    example: "skos:example";
     hasTopConcept: "skos:hasTopConcept";
     hiddenLabel: "skos:hiddenLabel";
     historyNote: "skos:historyNote";

package/types/library/rdf.d.ts

@@ -3,22 +3,23 @@ export type { RDF };
 export { fromRdf, toRdf } from "rdf-literal";
 import { DataFactory, DefaultGraph } from "rdf-data-factory";
 export { DataFactory, DefaultGraph };
+export * as N3 from "n3";
 import type { IDataSource, IQueryContextCommon } from "@comunica/types";
-export declare type LDkitContext = {
+export type LDkitContext = {
     graph?: string;
     language?: string;
 };
-export declare type Context = LDkitContext & RDF.QueryStringContext & RDF.QuerySourceContext<IDataSource> & IQueryContextCommon;
-export declare type IQueryEngine = RDF.StringSparqlQueryable<RDF.SparqlResultSupport, Context>;
-export declare type Iri = string;
-export declare type Node = Map<Iri, RDF.Term[]>;
-export declare type Graph = Map<Iri, Node>;
+export type Context = LDkitContext & RDF.QueryStringContext & RDF.QuerySourceContext<IDataSource> & IQueryContextCommon;
+export type IQueryEngine = RDF.StringSparqlQueryable<RDF.SparqlResultSupport, Context>;
+export type Iri = string;
+export type Node = Map<Iri, RDF.Term[]>;
+export type Graph = Map<Iri, Node>;
 export declare const quadsToGraph: (quads: RDF.Quad[]) => Graph;
 export declare namespace RDFJSON {
     type Term = {
         type: "uri" | "literal" | "bnode";
         value: string;
-        "xml:lang"?: string;
+        lang?: string;
         datatype?: string;
     };
     type Bindings = Record<string, Term>;

package/types/library/schema/data_types.d.ts

@@ -34,6 +34,6 @@ declare const SupportedDataTypesPrototype: {
     "xsd:hexBinary": string;
     "rdf:langString": string;
 };
-export declare type SupportedDataTypes = typeof SupportedDataTypesPrototype;
-export declare type SupportedNativeTypes = SupportedDataTypes[keyof SupportedDataTypes];
+export type SupportedDataTypes = typeof SupportedDataTypesPrototype;
+export type SupportedNativeTypes = SupportedDataTypes[keyof SupportedDataTypes];
 export {};

package/types/library/schema/interface.d.ts

@@ -1,32 +1,32 @@
 import type { SupportedDataTypes } from "./data_types.js";
 import type { PropertyPrototype, SchemaPrototype } from "./schema.js";
-declare type IsOptional<Property extends PropertyPrototype> = Property extends {
+type IsOptional<Property extends PropertyPrototype> = Property extends {
     "@optional": true;
 } ? true : false;
-declare type IsArray<Property extends PropertyPrototype> = Property extends {
+type IsArray<Property extends PropertyPrototype> = Property extends {
     "@array": true;
 } ? true : false;
-declare type IsMultilang<Property extends PropertyPrototype> = Property extends {
+type IsMultilang<Property extends PropertyPrototype> = Property extends {
     "@multilang": true;
 } ? true : false;
-declare type ValidPropertyDefinition = PropertyPrototype | string;
-declare type ConvertPropertyType<T extends PropertyPrototype> = T extends {
+type ValidPropertyDefinition = PropertyPrototype | string;
+type ConvertPropertyType<T extends PropertyPrototype> = T extends {
     "@context": SchemaPrototype;
 } ? SchemaInterface<T["@context"]> : T extends {
     "@type": unknown;
 } ? T["@type"] extends keyof SupportedDataTypes ? SupportedDataTypes[T["@type"]] : never : string;
-declare type ConvertPropertyOptional<T extends PropertyPrototype> = IsOptional<T> extends true ? ConvertPropertyType<T> | undefined : ConvertPropertyType<T>;
-declare type ConvertPropertyArray<T extends PropertyPrototype> = IsArray<T> extends true ? ConvertPropertyType<T>[] : ConvertPropertyOptional<T>;
-declare type ConvertPropertyMultilang<T extends PropertyPrototype> = IsMultilang<T> extends true ? IsArray<T> extends true ? Record<string, ConvertPropertyType<T>[]> : Record<string, ConvertPropertyType<T>> : ConvertPropertyArray<T>;
-declare type ConvertPropertyObject<T extends PropertyPrototype> = ConvertPropertyMultilang<T>;
-declare type ConvertProperty<T extends ValidPropertyDefinition> = T extends PropertyPrototype ? ConvertPropertyObject<T> : string;
-export declare type SchemaInterfaceIdentity = {
+type ConvertPropertyOptional<T extends PropertyPrototype> = IsOptional<T> extends true ? ConvertPropertyType<T> | undefined : ConvertPropertyType<T>;
+type ConvertPropertyArray<T extends PropertyPrototype> = IsArray<T> extends true ? ConvertPropertyType<T>[] : ConvertPropertyOptional<T>;
+type ConvertPropertyMultilang<T extends PropertyPrototype> = IsMultilang<T> extends true ? IsArray<T> extends true ? Record<string, ConvertPropertyType<T>[]> : Record<string, ConvertPropertyType<T>> : ConvertPropertyArray<T>;
+type ConvertPropertyObject<T extends PropertyPrototype> = ConvertPropertyMultilang<T>;
+type ConvertProperty<T extends ValidPropertyDefinition> = T extends PropertyPrototype ? ConvertPropertyObject<T> : string;
+export type SchemaInterfaceIdentity = {
     $id: string;
 };
-export declare type SchemaInterfaceType = {
+export type SchemaInterfaceType = {
     $type: string[];
 };
-export declare type SchemaInterface<T extends SchemaPrototype> = {
+export type SchemaInterface<T extends SchemaPrototype> = {
     [X in Exclude<keyof T, "@type">]: T[X] extends ValidPropertyDefinition ? ConvertProperty<T[X]> : never;
 } & SchemaInterfaceIdentity & SchemaInterfaceType;
 export {};

package/types/library/schema/schema.d.ts

@@ -1,6 +1,6 @@
 import type { SupportedDataTypes } from "./data_types.js";
-declare type PropertyType = keyof SupportedDataTypes;
-export declare type PropertyPrototype = {
+type PropertyType = keyof SupportedDataTypes;
+export type PropertyPrototype = {
     "@id": string;
     "@type"?: PropertyType;
     "@context"?: SchemaPrototype;
@@ -8,14 +8,14 @@ export declare type PropertyPrototype = {
     "@array"?: true;
     "@multilang"?: true;
 };
-export declare type SchemaPrototypeProperties = {
+export type SchemaPrototypeProperties = {
     [key: string]: PropertyPrototype | string | readonly string[];
 };
-export declare type SchemaPrototypeType = {
+export type SchemaPrototypeType = {
     "@type": string | readonly string[];
 };
-export declare type SchemaPrototype = SchemaPrototypeProperties & SchemaPrototypeType;
-export declare type Property = {
+export type SchemaPrototype = SchemaPrototypeProperties & SchemaPrototypeType;
+export type Property = {
     "@id": string;
     "@type"?: PropertyType;
     "@context"?: Schema;
@@ -23,7 +23,7 @@ export declare type Property = {
     "@array"?: true;
     "@multilang"?: true;
 };
-export declare type Schema = {
+export type Schema = {
     [key: string]: Property | string[];
     "@type": string[];
 };

package/types/library/sparql/sparql_query_builders.d.ts

@@ -1,7 +1,7 @@
 import { SparqlBuilder } from "./sparql_shared_builders.js";
 import { type RDF } from "../rdf.js";
 import { type SparqlValue } from "./sparql_tag.js";
-declare type Builders<T extends keyof SparqlQueryBuilder> = Pick<SparqlQueryBuilder, T>;
+type Builders<T extends keyof SparqlQueryBuilder> = Pick<SparqlQueryBuilder, T>;
 declare class SparqlQueryBuilder extends SparqlBuilder {
     OFFSET(number: number): Builders<"build">;
     LIMIT(number: number): Builders<"build" | "OFFSET">;

package/types/library/sparql/sparql_shared_builders.d.ts

@@ -1,6 +1,6 @@
 import { DataFactory, RDF } from "../rdf.js";
 import { type SparqlValue } from "./sparql_tag.js";
-declare type Wrap = (keyword: string, value: string) => string;
+type Wrap = (keyword: string, value: string) => string;
 export declare const braces: Wrap;
 export declare const parentheses: Wrap;
 export declare abstract class SparqlBuilder {

package/types/library/sparql/sparql_tag.d.ts

@@ -1,3 +1,3 @@
 import { type RDF } from "../rdf.js";
-export declare type SparqlValue = RDF.Term | string | number | boolean | Date | Iterable<SparqlValue> | null | undefined;
+export type SparqlValue = RDF.Term | string | number | boolean | Date | Iterable<SparqlValue> | null | undefined;
 export declare const sparql: (strings: TemplateStringsArray, ...values: SparqlValue[]) => string;

package/types/library/sparql/sparql_update_builders.d.ts

@@ -1,7 +1,7 @@
 import { SparqlBuilder } from "./sparql_shared_builders.js";
 import { type RDF } from "../rdf.js";
 import { type SparqlValue } from "./sparql_tag.js";
-declare type Builders<T extends keyof SparqlUpdateBuilder> = Pick<SparqlUpdateBuilder, T>;
+type Builders<T extends keyof SparqlUpdateBuilder> = Pick<SparqlUpdateBuilder, T>;
 declare class SparqlUpdateBuilder extends SparqlBuilder {
     WHERE(strings: TemplateStringsArray, ...values: SparqlValue[]): Builders<"build">;
     USING_NAMED(stringOrNamedNode: string | RDF.NamedNode<string>): Builders<"USING_NAMED" | "WHERE">;

package/types/mod.d.ts

@@ -3,3 +3,4 @@ export { setDefaultContext, setDefaultEngine } from "./library/global.js";
 export { type SchemaInterface } from "./library/schema/mod.js";
 export { createLens, createResource, type Lens } from "./library/lens/mod.js";
 export { createNamespace } from "./library/namespaces/namespace.js";
+export { QueryEngine } from "./library/engine/mod.js";