ldkit 0.6.4 → 0.7.0

package/script/library/{resource → lens}/query_builder.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryBuilder = void 0;
 const mod_js_1 = require("../schema/mod.js");
-const sparql_js_1 = require("../sparql.js");
+const mod_js_2 = require("../sparql/mod.js");
 const rdf_js_1 = require("../rdf.js");
 const ldkit_js_1 = __importDefault(require("../namespaces/ldkit.js"));
 const rdf_js_2 = __importDefault(require("../namespaces/rdf.js"));
@@ -42,11 +42,11 @@ class QueryBuilder {
             configurable: true,
             writable: true,
             value: (iris) => {
-                return (0, sparql_js_1.DELETE) `
-      ?s ?p ?o
-    `.WHERE `
-      ?s ?p ?o .
-      VALUES ?s { ${iris.map(this.df.namedNode)} }
+                return (0, mod_js_2.DELETE) `
+      ?s ?p ?o
+    `.WHERE `
+      ?s ?p ?o .
+      VALUES ?s { ${iris.map(this.df.namedNode)} }
     `.build();
             }
         });
@@ -83,14 +83,14 @@ class QueryBuilder {
                     return;
                 }
                 if (wrapOptional && isOptional) {
-                    conditions.push((0, sparql_js_1.$) `\nOPTIONAL {`);
+                    conditions.push((0, mod_js_2.sparql) `\nOPTIONAL {`);
                 }
                 conditions.push(this.df.quad(this.df.variable(varPrefix), this.df.namedNode(property["@id"]), this.df.variable(`${varPrefix}_${index}`)));
                 if (typeof property["@context"] === "object") {
                     populateConditionsRecursive(property["@context"], `${varPrefix}_${index}`);
                 }
                 if (wrapOptional && isOptional) {
-                    conditions.push((0, sparql_js_1.$) `\n}\n`);
+                    conditions.push((0, mod_js_2.sparql) `\n}\n`);
                 }
             });
         };
@@ -99,39 +99,39 @@ class QueryBuilder {
     }
     countQuery() {
         const quads = this.getShape();
-        return (0, sparql_js_1.SELECT) `(count(?iri) as ?count)`.WHERE `${quads}`.build();
+        return (0, mod_js_2.SELECT) `(count(?iri) as ?count)`.WHERE `${quads}`.build();
     }
     getQuery(where, limit = 1000) {
-        const selectSubQuery = (0, sparql_js_1.SELECT) `
-      ${this.df.variable("iri")}
-    `.WHERE `
-      ${this.getShape(false, true)}
-      ${where}
-    `.LIMIT(limit);
-        const query = (0, sparql_js_1.CONSTRUCT) `
-      ${this.getResourceSignature()}
-      ${this.getTypesSignature()}
-      ${this.getShape(true, false, true)}
-    `.WHERE `
-      ${this.getTypesSignature()}
-      ${this.getShape(true, true, true)}
-      {
-        ${selectSubQuery}
-      }
+        const selectSubQuery = (0, mod_js_2.SELECT) `
+      ${this.df.variable("iri")}
+    `.WHERE `
+      ${this.getShape(false, true)}
+      ${where}
+    `.LIMIT(limit).build();
+        const query = (0, mod_js_2.CONSTRUCT) `
+      ${this.getResourceSignature()}
+      ${this.getTypesSignature()}
+      ${this.getShape(true, false, true)}
+    `.WHERE `
+      ${this.getTypesSignature()}
+      ${this.getShape(true, true, true)}
+      {
+        ${selectSubQuery}
+      }
     `.build();
         return query;
     }
     getByIrisQuery(iris) {
-        const query = (0, sparql_js_1.CONSTRUCT) `
-      ${this.getResourceSignature()}
-      ${this.getTypesSignature()}
-      ${this.getShape(true, false, true)}
-    `.WHERE `
-      ${this.getTypesSignature()}
-      ${this.getShape(true, true, true)}
-      VALUES ?iri {
-        ${iris.map(this.df.namedNode)}
-      }
+        const query = (0, mod_js_2.CONSTRUCT) `
+      ${this.getResourceSignature()}
+      ${this.getTypesSignature()}
+      ${this.getShape(true, false, true)}
+    `.WHERE `
+      ${this.getTypesSignature()}
+      ${this.getShape(true, true, true)}
+      VALUES ?iri {
+        ${iris.map(this.df.namedNode)}
+      }
     `.build();
         return query;
     }
@@ -140,10 +140,10 @@ class QueryBuilder {
         return this.insertDataQuery(quads);
     }
     insertDataQuery(quads) {
-        return sparql_js_1.INSERT.DATA `${quads}`.build();
+        return mod_js_2.INSERT.DATA `${quads}`.build();
     }
     deleteDataQuery(quads) {
-        return (0, sparql_js_1.$) `DELETE DATA { ${quads} }`.toString();
+        return mod_js_2.DELETE.DATA `${quads}`.build();
     }
     updateQuery(entities) {
         const deleteQuads = [];
@@ -155,7 +155,7 @@ class QueryBuilder {
             insertQuads.push(...helper.getInsertQuads());
             whereQuads.push(...helper.getWhereQuads());
         });
-        return (0, sparql_js_1.DELETE) `${deleteQuads}`.INSERT `${insertQuads}`
+        return (0, mod_js_2.DELETE) `${deleteQuads}`.INSERT `${insertQuads}`
             .WHERE `${deleteQuads}`.build();
     }
 }

package/script/library/rdf.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QuadFactory = exports.BindingsFactory = exports.ReadOnlyBindings = exports.TermFactory = exports.quadsToGraph = exports.DataFactory = exports.toRdf = exports.fromRdf = void 0;
+exports.QuadFactory = exports.BindingsFactory = exports.ReadOnlyBindings = exports.TermFactory = exports.quadsToGraph = 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; } });
 const quadsToGraph = (quads) => {
     const graph = new Map();
     for (const quad of quads) {

package/script/library/sparql/escape.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escape = void 0;
+const escapeCharRegEx = /["\\\n\r]/;
+const escapeCharRegExAll = /["\\\n\r]/g;
+const replacer = (char) => {
+    switch (char) {
+        case `"`:
+            return `\\"`;
+        case `\\`:
+            return `\\\\`;
+        case `\n`:
+            return `\\n`;
+        case `\r`:
+            return `\\r`;
+        default:
+            return char; // this should never happen
+    }
+};
+const escape = (value) => {
+    if (escapeCharRegEx.test(value)) {
+        return value.replace(escapeCharRegExAll, replacer);
+    }
+    return value;
+};
+exports.escape = escape;

