rdflib 2.2.10 → 2.2.12-5f141ca2

package/esm/blank-node.js

@@ -0,0 +1,137 @@
+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 { BlankNodeTermType } from './types';
+
+/**
+ * An RDF blank node is a Node without a URI
+ * @link https://rdf.js.org/data-model-spec/#blanknode-interface
+ */
+var BlankNode = /*#__PURE__*/function (_Node) {
+  _inherits(BlankNode, _Node);
+
+  var _super = _createSuper(BlankNode);
+
+  /**
+   * Initializes this node
+   * @param [id] The identifier for the blank node
+   */
+  function BlankNode(id) {
+    var _this;
+
+    _classCallCheck(this, BlankNode);
+
+    _this = _super.call(this, BlankNode.getId(id));
+
+    _defineProperty(_assertThisInitialized(_this), "termType", BlankNodeTermType);
+
+    _defineProperty(_assertThisInitialized(_this), "classOrder", ClassOrder.BlankNode);
+
+    _defineProperty(_assertThisInitialized(_this), "isBlank", 1);
+
+    _defineProperty(_assertThisInitialized(_this), "isVar", 1);
+
+    return _this;
+  }
+  /**
+   * The identifier for the blank node
+   */
+
+
+  _createClass(BlankNode, [{
+    key: "id",
+    get: function get() {
+      return this.value;
+    },
+    set: function set(value) {
+      this.value = value;
+    }
+  }, {
+    key: "compareTerm",
+    value: function compareTerm(other) {
+      if (this.classOrder < other.classOrder) {
+        return -1;
+      }
+
+      if (this.classOrder > other.classOrder) {
+        return +1;
+      }
+
+      if (this.id < other.id) {
+        return -1;
+      }
+
+      if (this.id > other.id) {
+        return +1;
+      }
+
+      return 0;
+    }
+    /**
+     * Gets a copy of this blank node in the specified formula
+     * @param formula The formula
+     */
+
+  }, {
+    key: "copy",
+    value: function copy(formula) {
+      // depends on the formula
+      var bnodeNew = new BlankNode();
+      formula.copyTo(this, bnodeNew);
+      return bnodeNew;
+    }
+  }, {
+    key: "toCanonical",
+    value: function toCanonical() {
+      return BlankNode.NTAnonymousNodePrefix + this.value;
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      return BlankNode.NTAnonymousNodePrefix + this.id;
+    }
+  }], [{
+    key: "getId",
+    value:
+    /**
+     * The next unique identifier for blank nodes
+     */
+    function getId(id) {
+      if (id) {
+        if (typeof id !== 'string') {
+          console.log('Bad blank id:', id);
+          throw new Error('Bad id argument to new blank node: ' + id);
+        }
+
+        if (id.includes('#')) {
+          // Is a URI with hash fragment
+          var fragments = id.split('#');
+          return fragments[fragments.length - 1];
+        }
+
+        return id;
+      }
+
+      return 'n' + BlankNode.nextId++;
+    }
+  }]);
+
+  return BlankNode;
+}(Node);
+
+_defineProperty(BlankNode, "nextId", 0);
+
+_defineProperty(BlankNode, "NTAnonymousNodePrefix", '_:');
+
+export { BlankNode as default };

package/esm/class-order.js

@@ -0,0 +1,12 @@
+/**
+* Class orders
+*/
+var ClassOrder = {
+  'Literal': 1,
+  'Collection': 3,
+  'Graph': 4,
+  'NamedNode': 5,
+  'BlankNode': 6,
+  'Variable': 7
+};
+export default ClassOrder;

package/esm/collection.js

