rdflib 2.2.10 → 2.2.12-5f141ca2

package/lib/update-manager.d.ts

@@ -0,0 +1,198 @@
+import IndexedFormula from './store';
+import Fetcher from './fetcher';
+import Statement from './statement';
+import RDFlibNamedNode from './named-node';
+import { BlankNode, NamedNode, Quad_Subject, Quad, Term } from './tf-types';
+interface UpdateManagerFormula extends IndexedFormula {
+    fetcher: Fetcher;
+}
+declare type CallBackFunction = (uri: string, ok: boolean, message: string, response: Error | Response) => {} | void;
+/**
+* The UpdateManager is a helper object for a store.
+* Just as a Fetcher provides the store with the ability to read and write,
+* the Update Manager provides functionality for making small patches in real time,
+* and also looking out for concurrent updates from other agents
+*/
+export default class UpdateManager {
+    store: UpdateManagerFormula;
+    ifps: {};
+    fps: {};
+    /** Index of objects for coordinating incoming and outgoing patches */
+    patchControl: [];
+    /** Object of namespaces */
+    ns: any;
+    /**
+     * @param  store - The quadstore to store data and metadata. Created if not passed.
+    */
+    constructor(store?: IndexedFormula);
+    patchControlFor(doc: NamedNode): any;
+    isHttpUri(uri: string): boolean;
+    /**
+     * Tests whether a file is editable.
+     * If the file has a specific annotation that it is machine written,
+     * for safety, it is editable (this doesn't actually check for write access)
+     * If the file has wac-allow and accept patch headers, those are respected.
+     * and local write access is determined by those headers.
+     * This version only looks at past HTTP requests, does not make new ones.
+     *
+     * @returns The method string SPARQL or DAV or
+     *   LOCALFILE or false if known, undefined if not known.
+     */
+    editable(uri: string | NamedNode, kb?: IndexedFormula): string | boolean | undefined;
+    anonymize(obj: any): any;
+    anonymizeNT(stmt: Quad): string;
+    /**
+     * Returns a list of all bnodes occurring in a statement
+     * @private
+     */
+    statementBnodes(st: Quad): BlankNode[];
+    /**
+     * Returns a list of all bnodes occurring in a list of statements
+     * @private
+     */
+    statementArrayBnodes(sts: Quad[]): BlankNode[];
+    /**
+     * Makes a cached list of [Inverse-]Functional properties
+     * @private
+     */
+    cacheIfps(): void;
+    /**
+     * Returns a context to bind a given node, up to a given depth
+     * @private
+     */
+    bnodeContext2(x: any, source: any, depth: any): any;
+    /**
+     * Returns the smallest context to bind a given single bnode
+     * @private
+     */
+    bnodeContext1(x: any, source: any): any;
+    /**
+     * @private
+     */
+    mentioned(x: any): boolean;
+    /**
+     * @private
+     */
+    bnodeContext(bnodes: any, doc: any): never[];
+    /**
+     * Returns the best context for a single statement
+     * @private
+     */
+    statementContext(st: Quad): never[];
+    /**
+     * @private
+     */
+    contextWhere(context: any): string;
+    /**
+     * @private
+     */
+    fire(uri: string, query: string, callbackFunction: CallBackFunction): Promise<void>;
+    /** return a statemnet updating function
+     *
+     * This does NOT update the statement.
+     * It returns an object which includes
+     *  function which can be used to change the object of the statement.
+     */
+    update_statement(statement: Quad): {
+        statement: Term[] | undefined;
+        statementNT: string | undefined;
+        where: string;
+        set_object: (obj: any, callbackFunction: any) => void;
+    } | undefined;
+    insert_statement(st: Quad, callbackFunction: CallBackFunction): void;
+    delete_statement(st: Quad | Quad[], callbackFunction: CallBackFunction): void;
+    /**
+     * Requests a now or future action to refresh changes coming downstream
+     * This is designed to allow the system to re-request the server version,
+     * when a websocket has pinged to say there are changes.
+     * If the websocket, by contrast, has sent a patch, then this may not be necessary.
+     *
+     * @param doc
+     * @param action
+     */
+    requestDownstreamAction(doc: NamedNode, action: any): void;
+    /**
+     * We want to start counting websocket notifications
+     * to distinguish the ones from others from our own.
+     */
+    clearUpstreamCount(doc: NamedNode): void;
+    getUpdatesVia(doc: NamedNode): string | null;
+    addDownstreamChangeListener(doc: NamedNode, listener: any): void;
+    reloadAndSync(doc: NamedNode): void;
+    /**
+     * Sets up websocket to listen on
+     *
+     * There is coordination between upstream changes and downstream ones
+     * so that a reload is not done in the middle of an upstream patch.
+     * If you use this API then you get called when a change happens, and you
+     * have to reload the file yourself, and then refresh the UI.
+     * Alternative is addDownstreamChangeListener(), where you do not
+     * have to do the reload yourself. Do mot mix them.
+     *
+     * kb contains the HTTP  metadata from previous operations
+     *
+     * @param doc
+     * @param handler
+     *
+     * @returns {boolean}
+     */
+    setRefreshHandler(doc: NamedNode, handler: any): boolean;
+    /**
+     * This high-level function updates the local store iff the web is changed successfully.
+     * Deletions, insertions may be undefined or single statements or lists or formulae (may contain bnodes which can be indirectly identified by a where clause).
+     * The `why` property of each statement must be the give the web document to be updated.
+     * The statements to be deleted and inserted may span more than one web document.
+     * @param deletions - Statement or statements to be deleted.
+     * @param insertions - Statement or statements to be inserted.
+     * @returns a promise
+     */
+    updateMany(deletions: ReadonlyArray<Statement>, insertions?: ReadonlyArray<Statement>): Promise<void[]>;
+    /**
+     * This high-level function updates the local store iff the web is changed successfully.
+     * Deletions, insertions may be undefined or single statements or lists or formulae (may contain bnodes which can be indirectly identified by a where clause).
+     * The `why` property of each statement must be the same and give the web document to be updated.
+     * @param deletions - Statement or statements to be deleted.
+     * @param insertions - Statement or statements to be inserted.
+     * @param callback - called as callbackFunction(uri, success, errorbody)
+     *           OR returns a promise
+     */
+    update(deletions: ReadonlyArray<Statement>, insertions: ReadonlyArray<Statement>, callback?: (uri: string | undefined | null, success: boolean, errorBody?: string, response?: Response | Error) => void, secondTry?: boolean): void | Promise<void>;
+    updateDav(doc: Quad_Subject, ds: any, is: any, callbackFunction: any): null | Promise<void>;
+    /**
+     * Likely deprecated, since this lib no longer deals with browser extension
+     *
+     * @param doc
+     * @param ds
+     * @param is
+     * @param callbackFunction
+     */
+    updateLocalFile(doc: NamedNode, ds: any, is: any, callbackFunction: any): void;
+    /**
+     * @throws {Error} On unsupported content type
+     *
+     * @returns {string}
+     */
+    serialize(uri: string, data: string | Quad[], contentType: string): string;
+    /**
+     * This is suitable for an initial creation of a document.
+     */
+    put(doc: RDFlibNamedNode, data: string | Quad[], contentType: string, callback: (uri: string, ok: boolean, errorMessage?: string, response?: unknown) => void): Promise<void>;
+    /**
+     * Reloads a document.
+     *
+     * Fast and cheap, no metadata. Measure times for the document.
+     * Load it provisionally.
+     * Don't delete the statements before the load, or it will leave a broken
+     * document in the meantime.
+     *
+     * @param kb
+     * @param doc {RDFlibNamedNode}
+     * @param callbackFunction
+     */
+    reload(kb: IndexedFormula, doc: docReloadType, callbackFunction: (ok: boolean, message?: string, response?: Error | Response) => {} | void): void;
+}
+interface docReloadType extends NamedNode {
+    reloadTimeCount?: number;
+    reloadTimeTotal?: number;
+}
+export {};

