@lblod/graph-rdfa-processor 0.13.2

package/dist/graph-rdfa-processor.js

@@ -0,0 +1,256 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _rdfaProcessor = _interopRequireDefault(require("./rdfa-processor"));
+
+var _rdfaGraph = require("./rdfa-graph");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+var GraphRDFaProcessor =
+/*#__PURE__*/
+function (_RDFaProcessor) {
+  _inherits(GraphRDFaProcessor, _RDFaProcessor);
+
+  function GraphRDFaProcessor(target) {
+    _classCallCheck(this, GraphRDFaProcessor);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(GraphRDFaProcessor).call(this, target));
+  }
+
+  _createClass(GraphRDFaProcessor, [{
+    key: "getObjectSize",
+    value: function getObjectSize(obj) {
+      var size = 0;
+
+      for (var key in obj) {
+        if (obj.hasOwnProperty(key)) {
+          size++;
+        }
+      }
+
+      return size;
+    }
+  }, {
+    key: "init",
+    value: function init() {
+      var thisObj = this;
+      this.finishedHandlers.push(function (node) {
+        for (var subject in thisObj.target.graph.subjects) {
+          var snode = thisObj.target.graph.subjects[subject];
+
+          if (thisObj.getObjectSize(snode.predicates) == 0) {
+            delete thisObj.target.graph.subjects[subject];
+          }
+        }
+      });
+    }
+  }, {
+    key: "newBlankNode",
+    value: function newBlankNode() {
+      return this.target.graph.newBlankNode();
+    }
+  }, {
+    key: "newSubjectOrigin",
+    value: function newSubjectOrigin(origin, subject) {
+      var snode = this.newSubject(null, subject);
+
+      for (var i = 0; i < snode.origins.length; i++) {
+        if (snode.origins[i] === origin) {
+          return;
+        }
+      }
+
+      snode.origins.push(origin);
+
+      if (!origin.data) {
+        Object.defineProperty(origin, "data", {
+          value: snode,
+          writable: false,
+          configurable: true,
+          enumerable: true
+        });
+      }
+    }
+  }, {
+    key: "newSubject",
+    value: function newSubject(origin, subject) {
+      var snode = this.target.graph.subjects[subject];
+
+      if (!snode) {
+        snode = new _rdfaGraph.RDFaSubject(this.target.graph, subject);
+        this.target.graph.subjects[subject] = snode;
+      }
+
+      return snode;
+    }
+  }, {
+    key: "addTriple",
+    value: function addTriple(origin, subject, predicate, object) {
+      var snode = this.newSubject(origin, subject);
+      var pnode = snode.predicates[predicate];
+
+      if (!pnode) {
+        pnode = new _rdfaGraph.RDFaPredicate(predicate);
+        snode.predicates[predicate] = pnode;
+      }
+
+      for (var i = 0; i < pnode.objects.length; i++) {
+        if (pnode.objects[i].type == object.type && pnode.objects[i].value == object.value) {
+          if (pnode.objects[i].origin !== origin) {
+            if (!Array.isArray(pnode.objects[i].origin)) {
+              var origins = [];
+              origins.push(pnode.objects[i].origin);
+              pnode.objects[i].origin = origins;
+            }
+
+            pnode.objects[i].origin.push(origin);
+          }
+
+          return;
+        }
+      }
+
+      pnode.objects.push(object);
+      object.origin = origin;
+
+      if (predicate == _rdfaProcessor.default.typeURI) {
+        snode.types.push(object.value);
+      }
+    }
+  }, {
+    key: "copyProperties",
+    value: function copyProperties() {
+      var copySubjects = [];
+      var patternSubjects = {};
+
+      for (var subject in this.target.graph.subjects) {
+        var snode = this.target.graph.subjects[subject];
+        var pnode = snode.predicates[GraphRDFaProcessor.rdfaCopyPredicate];
+
+        if (!pnode) {
+          continue;
+        }
+
+        copySubjects.push(subject);
+
+        for (var i = 0; i < pnode.objects.length; i++) {
+          if (pnode.objects[i].type != _rdfaProcessor.default.objectURI) {
+            continue;
+          }
+
+          var target = pnode.objects[i].value;
+          var patternSubjectNode = this.target.graph.subjects[target];
+
+          if (!patternSubjectNode) {
+            continue;
+          }
+
+          var patternTypes = patternSubjectNode.predicates[_rdfaProcessor.default.typeURI];
+
+          if (!patternTypes) {
+            continue;
+          }
+
+          var isPattern = false;
+
+          for (var j = 0; j < patternTypes.objects.length && !isPattern; j++) {
+            if (patternTypes.objects[j].value == GraphRDFaProcessor.rdfaPatternType && patternTypes.objects[j].type == _rdfaProcessor.default.objectURI) {
+              isPattern = true;
+            }
+          }
+
+          if (!isPattern) {
+            continue;
+          }
+
+          patternSubjects[target] = true;
+
+          for (var predicate in patternSubjectNode.predicates) {
+            var targetPNode = patternSubjectNode.predicates[predicate];
+
+            if (predicate == _rdfaProcessor.default.typeURI) {
+              if (targetPNode.objects.length == 1) {
+                continue;
+              }
+
+              for (var j = 0; j < targetPNode.objects.length; j++) {
+                if (targetPNode.objects[j].value != GraphRDFaProcessor.rdfaPatternType) {
+                  var subjectPNode = snode.predicates[predicate];
+
+                  if (!subjectPNode) {
+                    subjectPNode = new _rdfaGraph.RDFaPredicate(predicate);
+                    snode.predicates[predicate] = subjectPNode;
+                  }
+
+                  subjectPNode.objects.push({
+                    type: targetPNode.objects[j].type,
+                    value: targetPNode.objects[j].value,
+                    language: targetPNode.objects[j].language,
+                    origin: targetPNode.objects[j].origin
+                  });
+                  snode.types.push(targetPNode.objects[j].value);
+                }
+              }
+            } else {
+              var subjectPNode = snode.predicates[predicate];
+
+              if (!subjectPNode) {
+                subjectPNode = new _rdfaGraph.RDFaPredicate(predicate);
+                snode.predicates[predicate] = subjectPNode;
+              }
+
+              for (var j = 0; j < targetPNode.objects.length; j++) {
+                subjectPNode.objects.push({
+                  type: targetPNode.objects[j].type,
+                  value: targetPNode.objects[j].value,
+                  language: targetPNode.objects[j].language,
+                  origin: targetPNode.objects[j].origin
+                });
+              }
+            }
+          }
+        }
+      }
+
+      for (var i = 0; i < copySubjects.length; i++) {
+        var snode = this.target.graph.subjects[copySubjects[i]];
+        delete snode.predicates[GraphRDFaProcessor.rdfaCopyPredicate];
+      }
+
+      for (var subject in patternSubjects) {
+        delete this.target.graph.subjects[subject];
+      }
+    }
+  }]);
+
+  return GraphRDFaProcessor;
+}(_rdfaProcessor.default);
+
+exports.default = GraphRDFaProcessor;
+;
+GraphRDFaProcessor.rdfaCopyPredicate = "http://www.w3.org/ns/rdfa#copy";
+GraphRDFaProcessor.rdfaPatternType = "http://www.w3.org/ns/rdfa#Pattern";
+module.exports = exports.default;

