terminusdb 12.0.2

package/lib/viewer/objectFrame.js

@@ -0,0 +1,1550 @@
+/* eslint-disable consistent-return */
+/* eslint-disable prefer-destructuring */
+/* eslint-disable guard-for-in */
+/* eslint-disable max-len */
+/* eslint-disable no-redeclare */
+/* eslint-disable block-scoped-var */
+/* eslint-disable no-var */
+/* eslint-disable vars-on-top */
+/* eslint-disable no-plusplus */
+/* eslint-disable no-unused-vars */
+/* eslint-disable no-shadow */
+/* eslint-disable no-param-reassign */
+/* eslint-disable no-continue */
+/* eslint-disable no-console */
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable no-use-before-define */
+const FrameHelper = require('../utils');
+const { FrameRule } = require('./frameRule');
+const WOQL = require('../woql');
+
+/**
+ * @file Javascript Terminus Document Classes
+ * @license Apache Version 2
+ * Helper classes for accessing documents returned by the Terminus DB API programmatically
+ *
+ * @example
+ * let doc = new TerminusDocument(client);
+ *
+ * //These set the objects document property and return promises:
+ *
+ * doc.loadDocument(URL).then(() => console.log(this.document));
+ * doc.loadComplete(URL, CLS).then(() => console.log(this.document))
+ * doc.loadSchema(cls).then(() => console.log(this.document))
+ *
+ * //These just set the object's document property
+ * doc.loadJSON(json_frames, cls) //console.log(this.document)
+ * doc.loadDataFrames(json_frames, cls)
+ * doc.loadClassFrames(json_frames, cls)
+ * @description Represents a frame for programmatic access to object frame,
+ * anywhere within a document
+ * Recursive data structure where this.children contains an indexed array of object frames
+ * and this.dataframes contains a property indexed array of data frames
+ * Every object frame carries a reference to its classframe
+ * This gives us instructions as to how to create new frames according to the schema
+ * After that it's turtles all the way down.
+ * @param cls - ID of the class (URL)
+ * @param classframe - an array of frames representing a class
+ * @param archetypes list of class frames
+ * @param parent parent object
+ * @returns {ObjectFrame}
+ */
+
+function ObjectFrame(cls, jsonld, classframes, parent) {
+  // the class of the frame - mandatory
+  this.empty();
+  this.cls = FrameHelper.unshorten(cls);
+
+  // array of frames representing the full class frame
+  // (optional - required to be able to safely add missing properties)
+  if (classframes && typeof classframes === 'object') {
+    this.loadClassFrames(classframes);
+  }
+  // console.log("this", this)
+  if (jsonld && typeof jsonld === 'object' && Object.keys(jsonld).length) {
+    this.originalDocument = jsonld;
+    this.loadJSONLDDocument(jsonld);
+    // console.log("this after jsonld doc call", this)
+  } else {
+    this.originalDocument = false;
+  }
+  // parent object frame
+  this.parent = parent;
+  // set to true if this is a newly created document
+  this.newDoc = false;
+}
+
+/**
+ * Loads class frames for the object's class - the instructions about how to put an object together
+ */
+ObjectFrame.prototype.loadClassFrames = function (classframes) {
+  for (let j = 0; j < classframes.length; j += 1) {
+    if (classframes[j]['@context']) this.jsonld_context = classframes[j]['@context'];
+
+    const cf = new ClassFrame(classframes[j], this);
+    if (cf.isValid()) {
+      if (!this.classframes) this.classframes = {};
+      this.classframes[classframes[j].property] = cf;
+      if (cf.isObject() && this.properties[classframes[j].property]) {
+        for (let i = 0; i < this.properties[classframes[j].property].values.length; i += 1) {
+          this.properties[classframes[j].property].values[i].loadClassFrames(classframes[j].frame);
+        }
+      }
+    } else {
+      // eslint-disable-next-line no-console
+      console.log('Invalid classframe', cf);
+    }
+  }
+  return this;
+};
+
+/**
+ * Does this object have a schema loaded?
+ */
+ObjectFrame.prototype.hasSchema = function () {
+  return !FrameHelper.empty(this.classframes);
+};
+
+/*
+ * Loads an array of data frames into the object's internal index
+ * {property: [frames]}
+ */
+/* ObjectFrame.prototype.loadDataFrames = function (frames) {
+  if (typeof frames !== 'object' || !frames.length) return undefined;
+  if (!this.originalFrames) this.originalFrames = frames;
+  if (!this.subjid && frames[0].domainValue) this.subjid = frames[0].domainValue;
+  for (let i = 0; i < frames.length; i += 1) {
+    if (frames[i]['@context']) this.jsonld_context = frames[i]['@context'];
+    let cframe = this.getPropertyClassFrame(frames[i].property, frames[i]);
+    if (cframe && cframe.isClassChoice()) {
+      cframe = cframe.getChosenClassFrame(frames[i].range);
+      if (!cframe) {
+        console.log(`no choice frame ${frames[i].range}`);
+      }
+    } else if (cframe && cframe.isLogic()) {
+      cframe = cframe.getChosenFrame(frames[i]);
+    }
+    if (cframe) {
+      if (typeof this.properties[frames[i].property] === 'undefined') {
+        this.properties[frames[i].property] = new PropertyFrame(frames[i].property, cframe, this);
+      }
+      this.properties[frames[i].property].addFrame(frames[i]);
+    }
+  }
+  return this;
+}; */
+
+ObjectFrame.prototype.loadJSONLDDocument = function (rdoc) { // KItty check herer
+  if (typeof rdoc !== 'object') return undefined;
+  const doc = FrameHelper.json_unshorten(rdoc);
+  if (!this.originalDocument) this.originalDocument = doc;
+  if (!this.subjid && doc['@id']) {
+    this.subjid = FrameHelper.unshorten(doc['@id']);
+  }
+  if (doc['@context']) this.jsonld_context = doc['@context'];
+  for (const prop in doc) {
+    if (prop[0] === '@' || (typeof doc[prop] === 'object' && Object.keys(doc[prop]).length === 0)) continue;
+    let cframe = this.getPropertyClassFrame(prop, doc);
+    if (cframe && cframe.isClassChoice()) {
+    // cframe = cframe.getChosenClassFrame(FrameHelper.unshorten(doc[prop]["@type"]),cframe.parent)
+      if (!cframe) {
+        console.log(`no choice frame ${doc[prop]['@type']}`);
+      }
+    } else if (cframe && cframe.isLogic()) {
+      cframe = cframe.getChosenFrame(doc[prop]);
+    }
+    if (cframe) {
+      if (typeof this.properties[prop] === 'undefined') {
+        this.properties[prop] = new PropertyFrame(prop, cframe, this);
+      }
+      this.properties[prop].addJSONLDDocument(doc[prop]);
+    }
+  }
+  return this;
+};
+
+/*
+ * Serialises the javascript object as an array of frames
+ */
+ObjectFrame.prototype.getAsFrame = function (prop, parent) {
+  prop = FrameHelper.unshorten(prop);
+  if (this.parentframe) return this.parentframe;
+  const ff = { type: 'objectProperty', property: prop };
+  ff.range = this.cls;
+  ff.domain = parent.cls;
+  ff.domainValue = parent.subjid;
+  ff.frame = [];
+  for (const prop of Object.keys(this.properties)) {
+    ff.frame = ff.frame.concat(ff.frame, this.properties[prop].getAsFrames());
+  }
+  return ff;
+};
+
+ObjectFrame.prototype.getAsFrames = function (prop, parent) {
+  let frames = [];
+  for (const prop of Object.keys(this.properties)) {
+    frames = frames.concat(frames, this.properties[prop].getAsFrames());
+  }
+  return frames;
+};
+
+/**
+ * Cleans out object and sets everything empty
+ */
+ObjectFrame.prototype.empty = function () {
+  // all indexed by property
+  this.properties = {};
+  this.restrictions = {};
+  this.subjid = false;
+  this.cls = false;
+};
+
+/*
+ * Resets object state to original state
+ */
+ObjectFrame.prototype.reset = function (prop) {
+  if (prop) {
+    prop = FrameHelper.unshorten(prop);
+    const props = [];
+    for (let i = 0; i < this.originalFrames.length; i += 1) {
+      if (this.originalFrames[i].property === prop) {
+        props.push(this.originalFrames[i]);
+      }
+    }
+    if (this.properties[prop]) this.properties[prop] = [];
+    this.loadDataFrames(props);
+  } else {
+    this.restrictions = {};
+    this.properties = {};
+    this.loadDataFrames(this.originalFrames);
+  }
+};
+
+/*
+ * Clears out any specific information from a tree
+ */
+ObjectFrame.prototype.clear = function () {
+  for (const prop of Object.keys(this.properties)) {
+    this.properties[prop].clear();
+  }
+  return this;
+};
+
+/*
+ * Filters the frame and its children
+ */
+ObjectFrame.prototype.mfilter = function (rules, onmatch) {
+  const hits = new FrameRule().testRules(rules, this, onmatch);
+  for (const prop of Object.keys(this.properties)) {
+    if (!this.properties[prop].mfilter) {
+      console.log(prop, this.properties[prop]);
+    } else {
+      this.properties[prop].mfilter(rules, onmatch);
+    }
+  }
+  return this;
+};
+
+/**
+ * If a class frame is present, it is returned for the given property
+ * If no class frame is present and an instance frame is passed in the
+ * this enables make it up as you go along editing
+ * second argument a class frame will be created from the instance frame.
+ */
+ObjectFrame.prototype.getPropertyClassFrame = function (prop, jsonlddoc) {
+  if (typeof prop === 'object') {
+    return new ClassFrame(prop);
+  }
+
+  prop = FrameHelper.unshorten(prop);
+
+  if (this.classframes && typeof this.classframes === 'object' && typeof this.classframes[prop] === 'object') {
+    // console.log("returning " + prop, this.classframes[prop])
+    return this.classframes[prop];
+  }
+  if (jsonlddoc) {
+    const cf = new ClassFrame();
+    cf.loadFromJSONLD(jsonlddoc, prop);
+    return cf;
+  }
+  if (this.properties[prop]) {
+    return new ClassFrame(this.properties[prop].values[0]);
+  }
+  return false;
+};
+
+/*
+ * Returns a list of properties - type can be filled|missing|all
+ */
+ObjectFrame.prototype.getProperties = function (type) {
+  if (type === 'filled' || !this.classframes) {
+    return Object.keys(this.properties);
+  }
+  if (type === 'missing') {
+    const filled = Object.keys(this.properties).map((item) => FrameHelper.unshorten(item));
+    const all = Object.keys(this.classframes).map((item) => FrameHelper.unshorten(item));
+    const missing = [];
+    for (let i = 0; i < all.length; i++) {
+      if (filled.indexOf(all[i]) === -1 && missing.indexOf(all[i]) === -1) {
+        missing.push(all[i]);
+      }
+    }
+    return missing;
+  }
+  return Object.keys(this.classframes);
+};
+
+/**
+ * Missing properties are those that are present in the classframe,
+ * but not instantiated in the current object frame
+ * for this to work we need to load the frame with the associated classframe
+ */
+ObjectFrame.prototype.getMissingPropertyList = function () {
+  const missing = this.getProperties('missing');
+  const nmissing = [];
+  for (let i = 0; i < missing.length; i++) {
+    const cframe = this.getPropertyClassFrame(missing[i]);
+    if (cframe) {
+      var newb = { label: cframe.getLabel(), value: missing[i] };
+    } else {
+      var newb = { label: missing[i], value: missing[i] };
+    }
+    nmissing.push(newb);
+  }
+  return nmissing;
+};
+
+/**
+ * Returns a list of all the classes that can show up in the frame
+ */
+ObjectFrame.prototype.getPossibleContainedClasses = function () {
+  const cls = [];
+  function efcf(frames) {
+    if (frames.type && frames.type === 'class_choice') {
+      efcf(frames.operands);
+    }
+    if (!Array.isArray(frames)) frames = [frames];
+    for (let i = 0; i < frames.length; i++) {
+      if (frames[i].domain && cls.indexOf(frames[i].domain) === -1) cls.push(frames[i].domain);
+      if (frames[i].frame) {
+        efcf(frames[i].frame);
+      }
+    }
+  }
+  efcf(Object.values(this.classframes));
+  return cls;
+};
+
+ObjectFrame.prototype.getDocumentLinks = function () {
+  const vals = [];
+  const props = this.getProperties('filled');
+  for (let i = 0; i < props.length; i++) {
+    const mprop = this.properties[props[i]];
+    for (let k = 0; k < mprop.values.length; k++) {
+      const dval = mprop.values[k];
+      if (dval.isObject() && dval.getDocumentLinks) {
+        const nvals = dval.getDocumentLinks();
+        for (let l = 0; l < nvals.length; l++) {
+          if (vals.indexOf(nvals[l]) === -1) {
+            vals.push(nvals[l]);
+          }
+        }
+      } else if (dval.isDocument()) {
+        const nv = dval.get();
+        if (vals.indexOf(nv) === -1) {
+          vals.push(nv);
+        }
+      }
+    }
+  }
+  return vals;
+};
+
+/**
+ * List of properties that are filled in the object
+ */
+ObjectFrame.prototype.getFilledPropertyList = function () {
+  const props = this.getProperties('filled');
+  const filled = [];
+  for (let i = 0; i < props.length; i++) {
+    const cframe = this.getPropertyClassFrame(props[i]);
+    if (cframe) {
+      var newb = { label: cframe.getLabel(), value: props[i] };
+    } else {
+      var newb = { label: props[i], value: props[i] };
+    }
+    filled.push(newb);
+  }
+  return filled;
+};
+
+/*
+ * Fills the object frame from the schema - adding all the necessary property
+ * frames, etc to make it complete
+ */
+ObjectFrame.prototype.fillFromSchema = function (newid) {
+  if (newid) this.subjid = newid;
+  newid = (newid || FrameHelper.genBNID(`${FrameHelper.urlFragment(this.cls)}_`));
+  const properties = {};
+  if (this.classframes) {
+    for (const prop of Object.keys(this.classframes)) {
+      const pf = this.getPropertyClassFrame(prop);
+      properties[prop] = new PropertyFrame(prop, pf, this);
+      properties[prop].fillFromSchema(newid);
+    }
+  }
+  this.properties = properties;
+  this.originalFrames = [];
+  for (const prop of Object.keys(this.properties)) {
+    this.originalFrames.push(this.properties[prop].getAsFrames());
+  }
+  return this;
+};
+
+/*
+ * Clones an object frame to be a copy of the current frame
+ */
+ObjectFrame.prototype.clone = function (newid) {
+  const properties = {};
+  const cloned = new ObjectFrame(this.cls, false, false, this.parent);
+  cloned.classframes = this.classframes;
+  cloned.subjid = newid;
+  for (const prop of Object.keys(this.properties)) {
+    properties[prop] = this.properties[prop].clone();
+  }
+  cloned.properties = properties;
+  return cloned;
+};
+
+/**
+ * Returns a child frame with a particular id
+ * If the second parameter is included, it will only look in that specific property
+ * Otherwise searches all properties for the child
+ */
+ObjectFrame.prototype.getChild = function (childid, prop) {
+  let pframe = this.getProperty(prop);
+  for (let i = 0; i < pframe.values.length; pframe++) {
+    if (pframe.values[i].isObject() && pframe.values[i].subject === childid) return pframe.values[i];
+  }
+  if (!prop) {
+    for (const key of Object.keys(this.properties)) {
+      for (let i = 0; i < this.properties[key].values.length; i += 1) {
+        if (this.properties[key].values[i].subject() === childid) return this.properties[key].values[i];
+      }
+    }
+  }
+  return false;
+};
+
+ObjectFrame.prototype.addProperty = function (prop, cls) {
+  if (typeof prop !== 'object') prop = FrameHelper.unshorten(prop);
+  const cframe = this.getPropertyClassFrame(prop);
+  let ndata = false;
+  if (cframe) {
+    const nprop = new PropertyFrame(prop, cframe, this);
+    if (cframe.isObject()) {
+      if (!cframe.isClassChoice()) {
+        ndata = cframe.createEmpty(FrameHelper.genBNID(`${FrameHelper.urlFragment(cframe.range)}_`));
+      }
+      if (cls) {
+        ndata = cframe.createEmptyChoice(cls, FrameHelper.genBNID(`${FrameHelper.urlFragment(cls)}_`));
+      }
+      const clss = cframe.getClassChoices();
+      if (clss && clss.length) {
+        ndata = cframe.createEmptyChoice(clss[0], FrameHelper.genBNID(`${FrameHelper.urlFragment(clss[0])}_`));
+      }
+    } else {
+      ndata = cframe.createEmpty();
+    }
+    if (ndata) {
+      nprop.addValueFrame(ndata);
+    }
+    if (typeof this.properties[prop] === 'undefined') {
+      if (typeof prop === 'object') var p = prop.property;
+      else var p = prop;
+      this.properties[p] = nprop;
+      // this.properties[prop] = nprop;
+    }
+    // else {
+    // this.properties[prop].push(nprop);
+    // }
+    nprop.status = 'new';
+    return nprop;
+  }
+  return false;
+};
+
+ObjectFrame.prototype.addPropertyValue = function (prop, value) {
+  prop = FrameHelper.unshorten(prop);
+  if (this.properties[prop]) return this.properties[prop].addValue(value);
+  return null;
+};
+
+ObjectFrame.prototype.removeProperty = function (prop) {
+  prop = FrameHelper.unshorten(prop);
+  if (typeof this.properties[prop] !== 'undefined') {
+    delete (this.properties[prop]);
+  }
+};
+
+ObjectFrame.prototype.removePropertyValue = function (prop, value, index) {
+  prop = FrameHelper.unshorten(prop);
+  const pframe = this.properties[prop];
+  pframe.removeValue(value, index);
+  if (pframe.values.length === 0) {
+    this.removeProperty(prop);
+  }
+};
+
+ObjectFrame.prototype.error = function (msg) {
+  if (!this.errors) this.errors = [];
+  this.errors.push({ type: 'Internal Object Frame Error', msg });
+};
+
+ObjectFrame.prototype.extract = function () {
+  const extracts = {};
+  for (const prop in this.properties) {
+    const extracted = this.properties[prop].extract();
+    if (!FrameHelper.empty(extracted)) {
+      if (typeof extracts[prop] === 'undefined') extracts[prop] = [];
+      extracts[prop] = extracts[prop].concat(extracted);
+    }
+    if (extracts[prop] && extracts[prop].length === 1) extracts[prop] = extracts[prop][0];
+  }
+  if (FrameHelper.empty(extracts) && this.parent) {
+    return false;
+  }
+
+  const ext = this.extractJSONLD(extracts);
+  return ext;
+};
+
+ObjectFrame.prototype.extractJSONLD = function (extracts) {
+  extracts['@type'] = this.cls;
+  if (this.subject() !== '_:') extracts['@id'] = this.subject();
+  if (this.jsonld_context) extracts['@context'] = this.jsonld_context;
+  return extracts;
+};
+
+ObjectFrame.prototype.subject = function () {
+  return this.subjid || '';
+};
+
+ObjectFrame.prototype.get = ObjectFrame.prototype.subject;
+ObjectFrame.prototype.set = function (val) {
+  this.subjid = val;
+};
+
+ObjectFrame.prototype.isObject = function () { return true; };
+ObjectFrame.prototype.isProperty = function () { return false; };
+ObjectFrame.prototype.isData = function () { return false; };
+ObjectFrame.prototype.isClassChoice = function () {
+  return (this.frame && this.frame.type === 'class_choice');
+};
+
+ObjectFrame.prototype.subjectClass = function () {
+  return this.cls;
+};
+
+ObjectFrame.prototype.depth = function () {
+  if (this.parent) return (this.parent.depth() + 1);
+  return 0;
+};
+
+ObjectFrame.prototype.getProperty = function (prop) {
+  return this.properties[prop];
+};
+
+ObjectFrame.prototype.first = function (prop) {
+  if (this.properties && this.properties[prop]) {
+    return this.properties[prop].first();
+  }
+};
+
+ObjectFrame.prototype.property = function (prop) {
+  if (this.parent) return this.parent.property();
+  return false;
+};
+
+ObjectFrame.prototype.parentObject = function () {
+  if (this.parent && this.parent.parent) {
+    return this.parent.parent;
+  }
+  return false;
+};
+
+ObjectFrame.prototype.root = function () {
+  if (this.parent) return false;
+  return true;
+};
+
+ObjectFrame.prototype.renderProperties = function () {
+  const props = this.sortProperties();
+  const nprops = [];
+  for (let i = 0; i < props.length; i++) {
+    if (this.properties[props[i]].render) {
+      const rend = this.properties[props[i]].render(this.properties[props[i]]);
+      if (rend) nprops.push(rend);
+    }
+  }
+  return nprops;
+};
+
+ObjectFrame.prototype.sortProperties = function () {
+  const unsorted = Object.keys(this.properties);
+  if (this.compare) {
+    return unsorted.sort((a, b) => this.compare(a, b, this));
+  }
+  return unsorted.sort((a, b) => this.standardCompare(a, b, this));
+};
+
+/*
+ * Label first, then datatype properties, then object properties
+ */
+ObjectFrame.prototype.standardCompare = function (a, b, doc) {
+  if (FrameHelper.shorten(a) === 'rdfs:label') return -1;
+  if (FrameHelper.shorten(b) === 'rdfs:label') return 1;
+  if (FrameHelper.shorten(a) === 'rdfs:comment') return -1;
+  if (FrameHelper.shorten(b) === 'rdfs:comment') return 1;
+  if (doc.properties[a].isData() && doc.properties[b].isObject()) return -1;
+  if (doc.properties[b].isData() && doc.properties[a].isObject()) return 1;
+  return 0;
+};
+
+ObjectFrame.prototype.cardControlAllows = function (action) {
+  if (!this.parent) return true;
+  if (this.parent.cframe.hasRestriction()) {
+    const rest = this.parent.cframe.restriction;
+    const currentnum = this.parent.values.length;
+    if (action === 'add' || action === 'clone') {
+      if (rest.max && currentnum >= rest.max) {
+        return false;
+      }
+    }
+    if (action === 'delete' && (rest.min && currentnum <= rest.min)) {
+      return false;
+    }
+  }
+  return true;
+};
+
+ObjectFrame.prototype.isUpdated = function () {
+  let i = 0;
+  for (const prop in this.properties) {
+    if (this.originalFrames[i] !== prop) return true;
+    if (this.properties[prop].isUpdated()) return true;
+    i++;
+  }
+  if (i !== this.originalFrames.length) return true;
+  return false;
+};
+
+ObjectFrame.prototype.isNew = function () {
+  return (this.subject().substring(0, 2) === '_:');
+};
+
+ObjectFrame.prototype.getSummary = function () {
+  const ret = { status: 'ok' };
+  if (this.isUpdated()) ret.status = 'updated';
+  if (this.isNew()) ret.status = 'new';
+  ret.propcount = 0;
+  for (const prop in this.properties) {
+    ret.propcount++;
+  }
+  ret.long = `${ret.propcount} properties`;
+  return ret;
+};
+
+ObjectFrame.prototype.saveQuery = function () {
+  const q = WOQL.update_object(this.extract());
+  this.pathToDoc(q);
+  return q;
+};
+
+ObjectFrame.prototype.pathToDoc = function (q) {
+  q.add_triple(this.subjid, 'type', this.cls);
+  if (this.parent) {
+    q.add_triple(this.parent.subject(), 'type', this.parent.subjectClass());
+    q.add_triple(this.parent.subject(), this.parent.predicate, this.subjid);
+    if (this.parent.parent) {
+      this.parent.parent.pathToDoc(q);
+    }
+  }
+};
+
+ObjectFrame.prototype.deleteQuery = function () {
+  const q = WOQL.delete_object(this.subjid);
+  if (this.parent) {
+    q.delete_triple(this.parent.subject(), this.parent.predicate, this.subjid);
+  }
+  return q;
+};
+
+function PropertyFrame(property, cframe, parent) {
+  this.predicate = property;
+  this.cframe = cframe;
+  this.parent = parent;
+  this.values = [];
+}
+
+PropertyFrame.prototype.addJSONLDDocument = function (jsonld) {
+  if (this.cframe.isData()) {
+    if (Array.isArray(jsonld)) {
+      for (var i = 0; i < jsonld.length; i++) {
+        var df = new DataFrame(jsonld[i], this, this.values.length);
+        this.values.push(df);
+      }
+    } else {
+      var df = new DataFrame(jsonld, this, this.values.length);
+      this.values.push(df);
+    }
+  } else if (Array.isArray(jsonld)) {
+    for (var i = 0; i < jsonld.length; i++) {
+      const kid = new ObjectFrame(FrameHelper.unshorten(jsonld[i]['@type']), jsonld[i], this.cframe.frame, this);
+      this.values.push(kid);
+    }
+  } else {
+    const kid = new ObjectFrame(jsonld['@type'], jsonld, this.cframe.frame, this);
+    this.values.push(kid);
+  }
+};
+
+PropertyFrame.prototype.addFrame = function (frame) {
+  if (this.cframe.isData()) {
+    const df = new DataFrame(frame, this, this.values.length);
+    this.values.push(df);
+  } else {
+    const kid = new ObjectFrame(this.range(), this.cframe.frame, frame.frame, this, frame);
+    this.values.push(kid);
+  }
+};
+
+PropertyFrame.prototype.addValueFrame = function (oframe) {
+  if (oframe) {
+    oframe.parent = this;
+    oframe.index = this.values.length;
+    this.values.push(oframe);
+  }
+};
+
+PropertyFrame.prototype.addValue = function (val) {
+  const nu = this.createEmpty();
+  if (val) nu.set(val);
+  this.addValueFrame(nu);
+  return nu;
+};
+
+PropertyFrame.prototype.fillFromSchema = function (newid) {
+  if (this.isData() || (this.isObject() && !this.isClassChoice())) {
+    const values = [];
+    if (this.cframe.hasRestriction() && this.cframe.restriction.min) {
+      for (let i = 0; i < this.cframe.restriction.min; i += 1) {
+        var nframe = this.createEmpty(newid);
+        nframe.parent = this;
+        values.push(nframe);
+      }
+    } else {
+      var nframe = this.createEmpty(newid);
+      nframe.parent = this;
+      values.push(nframe);
+    }
+    this.values = values;
+  } else if (this.isClassChoice()) {
+    const clss = this.cframe.getClassChoices();
+    if (clss && clss.length) {
+      const empty = this.cframe.createEmptyChoice(clss[0], FrameHelper.genBNID(`${FrameHelper.urlFragment(clss[0])}_`));
+      empty.parent = this;
+      this.values = [empty];
+    }
+  }
+};
+
+PropertyFrame.prototype.isData = function () {
+  return this.cframe.isData();
+};
+
+PropertyFrame.prototype.isObject = function () {
+  return this.cframe.isObject();
+};
+
+PropertyFrame.prototype.isProperty = function () {
+  return true;
+};
+
+PropertyFrame.prototype.property = function () {
+  return this.predicate;
+};
+
+PropertyFrame.prototype.extract = function () {
+  const extracts = [];
+  const hasVal = (val) => {
+    if (val['@value']) {
+      for (var i = 0; i < extracts.length; i++) {
+        if (extracts[i]['@value'] && extracts[i]['@value'] === val['@value']
+                && extracts[i]['@type'] && extracts[i]['@type'] === val['@type']) return true;
+      }
+      return false;
+    }
+    if (val['@id']) {
+      for (var i = 0; i < extracts.length; i++) {
+        if (extracts[i]['@id'] && extracts[i]['@id'] === val['@id']) return true;
+      }
+      return false;
+    }
+  };
+
+  for (let i = 0; i < this.values.length; i++) {
+    const val = this.values[i].extract();
+    if (val !== '' && val !== false && typeof val !== 'undefined' && !hasVal(val)) extracts.push(val);
+  }
+  return extracts;
+};
+
+PropertyFrame.prototype.subject = function () {
+  return (this.parent ? this.parent.subject() : false);
+};
+PropertyFrame.prototype.subjectClass = function () {
+  return (this.parent ? this.parent.subjectClass() : false);
+};
+PropertyFrame.prototype.depth = function () {
+  return (this.parent ? this.parent.depth() : false);
+};
+PropertyFrame.prototype.updated = function () {
+  return (this.parent ? this.parent.childUpdated() : false);
+};
+PropertyFrame.prototype.range = function () {
+  return (this.cframe ? this.cframe.range : '');
+};
+PropertyFrame.prototype.getLabel = function () {
+  return (
+  // this.cframe ? this.cframe.getLabel() : '');
+    this.cframe ? this.cframe.getLabel() : this.predicate.getLabel());
+};
+PropertyFrame.prototype.getComment = function () {
+  return (this.cframe ? this.cframe.getComment() : false);
+};
+PropertyFrame.prototype.hasCardinalityRestriction = function () {
+  return (this.cframe ? this.cframe.hasRestriction() : false);
+};
+PropertyFrame.prototype.getRestriction = function () {
+  return (this.cframe ? this.cframe.restriction : false);
+};
+PropertyFrame.prototype.isClassChoice = function () {
+  return (this.cframe ? this.cframe.isClassChoice() : false);
+};
+
+PropertyFrame.prototype.deletePropertyValue = function (value, index) {
+  this.parent.removePropertyValue(this.property(), value, index);
+};
+
+PropertyFrame.prototype.removeValue = function (value, index) {
+  const nvals = [];
+  for (let i = 0; i < this.values.length; i++) {
+    if (this.values[i].index !== value.index) {
+      nvals.push(this.values[i]);
+    }
+  }
+  this.values = nvals;
+  /* let nvals = [] //trial
+    for(var i = 0; i<this.values.length; i++){
+        if(this.values[i].get() != value){
+            nvals.push(this.values[i])
+        }
+    }
+    this.values = nvals */
+};
+
+PropertyFrame.prototype.get = function () {
+  const gets = [];
+  for (let i = 0; i < this.values.length; i++) {
+    if (this.values[i]) {
+      const x = this.values[i].get();
+      if (x) gets.push(x);
+    }
+  }
+  return gets;
+};
+
+PropertyFrame.prototype.set = function (val) {
+  for (let i = 0; i < this.values.length; i++) {
+    if (this.values[i]) {
+      this.values[i].set(val);
+    }
+  }
+};
+
+PropertyFrame.prototype.clear = function () {
+  for (let i = 0; i < this.values.length; i++) {
+    this.values[i].clear();
+  }
+};
+
+PropertyFrame.prototype.clone = function () {
+  const cvalues = [];
+  const cloned = new PropertyFrame(this.predicate, this.cframe, this.parent);
+  for (let i = 0; i < this.values.length; i++) {
+    cvalues.push(this.values[i].clone());
+  }
+  cloned.values = cvalues;
+  return cloned;
+  //
+};
+
+PropertyFrame.prototype.getAsFrames = function () {
+  let fs = [];
+  for (let i = 0; i < this.values.length; i++) {
+    if (this.values[i]) {
+      if (this.isData()) {
+        fs.push(this.values[i].getAsFrame());
+      } else {
+        fs = fs.concat(this.values[i].getAsFrames());
+      }
+    }
+  }
+  return fs;
+};
+
+PropertyFrame.prototype.createEmpty = function () {
+  if (this.cframe.isData()) {
+    const df = this.cframe.copy(this.subject());
+    df.set('');
+    df.status = 'new';
+    return df;
+  }
+  if (this.cframe.isObject()) {
+    if (!this.cframe.isClassChoice()) {
+      const df = this.cframe.createEmpty(FrameHelper.genBNID(`${FrameHelper.urlFragment(this.cframe.range)}_`));
+      df.status = 'new';
+      return df;
+    }
+
+    const df = new ClassFrame(this.cframe);
+    df.status = 'new';
+    return df;
+  }
+};
+
+PropertyFrame.prototype.mfilter = function (rules, onmatch) {
+  const hits = new FrameRule().testRules(rules, this, onmatch);
+  for (let i = 0; i < this.values.length; i++) {
+    this.values[i].mfilter(rules, onmatch);
+  }
+  return this;
+};
+
+/*
+ * Shorthand functions to make it easier to access the underlying data
+ */
+
+PropertyFrame.prototype.first = function () {
+  if (this.values && this.values[0]) {
+    return this.values[0].get();
+  }
+};
+
+PropertyFrame.prototype.renderValues = function () {
+  const sortedVals = this.sortValues();
+  const vals = [];
+  for (let i = 0; i < sortedVals.length; i++) {
+    if (sortedVals[i] && sortedVals[i].render) {
+      const rend = sortedVals[i].render(sortedVals[i]);
+      if (rend) vals.push(rend);
+    }
+  }
+  return vals;
+};
+
+PropertyFrame.prototype.sortValues = function () {
+  if (this.compare) {
+    return this.values.sort((a, b) => this.compare(a, b, this));
+  }
+  return this.values;
+};
+
+PropertyFrame.prototype.cardControlAllows = function (action) {
+  if (this.cframe.hasRestriction()) {
+    const rest = this.cframe.restriction;
+    const currentnum = this.values.length;
+    if (action === 'add' || action === 'clone') {
+      if (rest.max && currentnum >= rest.max) {
+        return false;
+      }
+    }
+    if (action === 'delete' && (rest.min)) {
+      return false;
+    }
+  }
+  return true;
+};
+
+PropertyFrame.prototype.isUpdated = function () {
+  return true;
+  // eslint-disable-next-line no-unreachable
+  if (this.values.length !== this.originalValues.length) return true;
+  for (let i = 0; i < this.values.length; i++) {
+    if (this.cframe && this.cframe.isData()) {
+      if (this.values[i].value() !== this.originalValues[i]) {
+        return true;
+      }
+    } else {
+      if (this.values[i].subject() !== this.originalValues[i]) {
+        return true;
+      }
+      if (this.values[i].isUpdated()) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+
+PropertyFrame.prototype.saveQuery = function () {
+  const q = WOQL.query();
+  for (let i = 0; i < this.values.length; i++) {
+    q.and(this.values[i].saveQuery());
+  }
+  this.parent.pathToDoc(q);
+  return q;
+};
+
+PropertyFrame.prototype.deleteQuery = function () {
+  const q = WOQL.query();
+  for (let i = 0; i < this.values.length; i++) {
+    q.and(this.values[i].deleteQuery());
+  }
+  return q;
+};
+
+function DataFrame(jsonld, parent, index) {
+  this.err = false;
+  this.index = index;
+  if (parent) {
+    this.loadParent(parent);
+  }
+  if (jsonld) {
+    this.rangeValue = jsonld;
+    if (jsonld['@type']) this.range = jsonld['@type'];
+    if (jsonld['@language']) this.language = jsonld['@language'];
+    if (!this.type) this.type = (jsonld['@value'] ? 'datatypeProperty' : 'objectProperty');
+  }
+  return this;
+}
+
+DataFrame.prototype.loadParent = function (parent, index) {
+  this.parent = parent;
+  this.type = parent.type;
+  // the id of the object that owns this dataframe
+  this.domainValue = parent.subject();
+  this.subjid = (parent.subject() || false);
+  this.domain = parent.cframe ? parent.cframe.domain : parent.subjectClass();
+  this.predicate = parent.cframe ? parent.cframe.predicate : parent.property();
+  this.frame = parent.cframe ? parent.cframe.frame : false;
+  this.label = parent.getLabel();
+  this.comment = parent.getComment();
+  this.range = ((parent && parent.cframe) ? parent.cframe.range : false);
+  const restriction = (parent.cframe ? parent.cframe.restriction : false);
+  this.restriction = false;
+  if (restriction && typeof restriction === 'object') {
+    this.restriction = new Restriction(restriction);
+  }
+};
+
+DataFrame.prototype.copy = function (newid) {
+  const copy = new DataFrame();
+  copy.parent = this.parent;
+  copy.range = this.range;
+  copy.rangeValue = this.rangeValue;
+  copy.index = this.index;
+  copy.type = this.type;
+  copy.domain = this.domain;
+  copy.domainValue = newid || this.domainValue;
+  copy.predicate = this.predicate;
+  copy.frame = this.frame;
+  copy.label = this.label;
+  copy.comment = this.comment;
+  if (this.restriction) copy.restriction = this.restriction;
+  if (this.language) copy.language = this.language;
+  return copy;
+};
+
+DataFrame.prototype.mfilter = function (rules, onmatch) {
+  const hits = new FrameRule().testRules(rules, this, onmatch);
+  return this;
+};
+
+DataFrame.prototype.reset = function () {
+  this.set(this.originalValue);
+  // this.redraw();
+};
+
+DataFrame.prototype.clone = function () {
+  const newb = this.parent.addPropertyValue(this.get());
+};
+
+DataFrame.prototype.depth = function () { return (this.parent ? this.parent.depth() : false); };
+DataFrame.prototype.property = function () { return (this.parent ? this.parent.property() : false); };
+DataFrame.prototype.subject = function () { return (this.parent ? this.parent.subject() : false); };
+DataFrame.prototype.subjectClass = function () { return (this.parent ? this.parent.subjectClass() : false); };
+DataFrame.prototype.type = function () { return (this.range ? this.range : false); };
+
+DataFrame.prototype.isValidType = function (dt) {
+  const vtypes = ['datatypeProperty', 'objectProperty', 'restriction '];
+  if (vtypes.indexOf(dt) === -1) return false;
+  return true;
+};
+
+DataFrame.prototype.getAsFrame = function () {
+  const ff = { type: this.type, property: this.property() };
+  if (this.range) ff.range = this.range;
+  if (this.rangeValue) ff.rangeValue = this.rangeValue;
+  if (this.domain) ff.domain = this.domain;
+  if (this.domainValue) ff.domainValue = this.domainValue;
+  if (this.frame) ff.frame = this.frame;
+  if (this.label) ff.label = this.label;
+  if (this.comment) ff.comment = this.comment;
+  return ff;
+};
+
+DataFrame.prototype.hasRestriction = function () {
+  if (this.restriction) {
+    return this.restriction.hasCardRestriction();
+  }
+  return false;
+};
+
+DataFrame.prototype.getLabel = function () {
+  let lab = '';
+  if (FrameHelper.shorten(this.predicate) === 'rdfs:label') return 'Name';
+  if (FrameHelper.shorten(this.predicate) === 'rdfs:comment') return 'Description';
+  if (this.label && typeof this.label === 'object') lab = this.label['@value'];
+  if (this.label && typeof this.label === 'string') lab = this.label;
+  // always return something
+  if (!lab && this.predicate) {
+    lab = FrameHelper.labelFromURL(this.predicate);
+  }
+  if (!lab) lab = FrameHelper.labelFromURL(this.cls);
+  return lab;
+};
+
+DataFrame.prototype.getType = function () {
+  if (this.range) return this.range;
+  if (this.rangeValue && this.rangeValue['@type']) return this.rangeValue['@type'];
+  return false;
+};
+
+ObjectFrame.prototype.getLabel = DataFrame.prototype.getLabel;
+
+DataFrame.prototype.getComment = function () {
+  let comment = '';
+  if (this.comment && typeof this.comment === 'object') comment = this.comment['@value'];
+  if (this.comment && typeof this.comment === 'string') comment = this.comment;
+  return comment;
+};
+
+ObjectFrame.prototype.getComment = DataFrame.prototype.getComment;
+
+DataFrame.prototype.error = function (msg) {
+  if (msg) this.err = msg;
+  if (!this.errors) this.errors = [];
+  this.errors.push({ type: 'Internal Data Frame Error', msg });
+  return this.err;
+};
+
+DataFrame.prototype.isValid = function () {
+  if (!(this.type && this.isValidType(this.type))) {
+    this.error(`Missing or Illegal Frame Type ${this.type}`);
+    return false;
+  }
+  if (!(this.predicate)) {
+    this.error('Missing Frame Property');
+    return false;
+  }
+  if (!(this.domain)) {
+    this.error('Missing Frame Domain');
+    return false;
+  }
+  if (!(this.range)) {
+    this.error('Missing Frame Range');
+    return false;
+  }
+  if (this.isObjectProperty() && !(this.frame && typeof this.frame === 'object')) {
+    this.error('Missing Object Frame');
+    return false;
+  }
+  return true;
+};
+
+DataFrame.prototype.isObjectProperty = function () {
+  return this.type === 'objectProperty';
+};
+
+DataFrame.prototype.isData = function () {
+  return true;
+};
+
+DataFrame.prototype.isDatatypeProperty = function () {
+  return this.type === 'datatypeProperty';
+};
+
+DataFrame.prototype.isLogic = function () {
+  if (this.type === 'and' || this.type === 'or' || this.type === 'xor') {
+    return true;
+  }
+  return false;
+};
+
+DataFrame.prototype.isRestriction = function () {
+  return this.type === 'restriction';
+};
+
+DataFrame.prototype.ftype = function () {
+  if (this.isDocument()) return 'document';
+  if (this.isDatatypeProperty()) return 'data';
+  if (this.isChoice()) return 'oneOf';
+  if (this.isObject()) return 'object';
+  if (this.isLogic()) return 'logic';
+  if (this.isClassChoice()) return 'class_choice';
+  return undefined;
+};
+
+DataFrame.prototype.isClassChoice = function () {
+  return (this.frame && this.frame.type === 'class_choice');
+};
+
+DataFrame.prototype.isString = function () {
+  if (this.range === FrameHelper.getStdURL('xsd', 'string')) {
+    return true;
+  }
+  return false;
+};
+
+DataFrame.prototype.getChoiceOptions = function () {
+  const opts = [];
+  for (let i = 0; i < this.frame.elements.length; i += 1) {
+    const option = {};
+    if (this.frame.elements[i].label) {
+      option.label = this.frame.elements[i].label['@value'];
+    } else {
+      option.label = FrameHelper.labelFromURL(this.frame.elements[i].class);
+    }
+    option.value = this.frame.elements[i].class;
+    opts.push(option);
+  }
+  return opts;
+};
+
+DataFrame.prototype.lang = function () {
+  return this.language || 'en';
+};
+
+DataFrame.prototype.isChoice = function () {
+  return (this.frame && this.frame.type === 'oneOf');
+};
+
+DataFrame.prototype.isDocument = function () {
+  return (this.frame && this.frame.type === 'document');
+};
+
+DataFrame.prototype.isObject = function () {
+  return (this.isObjectProperty() && this.frame && !(this.isChoice() || this.isDocument()));
+};
+
+DataFrame.prototype.isProperty = function () {
+  return false;
+};
+
+DataFrame.prototype.getTypeShorthand = function () {
+  if (this.isDocument()) return 'document';
+  if (this.isChoice()) return 'choice';
+  const sh = FrameHelper.getShorthand(this.getType());
+  return (sh || this.getType());
+};
+
+DataFrame.prototype.get = function () {
+  if (this.contents) {
+    return this.contents;
+  }
+  if (this.isDatatypeProperty() && this.rangeValue && typeof this.rangeValue['@value'] !== 'undefined') {
+    return this.rangeValue['@value'];
+  }
+  if (this.isChoice() || this.isDocument()) {
+    return (this.rangeValue && this.rangeValue['@id'] ? this.rangeValue['@id'] : '');
+  }
+  return '';
+};
+
+DataFrame.prototype.set = function (value, normalizer) {
+  if (normalizer) value = normalizer(value, this);
+  this.contents = value;
+  if (this.isChoice() || this.isDocument()) {
+    this.frame.domainValue = value;
+  }
+  if (this.isDatatypeProperty()) {
+    if (!this.rangeValue) this.rangeValue = { '@type': this.range };
+    this.rangeValue['@value'] = value;
+  }
+};
+
+DataFrame.prototype.clear = function () {
+  if (this.isDocument() || this.isChoice() || this.isDatatypeProperty()) {
+    this.set('');
+  }
+};
+
+DataFrame.prototype.cardControlAllows = function (action) {
+  if (this.parent.cframe.hasRestriction()) {
+    const rest = this.parent.cframe.restriction;
+    const currentnum = this.parent.values.length;
+    if (action === 'add' || action === 'clone') {
+      if (rest.max && currentnum >= rest.max) {
+        return false;
+      }
+    }
+    if (action === 'delete' && (rest.min && currentnum <= rest.min)) {
+      return false;
+    }
+  }
+  return true;
+};
+
+DataFrame.prototype.extract = function () {
+  const val = this.get();
+  if (val !== '' && val !== false) {
+    const objlit = {};
+    if (!this.isDocument()) {
+      objlit['@type'] = this.getType();
+    }
+    if (this.isChoice() || this.isDocument()) {
+      objlit['@id'] = val;
+    } else {
+      objlit['@value'] = val;
+    }
+    if (this.language) {
+      objlit['@language'] = this.language;
+    }
+    return objlit;
+  }
+  return val;
+};
+
+DataFrame.prototype.saveQuery = function (newval, ntype, nlang) {
+  let upd;
+  if (newval === '') return false;
+  if (this.isDocument() || this.isChoice()) {
+    upd = WOQL.iri(newval);
+  } else {
+    upd = { '@value': newval };
+    upd['@type'] = ntype || this.range;
+    if (nlang || this.language) upd['@language'] = nlang || this.language;
+  }
+  let q;
+  if (this.get() !== '') {
+    q = WOQL.update_triple(this.parent.subject(), this.predicate, upd, this.extract());
+  } else {
+    q = WOQL.add_triple(this.parent.subject(), this.predicate, upd);
+  }
+
+  if (this.parent.parent) {
+    this.parent.parent.pathToDoc(q);
+  }
+  return q;
+};
+
+DataFrame.prototype.deleteQuery = function () {
+  const q = WOQL.delete_triple(this.subject(), this.predicate, this.extract());
+  return q;
+};
+
+/*
+ * Class frames represent the archetypal version of a property frame as returned by the class frame api
+ */
+function ClassFrame(frame, parent, label) {
+  this.err = false;
+  this.parent = parent;
+  // the id of the object that owns this dataframe
+  this.subjid = (parent ? parent.subjid : false);
+  if (frame) {
+    if (frame.label) {
+      const dl = label || '';
+      if (frame.label['@value']) this.label = frame.label['@value'];
+      else if (frame.label) this.label = frame.label;
+      else this.label = dl;
+    }
+    this.load(frame);
+  }
+}
+
+ClassFrame.prototype = DataFrame.prototype;
+
+ClassFrame.prototype.load = function (frame) {
+  if (typeof frame !== 'object') {
+    this.error('No frame passed to load');
+    return;
+  }
+  this.domainValue = frame.domainValue;
+  this.subjid = (frame.domainValue ? frame.domainValue : false);
+  this.type = frame.type;
+  this.domain = frame.domain;
+  this.predicate = frame.property;
+  this.frame = frame.frame;
+  this.comment = frame.comment ? frame.comment['@value'] : '';
+  this.range = frame.range;
+
+  // all the meta-data carried in frames:
+  this.rangeValue = frame.rangeValue;
+};
+
+ClassFrame.prototype.loadFromJSONLD = function (jsonld, prop) {
+  if (jsonld[prop]) {
+    this.predicate = FrameHelper.unshorten(prop);
+    this.type = (jsonld[prop]['@value'] ? 'datatypeProperty' : 'objectProperty');
+    this.range = FrameHelper.unshorten(jsonld[prop]['@type']);
+    this.rangeValue = jsonld[prop]['@id'] ? jsonld[prop]['@id'] : jsonld[prop];
+  }
+  this.domain = FrameHelper.unshorten(jsonld['@type']);
+  this.domainValue = FrameHelper.unshorten(jsonld['@id']);
+  this.label = FrameHelper.labelFromURL(this.predicate);
+  this.comment = '';// this.getComment()
+};
+
+ClassFrame.prototype.isClassChoice = function () {
+  return (this.frame && this.frame.type === 'class_choice');
+};
+
+ClassFrame.prototype.loadFromObjectFrame = function (par, child) {
+  // all the meta-data carried in frames:
+  this.type = 'objectProperty';
+  this.predicate = par.property;
+  this.range = par.range;
+  this.rangeValue = child.subjid;
+  this.domain = par.cls;
+  this.domainValue = par.subjid;
+  this.label = par.getLabel();
+  this.comment = par.getComment();
+  this.restriction = par.restriction;
+};
+
+ClassFrame.prototype.createEmptyChoice = function (cls, newid) {
+  const cf = this.getChosenClassFrames(cls);
+  const objframe = new ObjectFrame(cls);
+  if (newid) objframe.subjid = newid;
+  objframe.loadClassFrames(cf);
+  const fframe = objframe.fillFromSchema();
+  fframe.status = 'new';
+  return fframe;
+};
+
+ClassFrame.prototype.getChosenClassFrames = function (chosen) {
+  let nc = [];
+  for (let i = 0; i < this.frame.operands.length; i += 1) {
+    for (let j = 0; j < this.frame.operands[i].length; j += 1) {
+      if (chosen === this.frame.operands[i][j].domain) {
+        nc = nc.concat(this.frame.operands[i][j]);
+      }
+    }
+  }
+  return nc;
+};
+
+ClassFrame.prototype.createEmpty = function (newid) {
+  let objframe;
+  if (this.isObject()) {
+    if (this.isClassChoice()) {
+      // objframe=new ObjectFrame(this.predicate, {}, this)
+      objframe = new ObjectFrame(this.predicate);
+    } else {
+      objframe = new ObjectFrame(this.range);
+    }
+    if (newid) objframe.subjid = newid;
+    objframe.loadClassFrames(this.frame);
+    const fframe = objframe.fillFromSchema();
+    fframe.status = 'new';
+    return fframe;
+  }
+  if (this.isData()) {
+    const dataframe = this.copy(newid);
+    dataframe.set('');
+    dataframe.status = 'new';
+    return dataframe;
+  }
+  return undefined;
+};
+
+ClassFrame.prototype.cloneDataFrame = function (newid, other) {
+  return other;
+};
+
+ClassFrame.prototype.clone = function (newid, other) {
+  if (this.isObject()) {
+    console.log('cannot clone class frame');
+  } else if (this.isData()) {
+    return this.cloneDataFrame(newid, other);
+  }
+  return undefined;
+};
+
+ClassFrame.prototype.getClassChoices = function () {
+  const choices = [];
+  // if (this.frame.operands) {
+  /* for (let i = 0; i < this.frame.operands.length; i += 1) {
+    for (let j = 0; j < this.frame.operands[i].length; j += 1) {
+      const domcls = this.frame.operands[i][j].domain;
+      if (domcls && choices.indexOf(domcls) === -1) {
+        choices.push(domcls);
+      }
+    }
+  } */
+  // }
+  return choices;
+};
+
+ClassFrame.prototype.getChosenClassFrame = function (chosen, parent) {
+  for (let i = 0; i < this.frame.operands.length; i += 1) {
+    const operand = this.frame.operands[i];
+    if (operand.class && chosen === operand.class) {
+      const cf = new ClassFrame(operand, parent, this.label);
+      return cf;
+    }
+  }
+  return false;
+};
+
+ClassFrame.prototype.getChosenFrame = function (dataframe) {
+  return dataframe;
+};
+
+ClassFrame.prototype.isData = function () {
+  return (this.isDocument() || this.isChoice() || this.isDatatypeProperty());
+};
+
+function Restriction(restriction) {
+  this.min = 0;
+  this.max = 0;
+  if (restriction) this.loadRestriction(restriction);
+}
+
+Restriction.prototype.hasCardRestriction = function () {
+  if (this.min === 0 && this.max === 0) return false;
+  return true;
+};
+
+Restriction.prototype.loadRestriction = function (restriction) {
+  if (typeof restriction.cardinality !== 'undefined') {
+    this.max = restriction.cardinality;
+    this.min = restriction.cardinality;
+  } else if (typeof restriction.maxCardinality !== 'undefined') {
+    this.max = restriction.maxCardinality;
+  } else if (typeof restriction.minCardinality !== 'undefined') {
+    this.min = restriction.minCardinality;
+  } else if (typeof restriction.type !== 'undefined' && restriction.type === 'and' && typeof restriction.operands === 'object') {
+    for (let i = 0; i < restriction.operands.length; i += 1) {
+      const nrest = new Restriction(restriction.operands[i]);
+      if (this.max === 0 && nrest.max > 0) this.max = nrest.max;
+      else if (this.max > 0 && nrest.max > 0 && nrest.max < this.max) this.max = nrest.max;
+      if (this.min === 0 && nrest.min > 0) this.min = nrest.min;
+      else if (this.min > 0 && nrest.min > 0 && nrest.min > this.min) this.min = nrest.min;
+    }
+  }
+};
+
+module.exports = ObjectFrame;