rdflib 2.2.10 → 2.2.12-5f141ca2

package/lib/formula.d.ts

@@ -0,0 +1,327 @@
+import Collection from './collection';
+import RDFlibNamedNode from './named-node';
+import Namespace from './namespace';
+import Node from './node-internal';
+import Statement from './statement';
+import { Bindings, GraphTermType } from './types';
+import Variable from './variable';
+import { Indexable, TFIDFactoryTypes } from './factories/factory-types';
+import { RdfJsDataFactory, Quad_Graph, Quad_Object, Quad_Predicate, Quad, Quad_Subject, Term } from './tf-types';
+import Fetcher from './fetcher';
+import BlankNode from './blank-node';
+import NamedNode from './named-node';
+export interface FormulaOpts {
+    dataCallback?: (q: Quad) => void;
+    rdfArrayRemove?: (arr: Quad[], q: Quad) => void;
+    rdfFactory?: RdfJsDataFactory;
+}
+interface BooleanMap {
+    [uri: string]: boolean;
+}
+interface MembersMap {
+    [uri: string]: Quad;
+}
+interface UriMap {
+    [uri: string]: string;
+}
+/**
+ * A formula, or store of RDF statements
+ */
+export default class Formula extends Node {
+    statements: Array<Statement>;
+    constraints: ReadonlyArray<any>;
+    initBindings: ReadonlyArray<any>;
+    optional: ReadonlyArray<any>;
+    termType: typeof GraphTermType;
+    classOrder: number;
+    /**
+     * The accompanying fetcher instance.
+     *
+     * Is set by the fetcher when initialized.
+     */
+    fetcher?: Fetcher;
+    isVar: number;
+    /**
+     * A namespace for the specified namespace's URI
+     * @param nsuri The URI for the namespace
+     */
+    ns: typeof Namespace;
+    /** The factory used to generate statements and terms */
+    rdfFactory: any;
+    /**
+     * Initializes this formula
+     * @constructor
+     * @param statements - Initial array of statements
+     * @param constraints - initial array of constraints
+     * @param initBindings - initial bindings used in Query
+     * @param optional - optional
+     * @param opts
+     * @param opts.rdfFactory - The rdf factory that should be used by the store
+  */
+    constructor(statements?: Array<Statement>, constraints?: ReadonlyArray<any>, initBindings?: ReadonlyArray<any>, optional?: ReadonlyArray<any>, opts?: FormulaOpts);
+    /** Add a statement from its parts
+     * @param subject - the first part of the statement
+     * @param predicate - the second part of the statement
+     * @param object - the third part of the statement
+     * @param graph - the last part of the statement
+     */
+    add(subject: Quad_Subject | Quad | Quad[], predicate?: Quad_Predicate, object?: Term | string, graph?: Quad_Graph): Statement | null | this | number;
+    /** Add a statment object
+     * @param {Statement} statement - An existing constructed statement to add
+     */
+    addStatement(statement: Quad): Statement | null | this | number;
+    /**
+     * Shortcut for adding blankNodes
+     * @param [id]
+     */
+    bnode(id?: string): BlankNode;
+    /**
+     * Adds all the statements to this formula
+     * @param statements - A collection of statements
+     */
+    addAll(statements: Quad[]): void;
+    /** Follow link from one node, using one wildcard, looking for one
+    *
+    * For example, any(me, knows, null, profile)  - a person I know accoring to my profile .
+    * any(me, knows, null, null)  - a person I know accoring to anything in store .
+    * any(null, knows, me, null)  - a person who know me accoring to anything in store .
+    *
+    * @param s - A node to search for as subject, or if null, a wildcard
+    * @param p - A node to search for as predicate, or if null, a wildcard
+    * @param o - A node to search for as object, or if null, a wildcard
+    * @param g - A node to search for as graph, or if null, a wildcard
+    * @returns A node which match the wildcard position, or null
+    */
+    any(s?: Quad_Subject | null, p?: Quad_Predicate | null, o?: Quad_Object | null, g?: Quad_Graph | null): Node | null;
+    /**
+     * Gets the value of a node that matches the specified pattern
+     * @param s The subject
+     * @param p The predicate
+     * @param o The object
+     * @param g The graph that contains the statement
+     */
+    anyValue(s?: Quad_Subject | null, p?: Quad_Predicate | null, o?: Quad_Object | null, g?: Quad_Graph | null): string | void;
+    /**
+     * Gets the first JavaScript object equivalent to a node based on the specified pattern
+     * @param s The subject
+     * @param p The predicate
+     * @param o The object
+     * @param g The graph that contains the statement
+     */
+    anyJS(s?: Quad_Subject | null, p?: Quad_Predicate | null, o?: Quad_Object | null, g?: Quad_Graph | null): any;
+    /**
+     * Gets the first statement that matches the specified pattern
+     */
+    anyStatementMatching(s?: Quad_Subject | null, p?: Quad_Predicate | null, o?: Quad_Object | null, g?: Quad_Graph | null): Statement | undefined;
+    /**
+     * Returns a unique index-safe identifier for the given term.
+     *
+     * Falls back to the rdflib hashString implementation if the given factory doesn't support id.
+     */
+    id(term: TFIDFactoryTypes): Indexable;
+    /**
+     * Search the Store
+     * This is really a teaching method as to do this properly you would use IndexedFormula
+     *
+     * @param s - A node to search for as subject, or if null, a wildcard
+     * @param p - A node to search for as predicate, or if null, a wildcard
+     * @param o - A node to search for as object, or if null, a wildcard
+     * @param g - A node to search for as graph, or if null, a wildcard
+     * @param justOne - flag - stop when found one rather than get all of them?
+     * @returns {Array<Node>} - An array of nodes which match the wildcard position
+     */
+    statementsMatching<JustOne extends boolean = false>(s?: Quad_Subject | null, p?: Quad_Predicate | null, o?: Quad_Object | null, g?: Quad_Graph | null, justOne?: boolean): Statement[];
+    /**
+     * Finds the types in the list which have no *stored* subtypes
+     * These are a set of classes which provide by themselves complete
+     * information -- the other classes are redundant for those who
+     * know the class DAG.
+     * @param types A map of the types
+     */
+    bottomTypeURIs(types: any): any;
+    /** Creates a new collection */
+    collection(): Collection;
+    /** Follow links from one node, using one wildcard.
+    *
+    * For example, each(me, knows, null, profile)  - people I know accoring to my profile .
+    * each(me, knows, null, null)  - people I know accoring to anything in store .
+    * each(null, knows, me, null)  - people who know me accoring to anything in store .
+    *
+    * @param s - A node to search for as subject, or if null, a wildcard
+    * @param p - A node to search for as predicate, or if null, a wildcard
+    * @param o - A node to search for as object, or if null, a wildcard
+    * @param g - A node to search for as graph, or if null, a wildcard
+    * @returns {Array<Node>} - An array of nodes which match the wildcard position
+    */
+    each(s?: Quad_Subject | null, p?: Quad_Predicate | null, o?: Quad_Object | null, g?: Quad_Graph | null): Node[];
+    /**
+     * Test whether this formula is equals to {other}
+     * @param other - The other formula
+     */
+    equals(other: Formula): boolean;
+    /**
+     * For thisClass or any subclass, anything which has it is its type
+     * or is the object of something which has the type as its range, or subject
+     * of something which has the type as its domain
+     * We don't bother doing subproperty (yet?)as it doesn't seeem to be used
+     * much.
+     * Get all the Classes of which we can RDFS-infer the subject is a member
+     * @return a hash of URIs
+     */
+    findMembersNT(thisClass: any): MembersMap;
+    /**
+     * For thisClass or any subclass, anything which has it is its type
+     * or is the object of something which has the type as its range, or subject
+     * of something which has the type as its domain
+     * We don't bother doing subproperty (yet?)as it doesn't seeem to be used
+     * much.
+     * Get all the Classes of which we can RDFS-infer the subject is a member
+     * @param subject - A named node
+     */
+    findMemberURIs(subject: Node): UriMap;
+    /**
+     * Get all the Classes of which we can RDFS-infer the subject is a superclass
+     * Returns a hash table where key is NT of type and value is statement why we
+     * think so.
+     * Does NOT return terms, returns URI strings.
+     * We use NT representations in this version because they handle blank nodes.
+     */
+    findSubClassesNT(subject: Node): {
+        [uri: string]: boolean;
+    };
+    /**
+     * Get all the Classes of which we can RDFS-infer the subject is a subclass
+     * @param {RDFlibNamedNode} subject - The thing whose classes are to be found
+     * @returns a hash table where key is NT of type and value is statement why we
+     * think so.
+     * Does NOT return terms, returns URI strings.
+     * We use NT representations in this version because they handle blank nodes.
+     */
+    findSuperClassesNT(subject: Node): {
+        [uri: string]: boolean;
+    };
+    /**
+     * Get all the Classes of which we can RDFS-infer the subject is a member
+     * todo: This will loop is there is a class subclass loop (Sublass loops are
+     * not illegal)
+     * @param {RDFlibNamedNode} subject - The thing whose classes are to be found
+     * @returns a hash table where key is NT of type and value is statement why we think so.
+     * Does NOT return terms, returns URI strings.
+     * We use NT representations in this version because they handle blank nodes.
+     */
+    findTypesNT(subject: any): {
+        [uri: string]: boolean;
+    };
+    /**
+     * Get all the Classes of which we can RDFS-infer the subject is a member
+     * todo: This will loop is there is a class subclass loop (Sublass loops are
+     * not illegal)
+     * Returns a hash table where key is NT of type and value is statement why we
+     * think so.
+     * Does NOT return terms, returns URI strings.
+     * We use NT representations in this version because they handle blank nodes.
+     * @param subject - A subject node
+     */
+    findTypeURIs(subject: Quad_Subject): UriMap;
+    /** Trace statements which connect directly, or through bnodes
+     *
+     * @param subject - The node to start looking for statments
+     * @param doc - The document to be searched, or null to search all documents
+     * @returns an array of statements, duplicate statements are suppresssed.
+     */
+    connectedStatements(subject: Quad_Subject, doc: Quad_Graph, excludePredicateURIs?: ReadonlyArray<string>): Statement[];
+    /**
+     * Creates a new empty formula
+     *
+     * @param _features - Not applicable, but necessary for typing to pass
+     */
+    formula(_features?: ReadonlyArray<string>): Formula;
+    /**
+     * Transforms an NTriples string format into a Node.
+     * The blank node bit should not be used on program-external values; designed
+     * for internal work such as storing a blank node id in an HTML attribute.
+     * This will only parse the strings generated by the various toNT() methods.
+     */
+    fromNT(str: any): any;
+    /** Returns true if this formula holds the specified statement(s) */
+    holds(s: any | any[], p?: any, o?: any, g?: any): boolean;
+    /**
+     * Returns true if this formula holds the specified {statement}
+     */
+    holdsStatement(statement: any): boolean;
+    /**
+     * Used by the n3parser to generate list elements
+     * @param values - The values of the collection
+     * @param context - The store
+     * @return {BlankNode|Collection} - The term for the statement
+     */
+    list(values: any, context: any): any;
+    /**
+     * Transform a collection of NTriple URIs into their URI strings
+     * @param t - Some iterable collection of NTriple URI strings
+     * @return A collection of the URIs as strings
+     * todo: explain why it is important to go through NT
+     */
+    NTtoURI(t: any): {};
+    /**
+     * Serializes this formula
+     * @param base - The base string
+     * @param contentType - The content type of the syntax to use
+     * @param provenance - The provenance URI
+     */
+    serialize(base: any, contentType: any, provenance: any): any;
+    /**
+     * Creates a new formula with the substituting bindings applied
+     * @param bindings - The bindings to substitute
+     */
+    substitute<T extends Node = Formula>(bindings: Bindings): T;
+    sym(uri: string, name?: any): NamedNode;
+    /**
+     * Gets the node matching the specified pattern. Throws when no match could be made.
+     * @param s - The subject
+     * @param p - The predicate
+     * @param o - The object
+     * @param g - The graph that contains the statement
+     */
+    the(s?: Quad_Subject | null, p?: Quad_Predicate | null, o?: Quad_Object | null, g?: Quad_Graph | null): Node | null | undefined;
+    /**
+     * RDFS Inference
+     * These are hand-written implementations of a backward-chaining reasoner
+     * over the RDFS axioms.
+     * @param seeds - A hash of NTs of classes to start with
+     * @param predicate - The property to trace though
+     * @param inverse - Trace inverse direction
+     */
+    transitiveClosure(seeds: BooleanMap, predicate: Quad_Predicate, inverse?: boolean): {
+        [uri: string]: boolean;
+    };
+    /**
+     * Finds the types in the list which have no *stored* supertypes
+     * We exclude the universal class, owl:Things and rdf:Resource, as it is
+     * information-free.
+     * @param types - The types
+     */
+    topTypeURIs(types: {
+        [id: string]: string | RDFlibNamedNode;
+    }): {
+        [id: string]: string | RDFlibNamedNode;
+    };
+    /**
+     * Serializes this formula to a string
+     */
+    toString(): string;
+    /**
+     * Gets a new variable
+     * @param name - The variable's name
+     */
+    variable(name: string): Variable;
+    /**
+     * Gets the number of statements in this formula that matches the specified pattern
+     * @param s - The subject
+     * @param p - The predicate
+     * @param o - The object
+     * @param g - The graph that contains the statement
+     */
+    whether(s?: Quad_Subject | null, p?: Quad_Predicate | null, o?: Quad_Object | null, g?: Quad_Graph | null): number;
+}
+export {};

