rdflib 2.2.10 → 2.2.12-5f141ca2

package/esm/utils-js.js

@@ -0,0 +1,348 @@
+/**
+ * Utility functions for $rdf
+ * @module util
+ */
+import { docpart } from './uri';
+import log from './log';
+import * as uri from './uri';
+import NamedNode from './named-node';
+var string = {
+  template: stringTemplate
+};
+export { log, uri, string };
+export function mediaTypeClass(mediaType) {
+  mediaType = mediaType.split(';')[0].trim(); // remove media type parameters
+
+  return new NamedNode('http://www.w3.org/ns/iana/media-types/' + mediaType + '#Resource');
+}
+export function linkRelationProperty(relation) {
+  return new NamedNode('http://www.w3.org/ns/iana/link-relations/relation#' + relation.trim());
+}
+/**
+ * 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, callbacks) {
+  obj.callbacks = {};
+
+  for (var x = callbacks.length - 1; x >= 0; x--) {
+    obj.callbacks[callbacks[x]] = [];
+  }
+
+  obj.addHook = function (hook) {
+    if (!obj.callbacks[hook]) {
+      obj.callbacks[hook] = [];
+    }
+  };
+
+  obj.addCallback = function (hook, func) {
+    obj.callbacks[hook].push(func);
+  };
+
+  obj.removeCallback = function (hook, funcName) {
+    for (var i = 0; i < obj.callbacks[hook].length; i++) {
+      if (obj.callbacks[hook][i].name === funcName) {
+        obj.callbacks[hook].splice(i, 1);
+        return true;
+      }
+    }
+
+    return false;
+  };
+
+  obj.insertCallback = function (hook, func) {
+    obj.callbacks[hook].unshift(func);
+  };
+
+  obj.fireCallbacks = function fireCallbacks(hook, args) {
+    var newCallbacks = [];
+    var replaceCallbacks = [];
+    var len = obj.callbacks[hook].length;
+    var x;
+    var callback; // log.info('!@$ Firing '+hook+' call back with length'+len)
+
+    for (x = len - 1; x >= 0; x--) {
+      // log.info('@@ Firing '+hook+' callback '+ obj.callbacks[hook][x])
+      callback = obj.callbacks[hook][x];
+
+      if (callback && callback.apply(obj, args)) {
+        newCallbacks.push(callback);
+      }
+    }
+
+    for (x = newCallbacks.length - 1; x >= 0; x--) {
+      replaceCallbacks.push(newCallbacks[x]);
+    }
+
+    for (x = len; x < obj.callbacks[hook].length; x++) {
+      replaceCallbacks.push(obj.callbacks[hook][x]);
+    }
+
+    obj.callbacks[hook] = replaceCallbacks;
+  };
+}
+/**
+ * Returns a DOM parser based on current runtime environment.
+ */
+
+export function DOMParserFactory() {
+  if (window.DOMParser) {
+    return new DOMParser();
+  } else if (window.ActiveXObject) {
+    return new ActiveXObject('Microsoft.XMLDOM');
+  } else {
+    return false;
+  }
+} // From https://github.com/linkeddata/dokieli
+
+export function domToString(node, options) {
+  options = options || {};
+  var selfClosing = [];
+
+  if (options && options.selfClosing) {
+    options.selfClosing.split(' ').forEach(function (n) {
+      selfClosing[n] = true;
+    });
+  }
+
+  var skipAttributes = [];
+
+  if (options && options.skipAttributes) {
+    options.skipAttributes.split(' ').forEach(function (n) {
+      skipAttributes[n] = true;
+    });
+  }
+
+  return dumpNode(node, options, selfClosing, skipAttributes);
+}
+export function dumpNode(node, options, selfClosing, skipAttributes) {
+  var i;
+  var out = '';
+  var noEsc = [false];
+  if (typeof node.nodeType === 'undefined') return out;
+
+  if (node.nodeType === 1) {
+    if (node.hasAttribute('class') && options && options.classWithChildText && node.matches(options.classWithChildText.class)) {
+      out += node.querySelector(options.classWithChildText.element).textContent;
+    } else if (!(options && options.skipNodeWithClass && node.matches('.' + options.skipNodeWithClass))) {
+      var ename = node.nodeName.toLowerCase();
+      out += '<' + ename;
+      var attrList = [];
+
+      for (i = node.attributes.length - 1; i >= 0; i--) {
+        var atn = node.attributes[i];
+        if (skipAttributes && skipAttributes.length > 0 && skipAttributes[atn.name]) continue;
+        if (/^\d+$/.test(atn.name)) continue;
+
+        if (atn.name === 'class' && options && options.replaceClassItemWith && atn.value.split(' ').indexOf(options.replaceClassItemWith.source) > -1) {
+          var re = new RegExp(options.replaceClassItemWith.source, 'g');
+          atn.value = atn.value.replace(re, options.replaceClassItemWith.target).trim();
+        }
+
+        if (!(atn.name === 'class' && options && options.skipClassWithValue && options.skipClassWithValue === atn.value)) {
+          attrList.push(atn.name + '=\'' + atn.value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/'/g, '&quot;') + '\'');
+        }
+      }
+
+      if (attrList.length > 0) {
+        if (options && options.sortAttributes) {
+          attrList.sort(function (a, b) {
+            return a.toLowerCase().localeCompare(b.toLowerCase());
+          });
+        }
+
+        out += ' ' + attrList.join(' ');
+      }
+
+      if (selfClosing && selfClosing.ename) {
+        out += ' />';
+      } else {
+        out += '>';
+        out += ename === 'html' ? '\n  ' : '';
+        noEsc.push(ename === 'style' || ename === 'script');
+
+        for (i = 0; i < node.childNodes.length; i++) {
+          out += dumpNode(node.childNodes[i]);
+        }
+
+        noEsc.pop();
+        out += ename === 'body' ? '</' + ename + '>' + '\n' : '</' + ename + '>';
+      }
+    }
+  } else if (node.nodeType === 8) {
+    // FIXME: If comments are not tabbed in source, a new line is not prepended
+    out += '<!--' + node.nodeValue + '-->';
+  } else if (node.nodeType === 3 || node.nodeType === 4) {
+    // XXX: Remove new lines which were added after DOM ready
+    var nl = node.nodeValue.replace(/\n+$/, '');
+    out += noEsc[noEsc.length - 1] ? nl : nl.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+  } else {
+    console.log('Warning; Cannot handle serialising nodes of type: ' + node.nodeType);
+    console.log(node);
+  }
+
+  return out;
+}
+export function dtstamp() {
+  var now = new Date();
+  var year = now.getYear() + 1900;
+  var month = now.getMonth() + 1;
+  var day = now.getDate();
+  var hour = now.getUTCHours();
+  var minute = now.getUTCMinutes();
+  var second = now.getSeconds();
+  if (month < 10) month = '0' + month;
+  if (day < 10) day = '0' + day;
+  if (hour < 10) hour = '0' + hour;
+  if (minute < 10) minute = '0' + minute;
+  if (second < 10) second = '0' + second;
+  return year + '-' + month + '-' + day + 'T' + hour + ':' + minute + ':' + second + 'Z';
+}
+/**
+ * Compares statements (heavy comparison for repeatable canonical ordering)
+ */
+
+export function heavyCompare(x, y, g, uriMap) {
+  var nonBlank = function nonBlank(x) {
+    return x.termType === 'BlankNode' ? null : x;
+  };
+
+  var signature = function signature(x) {
+    var lis = g.statementsMatching(x).map(function (st) {
+      return '' + nonBlank(st.subject) + ' ' + nonBlank(st.predicate) + ' ' + nonBlank(st.object);
+    }).concat(g.statementsMatching(undefined, undefined, x).map(function (st) {
+      return '' + nonBlank(st.subject) + ' ' + nonBlank(st.predicate) + ' ' + nonBlank(st.object);
+    }));
+    lis.sort();
+    return lis.join('\n');
+  };
+
+  var comparison = Object.prototype.hasOwnProperty.call(g, "compareTerms") ? g.compareTerms(x, y) : x.compareTerm(y);
+
+  if (x.termType === 'BlankNode' && y.termType === 'BlankNode') {
+    if (comparison === 0) return 0; // Same
+
+    if (signature(x) > signature(y)) return +1;
+    if (signature(x) < signature(y)) return -1;
+    return comparison; // Too bad -- this order not canonical.
+    // throw "different bnodes indistinquishable for sorting"
+  } else {
+    if (uriMap && x.uri && y.uri) {
+      return (uriMap[x.uri] || x.uri).localeCompare(uriMap[y.uri] || y.uri);
+    }
+
+    return comparison;
+  }
+}
+export function heavyCompareSPO(x, y, g, uriMap) {
+  return heavyCompare(x.subject, y.subject, g, uriMap) || heavyCompare(x.predicate, y.predicate, g, uriMap) || heavyCompare(x.object, y.object, g, uriMap);
+}
+/**
+ * Defines a simple debugging function
+ * @method output
+ * @param o {String}
+ */
+
+export function output(o) {
+  var k = document.createElement('div');
+  k.textContent = o;
+  document.body.appendChild(k);
+}
+import { DOMParser } from 'xmldom';
+/**
+ * Returns a DOM from parsex XML.
+ */
+
+export function parseXML(str, options) {
+  var dparser;
+  options = options || {};
+
+  if (typeof module !== 'undefined' && module && module.exports) {
+    // Node.js
+    var dom = new DOMParser().parseFromString(str, options.contentType || 'application/xhtml+xml');
+    return dom;
+  } else {
+    if (typeof window !== 'undefined' && window.DOMParser) {
+      dparser = new window.DOMParser(); // seems to actually work
+    } else {
+      dparser = new DOMParser(); // Doc says this works
+    }
+  }
+
+  return dparser.parseFromString(str, 'application/xml');
+}
+/**
+ * Removes all statements equal to x from a
+ */
+
+export function RDFArrayRemove(a, x) {
+  for (var i = 0; i < a.length; i++) {
+    // TODO: This used to be the following, which didnt always work..why
+    // if(a[i] === x)
+    if (a[i].subject.equals(x.subject) && a[i].predicate.equals(x.predicate) && a[i].object.equals(x.object) && a[i].why.equals(x.why)) {
+      a.splice(i, 1);
+      return;
+    }
+  }
+
+  throw new Error('RDFArrayRemove: Array did not contain ' + x + ' ' + x.why);
+}
+export function string_startswith(str, pref) {
+  // missing library routines
+  return str.slice(0, pref.length) === pref;
+}
+/**
+ * C++, python style %s -> subs
+ */
+
+function stringTemplate(base, subs) {
+  var baseA = base.split('%s');
+  var result = '';
+
+  for (var i = 0; i < subs.length; i++) {
+    subs[i] += '';
+    result += baseA[i] + subs[i];
+  }
+
+  return result + baseA.slice(subs.length).join();
+} // Stack dump on errors - to pass errors back
+
+
+export function stackString(e) {
+  var str = '' + e + '\n';
+
+  if (!e.stack) {
+    return str + 'No stack available.\n';
+  }
+
+  var lines = e.stack.toString().split('\n');
+  var toprint = [];
+
+  for (var i = 0; i < lines.length; i++) {
+    var line = lines[i];
+
+    if (line.indexOf('ecmaunit.js') > -1) {
+      // remove useless bit of traceback
+      break;
+    }
+
+    if (line.charAt(0) == '(') {
+      line = 'function' + line;
+    }
+
+    var chunks = line.split('@');
+    toprint.push(chunks);
+  } // toprint.reverse();  No - I prefer the latest at the top by the error message -tbl
+
+
+  for (var i = 0; i < toprint.length; i++) {
+    str += '  ' + toprint[i][1] + '\n    ' + toprint[i][0];
+  }
+
+  return str;
+}