package/lib/updates-via.d.ts

@@ -0,0 +1,26 @@
+export class UpdatesSocket {
+    constructor(parent: any, via: any);
+    parent: any;
+    via: any;
+    connected: boolean;
+    pending: {};
+    subscribed: {};
+    socket: {};
+    _decode(q: any): {};
+    _send(method: any, uri: any, data: any): any;
+    _subscribe(uri: any): any;
+    onClose(e: any): {};
+    onError(e: any): void;
+    onMessage(e: any): any;
+    onOpen(e: any): any[];
+    subscribe(uri: any): any;
+}
+export class UpdatesVia {
+    constructor(fetcher: any);
+    fetcher: any;
+    graph: {};
+    via: {};
+    onHeaders(d: any): boolean;
+    onUpdate(uri: any, d: any): any;
+    register(via: any, uri: any): any;
+}

package/lib/uri.d.ts

@@ -0,0 +1,33 @@
+import RDFlibNamedNode from './named-node';
+/**
+ * Gets the document part of an URI
+ * @param uri The URI
+ */
+export declare function docpart(uri: string): string;
+/**
+ * Gets the document part of an URI as a named node
+ * @param x - The URI
+ */
+export declare function document(x: string): RDFlibNamedNode;
+/**
+ * Gets the hostname in an URI
+ * @param u The URI
+ */
+export declare function hostpart(u: string): string;
+/**
+ * Joins an URI with a base
+ * @param given - The relative part
+ * @param base - The base URI
+ */
+export declare function join(given: string, base: string): string;
+/**
+ * Gets the protocol part of an URI
+ * @param uri The URI
+ */
+export declare function protocol(uri: string): string | null;
+/**
+ * Gets a relative uri
+ * @param base The base URI
+ * @param uri The absolute URI
+ */
+export declare function refTo(base: string, uri: string): string;

