ldkit 0.0.5 → 0.5.0

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

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

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

@@ -0,0 +1,10 @@
+import { type Context, type IQueryEngine, type RDF } from "../rdf.js";
+export declare class QueryEngine implements IQueryEngine {
+    protected getSparqlEndpoint(context?: Context): string;
+    protected getFetch(context?: Context): typeof fetch;
+    query(query: string, context?: Context): Promise<Response>;
+    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>;
+}

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

@@ -0,0 +1,10 @@
+import { type Context, IQueryEngine, type RDF } from "../rdf.js";
+export declare class QueryEngineProxy {
+    private readonly context;
+    private readonly engine;
+    constructor(context?: Context, engine?: IQueryEngine);
+    queryBoolean(query: string): import("rxjs/internal/Observable").Observable<boolean>;
+    queryBindings(query: string): import("rxjs/internal/Observable").Observable<RDF.Bindings[]>;
+    queryGraph(query: string): import("rxjs/internal/Observable").Observable<import("../rdf.js").Graph>;
+    queryVoid(query: string): import("rxjs/internal/Observable").Observable<void>;
+}

package/types/library/global.d.ts

@@ -0,0 +1,5 @@
+import type { Context, IQueryEngine } from "./rdf.js";
+export declare const setDefaultContext: (context: Context) => void;
+export declare const resolveContext: (context?: Context) => Context;
+export declare const setDefaultEngine: (engine: IQueryEngine) => void;
+export declare const resolveEngine: (engine?: IQueryEngine) => IQueryEngine;

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

@@ -1,7 +1,7 @@
 declare const _default: {
-    language: "dcterms:language";
     subject: "dcterms:subject";
     type: "dcterms:type";
+    language: "dcterms:language";
     Agent: "dcterms:Agent";
     AgentClass: "dcterms:AgentClass";
     BibliographicResource: "dcterms:BibliographicResource";

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

@@ -1,4 +1,5 @@
 export { default as rdf } from "./rdf.js";
+export { default as rdfs } from "./rdfs.js";
 export { default as dcterms } from "./dcterms.js";
 export { default as ldkit } from "./ldkit.js";
 export { default as schema } from "./schema.js";

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,13 @@
 declare const _default: {
     object: "schema:object";
+    value: "schema:value";
+    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 +204,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 +1566,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 +1768,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 +2094,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";

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 { type Resource, createResource } from "./library/resource/mod.js";
+export { createResource, type Resource } from "./library/resource/mod.js";
 export { createNamespace } from "./library/namespaces/namespace.js";
-export { createDefaultContext, createContext } from "./library/context.js";

package/types/namespaces.d.ts

@@ -0,0 +1 @@
+export * from "./library/namespaces/mod.js";

package/types/rdf.d.ts

@@ -0,0 +1 @@
+export * from "./library/rdf.js";

package/types/sparql.d.ts

@@ -0,0 +1 @@
+export * from "./library/sparql.js";

package/esm/_dnt.shims.js

@@ -1,58 +0,0 @@
-const dntGlobals = {};
-export const dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
-// deno-lint-ignore ban-types
-function createMergeProxy(baseObj, extObj) {
-    return new Proxy(baseObj, {
-        get(_target, prop, _receiver) {
-            if (prop in extObj) {
-                return extObj[prop];
-            }
-            else {
-                return baseObj[prop];
-            }
-        },
-        set(_target, prop, value) {
-            if (prop in extObj) {
-                delete extObj[prop];
-            }
-            baseObj[prop] = value;
-            return true;
-        },
-        deleteProperty(_target, prop) {
-            let success = false;
-            if (prop in extObj) {
-                delete extObj[prop];
-                success = true;
-            }
-            if (prop in baseObj) {
-                delete baseObj[prop];
-                success = true;
-            }
-            return success;
-        },
-        ownKeys(_target) {
-            const baseKeys = Reflect.ownKeys(baseObj);
-            const extKeys = Reflect.ownKeys(extObj);
-            const extKeysSet = new Set(extKeys);
-            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
-        },
-        defineProperty(_target, prop, desc) {
-            if (prop in extObj) {
-                delete extObj[prop];
-            }
-            Reflect.defineProperty(baseObj, prop, desc);
-            return true;
-        },
-        getOwnPropertyDescriptor(_target, prop) {
-            if (prop in extObj) {
-                return Reflect.getOwnPropertyDescriptor(extObj, prop);
-            }
-            else {
-                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
-            }
-        },
-        has(_target, prop) {
-            return prop in extObj || prop in baseObj;
-        },
-    });
-}