rdflib 2.2.10 → 2.2.12-5f141ca2

package/esm/index.js

@@ -0,0 +1,64 @@
+import BlankNode from './blank-node';
+import Collection from './collection';
+import * as convert from './convert';
+import Empty from './empty';
+import Fetcher from './fetcher';
+import Formula from './formula';
+import Store from './store';
+import jsonParser from './jsonparser';
+import Literal from './literal';
+import log from './log';
+import N3Parser from './n3parser';
+import NamedNode from './named-node';
+import Namespace from './namespace';
+import Node from './node';
+import parse from './parse';
+import { Query } from './query';
+import queryToSPARQL from './query-to-sparql';
+import RDFaProcessor from './rdfaparser';
+import RDFParser from './rdfxmlparser';
+import serialize from './serialize';
+import Serializer from './serializer';
+import SPARQLToQuery from './sparql-to-query';
+import sparqlUpdateParser from './patch-parser';
+import Statement from './statement';
+import UpdateManager from './update-manager';
+import { UpdatesSocket } from './updates-via';
+import { UpdatesVia } from './updates-via';
+import * as uri from './uri';
+import * as Util from './utils-js';
+import Variable from './variable';
+import DataFactory from './factories/rdflib-data-factory'; // Prepare bound versions of data factory methods for export
+
+var boundDataFactory = {};
+
+for (var name in DataFactory) {
+  if (typeof DataFactory[name] === 'function') boundDataFactory[name] = DataFactory[name].bind(DataFactory);
+}
+
+var fetcher = boundDataFactory.fetcher,
+    graph = boundDataFactory.graph,
+    lit = boundDataFactory.lit,
+    st = boundDataFactory.st,
+    namedNode = boundDataFactory.namedNode,
+    variable = boundDataFactory.variable,
+    blankNode = boundDataFactory.blankNode,
+    defaultGraph = boundDataFactory.defaultGraph,
+    literal = boundDataFactory.literal,
+    quad = boundDataFactory.quad,
+    triple = boundDataFactory.triple;
+var formula = new Formula();
+
+var fromNT = function fromNT(str) {
+  return formula.fromNT(str);
+};
+
+var term = Node.fromValue; // TODO: this export is broken;
+// it exports the _current_ value of nextId, which is always 0
+
+var NextId = BlankNode.nextId;
+export * from './utils/terms';
+export { BlankNode, Collection, convert, DataFactory, Empty, Fetcher, Formula, Store, jsonParser, Literal, log, N3Parser, NamedNode, Namespace, Node, parse, Query, queryToSPARQL, RDFaProcessor, RDFParser, serialize, Serializer, SPARQLToQuery, sparqlUpdateParser, Statement, term, UpdateManager, UpdatesSocket, UpdatesVia, uri, Util, Variable, Store as IndexedFormula, // Alias
+NextId, fromNT, fetcher, graph, lit, st, namedNode as sym, // RDFJS DataFactory interface
+blankNode, defaultGraph, literal, namedNode, quad, triple, variable };
+export { termValue } from './utils/termValue';

package/esm/jsonldparser.js

