ldkit 2.1.1 → 2.3.0

package/esm/library/decoder.js

@@ -1,6 +1,6 @@
-import { fromRdf } from "./rdf.js";
 import { ldkit } from "../namespaces/ldkit.js";
 import { rdf } from "../namespaces/rdf.js";
+import { translateFromRdf } from "./translator.js";
 export const decode = (graph, schema, options) => {
     return Decoder.decode(graph, schema, options);
 };
@@ -185,7 +185,7 @@ class Decoder {
             return term.value;
         }
         else if (term.termType === "Literal") {
-            return fromRdf(term);
+            return translateFromRdf(term);
         }
         else {
             throw new Error(`Unsupported term type to resolve: ${term.termType}`);

package/esm/library/encoder.js

@@ -1,7 +1,8 @@
-import { DataFactory, toRdf } from "./rdf.js";
+import { DataFactory } from "./rdf.js";
 import { xsd } from "../namespaces/xsd.js";
 import { rdf } from "../namespaces/rdf.js";
 import { ldkit } from "../namespaces/ldkit.js";
+import { translateToRdf } from "./translator.js";
 export const encode = (node, schema, options, includeType = true, variableInitCounter = 0) => {
     return Encoder.encode(node, schema, options, includeType, variableInitCounter);
 };
@@ -9,9 +10,7 @@ export const encodeValue = (value, datatype, df) => {
     if (datatype === ldkit.IRI) {
         return df.namedNode(value);
     }
-    return toRdf(value, {
-        datatype: df.namedNode(datatype),
-    });
+    return translateToRdf(value, datatype);
 };
 class Encoder {
     constructor(options, includeType, variableInitCounter) {

package/esm/library/engine/query_engine.js

@@ -41,21 +41,21 @@ export class QueryEngine {
     getFetch(context) {
         return context && context.fetch ? context.fetch : fetch;
     }
-    query(body, responseType, context) {
+    query(body, requestType, responseType, context) {
         const endpoint = this.getSparqlEndpoint(context);
         const fetchFn = this.getFetch(context);
         return fetchFn(endpoint, {
             method: "POST",
             headers: {
                 "accept": responseType,
-                "content-type": "application/x-www-form-urlencoded; charset=UTF-8",
+                "content-type": `${requestType}; charset=UTF-8`,
             },
-            body: new URLSearchParams(body),
+            body,
         });
     }
     async queryAndResolve(type, query, context) {
         const responseType = getResponseTypes(type).join(", ");
-        const response = await this.query({ query }, responseType, context);
+        const response = await this.query(query, "application/sparql-query", responseType, context);
         if (!response.ok) {
             await response.body?.cancel();
             throw new Error(`Invalid query response status '${response.status} ${response.statusText}'`);
@@ -100,6 +100,6 @@ export class QueryEngine {
      * @returns Nothing
      */
     async queryVoid(query, context) {
-        await this.query({ update: query }, "application/sparql-results+json", context);
+        await this.query(query, "application/sparql-update", "application/sparql-results+json", context);
     }
 }

package/esm/library/engine/query_engine_proxy.js

@@ -1,4 +1,4 @@
-import { N3, quadsToGraph } from "../rdf.js";
+import { quadsToGraph } from "../rdf.js";
 export class QueryEngineProxy {
     constructor(engine, context) {
         Object.defineProperty(this, "engine", {
@@ -25,9 +25,7 @@ export class QueryEngineProxy {
     }
     async queryGraph(query) {
         const quadStream = await this.engine.queryQuads(query, this.context);
-        const quads = await (quadStream.toArray());
-        const store = new N3.Store(quads);
-        return quadsToGraph(store);
+        return quadsToGraph(quadStream);
     }
     queryVoid(query) {
         return this.engine.queryVoid(query, this.context);

package/esm/library/engine/query_resolvers.js

@@ -1,3 +1,4 @@
+import { readableFromWeb } from "../utils.js";
 import { BindingsFactory, N3, QuadFactory } from "../rdf.js";
 import { ArrayIterator, MappingIterator, TreeIterator, } from "../asynciterator.js";
 class QueryResolver {
@@ -19,7 +20,6 @@ class BindingsJsonResolver extends QueryResolver {
         }
         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));
     }
 }
@@ -31,15 +31,35 @@ class QuadsJsonResolver extends QueryResolver {
         }
         const quadFactory = new QuadFactory();
         const treeIterator = new TreeIterator(json);
-        // TODO: review the unknown type cast
         return new MappingIterator(treeIterator, (i) => quadFactory.fromJson(i));
     }
 }
+const createN3Stream = async (response, format) => {
+    if (response.body === null) {
+        throw new Error("Response body is null, but it should contain quads from the SPARQL query");
+    }
+    const stream = readableFromWeb(response.body);
+    const parser = new N3.StreamParser({ format });
+    return await parser.import(stream);
+};
+class QuadsNTriplesResolver extends QueryResolver {
+    resolve(response) {
+        return createN3Stream(response, "N-Triples");
+    }
+}
+class QuadsNQuadsResolver extends QueryResolver {
+    resolve(response) {
+        return createN3Stream(response, "N-Quads");
+    }
+}
 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);
+    resolve(response) {
+        return createN3Stream(response, "Turtle");
+    }
+}
+class QuadsTrigResolver extends QueryResolver {
+    resolve(response) {
+        return createN3Stream(response, "TriG");
     }
 }
 const resolvers = {
@@ -51,7 +71,10 @@ const resolvers = {
     },
     "quads": {
         "application/rdf+json": new QuadsJsonResolver(),
+        "application/n-triples": new QuadsNTriplesResolver(),
+        "application/n-quads": new QuadsNQuadsResolver(),
         "text/turtle": new QuadsTurtleResolver(),
+        "application/trig": new QuadsTrigResolver(),
     },
 };
 export const getResponseTypes = (resolverType) => Object.keys(resolvers[resolverType]);

package/esm/library/rdf.js

@@ -1,17 +1,27 @@
 export { fromRdf, toRdf } from "rdf-literal";
+import { quadToStringQuad } from "rdf-string";
 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) {
-        const s = quad.subject.value;
-        const p = quad.predicate.value;
-        const predicateMap = graph.get(s) || graph.set(s, new Map()).get(s);
-        const termArray = predicateMap.get(p) || predicateMap.set(p, []).get(p);
-        termArray.push(quad.object);
-    }
-    return graph;
+export const quadsToGraph = (quadStream) => {
+    return new Promise((resolve, reject) => {
+        const graph = new Map();
+        const included = {};
+        quadStream.on("data", (quad) => {
+            const hash = Object.values(quadToStringQuad(quad)).join(" ");
+            if (included[hash]) {
+                return;
+            }
+            included[hash] = true;
+            const s = quad.subject.value;
+            const p = quad.predicate.value;
+            const predicateMap = graph.get(s) || graph.set(s, new Map()).get(s);
+            const termArray = predicateMap.get(p) || predicateMap.set(p, []).get(p);
+            termArray.push(quad.object);
+        });
+        quadStream.on("end", () => resolve(graph));
+        quadStream.on("error", reject);
+    });
 };
 export class TermFactory {
     constructor(dataFactory = new DataFactory()) {

package/esm/library/translator.js

@@ -0,0 +1,62 @@
+import { DataFactory, fromRdf, toRdf } from "./rdf.js";
+const df = new DataFactory();
+const rdfToNativeHandlers = new Map();
+const nativeToRdfHandlers = new Map();
+/**
+ * Registers a data type handler for translating between RDF literals and JavaScript values.
+ *
+ * In order to register a custom data type handler, the custom data type TypeScript mapping needs
+ * to be added to the {@link CustomDataTypes} interface using module augmentation.
+ *
+ * Two handlers are required:
+ * 1) A function to translate from RDF literal value (string) to JavaScript value.
+ * 2) A function to translate from JavaScript value to RDF literal value (string).
+ *
+ * @example
+ * ```typescript
+ * import { registerDataHandler } from "ldkit";
+ *
+ * const customNumberDataType = "http://example.org/number";
+ *
+ * declare module "ldkit" {
+ *   interface CustomDataTypes {
+ *     [customNumberDataType]: number;
+ *   }
+ * }
+ *
+ * registerDataHandler(
+ *   customNumberDataType,
+ *   (literalValue: string) => parseInt(literalValue),
+ *   (nativeValue: number) => nativeValue.toString(),
+ * );
+ * ```
+ *
+ * @param dataType - The data type to register.
+ * @param translateFromRDF - Function to translate from RDF literal to JavaScript value.
+ * @param translateToRDF - Function to translate from JavaScript value to RDF literal.
+ */
+export function registerDataHandler(dataType, translateFromRDF, translateToRDF) {
+    rdfToNativeHandlers.set(dataType, translateFromRDF);
+    nativeToRdfHandlers.set(dataType, translateToRDF);
+}
+export function translateFromRdf(literal) {
+    const dataType = literal.datatype.value;
+    const customHandler = rdfToNativeHandlers.get(dataType);
+    if (customHandler) {
+        return customHandler(literal.value);
+    }
+    else {
+        return fromRdf(literal);
+    }
+}
+export function translateToRdf(value, dataType) {
+    const customHandler = nativeToRdfHandlers.get(dataType);
+    if (customHandler) {
+        return df.literal(customHandler(value), df.namedNode(dataType));
+    }
+    else {
+        return toRdf(value, {
+            datatype: df.namedNode(dataType),
+        });
+    }
+}

package/esm/library/utils.js

@@ -0,0 +1 @@
+export { readableFromWeb } from "readable-from-web";

package/esm/mod.js

@@ -1,4 +1,5 @@
 export { setGlobalOptions } from "./library/options.js";
+export { registerDataHandler } from "./library/translator.js";
 export * from "./library/lens/mod.js";
 export * from "./library/namespace.js";
 export * from "./library/engine/mod.js";

package/package.json

@@ -3,7 +3,7 @@
   "main": "./script/mod.js",
   "types": "./types/mod.d.ts",
   "name": "ldkit",
-  "version": "2.1.1",
+  "version": "2.3.0",
   "description": "LDkit, a Linked Data query toolkit for TypeScript developers",
   "homepage": "https://ldkit.io",
   "author": "Karel Klima <karelklima@gmail.com> (https://karelklima.com)",
@@ -70,6 +70,8 @@
     "asynciterator": "^3.9.0",
     "n3": "^1.23.1",
     "rdf-data-factory": "^2.0.2",
-    "rdf-literal": "^2.0.0"
+    "rdf-literal": "^2.0.0",
+    "rdf-string": "^2.0.0",
+    "readable-from-web": "^0.0.4"
   }
 }

package/script/library/decoder.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.decode = void 0;
-const rdf_js_1 = require("./rdf.js");
 const ldkit_js_1 = require("../namespaces/ldkit.js");
-const rdf_js_2 = require("../namespaces/rdf.js");
+const rdf_js_1 = require("../namespaces/rdf.js");
+const translator_js_1 = require("./translator.js");
 const decode = (graph, schema, options) => {
     return Decoder.decode(graph, schema, options);
 };
@@ -56,8 +56,8 @@ class Decoder {
     decode() {
         const output = [];
         for (const [iri, properties] of this.graph) {
-            if (properties.has(rdf_js_2.rdf.type)) {
-                const types = properties.get(rdf_js_2.rdf.type);
+            if (properties.has(rdf_js_1.rdf.type)) {
+                const types = properties.get(rdf_js_1.rdf.type);
                 for (const type of types) {
                     if (type.termType === "NamedNode" && type.value === ldkit_js_1.ldkit.Resource) {
                         output.push(this.decodeNode(iri, this.schema));
@@ -96,7 +96,7 @@ class Decoder {
     }
     decodeNodeProperty(nodeIri, node, propertyKey, property) {
         const allTerms = node.get(property["@id"]);
-        const terms = property["@id"] !== rdf_js_2.rdf.type
+        const terms = property["@id"] !== rdf_js_1.rdf.type
             ? allTerms
             : allTerms?.filter((term) => term.value !== ldkit_js_1.ldkit.Resource);
         if (!terms) {
@@ -189,7 +189,7 @@ class Decoder {
             return term.value;
         }
         else if (term.termType === "Literal") {
-            return (0, rdf_js_1.fromRdf)(term);
+            return (0, translator_js_1.translateFromRdf)(term);
         }
         else {
             throw new Error(`Unsupported term type to resolve: ${term.termType}`);

package/script/library/encoder.js

@@ -5,6 +5,7 @@ const rdf_js_1 = require("./rdf.js");
 const xsd_js_1 = require("../namespaces/xsd.js");
 const rdf_js_2 = require("../namespaces/rdf.js");
 const ldkit_js_1 = require("../namespaces/ldkit.js");
+const translator_js_1 = require("./translator.js");
 const encode = (node, schema, options, includeType = true, variableInitCounter = 0) => {
     return Encoder.encode(node, schema, options, includeType, variableInitCounter);
 };
@@ -13,9 +14,7 @@ const encodeValue = (value, datatype, df) => {
     if (datatype === ldkit_js_1.ldkit.IRI) {
         return df.namedNode(value);
     }
-    return (0, rdf_js_1.toRdf)(value, {
-        datatype: df.namedNode(datatype),
-    });
+    return (0, translator_js_1.translateToRdf)(value, datatype);
 };
 exports.encodeValue = encodeValue;
 class Encoder {

package/script/library/engine/query_engine.js

@@ -44,21 +44,21 @@ class QueryEngine {
     getFetch(context) {
         return context && context.fetch ? context.fetch : fetch;
     }
-    query(body, responseType, context) {
+    query(body, requestType, responseType, context) {
         const endpoint = this.getSparqlEndpoint(context);
         const fetchFn = this.getFetch(context);
         return fetchFn(endpoint, {
             method: "POST",
             headers: {
                 "accept": responseType,
-                "content-type": "application/x-www-form-urlencoded; charset=UTF-8",
+                "content-type": `${requestType}; charset=UTF-8`,
             },
-            body: new URLSearchParams(body),
+            body,
         });
     }
     async queryAndResolve(type, query, context) {
         const responseType = (0, query_resolvers_js_1.getResponseTypes)(type).join(", ");
-        const response = await this.query({ query }, responseType, context);
+        const response = await this.query(query, "application/sparql-query", responseType, context);
         if (!response.ok) {
             await response.body?.cancel();
             throw new Error(`Invalid query response status '${response.status} ${response.statusText}'`);
@@ -103,7 +103,7 @@ class QueryEngine {
      * @returns Nothing
      */
     async queryVoid(query, context) {
-        await this.query({ update: query }, "application/sparql-results+json", context);
+        await this.query(query, "application/sparql-update", "application/sparql-results+json", context);
     }
 }
 exports.QueryEngine = QueryEngine;

package/script/library/engine/query_engine_proxy.js

@@ -28,9 +28,7 @@ class QueryEngineProxy {
     }
     async queryGraph(query) {
         const quadStream = await this.engine.queryQuads(query, this.context);
-        const quads = await (quadStream.toArray());
-        const store = new rdf_js_1.N3.Store(quads);
-        return (0, rdf_js_1.quadsToGraph)(store);
+        return (0, rdf_js_1.quadsToGraph)(quadStream);
     }
     queryVoid(query) {
         return this.engine.queryVoid(query, this.context);

package/script/library/engine/query_resolvers.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolve = exports.getResponseTypes = void 0;
+const utils_js_1 = require("../utils.js");
 const rdf_js_1 = require("../rdf.js");
 const asynciterator_js_1 = require("../asynciterator.js");
 class QueryResolver {
@@ -22,7 +23,6 @@ class BindingsJsonResolver extends QueryResolver {
         }
         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));
     }
 }
@@ -34,15 +34,35 @@ class QuadsJsonResolver extends QueryResolver {
         }
         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));
     }
 }
+const createN3Stream = async (response, format) => {
+    if (response.body === null) {
+        throw new Error("Response body is null, but it should contain quads from the SPARQL query");
+    }
+    const stream = (0, utils_js_1.readableFromWeb)(response.body);
+    const parser = new rdf_js_1.N3.StreamParser({ format });
+    return await parser.import(stream);
+};
+class QuadsNTriplesResolver extends QueryResolver {
+    resolve(response) {
+        return createN3Stream(response, "N-Triples");
+    }
+}
+class QuadsNQuadsResolver extends QueryResolver {
+    resolve(response) {
+        return createN3Stream(response, "N-Quads");
+    }
+}
 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);
+    resolve(response) {
+        return createN3Stream(response, "Turtle");
+    }
+}
+class QuadsTrigResolver extends QueryResolver {
+    resolve(response) {
+        return createN3Stream(response, "TriG");
     }
 }
 const resolvers = {
@@ -54,7 +74,10 @@ const resolvers = {
     },
     "quads": {
         "application/rdf+json": new QuadsJsonResolver(),
+        "application/n-triples": new QuadsNTriplesResolver(),
+        "application/n-quads": new QuadsNQuadsResolver(),
         "text/turtle": new QuadsTurtleResolver(),
+        "application/trig": new QuadsTrigResolver(),
     },
 };
 const getResponseTypes = (resolverType) => Object.keys(resolvers[resolverType]);

package/script/library/rdf.js

@@ -27,20 +27,30 @@ exports.QuadFactory = exports.BindingsFactory = exports.ReadOnlyBindings = expor
 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_string_1 = require("rdf-string");
 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) {
-        const s = quad.subject.value;
-        const p = quad.predicate.value;
-        const predicateMap = graph.get(s) || graph.set(s, new Map()).get(s);
-        const termArray = predicateMap.get(p) || predicateMap.set(p, []).get(p);
-        termArray.push(quad.object);
-    }
-    return graph;
+const quadsToGraph = (quadStream) => {
+    return new Promise((resolve, reject) => {
+        const graph = new Map();
+        const included = {};
+        quadStream.on("data", (quad) => {
+            const hash = Object.values((0, rdf_string_1.quadToStringQuad)(quad)).join(" ");
+            if (included[hash]) {
+                return;
+            }
+            included[hash] = true;
+            const s = quad.subject.value;
+            const p = quad.predicate.value;
+            const predicateMap = graph.get(s) || graph.set(s, new Map()).get(s);
+            const termArray = predicateMap.get(p) || predicateMap.set(p, []).get(p);
+            termArray.push(quad.object);
+        });
+        quadStream.on("end", () => resolve(graph));
+        quadStream.on("error", reject);
+    });
 };
 exports.quadsToGraph = quadsToGraph;
 class TermFactory {

package/script/library/translator.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translateToRdf = exports.translateFromRdf = exports.registerDataHandler = void 0;
+const rdf_js_1 = require("./rdf.js");
+const df = new rdf_js_1.DataFactory();
+const rdfToNativeHandlers = new Map();
+const nativeToRdfHandlers = new Map();
+/**
+ * Registers a data type handler for translating between RDF literals and JavaScript values.
+ *
+ * In order to register a custom data type handler, the custom data type TypeScript mapping needs
+ * to be added to the {@link CustomDataTypes} interface using module augmentation.
+ *
+ * Two handlers are required:
+ * 1) A function to translate from RDF literal value (string) to JavaScript value.
+ * 2) A function to translate from JavaScript value to RDF literal value (string).
+ *
+ * @example
+ * ```typescript
+ * import { registerDataHandler } from "ldkit";
+ *
+ * const customNumberDataType = "http://example.org/number";
+ *
+ * declare module "ldkit" {
+ *   interface CustomDataTypes {
+ *     [customNumberDataType]: number;
+ *   }
+ * }
+ *
+ * registerDataHandler(
+ *   customNumberDataType,
+ *   (literalValue: string) => parseInt(literalValue),
+ *   (nativeValue: number) => nativeValue.toString(),
+ * );
+ * ```
+ *
+ * @param dataType - The data type to register.
+ * @param translateFromRDF - Function to translate from RDF literal to JavaScript value.
+ * @param translateToRDF - Function to translate from JavaScript value to RDF literal.
+ */
+function registerDataHandler(dataType, translateFromRDF, translateToRDF) {
+    rdfToNativeHandlers.set(dataType, translateFromRDF);
+    nativeToRdfHandlers.set(dataType, translateToRDF);
+}
+exports.registerDataHandler = registerDataHandler;
+function translateFromRdf(literal) {
+    const dataType = literal.datatype.value;
+    const customHandler = rdfToNativeHandlers.get(dataType);
+    if (customHandler) {
+        return customHandler(literal.value);
+    }
+    else {
+        return (0, rdf_js_1.fromRdf)(literal);
+    }
+}
+exports.translateFromRdf = translateFromRdf;
+function translateToRdf(value, dataType) {
+    const customHandler = nativeToRdfHandlers.get(dataType);
+    if (customHandler) {
+        return df.literal(customHandler(value), df.namedNode(dataType));
+    }
+    else {
+        return (0, rdf_js_1.toRdf)(value, {
+            datatype: df.namedNode(dataType),
+        });
+    }
+}
+exports.translateToRdf = translateToRdf;

package/script/library/utils.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readableFromWeb = void 0;
+var readable_from_web_1 = require("readable-from-web");
+Object.defineProperty(exports, "readableFromWeb", { enumerable: true, get: function () { return readable_from_web_1.readableFromWeb; } });

package/script/mod.js

@@ -14,9 +14,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setGlobalOptions = void 0;
+exports.registerDataHandler = exports.setGlobalOptions = void 0;
 var options_js_1 = require("./library/options.js");
 Object.defineProperty(exports, "setGlobalOptions", { enumerable: true, get: function () { return options_js_1.setGlobalOptions; } });
+var translator_js_1 = require("./library/translator.js");
+Object.defineProperty(exports, "registerDataHandler", { enumerable: true, get: function () { return translator_js_1.registerDataHandler; } });
 __exportStar(require("./library/lens/mod.js"), exports);
 __exportStar(require("./library/namespace.js"), exports);
 __exportStar(require("./library/engine/mod.js"), exports);

package/types/library/encoder.d.ts

@@ -3,5 +3,5 @@ import { DataFactory, type RDF } from "./rdf.js";
 import type { ExpandedSchema } from "./schema/mod.js";
 type DecodedNode = Record<string, unknown>;
 export declare const encode: (node: DecodedNode, schema: ExpandedSchema, options: Options, includeType?: boolean, variableInitCounter?: number) => RDF.Quad[];
-export declare const encodeValue: (value: unknown, datatype: string, df: DataFactory) => RDF.Literal | import("rdf-data-factory").NamedNode<string>;
+export declare const encodeValue: (value: unknown, datatype: string, df: DataFactory) => RDF.Literal | import("rdf-data-factory").Literal | import("rdf-data-factory").NamedNode<string>;
 export {};

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

@@ -16,11 +16,7 @@ import { type ResolverType } from "./query_resolvers.js";
 export declare class QueryEngine implements IQueryEngine {
     protected getSparqlEndpoint(context?: QueryContext): string;
     protected getFetch(context?: QueryContext): typeof fetch;
-    protected query(body: {
-        query: string;
-    } | {
-        update: string;
-    }, responseType: string, context?: QueryContext): Promise<Response>;
+    protected query(body: string, requestType: "application/sparql-query" | "application/sparql-update", responseType: string, context?: QueryContext): Promise<Response>;
     protected queryAndResolve<T extends ResolverType>(type: T, query: string, context?: QueryContext): Promise<{
         boolean: boolean;
         bindings: RDF.ResultStream<RDF.Bindings>;

package/types/library/options.d.ts

@@ -66,5 +66,6 @@ export declare function resolveOptions(options?: Options): {
     extensionFunctions?: Record<string, (args: import("@rdfjs/types").Term[]) => Promise<import("@rdfjs/types").Term>> | undefined;
     explain?: import("@comunica/types").QueryExplainMode | undefined;
     recoverBrokenLinks?: boolean | undefined;
+    distinctConstruct?: boolean | undefined;
 };
 export declare function resolveQueryContext(options: Options): QueryContext;

package/types/library/rdf.d.ts

@@ -7,7 +7,7 @@ export * as N3 from "n3";
 export type IRI = string;
 export type Node = Map<IRI, RDF.Term[]>;
 export type Graph = Map<IRI, Node>;
-export declare const quadsToGraph: (quads: Iterable<RDF.Quad>) => Graph;
+export declare const quadsToGraph: (quadStream: RDF.ResultStream<RDF.Quad>) => Promise<Graph>;
 export declare namespace RDFJSON {
     type Term = {
         type: "uri" | "literal" | "bnode";

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

@@ -2,8 +2,8 @@ import { xsd } from "../../namespaces/xsd.js";
 import { rdf } from "../../namespaces/rdf.js";
 import { ldkit } from "../../namespaces/ldkit.js";
 import { type IRI } from "../rdf.js";
-/** Map of supported RDF data types and their JavaScript native counterparts */
-export type SupportedDataTypes = {
+/** Map of default RDF data types and their JavaScript native counterparts */
+type DefaultDataTypes = {
     [xsd.dateTime]: Date;
     [xsd.date]: Date;
     [xsd.gDay]: Date;
@@ -42,5 +42,15 @@ export type SupportedDataTypes = {
     [xsd.duration]: string;
     [ldkit.IRI]: IRI;
 };
+/** Custom data types definition. Keys are type IRIs, values are JavaScript native types */
+export interface CustomDataTypes {
+}
+/**
+ * Map of supported RDF data types and their JavaScript native counterparts,
+ * combines default data types with custom data types.
+ * The keys are the IRIs of the data types, and the values are the corresponding JavaScript types.
+ */
+export type SupportedDataTypes = Omit<DefaultDataTypes, keyof CustomDataTypes> & CustomDataTypes;
 /** List of supported native JavaScript types */
 export type SupportedNativeTypes = SupportedDataTypes[keyof SupportedDataTypes];
+export {};

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

@@ -1,4 +1,4 @@
-export type { SupportedDataTypes, SupportedNativeTypes } from "./data_types.js";
+export type { CustomDataTypes, SupportedDataTypes, SupportedNativeTypes, } from "./data_types.js";
 export type { Identity, SchemaInterface, SchemaSearchInterface, SchemaUpdateInterface, } from "./interface.js";
 export type { ExpandedProperty, ExpandedSchema, Property, Schema, } from "./schema.js";
 export type { SearchFilters, SearchSchema } from "./search.js";

package/types/library/translator.d.ts

@@ -0,0 +1,38 @@
+import { RDF } from "./rdf.js";
+import { SupportedDataTypes } from "./schema/mod.js";
+/**
+ * Registers a data type handler for translating between RDF literals and JavaScript values.
+ *
+ * In order to register a custom data type handler, the custom data type TypeScript mapping needs
+ * to be added to the {@link CustomDataTypes} interface using module augmentation.
+ *
+ * Two handlers are required:
+ * 1) A function to translate from RDF literal value (string) to JavaScript value.
+ * 2) A function to translate from JavaScript value to RDF literal value (string).
+ *
+ * @example
+ * ```typescript
+ * import { registerDataHandler } from "ldkit";
+ *
+ * const customNumberDataType = "http://example.org/number";
+ *
+ * declare module "ldkit" {
+ *   interface CustomDataTypes {
+ *     [customNumberDataType]: number;
+ *   }
+ * }
+ *
+ * registerDataHandler(
+ *   customNumberDataType,
+ *   (literalValue: string) => parseInt(literalValue),
+ *   (nativeValue: number) => nativeValue.toString(),
+ * );
+ * ```
+ *
+ * @param dataType - The data type to register.
+ * @param translateFromRDF - Function to translate from RDF literal to JavaScript value.
+ * @param translateToRDF - Function to translate from JavaScript value to RDF literal.
+ */
+export declare function registerDataHandler<T extends keyof SupportedDataTypes>(dataType: T, translateFromRDF: (literalValue: string) => SupportedDataTypes[T], translateToRDF: (nativeValue: SupportedDataTypes[T]) => string): void;
+export declare function translateFromRdf(literal: RDF.Literal): any;
+export declare function translateToRdf(value: unknown, dataType: keyof SupportedDataTypes | string): RDF.Literal | import("rdf-data-factory").Literal;

package/types/library/utils.d.ts

@@ -0,0 +1 @@
+export { readableFromWeb } from "readable-from-web";

package/types/mod.d.ts

@@ -1,5 +1,6 @@
 export { type Options, setGlobalOptions } from "./library/options.js";
-export type { Identity, Property, Schema, SchemaInterface, SchemaSearchInterface, SchemaUpdateInterface, SupportedDataTypes, } from "./library/schema/mod.js";
+export type { CustomDataTypes, Identity, Property, Schema, SchemaInterface, SchemaSearchInterface, SchemaUpdateInterface, SupportedDataTypes, } from "./library/schema/mod.js";
+export { registerDataHandler } from "./library/translator.js";
 export * from "./library/lens/mod.js";
 export * from "./library/namespace.js";
 export * from "./library/engine/mod.js";