rdflib 2.2.10 → 2.2.12-5f141ca2

package/esm/updates-via.js

@@ -0,0 +1,197 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+
+/*
+ * Updates-Via
+ */
+import DataFactory from './factories/rdflib-data-factory';
+export var UpdatesSocket = /*#__PURE__*/function () {
+  function UpdatesSocket(parent, via) {
+    _classCallCheck(this, UpdatesSocket);
+
+    this.parent = parent;
+    this.via = via;
+    this.connected = false;
+    this.pending = {};
+    this.subscribed = {};
+    this.socket = {};
+
+    try {
+      this.socket = new WebSocket(via);
+      this.socket.onopen = this.onOpen;
+      this.socket.onclose = this.onClose;
+      this.socket.onmessage = this.onMessage;
+      this.socket.onerror = this.onError;
+    } catch (error) {
+      this.onError(error);
+    }
+  }
+
+  _createClass(UpdatesSocket, [{
+    key: "_decode",
+    value: function _decode(q) {
+      var elt;
+      var i;
+      var k;
+      var r;
+      var ref;
+      var ref1;
+      var v;
+      r = {};
+
+      ref = function () {
+        var j, len, ref, results;
+        ref = q.split('&');
+        results = [];
+
+        for (j = 0, len = ref.length; j < len; j++) {
+          elt = ref[j];
+          results.push(elt.split('='));
+        }
+
+        return results;
+      }();
+
+      for (i in ref) {
+        elt = ref[i];
+        ref1 = [decodeURIComponent(elt[0]), decodeURIComponent(elt[1])];
+        k = ref1[0];
+        v = ref1[1];
+
+        if (r[k] == null) {
+          r[k] = [];
+        }
+
+        r[k].push(v);
+      }
+
+      return r;
+    }
+  }, {
+    key: "_send",
+    value: function _send(method, uri, data) {
+      var base, message;
+      message = [method, uri, data].join(' ');
+      return typeof (base = this.socket).send === 'function' ? base.send(message) : void 0;
+    }
+  }, {
+    key: "_subscribe",
+    value: function _subscribe(uri) {
+      this._send('sub', uri, '');
+
+      this.subscribed[uri] = true;
+      return this.subscribed[uri];
+    }
+  }, {
+    key: "onClose",
+    value: function onClose(e) {
+      var uri;
+      this.connected = false;
+
+      for (uri in this.subscribed) {
+        this.pending[uri] = true;
+      }
+
+      this.subscribed = {};
+      return this.subscribed;
+    }
+  }, {
+    key: "onError",
+    value: function onError(e) {
+      throw new Error('onError' + e);
+    }
+  }, {
+    key: "onMessage",
+    value: function onMessage(e) {
+      var base, message;
+      message = e.data.split(' ');
+
+      if (message[0] === 'ping') {
+        return typeof (base = this.socket).send === 'function' ? base.send('pong ' + message.slice(1).join(' ')) : void 0;
+      } else if (message[0] === 'pub') {
+        return this.parent.onUpdate(message[1], this._decode(message[2]));
+      }
+    }
+  }, {
+    key: "onOpen",
+    value: function onOpen(e) {
+      var results, uri;
+      this.connected = true;
+      results = [];
+
+      for (uri in this.pending) {
+        delete this.pending[uri];
+        results.push(this._subscribe(uri));
+      }
+
+      return results;
+    }
+  }, {
+    key: "subscribe",
+    value: function subscribe(uri) {
+      if (this.connected) {
+        return this._subscribe(uri);
+      } else {
+        this.pending[uri] = true;
+        return this.pending[uri];
+      }
+    }
+  }]);
+
+  return UpdatesSocket;
+}();
+export var UpdatesVia = /*#__PURE__*/function () {
+  function UpdatesVia(fetcher) {
+    _classCallCheck(this, UpdatesVia);
+
+    this.fetcher = fetcher;
+    this.graph = {};
+    this.via = {};
+    this.fetcher.addCallback('headers', this.onHeaders);
+  }
+
+  _createClass(UpdatesVia, [{
+    key: "onHeaders",
+    value: function onHeaders(d) {
+      var etag, uri, via;
+
+      if (d.headers == null) {
+        return true;
+      }
+
+      if (typeof WebSocket === 'undefined' || WebSocket === null) {
+        return true;
+      }
+
+      etag = d.headers['etag'];
+      via = d.headers['updates-via'];
+      uri = d.uri;
+
+      if (etag && via) {
+        this.graph[uri] = {
+          etag: etag,
+          via: via
+        };
+        this.register(via, uri);
+      }
+
+      return true;
+    }
+  }, {
+    key: "onUpdate",
+    value: function onUpdate(uri, d) {
+      return this.fetcher.refresh(DataFactory.namedNode(uri));
+    }
+  }, {
+    key: "register",
+    value: function register(via, uri) {
+      if (this.via[via] == null) {
+        this.via[via] = new UpdatesSocket(this, via);
+      }
+
+      return this.via[via].subscribe(uri);
+    }
+  }]);
+
+  return UpdatesVia;
+}();