package/lib/index.d.ts

@@ -0,0 +1,40 @@
+import BlankNode from './blank-node';
+import Collection from './collection';
+import * as convert from './convert';
+import Empty from './empty';
+import Fetcher from './fetcher';
+import Formula from './formula';
+import Store from './store';
+import jsonParser from './jsonparser';
+import Literal from './literal';
+import log from './log';
+import N3Parser from './n3parser';
+import NamedNode from './named-node';
+import Namespace from './namespace';
+import Node from './node';
+import parse from './parse';
+import { Query } from './query';
+import queryToSPARQL from './query-to-sparql';
+import RDFaProcessor from './rdfaparser';
+import RDFParser from './rdfxmlparser';
+import serialize from './serialize';
+import Serializer from './serializer';
+import SPARQLToQuery from './sparql-to-query';
+import sparqlUpdateParser from './patch-parser';
+import Statement from './statement';
+import UpdateManager from './update-manager';
+import { UpdatesSocket } from './updates-via';
+import { UpdatesVia } from './updates-via';
+import * as uri from './uri';
+import * as Util from './utils-js';
+import Variable from './variable';
+import DataFactory from './factories/rdflib-data-factory';
+declare const fetcher: (store: Store, options: any) => Fetcher, graph: (features?: any, opts?: any) => Store, lit: (val: string, lang?: string | undefined, dt?: import("./tf-types").NamedNode | undefined) => Literal, st: (subject: import("./tf-types").Quad_Subject, predicate: import("./tf-types").Quad_Predicate, object: import("./tf-types").Quad_Object, graph?: import("./tf-types").Quad_Graph | undefined) => Statement<import("./types").SubjectType, import("./types").PredicateType, import("./types").ObjectType, import("./types").GraphType>, namedNode: (value: string) => NamedNode, variable: (value: string) => Variable, blankNode: (value?: string | undefined) => BlankNode, defaultGraph: () => import("./default-graph").default, literal: (value: string, languageOrDatatype?: string | import("./tf-types").NamedNode | undefined) => Literal, quad: (subject: import("./tf-types").Term, predicate: import("./tf-types").Term, object: import("./tf-types").Term, graph?: import("./tf-types").Term | undefined) => Statement<import("./types").SubjectType, import("./types").PredicateType, import("./types").ObjectType, import("./types").GraphType>, triple: (subject: import("./tf-types").Term, predicate: import("./tf-types").Term, object: import("./tf-types").Term, graph?: import("./tf-types").Term | undefined) => import("./tf-types").Quad<any, any, any, any>;
+declare const fromNT: (str: any) => any;
+declare const term: <T extends import("./types").FromValueReturns<any>>(value: import("./types").ValueType) => T;
+declare const NextId: number;
+export * from './utils/terms';
+export type { AutoInitOptions, ExtendedResponse, FetchError } from './fetcher';
+export { BlankNode, Collection, convert, DataFactory, Empty, Fetcher, Formula, Store, jsonParser, Literal, log, N3Parser, NamedNode, Namespace, Node, parse, Query, queryToSPARQL, RDFaProcessor, RDFParser, serialize, Serializer, SPARQLToQuery, sparqlUpdateParser, Statement, term, UpdateManager, UpdatesSocket, UpdatesVia, uri, Util, Variable, Store as IndexedFormula, // Alias
+NextId, fromNT, fetcher, graph, lit, st, namedNode as sym, blankNode, defaultGraph, literal, namedNode, quad, triple, variable, };
+export { termValue } from './utils/termValue';

