rdflib 2.2.21 → 2.2.22-0de51c50

package/esm/named-node.js

@@ -5,25 +5,20 @@ 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 { NamedNodeTermType } from './types';
 import { termValue } from './utils/termValue';
 import { isTerm } from './utils/terms';
+
 /**
  * A named (IRI) RDF node
  */
-
 var NamedNode = /*#__PURE__*/function (_Node) {
   _inherits(NamedNode, _Node);
-
   var _super = _createSuper(NamedNode);
-
   /**
    * Create a named (IRI) RDF Node
    * @constructor
@@ -31,35 +26,26 @@ var NamedNode = /*#__PURE__*/function (_Node) {
    */
   function NamedNode(iri) {
     var _this;
-
     _classCallCheck(this, NamedNode);
-
     _this = _super.call(this, termValue(iri));
-
     _defineProperty(_assertThisInitialized(_this), "termType", NamedNodeTermType);
-
     _defineProperty(_assertThisInitialized(_this), "classOrder", ClassOrder.NamedNode);
-
     if (!_this.value) {
       throw new Error('Missing IRI for NamedNode');
     }
-
     if (!_this.value.includes(':')) {
       throw new Error('NamedNode IRI "' + iri + '" must be absolute.');
     }
-
     if (_this.value.includes(' ')) {
       var message = 'Error: NamedNode IRI "' + iri + '" must not contain unencoded spaces.';
       throw new Error(message);
     }
-
     return _this;
   }
+
   /**
    * Returns an $rdf node for the containing directory, ending in slash.
    */
-
-
   _createClass(NamedNode, [{
     key: "dir",
     value: function dir() {
@@ -69,11 +55,11 @@ var NamedNode = /*#__PURE__*/function (_Node) {
       if (q >= 0 && p < q + 2 || p < 0) return null;
       return new NamedNode(str.slice(0, p + 1));
     }
+
     /**
      * Returns an NN for the whole web site, ending in slash.
      * Contrast with the "origin" which does NOT have a trailing slash
      */
-
   }, {
     key: "site",
     value: function site() {
@@ -81,18 +67,17 @@ var NamedNode = /*#__PURE__*/function (_Node) {
       var p = str.indexOf('//');
       if (p < 0) throw new Error('This URI does not have a web site part (origin)');
       var q = str.indexOf('/', p + 2);
-
       if (q < 0) {
         return new NamedNode(str.slice(0) + '/'); // Add slash to a bare origin
       } else {
         return new NamedNode(str.slice(0, q + 1));
       }
     }
+
     /**
      * Creates the fetchable named node for the document.
      * Removes everything from the # anchor tag.
      */
-
   }, {
     key: "doc",
     value: function doc() {
@@ -102,24 +87,24 @@ var NamedNode = /*#__PURE__*/function (_Node) {
         return new NamedNode(this.value.split('#')[0]);
       }
     }
+
     /**
      * Returns the URI including <brackets>
      */
-
   }, {
     key: "toString",
     value: function toString() {
       return '<' + this.value + '>';
     }
-    /** The local identifier with the document */
 
+    /** The local identifier with the document */
   }, {
     key: "id",
     value: function id() {
       return this.value.split('#')[1];
     }
-    /** Alias for value, favored by Tim */
 
+    /** Alias for value, favored by Tim */
   }, {
     key: "uri",
     get: function get() {
@@ -128,27 +113,23 @@ var NamedNode = /*#__PURE__*/function (_Node) {
     set: function set(uri) {
       this.value = uri;
     }
+
     /**
      * Creates a named node from the specified input value
      * @param value - An input value
      */
-
   }], [{
     key: "fromValue",
     value: function fromValue(value) {
       if (typeof value === 'undefined' || value === null) {
         return value;
       }
-
       if (isTerm(value)) {
         return value;
       }
-
       return new NamedNode(value);
     }
   }]);
-
   return NamedNode;
 }(Node);
-
 export { NamedNode as default };

package/esm/namespace.js

@@ -1,5 +1,4 @@
 import RDFlibNamedNode from './named-node';
-
 /**
  * Gets a namespace for the specified namespace's URI
  * @param nsuri - The URI for the namespace

package/esm/node-internal.js

@@ -1,7 +1,6 @@
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-
 /**
  * The superclass of all RDF Statement objects, that is
  * NamedNode, Literal, BlankNode, etc.
@@ -12,6 +11,7 @@ import _defineProperty from "@babel/runtime/helpers/defineProperty";
  */
 var Node = /*#__PURE__*/function () {
   // Specified in './node.ts' to prevent circular dependency
+
   // Specified in './node.ts' to prevent circular dependency
 
   /** The type of node */
@@ -19,133 +19,120 @@ var Node = /*#__PURE__*/function () {
   /** The class order for this node */
 
   /** The node's value */
+
   function Node(value) {
     _classCallCheck(this, Node);
-
     _defineProperty(this, "termType", void 0);
-
     _defineProperty(this, "classOrder", void 0);
-
     _defineProperty(this, "value", void 0);
-
     this.value = value;
   }
+
   /**
    * Creates the substituted node for this one, according to the specified bindings
    * @param bindings - Bindings of identifiers to nodes
    */
-
-
   _createClass(Node, [{
     key: "substitute",
     value: function substitute(bindings) {
       console.log('@@@ node substitute' + this);
       return this;
     }
+
     /**
      * Compares this node with another
      * @see {equals} to check if two nodes are equal
      * @param other - The other node
      */
-
   }, {
     key: "compareTerm",
     value: function compareTerm(other) {
       if (this.classOrder < other.classOrder) {
         return -1;
       }
-
       if (this.classOrder > other.classOrder) {
         return +1;
       }
-
       if (this.value < other.value) {
         return -1;
       }
-
       if (this.value > other.value) {
         return +1;
       }
-
       return 0;
     }
+
     /**
      * Compares whether the two nodes are equal
      * @param other The other node
      */
-
   }, {
     key: "equals",
     value: function equals(other) {
       if (!other) {
         return false;
       }
-
       return this.termType === other.termType && this.value === other.value;
     }
+
     /**
      * Creates a hash for this node
      * @deprecated use {rdfFactory.id} instead if possible
      */
-
   }, {
     key: "hashString",
     value: function hashString() {
       return this.toCanonical();
     }
+
     /**
      * Compares whether this node is the same as the other one
      * @param other - Another node
      */
-
   }, {
     key: "sameTerm",
     value: function sameTerm(other) {
       return this.equals(other);
     }
+
     /**
      * Creates a canonical string representation of this node
      */
-
   }, {
     key: "toCanonical",
     value: function toCanonical() {
       return this.toNT();
     }
+
     /**
      * Creates a n-triples string representation of this node
      */
-
   }, {
     key: "toNT",
     value: function toNT() {
       return this.toString();
     }
+
     /**
      * Creates a n-quads string representation of this node
      */
-
   }, {
     key: "toNQ",
     value: function toNQ() {
       return this.toNT();
     }
+
     /**
      * Creates a string representation of this node
      */
-
   }, {
     key: "toString",
     value: function toString() {
       throw new Error('Node.toString() is abstract - see the subclasses instead');
     }
   }]);
-
   return Node;
 }();
-
 _defineProperty(Node, "fromValue", void 0);
-
 _defineProperty(Node, "toJS", void 0);
-
 export { Node as default };

package/esm/node.js

@@ -4,7 +4,6 @@ import { fromValue } from './collection';
 import Node from './node-internal';
 import Namespace from './namespace';
 import { isCollection, isLiteral } from './utils/terms';
-
 /**
  * Creates an RDF Node from a native javascript value.
  * RDF Nodes are returned unchanged, undefined returned as itself.
@@ -18,29 +17,25 @@ export default Node;
 var ns = {
   xsd: Namespace('http://www.w3.org/2001/XMLSchema#')
 };
+
 /**
  * Gets the javascript object equivalent to a node
  * @param term The RDF node
  */
-
 Node.toJS = function (term) {
   if (isCollection(term)) {
     return term.elements.map(Node.toJS); // Array node (not standard RDFJS)
   }
 
   if (!isLiteral(term)) return term;
-
   if (term.datatype.equals(ns.xsd('boolean'))) {
     return term.value === '1' || term.value === 'true';
   }
-
   if (term.datatype.equals(ns.xsd('dateTime')) || term.datatype.equals(ns.xsd('date'))) {
     return new Date(term.value);
   }
-
   if (term.datatype.equals(ns.xsd('integer')) || term.datatype.equals(ns.xsd('float')) || term.datatype.equals(ns.xsd('decimal'))) {
     return Number(term.value);
   }
-
   return term.value;
 };

package/esm/parse.js

@@ -1,15 +1,13 @@
 import DataFactory from './factories/extended-term-factory';
-import jsonldParser from './jsonldparser'; // @ts-ignore is this injected?
-
+import jsonldParser from './jsonldparser';
+// @ts-ignore is this injected?
 import { Parser as N3jsParser } from 'n3'; // @@ Goal: remove this dependency
-
 import N3Parser from './n3parser';
 import { parseRDFaDOM } from './rdfaparser';
 import RDFParser from './rdfxmlparser';
 import sparqlUpdateParser from './patch-parser';
 import * as Util from './utils-js';
 import { TurtleContentType, N3ContentType, RDFXMLContentType, XHTMLContentType, HTMLContentType, SPARQLUpdateContentType, SPARQLUpdateSingleMatchContentType, JSONLDContentType, NQuadsContentType, NQuadsAltContentType } from './types';
-
 /**
  * Parse a string and put the result into the graph kb.
  * Normal method is sync.
@@ -26,7 +24,6 @@ export default function parse(str, kb, base) {
   var callback = arguments.length > 4 ? arguments[4] : undefined;
   contentType = contentType || TurtleContentType;
   contentType = contentType.split(';')[0];
-
   try {
     if (contentType === N3ContentType || contentType === TurtleContentType) {
       var p = N3Parser(kb, kb, base, base, null, null, '', null);
@@ -66,7 +63,6 @@ export default function parse(str, kb, base) {
     // @ts-ignore
     executeErrorCallback(e);
   }
-
   parse.handled = {
     'text/n3': true,
     'text/turtle': true,
@@ -79,7 +75,6 @@ export default function parse(str, kb, base) {
     'application/nquads': true,
     'application/n-quads': true
   };
-
   function executeCallback() {
     if (callback) {
       callback(null, kb);
@@ -87,17 +82,19 @@ export default function parse(str, kb, base) {
       return;
     }
   }
-
   function executeErrorCallback(e) {
-    if ( // TODO: Always true, what is the right behavior
-    contentType !== JSONLDContentType || // @ts-ignore always true?
-    contentType !== NQuadsContentType || // @ts-ignore always true?
+    if (
+    // TODO: Always true, what is the right behavior
+    contentType !== JSONLDContentType ||
+    // @ts-ignore always true?
+    contentType !== NQuadsContentType ||
+    // @ts-ignore always true?
     contentType !== NQuadsAltContentType) {
       if (callback) {
         callback(e, kb);
       } else {
-        var e2 = new Error('' + e + ' while trying to parse <' + base + '> as ' + contentType); //@ts-ignore .cause is not a default error property
-
+        var e2 = new Error('' + e + ' while trying to parse <' + base + '> as ' + contentType);
+        //@ts-ignore .cause is not a default error property
         e2.cause = e;
         throw e2;
       }
@@ -114,20 +111,16 @@ export default function parse(str, kb, base) {
       doc['@context']['@base'] = base
     }
   */
-
-
   function nquadCallback(err, nquads) {
     if (err) {
       callback(err, kb);
     }
-
     try {
       n3Parser.parse(nquads, tripleCallback);
     } catch (err) {
       callback(err, kb);
     }
   }
-
   function tripleCallback(err, triple) {
     if (triple) {
       kb.add(triple.subject, triple.predicate, triple.object, triple.graph);

package/esm/patch-parser.js

@@ -13,98 +13,78 @@ export default function sparqlUpdateParser(str, kb, base) {
   var SQNS = Namespace('http://www.w3.org/ns/pim/patch#');
   var p = N3Parser(kb, kb, base, base, null, null, '', null);
   var clauses = {};
-
   var badSyntax = function badSyntax(uri, lines, str, i, why) {
     return 'Line ' + (lines + 1) + ' of <' + uri + '>: Bad syntax:\n   ' + why + '\n   at: "' + str.slice(i, i + 30) + '"';
-  }; // var check = function (next, last, message) {
+  };
+
+  // var check = function (next, last, message) {
   //   if (next < 0) {
   //     throw badSyntax(p._thisDoc, p.lines, str, j, last, message)
   //   }
   //   return next
   // }
-
-
   i = 0;
   var query = kb.sym(base + '#query'); // Invent a URI for the query
-
   clauses['query'] = query; // A way of accessing it in its N3 model.
 
   while (true) {
     // console.log("A Now at i = " + i)
     j = p.skipSpace(str, i);
-
     if (j < 0) {
       return clauses;
-    } // console.log("B After space at j= " + j)
-
-
+    }
+    // console.log("B After space at j= " + j)
     if (str[j] === ';') {
       i = p.skipSpace(str, j + 1);
-
       if (i < 0) {
         return clauses; // Allow end in a
       }
 
       j = i;
     }
-
     var found = false;
-
     for (k = 0; k < keywords.length; k++) {
       var key = keywords[k];
-
       if (str.slice(j, j + key.length) === key) {
         i = p.skipSpace(str, j + key.length);
-
         if (i < 0) {
           throw badSyntax(p._thisDoc, p.lines, str, j + key.length, 'found EOF, needed {...} after ' + key);
         }
-
         if ((key === 'INSERT' || key === 'DELETE') && str.slice(i, i + 4) === 'DATA') {
           // Some wanted 'DATA'. Whatever
           j = p.skipSpace(str, i + 4);
-
           if (j < 0) {
             throw badSyntax(p._thisDoc, p.lines, str, i + 4, 'needed {...} after INSERT DATA ' + key);
           }
-
           i = j;
         }
-
         var res2 = [];
         j = p.node(str, i, res2); // Parse all the complexity of the clause
 
         if (j < 0) {
           throw badSyntax(p._thisDoc, p.lines, str, i, 'bad syntax or EOF in {...} after ' + key);
         }
-
         clauses[key.toLowerCase()] = res2[0];
         kb.add(query, SQNS(key.toLowerCase()), res2[0]); // , kb.sym(base)
         // key is the keyword and res2 has the contents
-
         found = true;
         i = j;
       }
     }
-
     if (!found && str.slice(j, j + 7) === '@prefix') {
       i = p.directive(str, j);
-
       if (i < 0) {
         throw badSyntax(p._thisDoc, p.lines, str, i, 'bad syntax or EOF after @prefix ');
-      } // console.log("P before dot i= " + i)
-
-
-      i = p.checkDot(str, i); // console.log("Q after dot i= " + i)
-
+      }
+      // console.log("P before dot i= " + i)
+      i = p.checkDot(str, i);
+      // console.log("Q after dot i= " + i)
       found = true;
     }
-
     if (!found) {
       // console.log("Bad syntax " + j)
       throw badSyntax(p._thisDoc, p.lines, str, j, "Unknown syntax at start of statememt: '" + str.slice(j).slice(0, 20) + "'");
     }
   } // while
   // return clauses
-
 }

package/esm/query-to-sparql.js

@@ -1,44 +1,33 @@
 import log from './log';
 export default function queryToSPARQL(query) {
   var indent = 0;
-
   function getSelect(query) {
     var str = addIndent() + 'SELECT ';
-
     for (var i = 0; i < query.vars.length; i++) {
       str += query.vars[i] + ' ';
     }
-
     str += '\n';
     return str;
   }
-
   function getPattern(pat) {
     var str = '';
     var st = pat.statements;
-
     for (var x in st) {
       log.debug('Found statement: ' + st);
       str += addIndent() + st[x] + '\n';
     }
-
     return str;
   }
-
   function getConstraints(pat) {
     var str = '';
-
     for (var v in pat.constraints) {
       var foo = pat.constraints[v];
       str += addIndent() + 'FILTER ( ' + foo.describe(v) + ' ) ' + '\n';
     }
-
     return str;
   }
-
   function getOptionals(pat) {
     var str = '';
-
     for (var x = 0; x < pat.optional.length; x++) {
       // alert(pat.optional.termType)
       log.debug('Found optional query');
@@ -50,10 +39,8 @@ export default function queryToSPARQL(query) {
       indent--;
       str += addIndent() + '}' + '\n';
     }
-
     return str;
   }
-
   function getWhere(pat) {
     var str = addIndent() + 'WHERE \n' + '{ \n';
     indent++;
@@ -64,20 +51,15 @@ export default function queryToSPARQL(query) {
     str += '}';
     return str;
   }
-
   function addIndent() {
     var str = '';
-
     for (var i = 0; i < indent; i++) {
       str += '    ';
     }
-
     return str;
   }
-
   function getSPARQL(query) {
     return getSelect(query) + getWhere(query.pat);
   }
-
   return getSPARQL(query);
 }