package/lib/utils/default-graph-uri.d.ts

@@ -0,0 +1,3 @@
+import NamedNode from '../named-node';
+export declare const defaultGraphURI = "chrome:theSession";
+export declare const defaultGraphNode: NamedNode;

package/lib/utils/termValue.d.ts

@@ -0,0 +1,3 @@
+import { Term } from '../tf-types';
+/** Retrieve the value of a term, or self if already a string. */
+export declare function termValue(node: Term | string): string;

package/lib/utils/terms.d.ts

@@ -0,0 +1,33 @@
+import { ObjectType } from '../types';
+import Collection from '../collection';
+import IndexedFormula from '../store';
+import Statement from '../statement';
+import { BlankNode, Quad_Graph, Literal, NamedNode, Quad_Object, Quad_Predicate, Quad, Quad_Subject, Term, Variable } from '../tf-types';
+/** TypeGuard for RDFLib Statements */
+export declare function isStatement(obj: any): obj is Statement;
+/** TypeGuard for RDFlib Stores */
+export declare function isStore(obj: any): obj is IndexedFormula;
+/** TypeGuard for RDFLib Collections */
+export declare function isCollection(obj: any): obj is Collection<any>;
+/** TypeGuard for valid RDFlib Object types, also allows Collections */
+export declare function isRDFlibObject(obj: any): obj is ObjectType;
+/** TypeGuard for RDFLib Variables */
+export declare function isVariable(obj: any): obj is Variable;
+/** TypeGuard for RDF/JS spec Terms */
+export declare function isTerm(obj: any): obj is Term;
+/** TypeGuard for RDF/JS spec Literals */
+export declare function isLiteral(value: any): value is Literal;
+/** TypeGuard for RDF/JS spec Quads */
+export declare function isQuad(obj: any): obj is Quad<any, any, any, any>;
+/** TypeGuard for RDF/JS spec NamedNodes */
+export declare function isNamedNode(obj: any): obj is NamedNode;
+/** TypeGuard for RDF/JS spec BlankNodes */
+export declare function isBlankNode(obj: any): obj is BlankNode;
+/** TypeGuard for valid RDF/JS spec Subject types */
+export declare function isSubject(obj: any): obj is Quad_Subject;
+/** TypeGuard for valid RDF/JS spec Predicate types */
+export declare function isPredicate(obj: any): obj is Quad_Predicate;
+/** TypeGuard for valid RDF/JS spec Object types */
+export declare function isRDFObject(obj: any): obj is Quad_Object;
+/** TypeGuard for valid RDF/JS Graph types */
+export declare function isGraph(obj: any): obj is Quad_Graph;

package/lib/utils-js.d.ts

