rdflib 2.2.10 → 2.2.12-5f141ca2

package/lib/sparql-to-query.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @SPARQL: SPARQL text that is converted to a query object which is returned.
+ * @testMode: testing flag. Prevents loading of sources.
+ */
+export default function SPARQLToQuery(SPARQL: any, testMode: any, kb: any): false | Query;
+import { Query } from "./query";

package/lib/statement.d.ts

@@ -0,0 +1,55 @@
+import { Bindings, GraphType, ObjectType, PredicateType, SubjectType } from './types';
+import { Quad, DefaultGraph } from './tf-types';
+/** A Statement represents an RDF Triple or Quad. */
+export default class Statement<S extends SubjectType = SubjectType, P extends PredicateType = PredicateType, O extends ObjectType = ObjectType, G extends GraphType = GraphType> implements Quad<S, P, O, G | DefaultGraph> {
+    /** The subject of the triple.  What the Statement is about. */
+    subject: S;
+    /** The relationship which is asserted between the subject and object */
+    predicate: P;
+    /** The thing or data value which is asserted to be related to the subject */
+    object: O;
+    /**
+     * The graph param is a named node of the document in which the triple when
+     *  it is stored on the web.
+     */
+    graph: G | DefaultGraph;
+    /**
+     * Construct a new statement
+     *
+     * @param subject - The subject of the triple.  What the fact is about
+     * @param predicate - The relationship which is asserted between the subject and object
+     * @param object - The thing or data value which is asserted to be related to the subject
+     * @param {NamedNode} graph - The document where the triple is or was or will be stored on the web.
+     *
+     * The graph param is a named node of the document in which the triple when it is stored
+     *  on the web. It exists because when you have read data from various places in the web,
+     *  the “graph” tells you _why_ you have the triple. (At the moment, it is just the
+     *  document, in future it could be an inference step)
+     *
+     * When you do UpdateManager.update() then the graph’s of all the statements must be the same,
+     *  and give the document you are patching. In future, we may have a more
+     *  powerful update() which can update more than one document.
+     */
+    constructor(subject: S, predicate: P, object: O, graph?: G | DefaultGraph);
+    /** Alias for graph, favored by Tim */
+    get why(): DefaultGraph | G;
+    set why(g: DefaultGraph | G);
+    /**
+     * Checks whether two statements are the same
+     * @param other - The other statement
+     */
+    equals(other: Quad): boolean;
+    /**
+     * Creates a statement with the bindings substituted
+     * @param bindings The bindings
+     */
+    substitute(bindings: Bindings): Statement;
+    /** Creates a canonical string representation of this statement. */
+    toCanonical(): string;
+    /** Creates a n-triples string representation of this statement */
+    toNT(): string;
+    /** Creates a n-quads string representation of this statement */
+    toNQ(): string;
+    /** Creates a string representation of this statement */
+    toString(): string;
+}

package/lib/store.d.ts