@@ -0,0 +1,122 @@
+import jsonld from 'jsonld';
+import { arrayToStatements } from './utils';
+/**
+ * Parses json-ld formatted JS objects to a rdf Term.
+ * @param kb - The DataFactory to use.
+ * @param obj - The json-ld object to process.
+ * @return {Literal|NamedNode|BlankNode|Collection}
+ */
+
+export function jsonldObjectToTerm(kb, obj) {
+  if (typeof obj === 'string') {
+    return kb.rdfFactory.literal(obj);
+  }
+
+  if (Object.prototype.hasOwnProperty.call(obj, '@list')) {
+    if (kb.rdfFactory.supports["COLLECTIONS"] === true) {
+      return listToCollection(kb, obj['@list']);
+    }
+
+    return listToStatements(kb, obj);
+  }
+
+  if (Object.prototype.hasOwnProperty.call(obj, '@id')) {
+    return kb.rdfFactory.namedNode(obj['@id']);
+  }
+
+  if (Object.prototype.hasOwnProperty.call(obj, '@language')) {
+    return kb.rdfFactory.literal(obj['@value'], obj['@language']);
+  }
+
+  if (Object.prototype.hasOwnProperty.call(obj, '@type')) {
+    return kb.rdfFactory.literal(obj['@value'], kb.rdfFactory.namedNode(obj['@type']));
+  }
+
+  if (Object.prototype.hasOwnProperty.call(obj, '@value')) {
+    return kb.rdfFactory.literal(obj['@value']);
+  }
+
+  return kb.rdfFactory.literal(obj);
+}
+/**
+ * Adds the statements in a json-ld list object to {kb}.
+ */
+
+function listToStatements(kb, obj) {
+  var listId = obj['@id'] ? kb.rdfFactory.namedNode(obj['@id']) : kb.rdfFactory.blankNode();
+  var items = obj['@list'].map(function (listItem) {
+    return jsonldObjectToTerm(kb, listItem);
+  });
+  var statements = arrayToStatements(kb.rdfFactory, listId, items);
+  kb.addAll(statements);
+  return listId;
+}
+
+function listToCollection(kb, obj) {
+  if (!Array.isArray(obj)) {
+    throw new TypeError("Object must be an array");
+  }
+
+  return kb.rdfFactory.collection(obj.map(function (o) {
+    return jsonldObjectToTerm(kb, o);
+  }));
+}
+/**
+ * Takes a json-ld formatted string {str} and adds its statements to {kb}.
+ *
+ * Ensure that {kb.rdfFactory} is a DataFactory.
+ */
+
+
+export default function jsonldParser(str, kb, base, callback) {
+  var baseString = base && Object.prototype.hasOwnProperty.call(base, 'termType') ? base.value : base;
+  return jsonld.flatten(JSON.parse(str), null, {
+    base: baseString
+  }).then(function (flattened) {
+    return flattened.reduce(function (store, flatResource) {
+      var id = flatResource['@id'] ? kb.rdfFactory.namedNode(flatResource['@id']) : kb.rdfFactory.blankNode();
+
+      for (var _i = 0, _Object$keys = Object.keys(flatResource); _i < _Object$keys.length; _i++) {
+        var property = _Object$keys[_i];
+
+        if (property === '@id') {
+          continue;
+        }
+
+        var value = flatResource[property];
+
+        if (Array.isArray(value)) {
+          for (var i = 0; i < value.length; i++) {
+            kb.addStatement(createStatement(kb, id, property, value[i], base));
+          }
+        } else {
+          kb.addStatement(createStatement(kb, id, property, value, base));
+        }
+      }
+
+      return kb;
+    }, kb);
+  }).then(callback).catch(callback);
+}
+/**
+ * Create statement quad depending on @type being a type node
+ * @param kb
+ * @param subject id
+ * @param property
+ * @param value
+ * @return quad statement
+ */
+
+function createStatement(kb, id, property, value, base) {
+  var predicate, object;
+
+  if (property === "@type") {
+    predicate = kb.rdfFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#type");
+    object = kb.rdfFactory.namedNode(value);
+  } else {
+    predicate = kb.rdfFactory.namedNode(property);
+    object = jsonldObjectToTerm(kb, value);
+  }
+
+  return kb.rdfFactory.quad(id, predicate, object, kb.rdfFactory.namedNode(base));
+}

package/esm/jsonparser.js