@@ -0,0 +1,50 @@
+export function mediaTypeClass(mediaType: any): NamedNode;
+export function linkRelationProperty(relation: any): NamedNode;
+/**
+ * Adds callback functionality to an object.
+ * Callback functions are indexed by a 'hook' string.
+ * They return true if they want to be called again.
+ * @method callbackify
+ * @param obj {Object}
+ * @param callbacks {Array<string>}
+ */
+export function callbackify(obj: any, callbacks: Array<string>): void;
+/**
+ * Returns a DOM parser based on current runtime environment.
+ */
+export function DOMParserFactory(): any;
+export function domToString(node: any, options: any): string;
+export function dumpNode(node: any, options: any, selfClosing: any, skipAttributes: any): string;
+export function dtstamp(): string;
+/**
+ * Compares statements (heavy comparison for repeatable canonical ordering)
+ */
+export function heavyCompare(x: any, y: any, g: any, uriMap: any): any;
+export function heavyCompareSPO(x: any, y: any, g: any, uriMap: any): any;
+/**
+ * Defines a simple debugging function
+ * @method output
+ * @param o {String}
+ */
+export function output(o: string): void;
+/**
+ * Returns a DOM from parsex XML.
+ */
+export function parseXML(str: any, options: any): any;
+/**
+ * Removes all statements equal to x from a
+ */
+export function RDFArrayRemove(a: any, x: any): void;
+export function string_startswith(str: any, pref: any): boolean;
+export function stackString(e: any): string;
+import NamedNode from "./named-node";
+import log from "./log";
+import * as uri from "./uri";
+export namespace string {
+    export { stringTemplate as template };
+}
+/**
+ * C++, python style %s -> subs
+ */
+declare function stringTemplate(base: any, subs: any): string;
+export { log, uri };

package/lib/utils.d.ts

@@ -0,0 +1,20 @@
+import Fetcher from './fetcher';
+import { RdfJsDataFactory, Quad, Quad_Subject, Term } from './tf-types';
+/** RDF/JS spec Typeguards */
+/**
+ * Loads ontologies of the data we load (this is the callback from the kb to
+ * the fetcher).
+ */
+export declare function AJAR_handleNewTerm(kb: {
+    fetcher: Fetcher;
+}, p: any, requestedBy: any): any;
+export declare const appliedFactoryMethods: string[];
+/**
+ * Expands an array of Terms to a set of statements representing the rdf:list.
+ * @param rdfFactory - The factory to use
+ * @param subject - The iri of the first list item.
+ * @param data - The terms to expand into the list.
+ * @return The {data} as a set of statements.
+ */
+export declare function arrayToStatements(rdfFactory: RdfJsDataFactory, subject: Quad_Subject, data: Term[]): Quad[];
+export declare function ArrayIndexOf(arr: any, item: any, i?: number): number;

package/lib/variable.d.ts

@@ -0,0 +1,29 @@
+import Node from './node-internal';
+import { VariableTermType } from './types';
+import { Variable as TFVariable } from './tf-types';
+/**
+* Variables are placeholders used in patterns to be matched.
+* In cwm they are symbols which are the formula's list of quantified variables.
+* In sparql they are not visibly URIs.  Here we compromise, by having
+* a common special base URI for variables. Their names are uris,
+* but the ? notation has an implicit base uri of 'varid:'
+*/
+export default class Variable extends Node implements TFVariable {
+    termType: typeof VariableTermType;
+    /** The base string for a variable's name */
+    base: string;
+    classOrder: number;
+    isVar: number;
+    /** The unique identifier of this variable */
+    uri: string;
+    /**
+     * Initializes this variable
+     * @param name The variable's name
+     */
+    constructor(name?: string);
+    equals(other: any): boolean;
+    hashString(): string;
+    substitute(bindings: any): any;
+    toString(): string;
+    static toString(variable: any): string;
+}

package/lib/xsd-internal.d.ts

@@ -0,0 +1,11 @@
+declare namespace _default {
+    const boolean: NamedNode;
+    const dateTime: NamedNode;
+    const decimal: NamedNode;
+    const double: NamedNode;
+    const integer: NamedNode;
+    const langString: NamedNode;
+    const string: NamedNode;
+}
+export default _default;
+import NamedNode from "./named-node";

package/lib/xsd.d.ts

@@ -0,0 +1,19 @@
+export function createXSD(localFactory?: import("./factories/factory-types").DataFactory<import("./factories/factory-types").DefaultFactoryTypes, import("./factories/factory-types").Indexable>): {
+    boolean: import("./named-node").default;
+    dateTime: import("./named-node").default;
+    decimal: import("./named-node").default;
+    double: import("./named-node").default;
+    integer: import("./named-node").default;
+    langString: import("./named-node").default;
+    string: import("./named-node").default;
+};
+export default defaultXSD;
+declare namespace defaultXSD {
+    const boolean: import("./named-node").default;
+    const dateTime: import("./named-node").default;
+    const decimal: import("./named-node").default;
+    const double: import("./named-node").default;
+    const integer: import("./named-node").default;
+    const langString: import("./named-node").default;
+    const string: import("./named-node").default;
+}