package/esm/uri.js

@@ -0,0 +1,245 @@
+/*
+ * Implements URI-specific functions
+ *
+ * See RFC 2386
+ *
+ * See also:
+ *   http://www.w3.org/2005/10/ajaw/uri.js
+ *   http://www.w3.org/2000/10/swap/uripath.py
+ *
+ */
+var alert = alert || console.log;
+import RDFlibNamedNode from './named-node';
+/**
+ * Gets the document part of an URI
+ * @param uri The URI
+ */
+
+export function docpart(uri) {
+  var i;
+  i = uri.indexOf('#');
+
+  if (i < 0) {
+    return uri;
+  } else {
+    return uri.slice(0, i);
+  }
+}
+/**
+ * Gets the document part of an URI as a named node
+ * @param x - The URI
+ */
+
+export function document(x) {
+  return new RDFlibNamedNode(docpart(x));
+}
+/**
+ * Gets the hostname in an URI
+ * @param u The URI
+ */
+
+export function hostpart(u) {
+  var m = /[^\/]*\/\/([^\/]*)\//.exec(u);
+
+  if (m) {
+    return m[1];
+  } else {
+    return '';
+  }
+}
+/**
+ * Joins an URI with a base
+ * @param given - The relative part
+ * @param base - The base URI
+ */
+
+export function join(given, base) {
+  var baseColon, baseScheme, baseSingle;
+  var colon, lastSlash, path;
+  var baseHash = base.indexOf('#');
+
+  if (baseHash > 0) {
+    base = base.slice(0, baseHash);
+  }
+
+  if (given.length === 0) {
+    return base;
+  }
+
+  if (given.indexOf('#') === 0) {
+    return base + given;
+  }
+
+  colon = given.indexOf(':');
+
+  if (colon >= 0) {
+    return given;
+  }
+
+  baseColon = base.indexOf(':');
+
+  if (base.length === 0) {
+    return given;
+  }
+
+  if (baseColon < 0) {
+    alert('Invalid base: ' + base + ' in join with given: ' + given);
+    return given;
+  }
+
+  baseScheme = base.slice(0, +baseColon + 1 || 9e9);
+
+  if (given.indexOf('//') === 0) {
+    return baseScheme + given;
+  }
+
+  if (base.indexOf('//', baseColon) === baseColon + 1) {
+    baseSingle = base.indexOf('/', baseColon + 3);
+
+    if (baseSingle < 0) {
+      if (base.length - baseColon - 3 > 0) {
+        return base + '/' + given;
+      } else {
+        return baseScheme + given;
+      }
+    }
+  } else {
+    baseSingle = base.indexOf('/', baseColon + 1);
+
+    if (baseSingle < 0) {
+      if (base.length - baseColon - 1 > 0) {
+        return base + '/' + given;
+      } else {
+        return baseScheme + given;
+      }
+    }
+  }
+
+  if (given.indexOf('/') === 0) {
+    return base.slice(0, baseSingle) + given;
+  }
+
+  path = base.slice(baseSingle);
+  lastSlash = path.lastIndexOf('/');
+
+  if (lastSlash < 0) {
+    return baseScheme + given;
+  }
+
+  if (lastSlash >= 0 && lastSlash < path.length - 1) {
+    path = path.slice(0, +lastSlash + 1 || 9e9);
+  }
+
+  path += given;
+
+  while (path.match(/[^\/]*\/\.\.\//)) {
+    path = path.replace(/[^\/]*\/\.\.\//, '');
+  }
+
+  path = path.replace(/\.\//g, '');
+  path = path.replace(/\/\.$/, '/');
+  return base.slice(0, baseSingle) + path;
+}
+/**
+ * Gets the protocol part of an URI
+ * @param uri The URI
+ */
+
+export function protocol(uri) {
+  var i = uri.indexOf(':');
+
+  if (i < 0) {
+    return null;
+  } else {
+    return uri.slice(0, i);
+  }
+}
+/**
+ * Gets a relative uri
+ * @param base The base URI
+ * @param uri The absolute URI
+ */
+
+export function refTo(base, uri) {
+  var c, i, k, l, len, len1, n, o, p, q, ref, ref1, s;
+  var commonHost = new RegExp('^[-_a-zA-Z0-9.]+:(//[^/]*)?/[^/]*$');
+
+  if (!base) {
+    return uri;
+  }
+
+  if (base === uri) {
+    return '';
+  }
+
+  for (i = o = 0, len = uri.length; o < len; i = ++o) {
+    var _c = uri[i];
+
+    if (_c !== base[i]) {
+      break;
+    }
+  }
+
+  if (base.slice(0, i).match(commonHost)) {
+    k = uri.indexOf('//');
+
+    if (k < 0) {
+      k = -2;
+    }
+
+    l = uri.indexOf('/', k + 2);
+
+    if (uri[l + 1] !== '/' && base[l + 1] !== '/' && uri.slice(0, l) === base.slice(0, l)) {
+      return uri.slice(l);
+    }
+  }
+
+  if (uri[i] === '#' && base.length === i) {
+    return uri.slice(i);
+  }
+
+  while (i > 0 && uri[i - 1] !== '/') {
+    i--;
+  }
+
+  if (i < 3) {
+    return uri;
+  }
+
+  if (base.indexOf('//', i - 2) > 0 || uri.indexOf('//', i - 2) > 0) {
+    return uri;
+  }
+
+  if (base.indexOf(':', i) > 0) {
+    return uri;
+  }
+
+  n = 0;
+  ref = base.slice(i);
+
+  for (p = 0, len1 = ref.length; p < len1; p++) {
+    c = ref[p];
+
+    if (c === '/') {
+      n++;
+    }
+  }
+
+  if (n === 0 && i < uri.length && uri[i] === '#') {
+    return './' + uri.slice(i);
+  }
+
+  if (n === 0 && i === uri.length) {
+    return './';
+  }
+
+  s = '';
+
+  if (n > 0) {
+    for (q = 1, ref1 = n; ref1 >= 1 ? q <= ref1 : q >= ref1; ref1 >= 1 ? ++q : --q) {
+      s += '../';
+    }
+  }
+
+  return s + uri.slice(i);
+}

package/esm/utils/default-graph-uri.js

@@ -0,0 +1,4 @@
+// Prevents circular dependencies between data-factory-internal and statement
+import NamedNode from '../named-node';
+export var defaultGraphURI = 'chrome:theSession';
+export var defaultGraphNode = new NamedNode(defaultGraphURI);

package/esm/utils/termValue.js

@@ -0,0 +1,8 @@
+/** Retrieve the value of a term, or self if already a string. */
+export function termValue(node) {
+  if (typeof node === 'string') {
+    return node;
+  }
+
+  return node.value;
+}

package/esm/utils/terms.js

@@ -0,0 +1,72 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+import { CollectionTermType, NamedNodeTermType, VariableTermType, BlankNodeTermType, LiteralTermType, GraphTermType, DefaultGraphTermType } from '../types';
+
+/** TypeGuard for RDFLib Statements */
+export function isStatement(obj) {
+  return _typeof(obj) === 'object' && obj !== null && 'subject' in obj;
+}
+/** TypeGuard for RDFlib Stores */
+
+export function isStore(obj) {
+  return _typeof(obj) === 'object' && obj !== null && 'statements' in obj;
+}
+/** TypeGuard for RDFLib Collections */
+
+export function isCollection(obj) {
+  return isTerm(obj) && obj.termType === CollectionTermType;
+}
+/** TypeGuard for valid RDFlib Object types, also allows Collections */
+
+export function isRDFlibObject(obj) {
+  return obj && Object.prototype.hasOwnProperty.call(obj, 'termType') && (obj.termType === NamedNodeTermType || obj.termType === VariableTermType || obj.termType === BlankNodeTermType || obj.termType === CollectionTermType || obj.termType === LiteralTermType || obj.termType === GraphTermType);
+}
+/** TypeGuard for RDFLib Variables */
+
+export function isVariable(obj) {
+  return isTerm(obj) && obj.termType === VariableTermType;
+}
+/** TypeGuard for RDF/JS spec Terms */
+
+export function isTerm(obj) {
+  return _typeof(obj) === 'object' && obj !== null && 'termType' in obj;
+}
+/** TypeGuard for RDF/JS spec Literals */
+
+export function isLiteral(value) {
+  return value.termType === LiteralTermType;
+}
+/** TypeGuard for RDF/JS spec Quads */
+
+export function isQuad(obj) {
+  return _typeof(obj) === "object" && obj !== null && 'subject' in obj && 'predicate' in obj && 'object' in obj;
+}
+/** TypeGuard for RDF/JS spec NamedNodes */
+
+export function isNamedNode(obj) {
+  return isTerm(obj) && obj.termType === 'NamedNode';
+}
+/** TypeGuard for RDF/JS spec BlankNodes */
+
+export function isBlankNode(obj) {
+  return isTerm(obj) && 'termType' in obj && obj.termType === 'BlankNode';
+}
+/** TypeGuard for valid RDF/JS spec Subject types */
+
+export function isSubject(obj) {
+  return isTerm(obj) && (obj.termType === NamedNodeTermType || obj.termType === VariableTermType || obj.termType === BlankNodeTermType);
+}
+/** TypeGuard for valid RDF/JS spec Predicate types */
+
+export function isPredicate(obj) {
+  return isTerm(obj) && (obj.termType === NamedNodeTermType || obj.termType === VariableTermType);
+}
+/** TypeGuard for valid RDF/JS spec Object types */
+
+export function isRDFObject(obj) {
+  return isTerm(obj) && (obj.termType === NamedNodeTermType || obj.termType === VariableTermType || obj.termType === BlankNodeTermType || obj.termType === LiteralTermType);
+}
+/** TypeGuard for valid RDF/JS Graph types */
+
+export function isGraph(obj) {
+  return isTerm(obj) && (obj.termType === NamedNodeTermType || obj.termType === VariableTermType || obj.termType === BlankNodeTermType || obj.termType === DefaultGraphTermType);
+}