package/script/library/sparql/mod.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WITH = exports.INSERT = exports.DELETE = exports.SELECT = exports.DESCRIBE = exports.CONSTRUCT = exports.ASK = exports.sparql = void 0;
+var sparql_tag_js_1 = require("./sparql_tag.js");
+Object.defineProperty(exports, "sparql", { enumerable: true, get: function () { return sparql_tag_js_1.sparql; } });
+var sparql_query_builders_js_1 = require("./sparql_query_builders.js");
+Object.defineProperty(exports, "ASK", { enumerable: true, get: function () { return sparql_query_builders_js_1.ASK; } });
+Object.defineProperty(exports, "CONSTRUCT", { enumerable: true, get: function () { return sparql_query_builders_js_1.CONSTRUCT; } });
+Object.defineProperty(exports, "DESCRIBE", { enumerable: true, get: function () { return sparql_query_builders_js_1.DESCRIBE; } });
+Object.defineProperty(exports, "SELECT", { enumerable: true, get: function () { return sparql_query_builders_js_1.SELECT; } });
+var sparql_update_builders_js_1 = require("./sparql_update_builders.js");
+Object.defineProperty(exports, "DELETE", { enumerable: true, get: function () { return sparql_update_builders_js_1.DELETE; } });
+Object.defineProperty(exports, "INSERT", { enumerable: true, get: function () { return sparql_update_builders_js_1.INSERT; } });
+Object.defineProperty(exports, "WITH", { enumerable: true, get: function () { return sparql_update_builders_js_1.WITH; } });