package/esm/utils.js

@@ -0,0 +1,103 @@
+import log from './log';
+import { docpart } from './uri';
+import { string_startswith } from './utils-js';
+
+/** RDF/JS spec Typeguards */
+
+/**
+ * Loads ontologies of the data we load (this is the callback from the kb to
+ * the fetcher).
+ */
+export function AJAR_handleNewTerm(kb, p, requestedBy) {
+  var sf = null;
+
+  if (typeof kb.fetcher !== 'undefined') {
+    sf = kb.fetcher;
+  } else {
+    return;
+  }
+
+  if (p.termType !== 'NamedNode') return;
+  var docuri = docpart(p.uri);
+  var fixuri;
+
+  if (p.uri.indexOf('#') < 0) {
+    // No hash
+    // @@ major hack for dbpedia Categories, which spread indefinitely
+    if (string_startswith(p.uri, 'http://dbpedia.org/resource/Category:')) return;
+    /*
+      if (string_startswith(p.uri, 'http://xmlns.com/foaf/0.1/')) {
+      fixuri = "http://dig.csail.mit.edu/2005/ajar/ajaw/test/foaf"
+      // should give HTTP 303 to ontology -- now is :-)
+      } else
+    */
+
+    if (string_startswith(p.uri, 'http://purl.org/dc/elements/1.1/') || string_startswith(p.uri, 'http://purl.org/dc/terms/')) {
+      fixuri = 'http://dublincore.org/2005/06/13/dcq'; // dc fetched multiple times
+    } else if (string_startswith(p.uri, 'http://xmlns.com/wot/0.1/')) {
+      fixuri = 'http://xmlns.com/wot/0.1/index.rdf';
+    } else if (string_startswith(p.uri, 'http://web.resource.org/cc/')) {
+      //            log.warn("creative commons links to html instead of rdf. doesn't seem to content-negotiate.")
+      fixuri = 'http://web.resource.org/cc/schema.rdf';
+    }
+  }
+
+  if (fixuri) {
+    docuri = fixuri;
+  }
+
+  if (sf && sf.getState(docuri) !== 'unrequested') return;
+
+  if (fixuri) {
+    // only give warning once: else happens too often
+    log.warn('Assuming server still broken, faking redirect of <' + p.uri + '> to <' + docuri + '>');
+  }
+
+  return sf.fetch(docuri, {
+    referringTerm: requestedBy
+  });
+}
+export var appliedFactoryMethods = ['blankNode', 'defaultGraph', 'literal', 'namedNode', 'quad', 'variable', 'supports'];
+var rdf = {
+  first: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#first',
+  rest: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#rest',
+  nil: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#nil'
+};
+/**
+ * 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 function arrayToStatements(rdfFactory, subject, data) {
+  var statements = [];
+  data.reduce(function (id, _listObj, i, listData) {
+    statements.push(rdfFactory.quad(id, rdfFactory.namedNode(rdf.first), listData[i]));
+    var nextNode;
+
+    if (i < listData.length - 1) {
+      nextNode = rdfFactory.blankNode();
+      statements.push(rdfFactory.quad(id, rdfFactory.namedNode(rdf.rest), nextNode));
+    } else {
+      statements.push(rdfFactory.quad(id, rdfFactory.namedNode(rdf.rest), rdfFactory.namedNode(rdf.nil)));
+    }
+
+    return nextNode;
+  }, subject);
+  return statements;
+}
+export function ArrayIndexOf(arr, item) {
+  var i = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var length = arr.length;
+  if (i < 0) i = length + i;
+
+  for (; i < length; i++) {
+    if (arr[i] === item) {
+      return i;
+    }
+  }
+
+  return -1;
+}

package/esm/variable.js

@@ -0,0 +1,101 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+import ClassOrder from './class-order';
+import Node from './node-internal';
+import { VariableTermType } from './types';
+import * as Uri from './uri';
+
+/**
+* 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:'
+*/
+var Variable = /*#__PURE__*/function (_Node) {
+  _inherits(Variable, _Node);
+
+  var _super = _createSuper(Variable);
+
+  /** The base string for a variable's name */
+
+  /** The unique identifier of this variable */
+
+  /**
+   * Initializes this variable
+   * @param name The variable's name
+   */
+  function Variable() {
+    var _this;
+
+    var name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+
+    _classCallCheck(this, Variable);
+
+    _this = _super.call(this, name);
+
+    _defineProperty(_assertThisInitialized(_this), "termType", VariableTermType);
+
+    _defineProperty(_assertThisInitialized(_this), "base", 'varid:');
+
+    _defineProperty(_assertThisInitialized(_this), "classOrder", ClassOrder.Variable);
+
+    _defineProperty(_assertThisInitialized(_this), "isVar", 1);
+
+    _defineProperty(_assertThisInitialized(_this), "uri", void 0);
+
+    _this.base = 'varid:';
+    _this.uri = Uri.join(name, _this.base);
+    return _this;
+  }
+
+  _createClass(Variable, [{
+    key: "equals",
+    value: function equals(other) {
+      if (!other) {
+        return false;
+      }
+
+      return this.termType === other.termType && this.value === other.value;
+    }
+  }, {
+    key: "hashString",
+    value: function hashString() {
+      return this.toString();
+    }
+  }, {
+    key: "substitute",
+    value: function substitute(bindings) {
+      var ref;
+      return (ref = bindings[this.toNT()]) != null ? ref : this;
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      return Variable.toString(this);
+    }
+  }], [{
+    key: "toString",
+    value: function toString(variable) {
+      if (variable.uri.slice(0, variable.base.length) === variable.base) {
+        return "?".concat(variable.uri.slice(variable.base.length));
+      }
+
+      return "?".concat(variable.uri);
+    }
+  }]);
+
+  return Variable;
+}(Node);
+
+export { Variable as default };