@@ -0,0 +1,173 @@
+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 RdflibBlankNode from './blank-node';
+import ClassOrder from './class-order';
+import Literal from './literal';
+import Node from './node-internal';
+import { CollectionTermType } from './types';
+import { isTerm } from './utils/terms';
+
+/**
+ * Creates an RDF Node from a native javascript value.
+ * RDF Nodes are returned unchanged, undefined returned as itself.
+ * Arrays return Collections.
+ * Strings, numbers and booleans return Literals.
+ * @param value {Node|Date|String|Number|Boolean|Undefined}
+ * @return {Node|Collection}
+ */
+export function fromValue(value) {
+  if (typeof value === 'undefined' || value === null) {
+    return value;
+  }
+
+  if (isTerm(value)) {
+    // a Node subclass or a Collection
+    return value;
+  }
+
+  if (Array.isArray(value)) {
+    return new Collection(value);
+  }
+
+  return Literal.fromValue(value);
+}
+/**
+ * A collection of other RDF nodes
+ *
+ * Use generic T to control the contents of the array.
+ */
+
+var Collection = /*#__PURE__*/function (_Node) {
+  _inherits(Collection, _Node);
+
+  var _super = _createSuper(Collection);
+
+  /**
+   * The nodes in this collection
+   */
+  function Collection(initial) {
+    var _this;
+
+    _classCallCheck(this, Collection);
+
+    _this = _super.call(this, (RdflibBlankNode.nextId++).toString());
+
+    _defineProperty(_assertThisInitialized(_this), "termType", CollectionTermType);
+
+    _defineProperty(_assertThisInitialized(_this), "classOrder", ClassOrder.Collection);
+
+    _defineProperty(_assertThisInitialized(_this), "closed", false);
+
+    _defineProperty(_assertThisInitialized(_this), "compareTerm", RdflibBlankNode.prototype.compareTerm);
+
+    _defineProperty(_assertThisInitialized(_this), "elements", []);
+
+    _defineProperty(_assertThisInitialized(_this), "isVar", 0);
+
+    if (initial && initial.length > 0) {
+      initial.forEach(function (element) {
+        _this.elements.push(fromValue(element));
+      });
+    }
+
+    return _this;
+  }
+
+  _createClass(Collection, [{
+    key: "id",
+    get: function get() {
+      return this.value;
+    },
+    set: function set(value) {
+      this.value = value;
+    }
+    /**
+     * Appends an element to this collection
+     * @param element - The new element
+     */
+
+  }, {
+    key: "append",
+    value: function append(element) {
+      return this.elements.push(element);
+    }
+    /**
+     * Closes this collection
+     */
+
+  }, {
+    key: "close",
+    value: function close() {
+      this.closed = true;
+      return this.closed;
+    }
+    /**
+     * Removes the first element from the collection (and return it)
+     */
+
+  }, {
+    key: "shift",
+    value: function shift() {
+      return this.elements.shift();
+    }
+    /**
+     * Creates a new Collection with the substituting bindings applied
+     * @param bindings - The bindings to substitute
+     */
+
+  }, {
+    key: "substitute",
+    value: function substitute(bindings) {
+      var elementsCopy = this.elements.map(function (ea) {
+        return ea.substitute(bindings);
+      });
+      return new Collection(elementsCopy);
+    }
+  }, {
+    key: "toNT",
+    value: function toNT() {
+      return Collection.toNT(this);
+    }
+  }, {
+    key: "toString",
+    value:
+    /**
+     * Serializes the collection to a string.
+     * Surrounded by (parentheses) and separated by spaces.
+     */
+    function toString() {
+      return '(' + this.elements.join(' ') + ')';
+    }
+    /**
+     * Prepends the specified element to the collection's front
+     * @param element - The element to prepend
+     */
+
+  }, {
+    key: "unshift",
+    value: function unshift(element) {
+      return this.elements.unshift(element);
+    }
+  }], [{
+    key: "toNT",
+    value: function toNT(collection) {
+      return RdflibBlankNode.NTAnonymousNodePrefix + collection.id;
+    }
+  }]);
+
+  return Collection;
+}(Node);
+
+_defineProperty(Collection, "termType", CollectionTermType);
+
+export { Collection as default };

package/esm/convert.js

@@ -0,0 +1,61 @@
+import asyncLib from 'async'; // @@ Goal: remove this dependency
+
+import jsonld from 'jsonld';
+import { Parser, Writer } from 'n3'; // @@ Goal: remove this dependency
+
+export function convertToJson(n3String, jsonCallback) {
+  var jsonString;
+  var n3Parser = new Parser();
+  var n3Writer = new Writer({
+    format: 'N-Quads'
+  });
+  asyncLib.waterfall([function (callback) {
+    n3Parser.parse(n3String, function (error, quad, prefixes) {
+      if (error) {
+        callback(error);
+      } else if (quad !== null) {
+        n3Writer.addQuad(quad);
+      } else {
+        n3Writer.end(callback);
+      }
+    });
+  }, function (result, callback) {
+    try {
+      jsonld.fromRDF(result, {
+        format: 'application/nquads'
+      }).then(function (result) {
+        callback(null, result);
+      });
+    } catch (err) {
+      callback(err);
+    }
+  }, function (json, callback) {
+    jsonString = JSON.stringify(json);
+    jsonCallback(null, jsonString);
+  }], function (err, result) {
+    jsonCallback(err, jsonString);
+  });
+}
+export function convertToNQuads(n3String, nquadCallback) {
+  var nquadString;
+  var n3Parser = new Parser();
+  var n3Writer = new Writer({
+    format: 'N-Quads'
+  });
+  asyncLib.waterfall([function (callback) {
+    n3Parser.parse(n3String, function (error, triple, prefixes) {
+      if (error) {
+        callback(error);
+      } else if (quad !== null) {
+        n3Writer.addQuad(quad);
+      } else {
+        n3Writer.end(callback);
+      }
+    });
+  }, function (result, callback) {
+    nquadString = result;
+    nquadCallback(null, nquadString);
+  }], function (err, result) {
+    nquadCallback(err, nquadString);
+  });
+}