package/script/library/sparql/sparql_query_builders.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DESCRIBE = exports.ASK = exports.CONSTRUCT = exports.SELECT = void 0;
+const sparql_shared_builders_js_1 = require("./sparql_shared_builders.js");
+class SparqlQueryBuilder extends sparql_shared_builders_js_1.SparqlBuilder {
+    OFFSET(number) {
+        return this.number(number, "OFFSET");
+    }
+    LIMIT(number) {
+        return this.number(number, "LIMIT");
+    }
+    ORDER_BY(strings, ...values) {
+        return this.template(strings, values, "ORDER BY");
+    }
+    HAVING(strings, ...values) {
+        return this.template(strings, values, "HAVING", sparql_shared_builders_js_1.parentheses);
+    }
+    GROUP_BY(strings, ...values) {
+        return this.template(strings, values, "GROUP BY");
+    }
+    WHERE(strings, ...values) {
+        return this.template(strings, values, "WHERE", sparql_shared_builders_js_1.braces);
+    }
+    FROM_NAMED(stringOrNamedNode) {
+        return this.namedNode(stringOrNamedNode, "FROM NAMED");
+    }
+    FROM(stringOrNamedNode) {
+        return this.namedNode(stringOrNamedNode, "FROM");
+    }
+    SELECT(strings, ...values) {
+        return this.template(strings, values, "SELECT");
+    }
+    SELECT_DISTINCT(strings, ...values) {
+        return this.template(strings, values, "SELECT DISTINCT");
+    }
+    SELECT_REDUCED(strings, ...values) {
+        return this.template(strings, values, "SELECT REDUCED");
+    }
+    CONSTRUCT(strings, ...values) {
+        return this.template(strings, values, "CONSTRUCT", sparql_shared_builders_js_1.braces);
+    }
+    CONSTRUCT_WHERE(strings, ...values) {
+        return this.template(strings, values, "CONSTRUCT WHERE", sparql_shared_builders_js_1.braces);
+    }
+    ASK(strings, ...values) {
+        return this.template(strings, values, "ASK", sparql_shared_builders_js_1.braces);
+    }
+    ASK_FROM(stringOrNamedNode) {
+        return this.namedNode(stringOrNamedNode, "ASK\nFROM");
+    }
+    ASK_FROM_NAMED(stringOrNamedNode) {
+        return this.namedNode(stringOrNamedNode, "ASK\nFROM NAMED");
+    }
+    ASK_WHERE(strings, ...values) {
+        return this.template(strings, values, "ASK\nWHERE", sparql_shared_builders_js_1.braces);
+    }
+    DESCRIBE(strings, ...values) {
+        return this.template(strings, values, "DESCRIBE");
+    }
+}
+exports.SELECT = Object.assign((strings, ...values) => new SparqlQueryBuilder().SELECT(strings, ...values), {
+    DISTINCT: (strings, ...values) => new SparqlQueryBuilder().SELECT_DISTINCT(strings, ...values),
+    REDUCED: (strings, ...values) => new SparqlQueryBuilder().SELECT_REDUCED(strings, ...values),
+    get ALL() {
+        return new SparqlQueryBuilder().SELECT `*`;
+    },
+});
+exports.CONSTRUCT = Object.assign((strings, ...values) => new SparqlQueryBuilder().CONSTRUCT(strings, ...values), {
+    WHERE: (strings, ...values) => new SparqlQueryBuilder().CONSTRUCT_WHERE(strings, ...values),
+});
+exports.ASK = Object.assign((strings, ...values) => new SparqlQueryBuilder().ASK(strings, ...values), {
+    FROM: (stringOrNamedNode) => new SparqlQueryBuilder().ASK_FROM(stringOrNamedNode),
+    FROM_NAMED: (stringOrNamedNode) => new SparqlQueryBuilder().ASK_FROM_NAMED(stringOrNamedNode),
+    WHERE: (strings, ...values) => new SparqlQueryBuilder().ASK_WHERE(strings, ...values),
+});
+const DESCRIBE = (strings, ...values) => new SparqlQueryBuilder().DESCRIBE(strings, ...values);
+exports.DESCRIBE = DESCRIBE;