package/lib/xsd.js

@@ -8,25 +8,19 @@ Object.defineProperty(exports, "__esModule", {
 exports.createXSD = createXSD;
 exports.default = void 0;
 
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-
 var _canonicalDataFactory = _interopRequireDefault(require("./factories/canonical-data-factory"));
 
 function createXSD() {
   var localFactory = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _canonicalDataFactory.default;
-
-  var XSD = function XSD() {
-    (0, _classCallCheck2.default)(this, XSD);
+  return {
+    boolean: localFactory.namedNode("http://www.w3.org/2001/XMLSchema#boolean"),
+    dateTime: localFactory.namedNode("http://www.w3.org/2001/XMLSchema#dateTime"),
+    decimal: localFactory.namedNode("http://www.w3.org/2001/XMLSchema#decimal"),
+    double: localFactory.namedNode("http://www.w3.org/2001/XMLSchema#double"),
+    integer: localFactory.namedNode("http://www.w3.org/2001/XMLSchema#integer"),
+    langString: localFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#langString"),
+    string: localFactory.namedNode("http://www.w3.org/2001/XMLSchema#string")
   };
-
-  XSD.boolean = localFactory.namedNode('http://www.w3.org/2001/XMLSchema#boolean');
-  XSD.dateTime = localFactory.namedNode('http://www.w3.org/2001/XMLSchema#dateTime');
-  XSD.decimal = localFactory.namedNode('http://www.w3.org/2001/XMLSchema#decimal');
-  XSD.double = localFactory.namedNode('http://www.w3.org/2001/XMLSchema#double');
-  XSD.integer = localFactory.namedNode('http://www.w3.org/2001/XMLSchema#integer');
-  XSD.langString = localFactory.namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#langString');
-  XSD.string = localFactory.namedNode('http://www.w3.org/2001/XMLSchema#string');
-  return XSD;
 }
 
 var defaultXSD = createXSD(_canonicalDataFactory.default);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rdflib",
   "description": "an RDF library for node.js. Suitable for client and server side.",
-  "version": "2.2.10",
+  "version": "2.2.12-5f141ca2",
   "engines": {
     "node": ">=6.0"
   },
@@ -92,9 +92,9 @@
     "build": "babel src --extensions \".ts,.js\" -d lib",
     "build:esm": "babel src --extensions \".ts,.js\" --env-name esm -d esm",
     "build:browser": "webpack --progress",
-    "build:types": "tsc --emitDeclarationOnly -d --moduleResolution node --declarationDir lib --allowJs false",
+    "build:types": "tsc --emitDeclarationOnly -d --moduleResolution node --declarationDir lib",
     "doc": "typedoc --out ./doc ./src/index.ts --excludePrivate --excludeInternal --tsconfig ./tsconfig.json",
-    "prepublishOnly": "npm ci && npm run build && npm run build:types && npm run build:browser && npm run build:esm",
+    "ignore:prepublishOnly": "npm ci && npm run build && npm run build:types && npm run build:browser && npm run build:esm",
     "postversion": "git push --follow-tags",
     "start": "webpack-dev-server --https --port 4800",
     "test": "npm run test:unit && npm run test:serialize && npm run test:types",

package/src/fetcher.ts

@@ -115,8 +115,10 @@ declare global {
   interface Window {
     panes?: any
     solidFetcher?: any
+    solidFetch?: any
   }
-  var solidFetcher:Function
+  var solidFetcher: Function
+  var solidFetch: Function
 }
 declare var $SolidTestEnvironment: {
   localSiteMap?: any
@@ -754,9 +756,10 @@ export default class Fetcher implements CallbackifyInterface {
     this.ns = getNS(this.store.rdfFactory)
     this.timeout = options.timeout || 30000
 
+    // solidFetcher is deprecated
     this._fetch = options.fetch
-               || (typeof global !== 'undefined' && global.solidFetcher)
-               || (typeof window !== 'undefined' && window.solidFetcher)
+               || (typeof global !== 'undefined' && (global.solidFetcher || global.solidFetch))
+               || (typeof window !== 'undefined' && (window.solidFetcher || window.solidFetch))
                || crossFetch
     if (!this._fetch) {
       throw new Error('No _fetch function available for Fetcher')