package/esm/default-graph.js

@@ -0,0 +1,57 @@
+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 Node from './node-internal';
+import { DefaultGraphTermType } from './types';
+import { defaultGraphURI } from './utils/default-graph-uri';
+/** The RDF default graph */
+
+var DefaultGraph = /*#__PURE__*/function (_Node) {
+  _inherits(DefaultGraph, _Node);
+
+  var _super = _createSuper(DefaultGraph);
+
+  function DefaultGraph() {
+    var _this;
+
+    _classCallCheck(this, DefaultGraph);
+
+    _this = _super.call(this, '');
+
+    _defineProperty(_assertThisInitialized(_this), "value", '');
+
+    _defineProperty(_assertThisInitialized(_this), "termType", DefaultGraphTermType);
+
+    _defineProperty(_assertThisInitialized(_this), "uri", defaultGraphURI);
+
+    return _this;
+  }
+
+  _createClass(DefaultGraph, [{
+    key: "toCanonical",
+    value: function toCanonical() {
+      return this.value;
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      return 'DefaultGraph';
+    }
+  }]);
+
+  return DefaultGraph;
+}(Node);
+
+export { DefaultGraph as default };
+export function isDefaultGraph(object) {
+  return !!object && object.termType === DefaultGraphTermType;
+}

package/esm/empty.js

@@ -0,0 +1,46 @@
+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 Node from './node-internal';
+import { EmptyTermType } from './types';
+
+/**
+* An empty node
+*/
+var Empty = /*#__PURE__*/function (_Node) {
+  _inherits(Empty, _Node);
+
+  var _super = _createSuper(Empty);
+
+  function Empty() {
+    var _this;
+
+    _classCallCheck(this, Empty);
+
+    _this = _super.call(this, '');
+
+    _defineProperty(_assertThisInitialized(_this), "termType", EmptyTermType);
+
+    return _this;
+  }
+
+  _createClass(Empty, [{
+    key: "toString",
+    value: function toString() {
+      return '()';
+    }
+  }]);
+
+  return Empty;
+}(Node);
+
+export { Empty as default };

package/esm/factories/canonical-data-factory.js