@@ -0,0 +1,302 @@
+import { defaultGraphURI } from './factories/canonical-data-factory';
+import Formula, { FormulaOpts } from './formula';
+import Node from './node';
+import Variable from './variable';
+import { Query } from './query';
+import UpdateManager from './update-manager';
+import { Bindings } from './types';
+import Statement from './statement';
+import NamedNode from './named-node';
+import Fetcher from './fetcher';
+import { Quad_Graph, NamedNode as TFNamedNode, Quad_Object, Quad_Predicate, Quad, Quad_Subject, Term } from './tf-types';
+import BlankNode from './blank-node';
+declare type FeaturesType = Array<('sameAs' | 'InverseFunctionalProperty' | 'FunctionalProperty')> | undefined;
+export { defaultGraphURI };
+/**
+ * Indexed Formula aka Store
+ */
+export default class IndexedFormula extends Formula {
+    /**
+     * An UpdateManager initialised to this store
+     */
+    updater?: UpdateManager;
+    /**
+     * Dictionary of namespace prefixes
+     */
+    namespaces: {
+        [key: string]: string;
+    };
+    /** Map of iri predicates to functions to call when adding { s type X } */
+    classActions: {
+        [k: string]: Function[];
+    };
+    /** Map of iri predicates to functions to call when getting statement with {s X o} */
+    propertyActions: {
+        [k: string]: Function[];
+    };
+    /** Redirect to lexically smaller equivalent symbol */
+    redirections: any[];
+    /** Reverse mapping to redirection: aliases for this */
+    aliases: any[];
+    /** Redirections we got from HTTP */
+    HTTPRedirects: Statement[];
+    /** Array of statements with this X as subject */
+    subjectIndex: Statement[];
+    /** Array of statements with this X as predicate */
+    predicateIndex: Statement[];
+    /** Array of statements with this X as object */
+    objectIndex: Statement[];
+    /** Array of statements with X as provenance */
+    whyIndex: Statement[];
+    index: [
+        Statement[],
+        Statement[],
+        Statement[],
+        Statement[]
+    ];
+    features: FeaturesType;
+    static handleRDFType: Function;
+    _universalVariables?: NamedNode[];
+    _existentialVariables?: BlankNode[];
+    /** Function to remove quads from the store arrays with */
+    private rdfArrayRemove;
+    /** Callbacks which are triggered after a statement has been added to the store */
+    private dataCallbacks?;
+    /**
+     * Creates a new formula
+     * @param features - What sort of automatic processing to do? Array of string
+     * @param features.sameAs - Smush together A and B nodes whenever { A sameAs B }
+     * @param opts
+     * @param [opts.rdfFactory] - The data factory that should be used by the store
+     * @param [opts.rdfArrayRemove] - Function which removes statements from the store
+     * @param [opts.dataCallback] - Callback when a statement is added to the store, will not trigger when adding duplicates
+     */
+    constructor(features?: FeaturesType, opts?: FormulaOpts);
+    /**
+     * Gets the URI of the default graph
+     */
+    static get defaultGraphURI(): string;
+    /**
+     * Gets this graph with the bindings substituted
+     * @param bindings The bindings
+     */
+    substitute<T extends Node = IndexedFormula>(bindings: Bindings): T;
+    /**
+     * Add a callback which will be triggered after a statement has been added to the store.
+     * @param cb
+     */
+    addDataCallback(cb: (q: Quad) => void): void;
+    /**
+     * Apply a set of statements to be deleted and to be inserted
+     *
+     * @param patch - The set of statements to be deleted and to be inserted
+     * @param target - The name of the document to patch
+     * @param patchCallback - Callback to be called when patching is complete
+     */
+    applyPatch(patch: {
+        delete?: ReadonlyArray<Statement>;
+        patch?: ReadonlyArray<Statement>;
+        where?: any;
+    }, target: TFNamedNode, patchCallback: (errorString?: string) => void): void;
+    /**
+     * N3 allows for declaring blank nodes, this function enables that support
+     *
+     * @param x The blank node to be declared, supported in N3
+     */
+    declareExistential(x: BlankNode): BlankNode;
+    /**
+     * @param features
+     */
+    initPropertyActions(features: FeaturesType): void;
+    /** @deprecated Use {add} instead */
+    addStatement(st: Quad): number;
+    /**
+     * Adds a triple (quad) to the store.
+     *
+     * @param subj - The thing about which the fact a relationship is asserted.
+     *        Also accepts a statement or an array of Statements.
+     * @param pred - The relationship which is asserted
+     * @param obj - The object of the relationship, e.g. another thing or a value. If passed a string, this will become a literal.
+     * @param why - The document in which the triple (S,P,O) was or will be stored on the web
+     * @returns The statement added to the store, or the store
+     */
+    add(subj: Quad_Subject | Quad | Quad[] | Statement | Statement[], pred?: Quad_Predicate, obj?: Term | string, why?: Quad_Graph): Statement | null | this | number;
+    /**
+     * Returns the symbol with canonical URI as smushed
+     * @param term - An RDF node
+     */
+    canon(term?: Term): Node;
+    /**
+     * Checks this formula for consistency
+     */
+    check(): void;
+    /**
+     * Checks a list of statements for consistency
+     * @param sts - The list of statements to check
+     * @param from - An index with the array ['subject', 'predicate', 'object', 'why']
+     */
+    checkStatementList(sts: ReadonlyArray<Quad>, from?: number): boolean | void;
+    /**
+     * Closes this formula (and return it)
+     */
+    close(): IndexedFormula;
+    compareTerms(u1: Term, u2: Term): number;
+    /**
+     * replaces @template with @target and add appropriate triples
+     * removes no triples by default and is a one-direction replication
+     * @param template node to copy
+     * @param target node to copy to
+     * @param flags Whether or not to do a two-directional copy and/or delete triples
+     */
+    copyTo(template: Quad_Subject, target: Quad_Subject, flags?: Array<('two-direction' | 'delete')>): void;
+    /**
+     * Simplify graph in store when we realize two identifiers are equivalent
+     * We replace the bigger with the smaller.
+     * @param u1in The first node
+     * @param u2in The second node
+     */
+    equate(u1in: Term, u2in: Term): boolean;
+    /**
+     * Creates a new empty indexed formula
+     * Only applicable for IndexedFormula, but TypeScript won't allow a subclass to override a property
+     * @param features The list of features
+     */
+    formula(features: FeaturesType): IndexedFormula;
+    /**
+     * Returns the number of statements contained in this IndexedFormula.
+     * (Getter proxy to this.statements).
+     * Usage:
+     *    ```
+     *    var kb = rdf.graph()
+     *    kb.length  // -> 0
+     *    ```
+     * @returns {Number}
+     */
+    get length(): number;
+    /**
+     * Returns any quads matching the given arguments.
+     * Standard RDFJS spec method for Source objects, implemented as an
+     * alias to `statementsMatching()`
+     * @param subject The subject
+     * @param predicate The predicate
+     * @param object The object
+     * @param graph The graph that contains the statement
+     */
+    match(subject?: Quad_Subject | null, predicate?: Quad_Predicate | null, object?: Quad_Object | null, graph?: Quad_Graph | null): Quad[];
+    /**
+     * Find out whether a given URI is used as symbol in the formula
+     * @param uri The URI to look for
+     */
+    mentionsURI(uri: string): boolean;
+    /**
+     * Existentials are BNodes - something exists without naming
+     * @param uri An URI
+     */
+    newExistential(uri: string): Term;
+    /**
+     * Adds a new property action
+     * @param pred the predicate that the function should be triggered on
+     * @param action the function that should trigger
+     */
+    newPropertyAction(pred: Quad_Predicate, action: (store: IndexedFormula, subject: Quad_Subject, predicate: Quad_Predicate, object: Quad_Object) => boolean): boolean;
+    /**
+     * Creates a new universal node
+     * Universals are Variables
+     * @param uri An URI
+     */
+    newUniversal(uri: string): TFNamedNode;
+    variable(name: string): Variable;
+    /**
+     * Find an unused id for a file being edited: return a symbol
+     * (Note: Slow iff a lot of them -- could be O(log(k)) )
+     * @param doc A document named node
+     */
+    nextSymbol(doc: TFNamedNode): TFNamedNode;
+    /**
+     * Query this store asynchronously, return bindings in callback
+     *
+     * @param myQuery The query to be run
+     * @param callback Function to call when bindings
+     * @param Fetcher | null  If you want the query to do link following
+     * @param onDone OBSOLETE - do not use this // @@ Why not ?? Called when query complete
+     */
+    query(myQuery: Query, callback: (bindings: Bindings) => void, fetcher?: Fetcher | null, onDone?: () => void): void;
+    /**
+     * Query this store synchronously and return bindings
+     *
+     * @param myQuery The query to be run
+     */
+    querySync(myQuery: Query): any[];
+    /**
+     * Removes one or multiple statement(s) from this formula
+     * @param st - A Statement or array of Statements to remove
+     */
+    remove(st: Quad | Quad[]): IndexedFormula;
+    /**
+     * Removes all statements in a doc
+     * @param doc - The document / graph
+     */
+    removeDocument(doc: Quad_Graph): IndexedFormula;
+    /**
+     * Remove all statements matching args (within limit) *
+     * @param subj The subject
+     * @param pred The predicate
+     * @param obj The object
+     * @param why The graph that contains the statement
+     * @param limit The number of statements to remove
+     */
+    removeMany(subj?: Quad_Subject | null, pred?: Quad_Predicate | null, obj?: Quad_Object | null, why?: Quad_Graph | null, limit?: number): void;
+    /**
+     * Remove all matching statements
+     * @param subject The subject
+     * @param predicate The predicate
+     * @param object The object
+     * @param graph The graph that contains the statement
+     */
+    removeMatches(subject?: Quad_Subject | null, predicate?: Quad_Predicate | null, object?: Quad_Object | null, graph?: Quad_Graph | null): IndexedFormula;
+    /**
+     * Remove a particular statement object from the store
+     *
+     * @param st - a statement which is already in the store and indexed.
+     *        Make sure you only use this for these.
+     *        Otherwise, you should use remove() above.
+     */
+    removeStatement(st: Quad): IndexedFormula;
+    /**
+     * Removes statements
+     * @param sts The statements to remove
+     */
+    removeStatements(sts: ReadonlyArray<Quad>): IndexedFormula;
+    /**
+     * Replace big with small, obsoleted with obsoleting.
+     */
+    replaceWith(big: Quad_Subject, small: Quad_Subject): boolean;
+    /**
+     * Return all equivalent URIs by which this is known
+     * @param x A named node
+     */
+    allAliases(x: NamedNode): NamedNode[];
+    /**
+     * Compare by canonical URI as smushed
+     * @param x A named node
+     * @param y Another named node
+     */
+    sameThings(x: NamedNode, y: NamedNode): boolean;
+    setPrefixForURI(prefix: string, nsuri: string): void;
+    /** Search the Store
+     *
+     * ALL CONVENIENCE LOOKUP FUNCTIONS RELY ON THIS!
+     * @param subj - A node to search for as subject, or if null, a wildcard
+     * @param pred - A node to search for as predicate, or if null, a wildcard
+     * @param obj - A node to search for as object, or if null, a wildcard
+     * @param why - 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 An array of nodes which match the wildcard position
+     */
+    statementsMatching(subj?: Quad_Subject | null, pred?: Quad_Predicate | null, obj?: Quad_Object | null, why?: Quad_Graph | null, justOne?: boolean): Statement[];
+    /**
+     * A list of all the URIs by which this thing is known
+     * @param term
+     */
+    uris(term: Quad_Subject): string[];
+}

