ldkit 0.8.0 → 2.0.0

package/script/namespaces/owl.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.owl = void 0;
+const namespace_js_1 = require("../library/namespace.js");
+/**
+ * OWL Web Ontology Language
+ *
+ * `@owl: <http://www.w3.org/2002/07/owl#>`,
+ */
+exports.owl = (0, namespace_js_1.createNamespace)({
+    iri: "http://www.w3.org/2002/07/owl#",
+    prefix: "owl:",
+    terms: [
+        "owl:AllDifferent",
+        "owl:AllDisjointClasses",
+        "owl:AllDisjointProperties",
+        "owl:allValuesFrom",
+        "owl:annotatedProperty",
+        "owl:annotatedSource",
+        "owl:annotatedTarget",
+        "owl:Annotation",
+        "owl:AnnotationProperty",
+        "owl:assertionProperty",
+        "owl:AsymmetricProperty",
+        "owl:Axiom",
+        "owl:backwardCompatibleWith",
+        "owl:bottomDataProperty",
+        "owl:bottomObjectProperty",
+        "owl:cardinality",
+        "owl:Class",
+        "owl:complementOf",
+        "owl:DataRange",
+        "owl:datatypeComplementOf",
+        "owl:DatatypeProperty",
+        "owl:deprecated",
+        "owl:DeprecatedClass",
+        "owl:DeprecatedProperty",
+        "owl:differentFrom",
+        "owl:disjointUnionOf",
+        "owl:disjointWith",
+        "owl:distinctMembers",
+        "owl:equivalentClass",
+        "owl:equivalentProperty",
+        "owl:FunctionalProperty",
+        "owl:hasKey",
+        "owl:hasSelf",
+        "owl:hasValue",
+        "owl:imports",
+        "owl:incompatibleWith",
+        "owl:intersectionOf",
+        "owl:InverseFunctionalProperty",
+        "owl:inverseOf",
+        "owl:IrreflexiveProperty",
+        "owl:maxCardinality",
+        "owl:maxQualifiedCardinality",
+        "owl:members",
+        "owl:minCardinality",
+        "owl:minQualifiedCardinality",
+        "owl:NamedIndividual",
+        "owl:NegativePropertyAssertion",
+        "owl:Nothing",
+        "owl:ObjectProperty",
+        "owl:onClass",
+        "owl:onDataRange",
+        "owl:onDatatype",
+        "owl:oneOf",
+        "owl:onProperty",
+        "owl:onProperties",
+        "owl:Ontology",
+        "owl:OntologyProperty",
+        "owl:priorVersion",
+        "owl:propertyChainAxiom",
+        "owl:propertyDisjointWith",
+        "owl:qualifiedCardinality",
+        "owl:rational",
+        "owl:real",
+        "owl:ReflexiveProperty",
+        "owl:Restriction",
+        "owl:sameAs",
+        "owl:someValuesFrom",
+        "owl:sourceIndividual",
+        "owl:SymmetricProperty",
+        "owl:targetIndividual",
+        "owl:targetValue",
+        "owl:Thing",
+        "owl:topDataProperty",
+        "owl:topObjectProperty",
+        "owl:TransitiveProperty",
+        "owl:unionOf",
+        "owl:versionInfo",
+        "owl:versionIRI",
+        "owl:withRestrictions",
+    ],
+});

package/{esm/library → script}/namespaces/rdf.js

