graph-rdfa-processor/dist/graph-rdfa-processor.js

Green turtle GraphRdfaProcessor extracted and available as a commonJS module

"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;