package/script/library/sparql/sparql_shared_builders.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SparqlBuilder = exports.parentheses = exports.braces = void 0;
+const rdf_js_1 = require("../rdf.js");
+const sparql_tag_js_1 = require("./sparql_tag.js");
+const braces = (keyword, value) => `${keyword} {\n${value}\n}\n`;
+exports.braces = braces;
+const parentheses = (keyword, value) => `${keyword} (${value})\n`;
+exports.parentheses = parentheses;
+const none = (keyword, value) => `${keyword} ${value}\n`;
+class SparqlBuilder {
+    constructor() {
+        Object.defineProperty(this, "value", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ""
+        });
+        Object.defineProperty(this, "dataFactory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new rdf_js_1.DataFactory()
+        });
+    }
+    build() {
+        return this.value;
+    }
+    sparql(strings, ...values) {
+        return !values || values.length < 1
+            ? (0, sparql_tag_js_1.sparql)(strings)
+            : (0, sparql_tag_js_1.sparql)(strings, ...values);
+    }
+    template(strings, values, keyword, wrap = none) {
+        const inputSparql = this.sparql(strings, ...values);
+        this.value += wrap(keyword, inputSparql);
+        return this;
+    }
+    namedNode(stringOrNamedNode, keyword, wrap = none) {
+        const namedNode = typeof stringOrNamedNode === "string"
+            ? this.dataFactory.namedNode(stringOrNamedNode)
+            : stringOrNamedNode;
+        const inputSparql = this.sparql `${namedNode}`;
+        this.value += wrap(keyword, inputSparql);
+        return this;
+    }
+    number(number, keyword, wrap = none) {
+        this.value += wrap(keyword, number.toString());
+        return this;
+    }
+}
+exports.SparqlBuilder = SparqlBuilder;

package/script/library/sparql/sparql_tag.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sparql = void 0;
+const rdf_js_1 = require("../rdf.js");
+const xsd_js_1 = __importDefault(require("../namespaces/xsd.js"));
+const stringify_js_1 = require("./stringify.js");
+const sparql = (strings, ...values) => {
+    let counter = 0;
+    let result = "";
+    for (const value of values) {
+        result += strings[counter++];
+        result += valueToString(value);
+    }
+    result += strings[counter];
+    return result;
+};
+exports.sparql = sparql;
+const isIterable = (obj) => {
+    return Symbol.iterator in Object(obj);
+};
+const df = new rdf_js_1.DataFactory();
+const valueToString = (value) => {
+    if (typeof value === "undefined" || value === null) {
+        return "";
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number") {
+        const numberDataType = Number.isInteger(value) ? xsd_js_1.default.integer : xsd_js_1.default.decimal;
+        return (0, stringify_js_1.stringify)(df.literal(value.toString(), df.namedNode(numberDataType)));
+    }
+    if (typeof value === "boolean") {
+        return (0, stringify_js_1.stringify)(df.literal(value.toString(), df.namedNode(xsd_js_1.default.boolean)));
+    }
+    if (value instanceof Date) {
+        return (0, stringify_js_1.stringify)(df.literal(value.toISOString(), df.namedNode(xsd_js_1.default.dateTime)));
+    }
+    if (isIterable(value)) {
+        const [first, ...rest] = value;
+        let result = valueToString(first);
+        for (const part of rest) {
+            result += `\n${valueToString(part)}`;
+        }
+        return result;
+    }
+    if (value.termType) {
+        return (0, stringify_js_1.stringify)(value);
+    }
+    throw new Error("Not supported input type detected.");
+};

package/script/library/sparql/sparql_update_builders.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WITH = exports.DELETE = exports.INSERT = void 0;
+const sparql_shared_builders_js_1 = require("./sparql_shared_builders.js");
+class SparqlUpdateBuilder extends sparql_shared_builders_js_1.SparqlBuilder {
+    WHERE(strings, ...values) {
+        return this.template(strings, values, "WHERE", sparql_shared_builders_js_1.braces);
+    }
+    USING_NAMED(stringOrNamedNode) {
+        return this.namedNode(stringOrNamedNode, "USING NAMED");
+    }
+    USING(stringOrNamedNode) {
+        return this.namedNode(stringOrNamedNode, "USING");
+    }
+    INSERT(strings, ...values) {
+        return this.template(strings, values, "INSERT", sparql_shared_builders_js_1.braces);
+    }
+    INSERT_DATA(strings, ...values) {
+        return this.template(strings, values, "INSERT DATA", sparql_shared_builders_js_1.braces);
+    }
+    DELETE(strings, ...values) {
+        return this.template(strings, values, "DELETE", sparql_shared_builders_js_1.braces);
+    }
+    DELETE_DATA(strings, ...values) {
+        return this.template(strings, values, "DELETE DATA", sparql_shared_builders_js_1.braces);
+    }
+    WITH(stringOrNamedNode) {
+        return this.namedNode(stringOrNamedNode, "WITH");
+    }
+}
+exports.INSERT = Object.assign((strings, ...values) => new SparqlUpdateBuilder().INSERT(strings, ...values), {
+    DATA: (strings, ...values) => new SparqlUpdateBuilder().INSERT_DATA(strings, ...values),
+});
+exports.DELETE = Object.assign((strings, ...values) => new SparqlUpdateBuilder().DELETE(strings, ...values), {
+    DATA: (strings, ...values) => new SparqlUpdateBuilder().DELETE_DATA(strings, ...values),
+});
+const WITH = (stringOrNamedNode) => new SparqlUpdateBuilder().WITH(stringOrNamedNode);
+exports.WITH = WITH;