package/lib/jsonldparser.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Parses json-ld formatted JS objects to a rdf Term.
+ * @param kb - The DataFactory to use.
+ * @param obj - The json-ld object to process.
+ * @return {Literal|NamedNode|BlankNode|Collection}
+ */
+export function jsonldObjectToTerm(kb: any, obj: any): any | any | any | any;
+/**
+ * Takes a json-ld formatted string {str} and adds its statements to {kb}.
+ *
+ * Ensure that {kb.rdfFactory} is a DataFactory.
+ */
+export default function jsonldParser(str: any, kb: any, base: any, callback: any): Promise<any>;

package/lib/jsonparser.d.ts

@@ -0,0 +1,4 @@
+declare namespace _default {
+    function parseJSON(data: any, source: any, store: any): void;
+}
+export default _default;

package/lib/literal.d.ts

@@ -0,0 +1,67 @@
+import RDFlibNamedNode from './named-node';
+import Node from './node-internal';
+import { FromValueReturns, LiteralTermType, ValueType } from './types';
+import { Literal as TFLiteral, Term } from './tf-types';
+/**
+ * An RDF literal, containing some value which isn't expressed as an IRI.
+ * @link https://rdf.js.org/data-model-spec/#literal-interface
+ */
+export default class Literal extends Node implements TFLiteral {
+    termType: typeof LiteralTermType;
+    classOrder: number;
+    /**
+     * The literal's datatype as a named node
+     */
+    datatype: RDFlibNamedNode;
+    isVar: number;
+    /**
+     * The language for the literal
+     */
+    language: string;
+    /**
+     * Initializes a literal
+     * @param value - The literal's lexical value
+     * @param language - The language for the literal. Defaults to ''.
+     * @param datatype - The literal's datatype as a named node. Defaults to xsd:string.
+     */
+    constructor(value: string, language?: string | null, datatype?: any);
+    /**
+     * Gets a copy of this literal
+     */
+    copy(): Literal;
+    /**
+     * Gets whether two literals are the same
+     * @param other The other statement
+     */
+    equals(other: Term): boolean;
+    /**
+     * The language for the literal
+     * @deprecated use {language} instead
+     */
+    get lang(): string;
+    set lang(language: string);
+    toNT(): string;
+    /** Serializes a literal to an N-Triples string */
+    static toNT(literal: Literal): string;
+    toString(): string;
+    /**
+     * Builds a literal node from a boolean value
+     * @param value - The value
+     */
+    static fromBoolean(value: boolean): Literal;
+    /**
+     * Builds a literal node from a date value
+     * @param value The value
+     */
+    static fromDate(value: Date): Literal;
+    /**
+     * Builds a literal node from a number value
+     * @param value - The value
+     */
+    static fromNumber(value: number): Literal;
+    /**
+     * Builds a literal node from an input value
+     * @param value - The input value
+     */
+    static fromValue<T extends FromValueReturns>(value: ValueType): T;
+}