@@ -0,0 +1,204 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+var _supports;
+
+import BlankNode from '../blank-node';
+import Literal from '../literal';
+import NamedNode from '../named-node';
+import Statement from '../statement';
+import Variable from '../variable';
+import { EmptyTermType, DefaultGraphTermType, VariableTermType, BlankNodeTermType, LiteralTermType, NamedNodeTermType, CollectionTermType, GraphTermType } from '../types';
+import DefaultGraph from '../default-graph';
+import { Feature } from './factory-types';
+import { isQuad, isTerm } from '../utils/terms';
+export { defaultGraphURI } from '../utils/default-graph-uri';
+/**
+ * Gets the default graph
+ */
+
+var _defaultGraph = new DefaultGraph();
+/** A basic internal RDFlib datafactory, which does not support Collections  */
+
+
+var CanonicalDataFactory = {
+  supports: (_supports = {}, _defineProperty(_supports, Feature.collections, false), _defineProperty(_supports, Feature.defaultGraphType, false), _defineProperty(_supports, Feature.equalsMethod, true), _defineProperty(_supports, Feature.identity, false), _defineProperty(_supports, Feature.id, true), _defineProperty(_supports, Feature.reversibleId, false), _defineProperty(_supports, Feature.variableType, true), _supports),
+
+  /**
+   * Creates a new blank node
+   * @param value - The blank node's identifier
+   */
+  blankNode: function blankNode(value) {
+    return new BlankNode(value);
+  },
+  defaultGraph: function defaultGraph() {
+    return _defaultGraph;
+  },
+
+  /**
+   * Compares to (rdf) objects for equality.
+   */
+  equals: function equals(a, b) {
+    if (a === b || !a || !b) {
+      return true;
+    }
+
+    if (isQuad(a) || isQuad(b)) {
+      if (isQuad(a) && isQuad(b)) {
+        return this.equals(a.subject, b.subject) && this.equals(a.predicate, b.predicate) && this.equals(a.object, b.object) && this.equals(a.graph, b.graph);
+      }
+
+      return false;
+    }
+
+    if (isTerm(a) && isTerm(b)) {
+      return this.id(a) === this.id(b);
+    }
+
+    return false;
+  },
+
+  /**
+   * Generates a uniquely identifiably *idempotent* string for the given {term}.
+   *
+   * Equivalent to [[Term.hashString]]
+   *
+   * @example Use this to associate data with a term in an object
+   *   { obj[id(term)] = "myData" }
+   */
+  id: function id(term) {
+    if (!term) {
+      return 'undefined';
+    }
+
+    if (isQuad(term)) {
+      return this.quadToNQ(term);
+    }
+
+    switch (term.termType) {
+      case DefaultGraphTermType:
+        return 'defaultGraph';
+
+      case VariableTermType:
+        return Variable.toString(term);
+
+      default:
+        var nq = this.termToNQ(term);
+
+        if (nq) {
+          return nq;
+        }
+
+        throw new Error("Can't id term with type '".concat(term.termType, "'"));
+    }
+  },
+  isQuad: function isQuad(obj) {
+    return obj instanceof Statement;
+  },
+
+  /**
+   * Creates a new literal node. Does some JS literal parsing for ease of use.
+   * @param value - The lexical value
+   * @param languageOrDatatype - Either the language or the datatype
+   */
+  literal: function literal(value, languageOrDatatype) {
+    if (typeof value !== "string" && !languageOrDatatype) {
+      return Literal.fromValue(value);
+    }
+
+    var strValue = typeof value === 'string' ? value : '' + value;
+
+    if (typeof languageOrDatatype === 'string') {
+      if (languageOrDatatype.indexOf(':') === -1) {
+        return new Literal(strValue, languageOrDatatype);
+      } else {
+        return new Literal(strValue, null, this.namedNode(languageOrDatatype));
+      }
+    } else {
+      return new Literal(strValue, null, languageOrDatatype);
+    }
+  },
+
+  /**
+   * Creates a new named node
+   * @param value - The new named node
+   */
+  namedNode: function namedNode(value) {
+    return new NamedNode(value);
+  },
+
+  /**
+   * Creates a new statement
+   * @param subject - The subject
+   * @param predicate - The predicate
+   * @param object - The object
+   * @param graph - The containing graph
+   */
+  quad: function quad(subject, predicate, object, graph) {
+    return new Statement(subject, predicate, object, graph || _defaultGraph);
+  },
+
+  /**
+   * Creates a new statement
+   * @param subject - The subject
+   * @param predicate - The predicate
+   * @param object - The object
+   * @param graph - The containing graph
+   */
+  triple: function triple(subject, predicate, object, graph) {
+    return this.quad(subject, predicate, object, graph);
+  },
+  quadToNQ: function quadToNQ(q) {
+    return "".concat(this.termToNQ(q.subject), " ").concat(this.termToNQ(q.predicate), " ").concat(this.termToNQ(q.object), " ").concat(this.termToNQ(q.graph), " .");
+  },
+
+  /** Stringify a {term} to n-quads serialization. */
+  termToNQ: function termToNQ(term) {
+    var _this = this;
+
+    switch (term.termType) {
+      case BlankNodeTermType:
+        return '_:' + term.value;
+
+      case DefaultGraphTermType:
+        return '';
+
+      case EmptyTermType:
+        return '<http://www.w3.org/1999/02/22-rdf-syntax-ns#nil>';
+
+      case LiteralTermType:
+        return Literal.toNT(term);
+
+      case GraphTermType:
+      case NamedNodeTermType:
+        return '<' + term.value + '>';
+
+      case CollectionTermType:
+        return '(' + term.elements.map(function (t) {
+          return _this.termToNQ(t);
+        }).join(' ') + ')';
+
+      default:
+        throw new Error("Can't serialize nonstandard term type (was '".concat(term.termType, "')"));
+    }
+  },
+
+  /** Convert an rdf object (term or quad) to n-quads serialization. */
+  toNQ: function toNQ(term) {
+    if (this.isQuad(term)) {
+      return this.quadToNQ(term);
+    }
+
+    return this.termToNQ(term);
+  },
+
+  /**
+   * Creates a new variable
+   * @param name - The name for the variable
+   */
+  variable: function variable(name) {
+    return new Variable(name);
+  }
+};
+/** Contains the factory methods as defined in the spec, plus id */
+
+export default CanonicalDataFactory;