package/lib/tf-types.d.ts

@@ -0,0 +1,151 @@
+import { SupportTable } from './factories/factory-types';
+import { BlankNodeTermType, DefaultGraphTermType, LiteralTermType, NamedNodeTermType, VariableTermType } from './types';
+/**
+ * RDF/JS spec Term
+ * @link https://rdf.js.org/data-model-spec/#term-interface
+ */
+export interface Term {
+    termType: string;
+    value: string;
+    /**
+     * Compare this term with {other} for structural equality
+     *
+     * Note that the task force spec only allows comparison with other terms
+     */
+    equals(other: Term): boolean;
+}
+/**
+ * RDF/JS spec NamedNode
+ * @link https://rdf.js.org/data-model-spec/#namednode-interface
+ */
+export interface NamedNode extends Term {
+    termType: typeof NamedNodeTermType;
+    value: string;
+}
+/**
+ * RDF/JS spec Literal
+ * @link https://rdf.js.org/data-model-spec/#literal-interface
+ */
+export interface BlankNode extends Term {
+    termType: typeof BlankNodeTermType;
+    value: string;
+}
+export interface BaseQuad {
+    subject: Term;
+    predicate: Term;
+    object: Term;
+    graph: Term;
+}
+/**
+ * RDF/JS spec Quad
+ * @link https://rdf.js.org/data-model-spec/#quad-interface
+ */
+export interface Quad<S extends Term = Quad_Subject, P extends Term = Quad_Predicate, O extends Term = Quad_Object, G extends Term = Quad_Graph> {
+    subject: S;
+    predicate: P;
+    object: O;
+    graph: G;
+    equals(other: BaseQuad): boolean;
+}
+/**
+ * RDF/JS spec Literal
+ * @link https://rdf.js.org/data-model-spec/#literal-interface
+ */
+export interface Literal extends Term {
+    /** Contains the constant "Literal". */
+    termType: typeof LiteralTermType;
+    /** The text value, unescaped, without language or type (example: "Brad Pitt") */
+    value: string;
+    /**
+     * The language as lowercase BCP-47 [BCP47] string (examples: "en", "en-gb")
+     * or an empty string if the literal has no language.
+     */
+    language: string;
+    /** A NamedNode whose IRI represents the datatype of the literal. */
+    datatype: NamedNode;
+}
+/**
+ * RDF/JS spec Variable
+ * @link https://rdf.js.org/data-model-spec/#variable-interface
+ */
+export interface Variable extends Term {
+    /** Contains the constant "Variable". */
+    termType: typeof VariableTermType;
+    /** The name of the variable without leading "?" (example: "a"). */
+    value: string;
+}
+/**
+ * RDF/JS spec DefaultGraph
+ * An instance of DefaultGraph represents the default graph.
+ * It's only allowed to assign a DefaultGraph to the graph property of a Quad.
+ * @link https://rdf.js.org/data-model-spec/#defaultgraph-interface
+ */
+export interface DefaultGraph extends Term {
+    termType: typeof DefaultGraphTermType;
+    /** should return and empty string'' */
+    value: '';
+}
+/**
+ * RDF/JS spec DataFactory
+ *
+ * Not 100% compliant due to to practicality problems.
+ *
+ * @link https://rdf.js.org/data-model-spec/#datafactory-interface
+ */
+export interface RdfJsDataFactory {
+    /** Returns a new instance of NamedNode. */
+    namedNode: (value: string) => NamedNode;
+    /**
+     * Returns a new instance of BlankNode.
+     * If the value parameter is undefined a new identifier for the
+     * blank node is generated for each call.
+     */
+    blankNode: (value?: string) => BlankNode;
+    /**
+     * Returns a new instance of Literal.
+     * If languageOrDatatype is a NamedNode, then it is used for the value of datatype.
+     * Otherwise languageOrDatatype is used for the value of language. */
+    literal: (value: string, languageOrDatatype: string | NamedNode) => Literal;
+    /** Returns a new instance of Variable. This method is optional. */
+    variable?: (value: string) => Variable;
+    /**
+     * Returns an instance of DefaultGraph.
+     */
+    defaultGraph: () => DefaultGraph;
+    /**
+     * Returns a new instance of the specific Term subclass given by original.termType
+     * (e.g., NamedNode, BlankNode, Literal, etc.),
+     * such that newObject.equals(original) returns true.
+     * Not implemented in RDFJS, so optional.
+     */
+    fromTerm?: (original: Term) => Term;
+    /**
+     * Returns a new instance of Quad, such that newObject.equals(original) returns true.
+     * Not implemented in RDFJS, so optional.
+     */
+    fromQuad?: (original: Quad) => Quad;
+    /**
+     * Returns a new instance of Quad.
+     * If graph is undefined or null it MUST set graph to a DefaultGraph.
+     */
+    quad: (subject: Term, predicate: Term, object: Term, graph?: Term) => Quad<any, any, any, any>;
+    /**
+     * Returns a new instance of Quad.
+     * If graph is undefined or null it MUST set graph to a DefaultGraph.
+     */
+    triple: (subject: Term, predicate: Term, object: Term, graph?: Term) => Quad<any, any, any, any>;
+    /**
+     * Check for specific features/behaviour on the factory.
+     *
+     * This does not exist on the original RDF/JS spec
+     */
+    supports: SupportTable;
+}
+/** A RDF/JS spec Subject */
+export declare type Quad_Subject = NamedNode | BlankNode | Variable;
+/** A RDF/JS spec Predicate */
+export declare type Quad_Predicate = NamedNode | Variable;
+/** A RDF/JS spec Object */
+export declare type Quad_Object = NamedNode | BlankNode | Literal | Variable | Term;
+/** A RDF/JS spec Graph */
+export declare type Quad_Graph = NamedNode | DefaultGraph | BlankNode | Variable;