package/lib/log.d.ts

@@ -0,0 +1,15 @@
+export default log;
+declare namespace log {
+    function debug(x: any): void;
+    function debug(x: any): void;
+    function warn(x: any): void;
+    function warn(x: any): void;
+    function info(x: any): void;
+    function info(x: any): void;
+    function error(x: any): void;
+    function error(x: any): void;
+    function success(x: any): void;
+    function success(x: any): void;
+    function msg(x: any): void;
+    function msg(x: any): void;
+}

package/lib/n3parser.d.ts

@@ -0,0 +1,62 @@
+export default createSinkParser;
+export class SinkParser {
+    constructor(store: any, openFormula: any, thisDoc: any, baseURI: any, genPrefix: any, metaURI: any, flags: any, why: any);
+    _bindings: any;
+    _flags: any;
+    _store: any;
+    _thisDoc: any;
+    source: any;
+    lines: number;
+    statementCount: number;
+    startOfLine: number;
+    previousLine: number;
+    _genPrefix: any;
+    keywords: any;
+    keywordsSet: number;
+    _anonymousNodes: any;
+    _variables: any;
+    _parentVariables: any;
+    _reason: any;
+    _reason2: any;
+    _baseURI: any;
+    _formula: any;
+    _context: any;
+    _parentContext: any;
+    here(i: any): string;
+    formula(): any;
+    loadStream(stream: any): any;
+    loadBuf(buf: any): any;
+    feed(octets: any): void;
+    directiveOrStatement(str: any, h: any): any;
+    tok(tok: any, str: any, i: any): any;
+    directive(str: any, i: any): any;
+    bind(qn: any, uri: any): void;
+    setKeywords(k: any): void;
+    startDoc(): void;
+    endDoc(): any;
+    makeStatement(quad: any): void;
+    statement(str: any, i: any): any;
+    subject(str: any, i: any, res: any): any;
+    verb(str: any, i: any, res: any): any;
+    prop(str: any, i: any, res: any): any;
+    item(str: any, i: any, res: any): any;
+    blankNode(uri: any): any;
+    path(str: any, i: any, res: any): any;
+    anonymousNode(ln: any): any;
+    node(str: any, i: any, res: any, subjectAlready: any): any;
+    property_list(str: any, i: any, subj: any): any;
+    commaSeparatedList(str: any, j: any, res: any, ofUris: any): any;
+    objectList(str: any, i: any, res: any): any;
+    checkDot(str: any, i: any): any;
+    uri_ref2(str: any, i: any, res: any): any;
+    skipSpace(str: any, i: any): any;
+    variable(str: any, i: any, res: any): any;
+    bareWord(str: any, i: any, res: any): any;
+    qname(str: any, i: any, res: any): any;
+    object(str: any, i: any, res: any): any;
+    nodeOrLiteral(str: any, i: any, res: any): any;
+    strconst(str: any, i: any, delim: any): any;
+    uEscape(str: any, i: any, startline: any): any;
+    UEscape(str: any, i: any, startline: any): any;
+}
+declare function createSinkParser(store: any, openFormula: any, thisDoc: any, baseURI: any, genPrefix: any, metaURI: any, flags: any, why: any): SinkParser;