@@ -1,5 +1,13 @@
-import { createNamespace } from "./namespace.js";
-export default createNamespace({
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rdf = void 0;
+const namespace_js_1 = require("../library/namespace.js");
+/**
+ * The RDF Concepts Vocabulary (RDF)
+ *
+ * `@rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>`,
+ */
+exports.rdf = (0, namespace_js_1.createNamespace)({
     iri: "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
     prefix: "rdf:",
     terms: [

package/{esm/library → script}/namespaces/rdfs.js

@@ -1,5 +1,13 @@
-import { createNamespace } from "./namespace.js";
-export default createNamespace({
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rdfs = void 0;
+const namespace_js_1 = require("../library/namespace.js");
+/**
+ * The RDF Schema vocabulary (RDFS)
+ *
+ * `@rdfs: <http://www.w3.org/2000/01/rdf-schema#>`,
+ */
+exports.rdfs = (0, namespace_js_1.createNamespace)({
     iri: "http://www.w3.org/2000/01/rdf-schema#",
     prefix: "rdfs:",
     terms: [

package/script/{library/namespaces → namespaces}/schema.js

@@ -1,7 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const namespace_js_1 = require("./namespace.js");
-exports.default = (0, namespace_js_1.createNamespace)({
+exports.schema = void 0;
+const namespace_js_1 = require("../library/namespace.js");
+/**
+ * Schema.org vocabulary
+ *
+ * `@schema: <http://schema.org/>`,
+ */
+exports.schema = (0, namespace_js_1.createNamespace)({
     iri: "http://schema.org/",
     prefix: "schema:",
     terms: [

package/script/{library/namespaces → namespaces}/sioc.js

@@ -1,7 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const namespace_js_1 = require("./namespace.js");
-exports.default = (0, namespace_js_1.createNamespace)({
+exports.sioc = void 0;
+const namespace_js_1 = require("../library/namespace.js");
+/**
+ * SIOC Core Ontology Namespace
+ *
+ * `@sioc: <http://rdfs.org/sioc/ns#>`,
+ */
+exports.sioc = (0, namespace_js_1.createNamespace)({
     iri: "http://rdfs.org/sioc/ns#",
     prefix: "sioc:",
     terms: [

package/{esm/library → script}/namespaces/skos.js

@@ -1,5 +1,13 @@
-import { createNamespace } from "./namespace.js";
-export default createNamespace({
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.skos = void 0;
+const namespace_js_1 = require("../library/namespace.js");
+/**
+ * SKOS - Simple Knowledge Organization System
+ *
+ * `@skos: <http://www.w3.org/2004/02/skos/core#>`,
+ */
+exports.skos = (0, namespace_js_1.createNamespace)({
     iri: "http://www.w3.org/2004/02/skos/core#",
     prefix: "skos:",
     terms: [

package/{esm/library → script}/namespaces/xsd.js

@@ -1,5 +1,13 @@
-import { createNamespace } from "./namespace.js";
-export default createNamespace({
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xsd = void 0;
+const namespace_js_1 = require("../library/namespace.js");
+/**
+ * XML Schema Definition Language (XSD)
+ *
+ * `@xsd: <http://www.w3.org/2001/XMLSchema#>`,
+ */
+exports.xsd = (0, namespace_js_1.createNamespace)({
     iri: "http://www.w3.org/2001/XMLSchema#",
     prefix: "xsd:",
     terms: [

package/script/namespaces.js

@@ -14,4 +14,47 @@ 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/namespaces/mod.js"), exports);
+exports.xsd = exports.skos = exports.sioc = exports.schema = exports.rdfs = exports.rdf = exports.owl = exports.ldkit = exports.gr = exports.foaf = exports.dcterms = exports.dc = exports.dbo = void 0;
+/**
+ * Popular namespaces used in Linked Data, fully compatible with LDkit,
+ * offering autocompletion and type checking in IDE.
+ *
+ * Create your own namespaces using {@link createNamespace} helper.
+ *
+ * @example
+ * ```typescript
+ * import { rdf, schema } from "ldkit/namespaces";
+ *
+ * console.log(rdf.type); // "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"
+ * console.log(schema.Person); // "http://schema.org/Person"
+ * ```
+ *
+ * @module
+ */
+var dbo_js_1 = require("./namespaces/dbo.js");
+Object.defineProperty(exports, "dbo", { enumerable: true, get: function () { return dbo_js_1.dbo; } });
+var dc_js_1 = require("./namespaces/dc.js");
+Object.defineProperty(exports, "dc", { enumerable: true, get: function () { return dc_js_1.dc; } });
+var dcterms_js_1 = require("./namespaces/dcterms.js");
+Object.defineProperty(exports, "dcterms", { enumerable: true, get: function () { return dcterms_js_1.dcterms; } });
+var foaf_js_1 = require("./namespaces/foaf.js");
+Object.defineProperty(exports, "foaf", { enumerable: true, get: function () { return foaf_js_1.foaf; } });
+var gr_js_1 = require("./namespaces/gr.js");
+Object.defineProperty(exports, "gr", { enumerable: true, get: function () { return gr_js_1.gr; } });
+var ldkit_js_1 = require("./namespaces/ldkit.js");
+Object.defineProperty(exports, "ldkit", { enumerable: true, get: function () { return ldkit_js_1.ldkit; } });
+var owl_js_1 = require("./namespaces/owl.js");
+Object.defineProperty(exports, "owl", { enumerable: true, get: function () { return owl_js_1.owl; } });
+var rdf_js_1 = require("./namespaces/rdf.js");
+Object.defineProperty(exports, "rdf", { enumerable: true, get: function () { return rdf_js_1.rdf; } });
+var rdfs_js_1 = require("./namespaces/rdfs.js");
+Object.defineProperty(exports, "rdfs", { enumerable: true, get: function () { return rdfs_js_1.rdfs; } });
+var schema_js_1 = require("./namespaces/schema.js");
+Object.defineProperty(exports, "schema", { enumerable: true, get: function () { return schema_js_1.schema; } });
+var sioc_js_1 = require("./namespaces/sioc.js");
+Object.defineProperty(exports, "sioc", { enumerable: true, get: function () { return sioc_js_1.sioc; } });
+var skos_js_1 = require("./namespaces/skos.js");
+Object.defineProperty(exports, "skos", { enumerable: true, get: function () { return skos_js_1.skos; } });
+var xsd_js_1 = require("./namespaces/xsd.js");
+Object.defineProperty(exports, "xsd", { enumerable: true, get: function () { return xsd_js_1.xsd; } });
+__exportStar(require("./library/namespace.js"), exports);

package/script/rdf.js

@@ -1,17 +1,22 @@
 "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 __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/rdf.js"), exports);
+exports.toRdf = exports.N3 = exports.fromRdf = exports.DefaultGraph = exports.DataFactory = void 0;
+/**
+ * RDF utilities
+ *
+ * This module contains a re-export of external RDF libraries that are used
+ * in LDkit and may be used in tandem with LDkit in Linked Data applications as well.
+ *
+ * Included packages:
+ * - [@rdfjs/types](https://github.com/rdfjs/types) [RDF/JS](https://rdf.js.org/) authoritative TypeScript typings
+ * - [n3](https://rdf.js.org/N3.js/) RDF parser and serializer
+ * - [rdf-data-factory](https://github.com/rubensworks/rdf-data-factory.js) A TypeScript/JavaScript implementation of the RDF/JS data factory
+ * - [rdf-literal](https://github.com/rubensworks/rdf-literal.js) Translates between RDF literals and JavaScript primitives
+ * @module
+ */
+var rdf_js_1 = require("./library/rdf.js");
+Object.defineProperty(exports, "DataFactory", { enumerable: true, get: function () { return rdf_js_1.DataFactory; } });
+Object.defineProperty(exports, "DefaultGraph", { enumerable: true, get: function () { return rdf_js_1.DefaultGraph; } });
+Object.defineProperty(exports, "fromRdf", { enumerable: true, get: function () { return rdf_js_1.fromRdf; } });
+Object.defineProperty(exports, "N3", { enumerable: true, get: function () { return rdf_js_1.N3; } });
+Object.defineProperty(exports, "toRdf", { enumerable: true, get: function () { return rdf_js_1.toRdf; } });

package/script/sparql.js

@@ -14,4 +14,17 @@ 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 });
+/**
+ * SPARQL builders that provide a fluent interface for building SPARQL queries
+ *
+ * @example
+ * ```typescript
+ * import { SELECT } from "ldkit/sparql";
+ *
+ * const query = SELECT`?s ?p ?o`.WHERE`?s ?p ?o`.LIMIT(10).build();
+ * console.log(query); // SELECT ?s ?p ?o WHERE { ?s ?p ?o } LIMIT 10;
+ * ```
+ *
+ * @module
+ */
 __exportStar(require("./library/sparql/mod.js"), exports);

package/types/library/decoder.d.ts

@@ -1,5 +1,6 @@
-import { type Context, Graph } from "./rdf.js";
-import type { Schema } from "./schema/mod.js";
+import type { Options } from "./options.js";
+import { Graph } from "./rdf.js";
+import type { ExpandedSchema } from "./schema/mod.js";
+export declare const decode: (graph: Graph, schema: ExpandedSchema, options: Options) => DecodedNode[];
 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,7 @@
-import { type Context, type RDF } from "./rdf.js";
-import type { Schema } from "./schema/mod.js";
+import type { Options } from "./options.js";
+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: Schema, context: Context, variableInitCounter?: number) => RDF.Quad[];
+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) => any;
 export {};

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

@@ -1,2 +1,2 @@
-export { QueryEngine } from "./query_engine.js";
-export { QueryEngineProxy } from "./query_engine_proxy.js";
+export * from "./query_engine.js";
+export * from "./types.js";

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

@@ -1,15 +1,57 @@
-import { type Context, type IQueryEngine, type RDF, RDFJSON } from "../rdf.js";
-type QueryResponseFormat = {
-    "application/sparql-results+json": RDFJSON.SparqlResultsJsonFormat;
-    "application/rdf+json": RDFJSON.RdfJsonFormat;
-};
+import { type RDF } from "../rdf.js";
+import { type IQueryEngine, type QueryContext } from "./types.js";
+import { type ResolverType } from "./query_resolvers.js";
+/**
+ * A query engine that can query a SPARQL endpoint.
+ *
+ * Implements {@link IQueryEngine} interface.
+ *
+ * This engine is used by default if no other engine is configured.
+ * See {@link Options} for more details.
+ *
+ * If you need to query other data sources, or multiple SPARQL endpoints,
+ * you can use [Comunica](https://comunica.dev) instead, extend this engine,
+ * or implement your own.
+ */
 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>;
-    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>;
+    protected getSparqlEndpoint(context?: QueryContext): string;
+    protected getFetch(context?: QueryContext): typeof fetch;
+    protected query(query: string, 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>;
+        quads: RDF.ResultStream<RDF.Quad>;
+    }[T]>;
+    /**
+     * Executes a SPARQL SELECT query and returns a stream of bindings.
+     *
+     * @param query SPARQL query string
+     * @param context Engine context
+     * @returns Stream of bindings
+     */
+    queryBindings(query: string, context?: QueryContext): Promise<RDF.ResultStream<RDF.Bindings>>;
+    /**
+     * Executes a SPARQL ASK query and returns a boolean result.
+     *
+     * @param query SPARQL query string
+     * @param context Engine context
+     * @returns Boolean result
+     */
+    queryBoolean(query: string, context?: QueryContext): Promise<boolean>;
+    /**
+     * Executes a SPARQL CONSTRUCT query and returns a stream of quads.
+     *
+     * @param query SPARQL query string
+     * @param context Engine context
+     * @returns Stream of quads
+     */
+    queryQuads(query: string, context?: QueryContext): Promise<RDF.ResultStream<RDF.Quad>>;
+    /**
+     * Executes a SPARQL UPDATE query and returns nothing.
+     *
+     * @param query SPARQL query string
+     * @param context Engine context
+     * @returns Nothing
+     */
+    queryVoid(query: string, context?: QueryContext): Promise<void>;
 }
-export {};

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

@@ -1,8 +1,9 @@
-import { type Context, IQueryEngine, type RDF } from "../rdf.js";
+import { type RDF } from "../rdf.js";
+import type { IQueryEngine, QueryContext } from "./types.js";
 export declare class QueryEngineProxy {
-    private readonly context;
     private readonly engine;
-    constructor(context?: Context, engine?: IQueryEngine);
+    private readonly context;
+    constructor(engine: IQueryEngine, context: QueryContext);
     queryBoolean(query: string): Promise<boolean>;
     queryBindings(query: string): Promise<RDF.Bindings[]>;
     queryGraph(query: string): Promise<import("../rdf.js").Graph>;

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/engine/types.d.ts

@@ -0,0 +1,23 @@
+import type { IDataSource, IQueryContextCommon } from "@comunica/types";
+import { RDF } from "../rdf.js";
+/**
+ * A set of context entries that can be passed to a query engine,
+ * such as data sources, fetch configuration, etc.
+ *
+ * @example
+ * ```typescript
+ * import { QueryContext, QueryEngine } from "ldkit";
+ *
+ * const context: QueryContext = {
+ *   sources: ["https://dbpedia.org/sparql"],
+ * };
+ *
+ * const engine = new QueryEngine();
+ * await engine.queryBoolean("ASK { ?s ?p ?o }", context);
+ * ```
+ */
+export type QueryContext = RDF.QueryStringContext & RDF.QuerySourceContext<IDataSource> & IQueryContextCommon;
+/**
+ * Interface of a query engine compatible with LDkit
+ */
+export type IQueryEngine = RDF.StringSparqlQueryable<RDF.SparqlResultSupport, QueryContext>;