ldkit 0.6.2 → 0.6.4

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

@@ -0,0 +1,105 @@
+declare const _default: {
+    subject: "sioc:subject";
+    link: "sioc:link";
+    description: "sioc:description";
+    Community: "sioc:Community";
+    follows: "sioc:follows";
+    id: "sioc:id";
+    name: "sioc:name";
+    note: "sioc:note";
+    reference: "sioc:reference";
+    sibling: "sioc:sibling";
+    title: "sioc:title";
+    topic: "sioc:topic";
+    Container: "sioc:Container";
+    Role: "sioc:Role";
+    about: "sioc:about";
+    email: "sioc:email";
+    mentions: "sioc:mentions";
+    Forum: "sioc:Forum";
+    Item: "sioc:Item";
+    Post: "sioc:Post";
+    Site: "sioc:Site";
+    Space: "sioc:Space";
+    Thread: "sioc:Thread";
+    User: "sioc:User";
+    UserAccount: "sioc:UserAccount";
+    Usergroup: "sioc:Usergroup";
+    account_of: "sioc:account_of";
+    addressed_to: "sioc:addressed_to";
+    administrator_of: "sioc:administrator_of";
+    attachment: "sioc:attachment";
+    avatar: "sioc:avatar";
+    container_of: "sioc:container_of";
+    content: "sioc:content";
+    content_encoded: "sioc:content_encoded";
+    created_at: "sioc:created_at";
+    creator_of: "sioc:creator_of";
+    delivered_at: "sioc:delivered_at";
+    discussion_of: "sioc:discussion_of";
+    earlier_version: "sioc:earlier_version";
+    email_sha1: "sioc:email_sha1";
+    embeds_knowledge: "sioc:embeds_knowledge";
+    feed: "sioc:feed";
+    first_name: "sioc:first_name";
+    function_of: "sioc:function_of";
+    generator: "sioc:generator";
+    group_of: "sioc:group_of";
+    has_administrator: "sioc:has_administrator";
+    has_container: "sioc:has_container";
+    has_creator: "sioc:has_creator";
+    has_discussion: "sioc:has_discussion";
+    has_function: "sioc:has_function";
+    has_group: "sioc:has_group";
+    has_host: "sioc:has_host";
+    has_member: "sioc:has_member";
+    has_moderator: "sioc:has_moderator";
+    has_modifier: "sioc:has_modifier";
+    has_owner: "sioc:has_owner";
+    has_parent: "sioc:has_parent";
+    has_part: "sioc:has_part";
+    has_reply: "sioc:has_reply";
+    has_scope: "sioc:has_scope";
+    has_space: "sioc:has_space";
+    has_subscriber: "sioc:has_subscriber";
+    has_usergroup: "sioc:has_usergroup";
+    host_of: "sioc:host_of";
+    ip_address: "sioc:ip_address";
+    last_activity_date: "sioc:last_activity_date";
+    last_item_date: "sioc:last_item_date";
+    last_name: "sioc:last_name";
+    last_reply_date: "sioc:last_reply_date";
+    later_version: "sioc:later_version";
+    latest_version: "sioc:latest_version";
+    likes: "sioc:likes";
+    links_to: "sioc:links_to";
+    member_of: "sioc:member_of";
+    moderator_of: "sioc:moderator_of";
+    modified_at: "sioc:modified_at";
+    modifier_of: "sioc:modifier_of";
+    next_by_date: "sioc:next_by_date";
+    next_version: "sioc:next_version";
+    num_authors: "sioc:num_authors";
+    num_items: "sioc:num_items";
+    num_replies: "sioc:num_replies";
+    num_threads: "sioc:num_threads";
+    num_views: "sioc:num_views";
+    owner_of: "sioc:owner_of";
+    parent_of: "sioc:parent_of";
+    part_of: "sioc:part_of";
+    previous_by_date: "sioc:previous_by_date";
+    previous_version: "sioc:previous_version";
+    read_at: "sioc:read_at";
+    related_to: "sioc:related_to";
+    reply_of: "sioc:reply_of";
+    respond_to: "sioc:respond_to";
+    scope_of: "sioc:scope_of";
+    shared_by: "sioc:shared_by";
+    space_of: "sioc:space_of";
+    subscriber_of: "sioc:subscriber_of";
+    usergroup_of: "sioc:usergroup_of";
+} & {
+    $prefix: "sioc:";
+    $iri: "http://rdfs.org/sioc/ns#";
+};
+export default _default;

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

