rdflib 2.2.10 → 2.2.12-5f141ca2

package/lib/named-node.d.ts

@@ -0,0 +1,44 @@
+import Node from './node-internal';
+import { NamedNodeTermType } from './types';
+import { NamedNode as TFNamedNode } from './tf-types';
+/**
+ * A named (IRI) RDF node
+ */
+export default class NamedNode extends Node implements TFNamedNode {
+    termType: typeof NamedNodeTermType;
+    classOrder: number;
+    /**
+     * Create a named (IRI) RDF Node
+     * @constructor
+     * @param iri - The IRI for this node
+     */
+    constructor(iri: string);
+    /**
+     * Returns an $rdf node for the containing directory, ending in slash.
+     */
+    dir(): NamedNode | null;
+    /**
+     * Returns an NN for the whole web site, ending in slash.
+     * Contrast with the "origin" which does NOT have a trailing slash
+     */
+    site(): NamedNode;
+    /**
+     * Creates the fetchable named node for the document.
+     * Removes everything from the # anchor tag.
+     */
+    doc(): NamedNode;
+    /**
+     * Returns the URI including <brackets>
+     */
+    toString(): string;
+    /** The local identifier with the document */
+    id(): string;
+    /** Alias for value, favored by Tim */
+    get uri(): string;
+    set uri(uri: string);
+    /**
+     * Creates a named node from the specified input value
+     * @param value - An input value
+     */
+    static fromValue(value: any): any;
+}

package/lib/namespace.d.ts

@@ -0,0 +1,7 @@
+import { RdfJsDataFactory, NamedNode } from './tf-types';
+/**
+ * Gets a namespace for the specified namespace's URI
+ * @param nsuri - The URI for the namespace
+ * @param [factory] - The factory for creating named nodes with
+ */
+export default function Namespace(nsuri: string, factory?: RdfJsDataFactory): (ln: string) => NamedNode;

package/lib/node-internal.d.ts

@@ -0,0 +1,63 @@
+import { ValueType, Bindings, FromValueReturns, TermType } from './types';
+import { Term } from './tf-types';
+/**
+ * The superclass of all RDF Statement objects, that is
+ * NamedNode, Literal, BlankNode, etc.
+ * Should not be instantiated directly.
+ * Also called Term.
+ * @link https://rdf.js.org/data-model-spec/#term-interface
+ * @class Node
+ */
+export default abstract class Node {
+    static fromValue: <T extends FromValueReturns>(value: ValueType) => T;
+    static toJS: (term: any) => Date | Number | string | boolean | object | Array<Date | Number | string | boolean | object>;
+    /** The type of node */
+    termType: TermType;
+    /** The class order for this node */
+    classOrder: number;
+    /** The node's value */
+    value: string;
+    protected constructor(value: string);
+    /**
+     * Creates the substituted node for this one, according to the specified bindings
+     * @param bindings - Bindings of identifiers to nodes
+     */
+    substitute<T extends Node = Node>(bindings: Bindings): T;
+    /**
+     * Compares this node with another
+     * @see {equals} to check if two nodes are equal
+     * @param other - The other node
+     */
+    compareTerm(other: Node): number;
+    /**
+     * Compares whether the two nodes are equal
+     * @param other The other node
+     */
+    equals(other: Term): boolean;
+    /**
+     * Creates a hash for this node
+     * @deprecated use {rdfFactory.id} instead if possible
+     */
+    hashString(): string;
+    /**
+     * Compares whether this node is the same as the other one
+     * @param other - Another node
+     */
+    sameTerm(other: Node): boolean;
+    /**
+     * Creates a canonical string representation of this node
+     */
+    toCanonical(): string;
+    /**
+     * Creates a n-triples string representation of this node
+     */
+    toNT(): string;
+    /**
+     * Creates a n-quads string representation of this node
+     */
+    toNQ(): string;
+    /**
+     * Creates a string representation of this node
+     */
+    toString(): string;
+}

package/lib/node.d.ts

@@ -0,0 +1,2 @@
+import Node from './node-internal';
+export default Node;

package/lib/parse.d.ts

@@ -0,0 +1,16 @@
+import Formula from './formula';
+import { ContentType } from './types';
+declare type CallbackFunc = (error: any, kb: Formula | null) => void;
+/**
+ * Parse a string and put the result into the graph kb.
+ * Normal method is sync.
+ * Unfortunately jsdonld is currently written to need to be called async.
+ * Hence the mess below with executeCallback.
+ * @param str - The input string to parse
+ * @param kb - The store to use
+ * @param base - The base URI to use
+ * @param contentType - The MIME content type string for the input - defaults to text/turtle
+ * @param [callback] - The callback to call when the data has been loaded
+ */
+export default function parse(str: string, kb: Formula, base: string, contentType?: string | ContentType, callback?: CallbackFunc): void;
+export {};

package/lib/patch-parser.d.ts

@@ -0,0 +1,3 @@
+export default function sparqlUpdateParser(str: any, kb: any, base: any): {
+    query: any;
+};

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

@@ -0,0 +1 @@
+export default function queryToSPARQL(query: any): string;

package/lib/query.d.ts