@@ -0,0 +1,60 @@
+export default (function () {
+  return {
+    parseJSON: function parseJSON(data, source, store) {
+      var subject, predicate, object;
+      var bnodes = {};
+      var why = store.sym(source);
+
+      for (var x in data) {
+        if (x.indexOf('_:') === 0) {
+          if (bnodes[x]) {
+            subject = bnodes[x];
+          } else {
+            subject = store.bnode(x);
+            bnodes[x] = subject;
+          }
+        } else {
+          subject = store.sym(x);
+        }
+
+        var preds = data[x];
+
+        for (var y in preds) {
+          var objects = preds[y];
+          predicate = store.sym(y);
+
+          for (var z in objects) {
+            var obj = objects[z];
+
+            if (obj.type === 'uri') {
+              object = store.sym(obj.value);
+              store.add(subject, predicate, object, why);
+            } else if (obj.type === 'BlankNode') {
+              if (bnodes[obj.value]) {
+                object = bnodes[obj.value];
+              } else {
+                object = store.bnode(obj.value);
+                bnodes[obj.value] = object;
+              }
+
+              store.add(subject, predicate, object, why);
+            } else if (obj.type === 'Literal') {
+              // var datatype
+              if (obj.datatype) {
+                object = store.literal(obj.value, undefined, store.sym(obj.datatype));
+              } else if (obj.lang) {
+                object = store.literal(obj.value, obj.lang);
+              } else {
+                object = store.literal(obj.value);
+              }
+
+              store.add(subject, predicate, object, why);
+            } else {
+              throw new Error('error: unexpected termtype: ' + z.type);
+            }
+          }
+        }
+      }
+    }
+  };
+})();

package/esm/literal.js