package/script/library/sparql/stringify.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringify = exports.literal = exports.variable = exports.namedNode = exports.blankNode = void 0;
+const rdf_js_1 = require("../rdf.js");
+const xsd_js_1 = __importDefault(require("../namespaces/xsd.js"));
+const escape_js_1 = require("./escape.js");
+const blankNode = (term) => {
+    return `_:${term.value}`;
+};
+exports.blankNode = blankNode;
+const namedNode = (term) => {
+    return `<${term.value}>`;
+};
+exports.namedNode = namedNode;
+const variable = (term) => {
+    return `?${term.value}`;
+};
+exports.variable = variable;
+const literal = (term) => {
+    const datatype = term.datatype.value;
+    if (datatype === xsd_js_1.default.integer || datatype === xsd_js_1.default.boolean ||
+        datatype === xsd_js_1.default.decimal) {
+        return term.value;
+    }
+    const value = `"${(0, escape_js_1.escape)(term.value)}"`;
+    if (term.language) {
+        return `${value}@${term.language}`;
+    }
+    if (datatype !== xsd_js_1.default.string) {
+        return `${value}^^${(0, exports.namedNode)(term.datatype)}`;
+    }
+    return value;
+};
+exports.literal = literal;
+const quad = (term) => {
+    const triple = `${(0, exports.stringify)(term.subject)} ${(0, exports.stringify)(term.predicate)} ${(0, exports.stringify)(term.object)} .`;
+    if (term.graph.equals(rdf_js_1.DefaultGraph.INSTANCE)) {
+        return triple;
+    }
+    return `GRAPH ${(0, exports.stringify)(term.graph)} { ${triple} }`;
+};
+const stringify = (term) => {
+    switch (term.termType) {
+        case "BlankNode":
+            return (0, exports.blankNode)(term);
+        case "NamedNode":
+            return (0, exports.namedNode)(term);
+        case "Variable":
+            return (0, exports.variable)(term);
+        case "Literal":
+            return (0, exports.literal)(term);
+        case "Quad":
+            return quad(term);
+        default:
+            throw new Error("Unknown RDF type found.");
+    }
+};
+exports.stringify = stringify;

package/script/mod.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNamespace = exports.createResource = exports.setDefaultEngine = exports.setDefaultContext = void 0;
+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; } });
-var mod_js_1 = require("./library/resource/mod.js");
+var mod_js_1 = require("./library/lens/mod.js");
+Object.defineProperty(exports, "createLens", { enumerable: true, get: function () { return mod_js_1.createLens; } });
 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; } });

package/script/sparql.js

@@ -14,4 +14,4 @@ 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 });
-__exportStar(require("./library/sparql.js"), exports);
+__exportStar(require("./library/sparql/mod.js"), exports);

package/types/library/{resource/resource.d.ts → lens/lens.d.ts}

@@ -1,8 +1,23 @@
 import type { Context, IQueryEngine, Iri, RDF } from "../rdf.js";
 import { type SchemaInterface, type SchemaInterfaceIdentity, type SchemaPrototype } from "../schema/mod.js";
 import type { Entity } from "./types.js";