package/dist/index.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+var _uriResolver = _interopRequireDefault(require("./uri-resolver"));
+
+var _graphRdfaProcessor = _interopRequireDefault(require("./graph-rdfa-processor"));
+
+var _rdfaGraph = require("./rdfa-graph");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _default(document) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var node = document.documentElement || document;
+  var baseURI = options.baseURI ? options.baseURI : node.baseURI;
+  var specialHtmlPredicates = options.specialHtmlPredicates || [];
+  var graph = new _rdfaGraph.RDFaGraph();
+  var target = {
+    graph: graph,
+    baseURI: new _uriResolver.default().parseURI(baseURI),
+    specialHtmlPredicates: specialHtmlPredicates
+  };
+  var processor = new _graphRdfaProcessor.default(target);
+  processor.process(node, options);
+  return target.graph;
+}
+
+module.exports = exports.default;

package/dist/node.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var Node = {
+  ELEMENT_NODE: 1,
+  ATTRIBUTE_NODE: 2,
+  TEXT_NODE: 3,
+  CDATA_SECTION_NODE: 4,
+  ENTITY_REFERENCE_NODE: 5,
+  ENTITY_NODE: 6,
+  PROCESSING_INSTRUCTION_NODE: 7,
+  COMMENT_NODE: 8,
+  DOCUMENT_NODE: 9,
+  DOCUMENT_TYPE_NODE: 10,
+  DOCUMENT_FRAGMENT_NODE: 11,
+  NOTATION_NODE: 12
+};
+var _default = Node;
+exports.default = _default;
+module.exports = exports.default;