ldkit 0.4.2 → 0.5.1

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

@@ -1,5 +1,9 @@
 declare const _default: {
     object: "rdf:object";
+    subject: "rdf:subject";
+    predicate: "rdf:predicate";
+    value: "rdf:value";
+    type: "rdf:type";
     Alt: "rdf:Alt";
     Bag: "rdf:Bag";
     CompoundLiteral: "rdf:CompoundLiteral";
@@ -16,11 +20,7 @@ declare const _default: {
     langString: "rdf:langString";
     language: "rdf:language";
     nil: "rdf:nil";
-    predicate: "rdf:predicate";
     rest: "rdf:rest";
-    subject: "rdf:subject";
-    type: "rdf:type";
-    value: "rdf:value";
 } & {
     $prefix: "rdf:";
     $iri: "http://www.w3.org/1999/02/22-rdf-syntax-ns#";

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

@@ -0,0 +1,21 @@
+declare const _default: {
+    Literal: "rdfs:Literal";
+    Class: "rdfs:Class";
+    Container: "rdfs:Container";
+    ContainerMembershipProperty: "rdfs:ContainerMembershipProperty";
+    Datatype: "rdfs:Datatype";
+    Resource: "rdfs:Resource";
+    comment: "rdfs:comment";
+    domain: "rdfs:domain";
+    isDefinedBy: "rdfs:isDefinedBy";
+    label: "rdfs:label";
+    member: "rdfs:member";
+    range: "rdfs:range";
+    seeAlso: "rdfs:seeAlso";
+    subClassOf: "rdfs:subClassOf";
+    subPropertyOf: "rdfs:subPropertyOf";
+} & {
+    $prefix: "rdfs:";
+    $iri: "http://www.w3.org/2000/01/rdf-schema#";
+};
+export default _default;

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

@@ -1,9 +1,14 @@
 declare const _default: {
     object: "schema:object";
+    value: "schema:value";
+    query: "schema:query";
+    error: "schema:error";
     map: "schema:map";
     Property: "schema:Property";
     language: "schema:language";
-    value: "schema:value";
+    Class: "schema:Class";
+    comment: "schema:comment";
+    member: "schema:member";
     abstract: "schema:abstract";
     audience: "schema:audience";
     contributor: "schema:contributor";
@@ -200,7 +205,6 @@ declare const _default: {
     CivicStructure: "schema:CivicStructure";
     Claim: "schema:Claim";
     ClaimReview: "schema:ClaimReview";
-    Class: "schema:Class";
     CleaningFee: "schema:CleaningFee";
     Clinician: "schema:Clinician";
     Clip: "schema:Clip";
@@ -1563,7 +1567,6 @@ declare const _default: {
     collectionSize: "schema:collectionSize";
     color: "schema:color";
     colorist: "schema:colorist";
-    comment: "schema:comment";
     commentCount: "schema:commentCount";
     commentText: "schema:commentText";
     commentTime: "schema:commentTime";
@@ -1766,7 +1769,6 @@ declare const _default: {
     episodeNumber: "schema:episodeNumber";
     episodes: "schema:episodes";
     equal: "schema:equal";
-    error: "schema:error";
     estimatedCost: "schema:estimatedCost";
     estimatedFlightDuration: "schema:estimatedFlightDuration";
     estimatedSalary: "schema:estimatedSalary";
@@ -2093,7 +2095,6 @@ declare const _default: {
     medicalSpecialty: "schema:medicalSpecialty";
     medicineSystem: "schema:medicineSystem";
     meetsEmissionStandard: "schema:meetsEmissionStandard";
-    member: "schema:member";
     memberOf: "schema:memberOf";
     members: "schema:members";
     membershipNumber: "schema:membershipNumber";
@@ -2327,7 +2328,6 @@ declare const _default: {
     purchaseDate: "schema:purchaseDate";
     qualifications: "schema:qualifications";
     quarantineGuidelines: "schema:quarantineGuidelines";
-    query: "schema:query";
     quest: "schema:quest";
     question: "schema:question";
     rangeIncludes: "schema:rangeIncludes";

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

@@ -1,6 +1,6 @@
 declare const _default: {
-    Collection: "skos:Collection";
     member: "skos:member";
+    Collection: "skos:Collection";
     Concept: "skos:Concept";
     ConceptScheme: "skos:ConceptScheme";
     OrderedCollection: "skos:OrderedCollection";

package/types/library/rdf.d.ts

@@ -1,14 +1,53 @@
-import type { NamedNode, BlankNode, Literal, Variable, Quad, Term, Bindings } from "rdf-js";
-export type { NamedNode, BlankNode, Literal, Variable, Quad, Term, Bindings };
+import type { Bindings, BlankNode, Literal, NamedNode, Quad, Term, Variable } from "rdf-js";
+export type { Bindings, BlankNode, Literal, NamedNode, Quad, Term, Variable };
+import type * as RDF from "rdf-js";
+export type { RDF };
 export { fromRdf, toRdf } from "rdf-literal";
-import * as DataFactory from "rdf-data-factory";
 export { DataFactory } from "rdf-data-factory";
+import { BindingsFactory as ComunicaBindingsFactory } from "@comunica/bindings-factory";
+import type { IDataSource, IQueryContextCommon } from "@comunica/types";
+export declare 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, Term[]>;
 export declare type Graph = Map<Iri, Node>;
-export declare const namedNode: <Iri_1 extends string = string>(value: Iri_1) => NamedNode<Iri_1>;
-export declare const blankNode: (value: string) => DataFactory.BlankNode;
-export declare const literal: (value: string, languageOrDatatype?: string | NamedNode) => Literal;
-export declare const quad: (subject: Quad["subject"], predicate: Quad["predicate"], object: Quad["object"], graph?: Quad["graph"]) => Quad;
-export declare const variable: (value: string) => Variable;
 export declare const quadsToGraph: (quads: Quad[]) => Graph;
+export declare namespace RDFJSON {
+    type Term = {
+        type: "uri" | "literal" | "bnode";
+        value: string;
+        "xml:lang"?: string;
+        datatype?: string;
+    };
+    type Bindings = Record<string, Term>;
+    interface TermFactory {
+        fromJson(jsonTerm: Term): RDF.Term;
+    }
+    interface BindingsFactory {
+        fromJson(jsonBindings: Bindings): RDF.Bindings;
+    }
+    interface QuadFactory {
+        fromJson(jsonBindings: Bindings): RDF.Quad;
+    }
+}
+export declare class TermFactory implements RDFJSON.TermFactory {
+    protected readonly dataFactory: RDF.DataFactory;
+    constructor(dataFactory?: RDF.DataFactory);
+    fromJson(jsonTerm: RDFJSON.Term): BlankNode | Literal | NamedNode<string>;
+}
+export declare class BindingsFactory extends ComunicaBindingsFactory implements RDFJSON.BindingsFactory {
+    protected readonly localDataFactory: RDF.DataFactory;
+    protected readonly termFactory: RDFJSON.TermFactory;
+    constructor(dataFactory?: RDF.DataFactory, termFactory?: RDFJSON.TermFactory);
+    fromJson(jsonBindings: RDFJSON.Bindings): Bindings;
+}
+export declare class QuadFactory implements RDFJSON.QuadFactory {
+    protected readonly dataFactory: RDF.DataFactory;
+    protected readonly bindingsFactory: RDFJSON.BindingsFactory;
+    constructor(dataFactory?: RDF.DataFactory, bindingsFactory?: RDFJSON.BindingsFactory);
+    fromJson(jsonBindings: RDFJSON.Bindings): Quad;
+}

package/types/library/resource/query_builder.d.ts

@@ -1,22 +1,22 @@
 import type { Schema } from "../schema/mod.js";
-import { Quad, Iri } from "../rdf.js";
-import type { Context } from "../context.js";
+import { type Context, type Iri, type RDF } from "../rdf.js";
 import type { Entity } from "./types.js";
 export declare class QueryBuilder {
     private readonly schema;
     private readonly schemaProperties;
     private readonly context;
+    private readonly df;
     constructor(schema: Schema, context: Context);
     private getResourceSignature;
     private getTypesSignature;
     private entitiesToQuads;
     private getShape;
     countQuery(): string;
-    getQuery(where?: string | Quad[], limit?: number): string;
+    getQuery(where?: string | RDF.Quad[], limit?: number): string;
     getByIrisQuery(iris: Iri[]): string;
     insertQuery(entities: Entity[]): string;
-    insertDataQuery(quads: Quad[]): string;
+    insertDataQuery(quads: RDF.Quad[]): string;
     deleteQuery: (iris: Iri[]) => string;
-    deleteDataQuery(quads: Quad[]): string;
+    deleteDataQuery(quads: RDF.Quad[]): string;
     updateQuery(entities: Entity[]): string;
 }

package/types/library/resource/query_helper.d.ts

@@ -1,6 +1,5 @@
-import type { Context } from "../context.js";
+import type { Context, RDF } from "../rdf.js";
 import type { Schema } from "../schema/mod.js";
-import type { Quad } from "../rdf.js";
 import type { Entity } from "./types.js";
 export declare class QueryHelper {
     private readonly entity;
@@ -10,11 +9,11 @@ export declare class QueryHelper {
     private quads?;
     private variableQuads?;
     constructor(entity: Entity, schema: Schema, context: Context, variableInitCounter?: number);
-    getQuads(): Quad[];
-    getVariableQuads(): Quad[];
-    getDeleteQuads(): Quad[];
-    getInsertQuads(): Quad[];
-    getWhereQuads(): Quad[];
+    getQuads(): RDF.Quad[];
+    getVariableQuads(): RDF.Quad[];
+    getDeleteQuads(): RDF.Quad[];
+    getInsertQuads(): RDF.Quad[];
+    getWhereQuads(): RDF.Quad[];
     private getEntityWithReplacedVariables;
     private replaceVariables;
 }

package/types/library/resource/resource.d.ts

@@ -1,24 +1,24 @@
-import type { Iri, Quad } from "../rdf.js";
-import { type Context } from "../context.js";
-import { type SchemaPrototype, type SchemaInterface, type SchemaInterfaceIdentity } from "../schema/mod.js";
+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) => Resource<T, SchemaInterface<T>>;
+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>> {
     private readonly schema;
     private readonly context;
+    private readonly engine;
     private readonly queryBuilder;
     private readonly $trigger;
-    constructor(schema: S, context?: Context);
+    constructor(schema: S, context?: Context, engine?: IQueryEngine);
     private decode;
     count(): import("rxjs/internal/Observable").Observable<number>;
     query(sparqlConstructQuery: string): import("rxjs/internal/Observable").Observable<I[]>;
-    find(where?: string | Quad[], limit?: number): import("rxjs/internal/Observable").Observable<I[]>;
+    find(where?: string | RDF.Quad[], limit?: number): import("rxjs/internal/Observable").Observable<I[]>;
     findByIri(iri: Iri): import("rxjs/internal/Observable").Observable<I | undefined>;
     findByIris(iris: Iri[]): import("rxjs/internal/Observable").Observable<I[]>;
     private updateQuery;
     insert(...entities: Entity<I>[]): import("rxjs/internal/Observable").Observable<void>;
-    insertData(...quads: Quad[]): import("rxjs/internal/Observable").Observable<void>;
+    insertData(...quads: RDF.Quad[]): import("rxjs/internal/Observable").Observable<void>;
     update(...entities: Entity<I>[]): import("rxjs/internal/Observable").Observable<void>;
     delete(...identities: SchemaInterfaceIdentity[] | Iri[]): import("rxjs/internal/Observable").Observable<void>;
-    deleteData(...quads: Quad[]): import("rxjs/internal/Observable").Observable<void>;
+    deleteData(...quads: RDF.Quad[]): import("rxjs/internal/Observable").Observable<void>;
 }

package/types/library/rxjs.d.ts

@@ -1,2 +1,2 @@
-export { type Observable, from, BehaviorSubject, } from "rxjs";
-export { map, switchMap, tap, share, } from "rxjs/operators";
+export { BehaviorSubject, firstValueFrom, from, lastValueFrom, type Observable, of, } from "rxjs";
+export { map, share, switchMap, tap, } from "rxjs/operators";

package/types/mod.d.ts

@@ -1,4 +1,5 @@
+export { type Context, type IQueryEngine } from "./library/rdf.js";
+export { setDefaultContext, setDefaultEngine } from "./library/global.js";
 export { type SchemaInterface } from "./library/schema/mod.js";
 export { createResource, type Resource } from "./library/resource/mod.js";
 export { createNamespace } from "./library/namespaces/namespace.js";
-export { type Context, createContext, createDefaultContext, } from "./library/context.js";

package/esm/library/context.js

@@ -1,13 +0,0 @@
-let defaultContext = undefined;
-export const createContext = (context) => {
-    return context;
-};
-export const createDefaultContext = (context) => {
-    defaultContext = createContext(context);
-};
-export const resolveContext = (context) => {
-    if (!context && !defaultContext) {
-        throw new Error("No context found. Please create a default context or pass one to createResource function");
-    }
-    return context || defaultContext;
-};

package/esm/library/engine.js

@@ -1,9 +0,0 @@
-import { QueryEngine } from "@comunica/query-sparql";
-import { from, map, switchMap } from "./rxjs.js";
-import { resolveContext } from "./context.js";
-import { quadsToGraph } from "./rdf.js";
-const engine = new QueryEngine();
-export const booleanQuery = (query, context) => from(engine.queryBoolean(query, resolveContext(context)));
-export const bindingsQuery = (query, context) => from(engine.queryBindings(query, resolveContext(context))).pipe(switchMap((stream) => from(stream.toArray())));
-export const quadsQuery = (query, context) => from(engine.queryQuads(query, resolveContext(context))).pipe(switchMap((stream) => from(stream.toArray())), map((quads) => quadsToGraph(quads)));
-export const updateQuery = (query, context) => from(engine.queryVoid(query, resolveContext(context)));

package/script/library/context.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveContext = exports.createDefaultContext = exports.createContext = void 0;
-let defaultContext = undefined;
-const createContext = (context) => {
-    return context;
-};
-exports.createContext = createContext;
-const createDefaultContext = (context) => {
-    defaultContext = (0, exports.createContext)(context);
-};
-exports.createDefaultContext = createDefaultContext;
-const resolveContext = (context) => {
-    if (!context && !defaultContext) {
-        throw new Error("No context found. Please create a default context or pass one to createResource function");
-    }
-    return context || defaultContext;
-};
-exports.resolveContext = resolveContext;

package/script/library/engine.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateQuery = exports.quadsQuery = exports.bindingsQuery = exports.booleanQuery = void 0;
-const query_sparql_1 = require("@comunica/query-sparql");
-const rxjs_js_1 = require("./rxjs.js");
-const context_js_1 = require("./context.js");
-const rdf_js_1 = require("./rdf.js");
-const engine = new query_sparql_1.QueryEngine();
-const booleanQuery = (query, context) => (0, rxjs_js_1.from)(engine.queryBoolean(query, (0, context_js_1.resolveContext)(context)));
-exports.booleanQuery = booleanQuery;
-const bindingsQuery = (query, context) => (0, rxjs_js_1.from)(engine.queryBindings(query, (0, context_js_1.resolveContext)(context))).pipe((0, rxjs_js_1.switchMap)((stream) => (0, rxjs_js_1.from)(stream.toArray())));
-exports.bindingsQuery = bindingsQuery;
-const quadsQuery = (query, context) => (0, rxjs_js_1.from)(engine.queryQuads(query, (0, context_js_1.resolveContext)(context))).pipe((0, rxjs_js_1.switchMap)((stream) => (0, rxjs_js_1.from)(stream.toArray())), (0, rxjs_js_1.map)((quads) => (0, rdf_js_1.quadsToGraph)(quads)));
-exports.quadsQuery = quadsQuery;
-const updateQuery = (query, context) => (0, rxjs_js_1.from)(engine.queryVoid(query, (0, context_js_1.resolveContext)(context)));
-exports.updateQuery = updateQuery;

package/types/library/context.d.ts

@@ -1,9 +0,0 @@
-import type { QueryStringContext } from "@comunica/types";
-export declare type LibraryContext = Partial<{
-    graph: string;
-    language: string;
-}>;
-export declare type Context = LibraryContext & QueryStringContext;
-export declare const createContext: (context: Context) => Context;
-export declare const createDefaultContext: (context: Context) => void;
-export declare const resolveContext: (context?: Context) => Context;

package/types/library/engine.d.ts

@@ -1,6 +0,0 @@
-import { Context } from "./context.js";
-import { type Bindings } from "./rdf.js";
-export declare const booleanQuery: (query: string, context?: Context) => import("rxjs/internal/Observable").Observable<boolean>;
-export declare const bindingsQuery: (query: string, context?: Context) => import("rxjs/internal/Observable").Observable<Bindings[]>;
-export declare const quadsQuery: (query: string, context?: Context) => import("rxjs/internal/Observable").Observable<import("./rdf.js").Graph>;
-export declare const updateQuery: (query: string, context?: Context) => import("rxjs/internal/Observable").Observable<void>;