-export declare const createResource: <T extends SchemaPrototype>(spec: T, context?: Context, engine?: IQueryEngine) => Resource<T, SchemaInterface<T>>;
-export declare class Resource<S extends SchemaPrototype, I = SchemaInterface<S>> {
+/**
+ * Lens lets you query and update RDF data via data schema using TypeScript native data types.
+ *
+ * https://ldkit.io/docs/components/lens
+ *
+ * @param schema data schema which extends `SchemaPrototype`
+ * @param context optional `Context` - contains LDkit and query engine configuration
+ * @param engine optional Query Engine
+ * @returns Lens instance
+ */
+export declare const createLens: <T extends SchemaPrototype>(schema: T, context?: Context, engine?: IQueryEngine) => Lens<T, SchemaInterface<T>>;
+/**
+ * @deprecated
+ * Use `createLens` instead
+ */
+export declare const createResource: <T extends SchemaPrototype>(schema: T, context?: Context, engine?: IQueryEngine) => Lens<T, SchemaInterface<T>>;
+export declare class Lens<S extends SchemaPrototype, I = SchemaInterface<S>> {
     private readonly schema;
     private readonly context;
     private readonly engine;

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

@@ -0,0 +1 @@
+export { createLens, createResource, type Lens } from "./lens.js";

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

@@ -0,0 +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> ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;

package/types/library/rdf.d.ts

@@ -1,8 +1,8 @@
 import type * as RDF from "rdf-js";
 export type { RDF };
 export { fromRdf, toRdf } from "rdf-literal";
-import { DataFactory } from "rdf-data-factory";
-export { DataFactory };
+import { DataFactory, DefaultGraph } from "rdf-data-factory";
+export { DataFactory, DefaultGraph };
 import type { IDataSource, IQueryContextCommon } from "@comunica/types";
 export declare type LDkitContext = {
     graph?: string;

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

@@ -1,5 +1,5 @@
 import type { SupportedDataTypes } from "./data_types.js";
-import type { SchemaPrototype, PropertyPrototype } from "./schema.js";
+import type { PropertyPrototype, SchemaPrototype } from "./schema.js";
 declare type IsOptional<Property extends PropertyPrototype> = Property extends {
     "@optional": true;
 } ? true : false;
@@ -13,7 +13,7 @@ declare type ValidPropertyDefinition = PropertyPrototype | string;
 declare type ConvertPropertyType<T extends PropertyPrototype> = T extends {
     "@context": SchemaPrototype;
 } ? SchemaInterface<T["@context"]> : T extends {
-    "@type": any;
+    "@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>;

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

@@ -1,3 +1,3 @@
 export type { SchemaInterface, SchemaInterfaceIdentity, SchemaInterfaceType, } from "./interface.js";
-export type { Schema, SchemaPrototype, Property, PropertyPrototype, } from "./schema.js";
+export type { Property, PropertyPrototype, Schema, SchemaPrototype, } from "./schema.js";
 export { expandSchema, getSchemaProperties } from "./utils.js";

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

@@ -0,0 +1 @@
+export declare const escape: (value: string) => string;

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

@@ -0,0 +1,3 @@
+export { sparql, type SparqlValue } from "./sparql_tag.js";
+export { ASK, CONSTRUCT, DESCRIBE, SELECT } from "./sparql_query_builders.js";
+export { DELETE, INSERT, WITH } from "./sparql_update_builders.js";

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

@@ -0,0 +1,39 @@
+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>;
+declare class SparqlQueryBuilder extends SparqlBuilder {
+    OFFSET(number: number): Builders<"build">;
+    LIMIT(number: number): Builders<"build" | "OFFSET">;
+    ORDER_BY(strings: TemplateStringsArray, ...values: SparqlValue[]): Builders<"build" | "LIMIT">;
+    HAVING(strings: TemplateStringsArray, ...values: SparqlValue[]): Builders<"build" | "ORDER_BY" | "LIMIT">;
+    GROUP_BY(strings: TemplateStringsArray, ...values: SparqlValue[]): Builders<"build" | "HAVING" | "ORDER_BY" | "LIMIT">;
+    WHERE(strings: TemplateStringsArray, ...values: SparqlValue[]): Builders<"build" | "GROUP_BY" | "ORDER_BY" | "LIMIT">;
+    FROM_NAMED(stringOrNamedNode: string | RDF.NamedNode<string>): Builders<"FROM_NAMED" | "WHERE">;
+    FROM(stringOrNamedNode: string | RDF.NamedNode<string>): Builders<"FROM" | "FROM_NAMED" | "WHERE">;
+    SELECT(strings: TemplateStringsArray, ...values: SparqlValue[]): Builders<"FROM" | "FROM_NAMED" | "WHERE">;
+    SELECT_DISTINCT(strings: TemplateStringsArray, ...values: SparqlValue[]): Builders<"FROM" | "FROM_NAMED" | "WHERE">;
+    SELECT_REDUCED(strings: TemplateStringsArray, ...values: SparqlValue[]): Builders<"FROM" | "FROM_NAMED" | "WHERE">;
+    CONSTRUCT(strings: TemplateStringsArray, ...values: SparqlValue[]): Builders<"WHERE">;
+    CONSTRUCT_WHERE(strings: TemplateStringsArray, ...values: SparqlValue[]): Builders<"build" | "GROUP_BY" | "ORDER_BY" | "LIMIT">;
+    ASK(strings: TemplateStringsArray, ...values: SparqlValue[]): Builders<"build">;
+    ASK_FROM(stringOrNamedNode: string | RDF.NamedNode<string>): Builders<"FROM" | "FROM_NAMED" | "WHERE">;
+    ASK_FROM_NAMED(stringOrNamedNode: string | RDF.NamedNode<string>): Builders<"FROM_NAMED" | "WHERE">;
+    ASK_WHERE(strings: TemplateStringsArray, ...values: SparqlValue[]): Builders<"build" | "GROUP_BY" | "ORDER_BY" | "LIMIT">;
+    DESCRIBE(strings: TemplateStringsArray, ...values: SparqlValue[]): Builders<"build" | "FROM" | "FROM_NAMED" | "WHERE">;
+}
+export declare const SELECT: ((strings: TemplateStringsArray, ...values: SparqlValue[]) => Builders<"WHERE" | "FROM_NAMED" | "FROM">) & {
+    DISTINCT: (strings: TemplateStringsArray, ...values: SparqlValue[]) => Builders<"WHERE" | "FROM_NAMED" | "FROM">;
+    REDUCED: (strings: TemplateStringsArray, ...values: SparqlValue[]) => Builders<"WHERE" | "FROM_NAMED" | "FROM">;
+    readonly ALL: Builders<"WHERE" | "FROM_NAMED" | "FROM">;
+};
+export declare const CONSTRUCT: ((strings: TemplateStringsArray, ...values: SparqlValue[]) => Builders<"WHERE">) & {
+    WHERE: (strings: TemplateStringsArray, ...values: SparqlValue[]) => Builders<"LIMIT" | "ORDER_BY" | "GROUP_BY" | "build">;
+};
+export declare const ASK: ((strings: TemplateStringsArray, ...values: SparqlValue[]) => Builders<"build">) & {
+    FROM: (stringOrNamedNode: string | RDF.NamedNode<string>) => Builders<"WHERE" | "FROM_NAMED" | "FROM">;
+    FROM_NAMED: (stringOrNamedNode: string | RDF.NamedNode<string>) => Builders<"WHERE" | "FROM_NAMED">;
+    WHERE: (strings: TemplateStringsArray, ...values: SparqlValue[]) => Builders<"LIMIT" | "ORDER_BY" | "GROUP_BY" | "build">;
+};
+export declare const DESCRIBE: (strings: TemplateStringsArray, ...values: SparqlValue[]) => Builders<"WHERE" | "FROM_NAMED" | "FROM" | "build">;
+export {};

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

@@ -0,0 +1,15 @@
+import { DataFactory, RDF } from "../rdf.js";
+import { type SparqlValue } from "./sparql_tag.js";
+declare type Wrap = (keyword: string, value: string) => string;
+export declare const braces: Wrap;
+export declare const parentheses: Wrap;
+export declare abstract class SparqlBuilder {
+    protected value: string;
+    protected dataFactory: DataFactory<RDF.Quad>;
+    build(): string;
+    private sparql;
+    protected template(strings: TemplateStringsArray, values: SparqlValue[], keyword: string, wrap?: Wrap): this;
+    protected namedNode(stringOrNamedNode: string | RDF.NamedNode<string>, keyword: string, wrap?: Wrap): this;
+    protected number(number: number, keyword: string, wrap?: Wrap): this;
+}
+export {};