@@ -0,0 +1,236 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+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 RDFlibNamedNode from './named-node';
+import Node from './node-internal';
+import { LiteralTermType } from './types';
+import { isLiteral } from './utils/terms';
+import XSD from './xsd-internal';
+
+/**
+ * An RDF literal, containing some value which isn't expressed as an IRI.
+ * @link https://rdf.js.org/data-model-spec/#literal-interface
+ */
+var Literal = /*#__PURE__*/function (_Node) {
+  _inherits(Literal, _Node);
+
+  var _super = _createSuper(Literal);
+
+  /**
+   * The literal's datatype as a named node
+   */
+
+  /**
+   * The language for the literal
+   */
+
+  /**
+   * Initializes a literal
+   * @param value - The literal's lexical value
+   * @param language - The language for the literal. Defaults to ''.
+   * @param datatype - The literal's datatype as a named node. Defaults to xsd:string.
+   */
+  function Literal(value, language, datatype) {
+    var _this;
+
+    _classCallCheck(this, Literal);
+
+    _this = _super.call(this, value);
+
+    _defineProperty(_assertThisInitialized(_this), "termType", LiteralTermType);
+
+    _defineProperty(_assertThisInitialized(_this), "classOrder", ClassOrder.Literal);
+
+    _defineProperty(_assertThisInitialized(_this), "datatype", XSD.string);
+
+    _defineProperty(_assertThisInitialized(_this), "isVar", 0);
+
+    _defineProperty(_assertThisInitialized(_this), "language", '');
+
+    if (language) {
+      _this.language = language;
+      _this.datatype = XSD.langString;
+    } else if (datatype) {
+      _this.datatype = RDFlibNamedNode.fromValue(datatype);
+    } else {
+      _this.datatype = XSD.string;
+    }
+
+    return _this;
+  }
+  /**
+   * Gets a copy of this literal
+   */
+
+
+  _createClass(Literal, [{
+    key: "copy",
+    value: function copy() {
+      return new Literal(this.value, this.lang, this.datatype);
+    }
+    /**
+     * Gets whether two literals are the same
+     * @param other The other statement
+     */
+
+  }, {
+    key: "equals",
+    value: function equals(other) {
+      if (!other) {
+        return false;
+      }
+
+      return this.termType === other.termType && this.value === other.value && this.language === other.language && (!this.datatype && !other.datatype || this.datatype && this.datatype.equals(other.datatype));
+    }
+    /**
+     * The language for the literal
+     * @deprecated use {language} instead
+     */
+
+  }, {
+    key: "lang",
+    get: function get() {
+      return this.language;
+    },
+    set: function set(language) {
+      this.language = language || '';
+    }
+  }, {
+    key: "toNT",
+    value: function toNT() {
+      return Literal.toNT(this);
+    }
+    /** Serializes a literal to an N-Triples string */
+
+  }, {
+    key: "toString",
+    value: function toString() {
+      return '' + this.value;
+    }
+    /**
+     * Builds a literal node from a boolean value
+     * @param value - The value
+     */
+
+  }], [{
+    key: "toNT",
+    value: function toNT(literal) {
+      if (typeof literal.value === 'number') {
+        return '' + literal.value;
+      } else if (typeof literal.value !== 'string') {
+        throw new Error('Value of RDF literal is not string or number: ' + literal.value);
+      }
+
+      var str = literal.value; // #x22 ("), #x5C (\), #x0A (\n) and #xD (\r) are disallowed and need to be replaced
+      // see https://www.w3.org/TR/n-triples/#grammar-production-STRING_LITERAL_QUOTE
+
+      str = str.replace(/\\/g, '\\\\');
+      str = str.replace(/\"/g, '\\"');
+      str = str.replace(/\n/g, '\\n');
+      str = str.replace(/\r/g, '\\r');
+      str = '"' + str + '"';
+
+      if (literal.language) {
+        str += '@' + literal.language;
+      } else if (!literal.datatype.equals(XSD.string)) {
+        // Only add datatype if it's not a string
+        str += '^^' + literal.datatype.toCanonical();
+      }
+
+      return str;
+    }
+  }, {
+    key: "fromBoolean",
+    value: function fromBoolean(value) {
+      var strValue = value ? '1' : '0';
+      return new Literal(strValue, null, XSD.boolean);
+    }
+    /**
+     * Builds a literal node from a date value
+     * @param value The value
+     */
+
+  }, {
+    key: "fromDate",
+    value: function fromDate(value) {
+      if (!(value instanceof Date)) {
+        throw new TypeError('Invalid argument to Literal.fromDate()');
+      }
+
+      var d2 = function d2(x) {
+        return ('' + (100 + x)).slice(1, 3);
+      };
+
+      var date = '' + value.getUTCFullYear() + '-' + d2(value.getUTCMonth() + 1) + '-' + d2(value.getUTCDate()) + 'T' + d2(value.getUTCHours()) + ':' + d2(value.getUTCMinutes()) + ':' + d2(value.getUTCSeconds()) + 'Z';
+      return new Literal(date, null, XSD.dateTime);
+    }
+    /**
+     * Builds a literal node from a number value
+     * @param value - The value
+     */
+
+  }, {
+    key: "fromNumber",
+    value: function fromNumber(value) {
+      if (typeof value !== 'number') {
+        throw new TypeError('Invalid argument to Literal.fromNumber()');
+      }
+
+      var datatype;
+      var strValue = value.toString();
+
+      if (strValue.indexOf('e') < 0 && Math.abs(value) <= Number.MAX_SAFE_INTEGER) {
+        datatype = Number.isInteger(value) ? XSD.integer : XSD.decimal;
+      } else {
+        datatype = XSD.double;
+      }
+
+      return new Literal(strValue, null, datatype);
+    }
+    /**
+     * Builds a literal node from an input value
+     * @param value - The input value
+     */
+
+  }, {
+    key: "fromValue",
+    value: function fromValue(value) {
+      if (isLiteral(value)) {
+        return value;
+      }
+
+      switch (_typeof(value)) {
+        case 'object':
+          if (value instanceof Date) {
+            return Literal.fromDate(value);
+          }
+
+        case 'boolean':
+          return Literal.fromBoolean(value);
+
+        case 'number':
+          return Literal.fromNumber(value);
+
+        case 'string':
+          return new Literal(value);
+      }
+
+      throw new Error("Can't make literal from " + value + ' of type ' + _typeof(value));
+    }
+  }]);
+
+  return Literal;
+}(Node);
+
+export { Literal as default };

package/esm/log.js

@@ -0,0 +1,13 @@
+/**
+ * A Dummy log
+ * @module log
+ */
+var log = {
+  debug: function debug(x) {},
+  warn: function warn(x) {},
+  info: function info(x) {},
+  error: function error(x) {},
+  success: function success(x) {},
+  msg: function msg(x) {}
+};
+export default log;