package/esm/xsd-internal.js

@@ -0,0 +1,10 @@
+import NamedNode from './named-node';
+export default {
+  boolean: new NamedNode('http://www.w3.org/2001/XMLSchema#boolean'),
+  dateTime: new NamedNode('http://www.w3.org/2001/XMLSchema#dateTime'),
+  decimal: new NamedNode('http://www.w3.org/2001/XMLSchema#decimal'),
+  double: new NamedNode('http://www.w3.org/2001/XMLSchema#double'),
+  integer: new NamedNode('http://www.w3.org/2001/XMLSchema#integer'),
+  langString: new NamedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#langString'),
+  string: new NamedNode('http://www.w3.org/2001/XMLSchema#string')
+};

package/esm/xsd.js

@@ -0,0 +1,15 @@
+import CanonicalDataFactory from "./factories/canonical-data-factory";
+export function createXSD() {
+  var localFactory = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : CanonicalDataFactory;
+  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")
+  };
+}
+var defaultXSD = createXSD(CanonicalDataFactory);
+export default defaultXSD;

package/lib/blank-node.d.ts

@@ -0,0 +1,44 @@
+import Node from './node-internal';
+import IndexedFormula from './store';
+import { BlankNodeTermType } from './types';
+import { BlankNode as TFBlankNode } from './tf-types';
+/**
+ * An RDF blank node is a Node without a URI
+ * @link https://rdf.js.org/data-model-spec/#blanknode-interface
+ */
+export default class BlankNode extends Node implements TFBlankNode {
+    termType: typeof BlankNodeTermType;
+    /**
+     * The next unique identifier for blank nodes
+     */
+    static nextId: number;
+    static NTAnonymousNodePrefix: '_:';
+    private static getId;
+    classOrder: number;
+    /** Whether this is a blank node */
+    isBlank: number;
+    /**
+     * This type of node is a variable.
+     *
+     * Note that the existence of this property already indicates that it is a variable.
+     */
+    isVar: number;
+    /**
+     * Initializes this node
+     * @param [id] The identifier for the blank node
+     */
+    constructor(id?: string | unknown);
+    /**
+     * The identifier for the blank node
+     */
+    get id(): string;
+    set id(value: string);
+    compareTerm(other: BlankNode): number;
+    /**
+     * Gets a copy of this blank node in the specified formula
+     * @param formula The formula
+     */
+    copy(formula: IndexedFormula): BlankNode;
+    toCanonical(): string;
+    toString(): string;
+}

package/lib/class-order.d.ts

@@ -0,0 +1,7 @@
+/**
+* Class orders
+*/
+declare const ClassOrder: {
+    [id: string]: number;
+};
+export default ClassOrder;