package/lib/types.d.ts

@@ -0,0 +1,68 @@
+import Node from './node-internal';
+import RDFlibVariable from './variable';
+import RDFlibBlankNode from './blank-node';
+import Collection from './collection';
+import RDFlibLiteral from './literal';
+import RDFlibNamedNode from './named-node';
+import RDFlibDefaultGraph from './default-graph';
+import { DataFactory } from './factories/factory-types';
+import IndexedFormula from './store';
+import Fetcher from './fetcher';
+import Statement from './statement';
+import Empty from './empty';
+import { NamedNode, Term, Quad_Subject, Quad_Predicate, Quad_Object, Quad_Graph } from './tf-types';
+export declare const NamedNodeTermType: "NamedNode";
+export declare const BlankNodeTermType: "BlankNode";
+export declare const LiteralTermType: "Literal";
+export declare const VariableTermType: "Variable";
+export declare const DefaultGraphTermType: "DefaultGraph";
+export declare const CollectionTermType: "Collection";
+export declare const EmptyTermType: "Empty";
+export declare const GraphTermType: "Graph";
+export declare type TermType = typeof NamedNodeTermType | typeof BlankNodeTermType | typeof LiteralTermType | typeof VariableTermType | typeof DefaultGraphTermType | typeof CollectionTermType | typeof EmptyTermType | typeof GraphTermType;
+export declare const HTMLContentType: "text/html";
+export declare const JSONLDContentType: "application/ld+json";
+export declare const N3ContentType: "text/n3";
+export declare const N3LegacyContentType: "application/n3";
+export declare const NQuadsAltContentType: "application/nquads";
+export declare const NQuadsContentType: "application/n-quads";
+export declare const NTriplesContentType: "application/n-triples";
+export declare const RDFXMLContentType: "application/rdf+xml";
+export declare const SPARQLUpdateContentType: "application/sparql-update";
+export declare const SPARQLUpdateSingleMatchContentType: "application/sparql-update-single-match";
+export declare const TurtleContentType: "text/turtle";
+export declare const TurtleLegacyContentType: "application/x-turtle";
+export declare const XHTMLContentType: "application/xhtml+xml";
+/**
+ * A valid mime type header
+ */
+export declare type ContentType = typeof RDFXMLContentType | typeof HTMLContentType | typeof JSONLDContentType | typeof N3ContentType | typeof N3LegacyContentType | typeof NQuadsAltContentType | typeof NQuadsContentType | typeof SPARQLUpdateContentType | typeof SPARQLUpdateSingleMatchContentType | typeof TurtleContentType | typeof TurtleLegacyContentType | typeof XHTMLContentType;
+/** A type for values that serves as inputs */
+export declare type ValueType = Term | Node | Date | string | number | boolean | undefined | null | Collection;
+/**
+ * In this project, there exist two types for the same kind of RDF concept.
+ * We have RDF/JS spec types (standardized, generic), and RDFlib types (internal, specific).
+ * When deciding which type to use in a function, it is preferable to accept generic inputs,
+ * whenever possible, and provide strict outputs.
+ * In some ways, the TF types in here are a bit more strict.
+ * Variables are missing, and the statement requires specific types of terms (e.g. NamedNode instead of Term).
+ */
+/** An RDF/JS Subject */
+export declare type SubjectType = RDFlibBlankNode | RDFlibNamedNode | RDFlibVariable;
+/** An RDF/JS Predicate */
+export declare type PredicateType = RDFlibNamedNode | RDFlibVariable;
+/** An RDF/JS Object */
+export declare type ObjectType = RDFlibNamedNode | RDFlibLiteral | Collection | RDFlibBlankNode | RDFlibVariable | Empty;
+/** An RDF/JS Graph */
+export declare type GraphType = RDFlibDefaultGraph | RDFlibNamedNode | RDFlibVariable;
+export interface Bindings {
+    [id: string]: Term;
+}
+/** All the types that a .fromValue() method might return */
+export declare type FromValueReturns<C extends Node = any> = Term | undefined | null | Collection<C>;
+export interface IRDFlibDataFactory extends DataFactory<RDFlibNamedNode | RDFlibBlankNode | RDFlibLiteral | Collection | Statement> {
+    fetcher: (store: IndexedFormula, options: any) => Fetcher;
+    lit: (val: string, lang?: string, dt?: NamedNode) => RDFlibLiteral;
+    graph: (features?: any, opts?: any) => IndexedFormula;
+    st: (subject: Quad_Subject, predicate: Quad_Predicate, object: Quad_Object, graph?: Quad_Graph) => Statement;
+}