@@ -1,5 +1,8 @@
 declare const _default: {
+    definition: "skos:definition";
     member: "skos:member";
+    note: "skos:note";
+    related: "skos:related";
     Collection: "skos:Collection";
     Concept: "skos:Concept";
     ConceptScheme: "skos:ConceptScheme";
@@ -10,7 +13,6 @@ declare const _default: {
     broaderTransitive: "skos:broaderTransitive";
     changeNote: "skos:changeNote";
     closeMatch: "skos:closeMatch";
-    definition: "skos:definition";
     editorialNote: "skos:editorialNote";
     exactMatch: "skos:exactMatch";
     example: "skos:example";
@@ -24,9 +26,7 @@ declare const _default: {
     narrower: "skos:narrower";
     narrowerTransitive: "skos:narrowerTransitive";
     notation: "skos:notation";
-    note: "skos:note";
     prefLabel: "skos:prefLabel";
-    related: "skos:related";
     relatedMatch: "skos:relatedMatch";
     scopeNote: "skos:scopeNote";
     semanticRelation: "skos:semanticRelation";

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

@@ -1,9 +1,6 @@
 declare const _default: {
     string: "xsd:string";
     boolean: "xsd:boolean";
-    language: "xsd:language";
-    date: "xsd:date";
-    duration: "xsd:duration";
     ENTITIES: "xsd:ENTITIES";
     ENTITY: "xsd:ENTITY";
     ID: "xsd:ID";
@@ -21,11 +18,13 @@ declare const _default: {
     anyURI: "xsd:anyURI";
     base64Binary: "xsd:base64Binary";
     byte: "xsd:byte";
+    date: "xsd:date";
     dateTime: "xsd:dateTime";
     dateTimeStamp: "xsd:dateTimeStamp";
     dayTimeDuration: "xsd:dayTimeDuration";
     decimal: "xsd:decimal";
     double: "xsd:double";
+    duration: "xsd:duration";
     float: "xsd:float";
     gDay: "xsd:gDay";
     gMonth: "xsd:gMonth";
@@ -35,6 +34,7 @@ declare const _default: {
     hexBinary: "xsd:hexBinary";
     int: "xsd:int";
     integer: "xsd:integer";
+    language: "xsd:language";
     long: "xsd:long";
     negativeInteger: "xsd:negativeInteger";
     nonNegativeInteger: "xsd:nonNegativeInteger";

package/types/library/rdf.d.ts

@@ -1,11 +1,8 @@
-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 { DataFactory } from "rdf-data-factory";
 export { DataFactory };
-import { BindingsFactory as ComunicaBindingsFactory } from "@comunica/bindings-factory";
 import type { IDataSource, IQueryContextCommon } from "@comunica/types";
 export declare type LDkitContext = {
     graph?: string;
@@ -14,9 +11,9 @@ export declare type LDkitContext = {
 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 Node = Map<Iri, RDF.Term[]>;
 export declare type Graph = Map<Iri, Node>;
-export declare const quadsToGraph: (quads: Quad[]) => Graph;
+export declare const quadsToGraph: (quads: RDF.Quad[]) => Graph;
 export declare namespace RDFJSON {
     type Term = {
         type: "uri" | "literal" | "bnode";
@@ -25,6 +22,7 @@ export declare namespace RDFJSON {
         datatype?: string;
     };
     type Bindings = Record<string, Term>;
+    type Triple = [Iri, Iri, Term];
     type SparqlResultsJsonFormat = {
         head: {
             vars?: string[];
@@ -42,23 +40,44 @@ export declare namespace RDFJSON {
         fromJson(jsonBindings: Bindings): RDF.Bindings;
     }
     interface QuadFactory {
-        fromJson(jsonRdf: [Iri, Iri, Term]): RDF.Quad;
+        fromJson(jsonRdf: Triple): 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>;
+    fromJson(jsonTerm: RDFJSON.Term): RDF.BlankNode | RDF.Literal | RDF.NamedNode<string>;
 }
-export declare class BindingsFactory extends ComunicaBindingsFactory implements RDFJSON.BindingsFactory {
-    protected readonly localDataFactory: RDF.DataFactory;
+export declare class ReadOnlyBindings implements RDF.Bindings {
+    readonly type = "bindings";
+    protected readonly dataFactory: RDF.DataFactory;
+    protected readonly entries: Map<RDF.Variable, RDF.Term>;
+    protected readonly variables: Map<string, RDF.Variable>;
+    constructor(bindings: Map<RDF.Variable, RDF.Term>, dataFactory?: RDF.DataFactory);
+    has(key: string | RDF.Variable): boolean;
+    get(key: string | RDF.Variable): RDF.Term | undefined;
+    set(_key: string | RDF.Variable, _value: RDF.Term): RDF.Bindings;
+    delete(_key: string | RDF.Variable): RDF.Bindings;
+    keys(): IterableIterator<RDF.Variable>;
+    values(): IterableIterator<RDF.Term>;
+    forEach(fn: (value: RDF.Term, key: RDF.Variable) => unknown): void;
+    get size(): number;
+    [Symbol.iterator](): IterableIterator<[RDF.Variable, RDF.Term]>;
+    equals(_other: RDF.Bindings | null | undefined): boolean;
+    filter(_fn: (value: RDF.Term, key: RDF.Variable) => boolean): RDF.Bindings;
+    map(_fn: (value: RDF.Term, key: RDF.Variable) => RDF.Term): RDF.Bindings;
+    merge(_other: RDF.Bindings): RDF.Bindings | undefined;
+    mergeWith(_merger: (self: RDF.Term, other: RDF.Term, key: RDF.Variable) => RDF.Term, _other: RDF.Bindings): RDF.Bindings;
+}
+export declare class BindingsFactory implements RDFJSON.BindingsFactory {
+    protected readonly dataFactory: RDF.DataFactory;
     protected readonly termFactory: RDFJSON.TermFactory;
     constructor(dataFactory?: RDF.DataFactory, termFactory?: RDFJSON.TermFactory);
-    fromJson(jsonBindings: RDFJSON.Bindings): Bindings;
+    fromJson(jsonBindings: RDFJSON.Bindings): ReadOnlyBindings;
 }
 export declare class QuadFactory implements RDFJSON.QuadFactory {
     protected readonly dataFactory: RDF.DataFactory;
     protected readonly termFactory: RDFJSON.TermFactory;
     constructor(dataFactory?: RDF.DataFactory, termFactory?: RDFJSON.TermFactory);
-    fromJson(jsonRdf: [Iri, Iri, RDFJSON.Term]): Quad;
+    fromJson(jsonRdf: [Iri, Iri, RDFJSON.Term]): RDF.Quad;
 }