@@ -0,0 +1,27 @@
+/**
+ * This function will match a pattern to the current Store
+ *
+ * The callback function is called whenever a match is found
+ * When fetcher is supplied this will be called to load from the web
+ * any new nodes as they are discovered.  This will cause the query to traverse the
+ * graph of linked data, sometimes called "Link Following Query"
+ *
+ * @param myQuery - a knowledgebase containing a pattern to use as query
+ * @param callback - whenever the pattern in myQuery is met this is called with
+ *  the new bindings as parameter
+ * @param fetcher? - If and only if,  you want link following, give a fetcher
+ *                which has been created for the quadstore being queried.
+ * @param onDone -  callback when query finished
+ */
+export function indexedFormulaQuery(myQuery: any, callback: any, fetcher: any, onDone: any): void;
+/**
+ * Query class, for tracking queries the user has in the UI.
+ */
+export class Query {
+    constructor(name: any, id: any);
+    pat: IndexedFormula;
+    vars: any[];
+    name: any;
+    id: any;
+}
+import IndexedFormula from "./store";

package/lib/rdfaparser.d.ts

@@ -0,0 +1,78 @@
+declare class RDFaProcessor {
+    static parseRDFaDOM(dom: any, kb: any, base: any): void;
+    static tokenize(str: any): any;
+    static trim(str: any): any;
+    constructor(kb: any, options: any);
+    options: any;
+    kb: any;
+    target: any;
+    blankNodes: any[];
+    htmlOptions: {
+        selfClosing: string;
+    };
+    theOne: string;
+    language: any;
+    vocabulary: any;
+    blankCounter: number;
+    langAttributes: {
+        namespaceURI: string;
+        localName: string;
+    }[];
+    inXHTMLMode: boolean;
+    absURIRE: RegExp;
+    finishedHandlers: any[];
+    addTriple(origin: any, subject: any, predicate: any, object: any): void;
+    ancestorPath(node: any): string;
+    copyMappings(mappings: any): {};
+    copyProperties(): void;
+    deriveDateTimeType(value: any): string | null;
+    init(): void;
+    newBlankNode(): string;
+    newSubjectOrigin(origin: any, subject: any): void;
+    parseCURIE(value: any, prefixes: any, base: any): any;
+    parseCURIEOrURI(value: any, prefixes: any, base: any): any;
+    parsePredicate(value: any, defaultVocabulary: any, terms: any, prefixes: any, base: any, ignoreTerms: any): any;
+    parsePrefixMappings(str: any, target: any): void;
+    parseSafeCURIEOrCURIEOrURI(value: any, prefixes: any, base: any): any;
+    parseTermOrCURIEOrAbsURI(value: any, defaultVocabulary: any, terms: any, prefixes: any, base: any): any;
+    parseTermOrCURIEOrURI(value: any, defaultVocabulary: any, terms: any, prefixes: any, base: any): any;
+    parseURI(uri: any): any;
+    process(node: any, options: any): void;
+    push(parent: any, subject: any): {
+        parent: any;
+        subject: any;
+        parentObject: null;
+        incomplete: never[];
+        listMapping: any;
+        language: any;
+        prefixes: any;
+        terms: any;
+        vocabulary: any;
+    };
+    resolveAndNormalize(base: any, uri: any): string;
+    setContext(node: any): void;
+    setHTMLContext(): void;
+    inHTMLMode: boolean | undefined;
+    setInitialContext(): void;
+    setXHTMLContext(): void;
+    setXMLContext(): void;
+    tokenize(str: any): any;
+    toRDFNodeObject(x: any): any;
+    trim(str: any): any;
+}
+declare namespace RDFaProcessor {
+    const XMLLiteralURI: string;
+    const HTMLLiteralURI: string;
+    const PlainLiteralURI: string;
+    const objectURI: string;
+    const typeURI: string;
+    const nameChar: string;
+    const nameStartChar: string;
+    const NCNAME: RegExp;
+    const dateTimeTypes: {
+        pattern: RegExp;
+        type: string;
+    }[];
+}
+export default RDFaProcessor;
+export function parseRDFaDOM(dom: any, kb: any, base: any): void;

package/lib/rdfxmlparser.d.ts

@@ -0,0 +1,60 @@
+export default class RDFParser {
+    /** Standard namespaces that we know how to handle @final
+     *  @member RDFParser
+     */
+    static ns: {
+        RDF: string;
+        RDFS: string;
+    };
+    /** DOM Level 2 node type magic numbers @final
+     *  @member RDFParser
+     */
+    static nodeType: {
+        ELEMENT: number;
+        ATTRIBUTE: number;
+        TEXT: number;
+        CDATA_SECTION: number;
+        ENTITY_REFERENCE: number;
+        ENTITY: number;
+        PROCESSING_INSTRUCTION: number;
+        COMMENT: number;
+        DOCUMENT: number;
+        DOCUMENT_TYPE: number;
+        DOCUMENT_FRAGMENT: number;
+        NOTATION: number;
+    };
+    constructor(store: any);
+    /** Our triple store reference @private */
+    store: any; /** Our identified blank nodes @private */
+    bnodes: {}; /** A context for context-aware stores @private */
+    why: any; /** Reification flag */
+    reify: boolean;
+    /**
+     * Frame class for namespace and base URI lookups
+     * Base lookups will always resolve because the parser knows
+     * the default base.
+     *
+     * @private
+     */
+    private frameFactory;
+    getAttributeNodeNS(node: any, uri: any, name: any): any;
+    /**
+     * Build our initial scope frame and parse the DOM into triples
+     * @param {DOMTree} document The DOM to parse
+     * @param {String} base The base URL to use
+     * @param {Object} why The context to which this resource belongs
+     */
+    parse(document: any, base: string, why: any): boolean;
+    base: string | undefined;
+    parseDOM(frame: any): void;
+    /**
+     * Cleans out state from a previous parse run
+     * @private
+     */
+    private cleanParser;
+    /**
+     * Builds scope frame
+     * @private
+     */
+    private buildFrame;
+}