terminusdb 12.0.2

package/lib/viewer/viewConfig.js

@@ -0,0 +1,219 @@
+/// /@ts-check
+const { WOQLRule } = require('./woqlRule');
+
+/**
+ * Generic functions / configs that are available to all config types
+ * @module ViewConfig
+ * @constructor
+ */
+function ViewConfig() {
+  this.rules = [];
+}
+
+ViewConfig.prototype.render = function (func) {
+  if (func) this.view_render = func;
+  return this.view_render;
+};
+
+ViewConfig.prototype.renderer = function (val) {
+  if (val) this.view_renderer = val;
+  return this.view_renderer;
+};
+
+ViewConfig.prototype.getRulesJSON = function () {
+  const jr = [];
+  // eslint-disable-next-line no-plusplus
+  for (let i = 0; i < this.rules.length; i++) {
+    jr.push(this.rules[i].json());
+  }
+  return jr;
+};
+
+ViewConfig.prototype.getBasicJSON = function () {
+  const jr = {};
+  if (this.view_render) jr.render = this.view_render;
+  if (this.view_renderer) jr.renderer = this.view_renderer;
+  if (this.vbindings) jr.bindings = this.vbindings;
+  return jr;
+};
+
+ViewConfig.prototype.loadBasicJSON = function (json) {
+  if (json.render) this.view_render = json.view_render;
+  if (json.renderer) this.view_renderer = json.view_renderer;
+  if (json.bindings) this.vbindings = json.bindings;
+};
+
+ViewConfig.prototype.getBasicprettyPrint = function () {
+  let str = '';
+  if (typeof this.render() !== 'undefined') {
+    str += `view.render(${this.render()})\n`;
+  }
+  if (typeof this.renderer() !== 'undefined') {
+    str += `view.renderer('${this.renderer()}')\n`;
+  }
+  if (typeof this.bindings() !== 'undefined') {
+    str += `view.bindings('${this.bindings()}')\n`;
+  }
+  return str;
+};
+
+ViewConfig.prototype.bindings = function (bindings) {
+  if (typeof bindings !== 'undefined') {
+    this.vbindings = bindings;
+  }
+  return this.vbindings;
+};
+
+/**
+ * @module WOQLViewRule
+ * @constructor
+ */
+function WOQLViewRule() {
+  WOQLRule.call(this);
+  this.rule = {};
+}
+
+Object.setPrototypeOf(WOQLViewRule.prototype, WOQLRule.prototype);
+
+WOQLViewRule.prototype.prettyPrint = function (type) {
+  let str = '';
+  if (this.pattern) {
+    str = this.pattern.prettyPrint(type);
+  }
+  if (typeof this.color() !== 'undefined') {
+    str += `.color([${this.color().join(',')}])`;
+  }
+  if (typeof this.hidden() !== 'undefined') {
+    str += `.hidden(${this.hidden()})`;
+  }
+  if (typeof this.size() !== 'undefined') {
+    str += `.size('${this.size()}')`;
+  }
+  if (typeof this.icon() !== 'undefined') {
+    str += `.icon(${JSON.stringify(this.icon())})`;
+  }
+  if (typeof this.text() !== 'undefined') {
+    str += `.text(${JSON.stringify(this.text())})`;
+  }
+  if (typeof this.border() !== 'undefined') {
+    str += `.border(${JSON.stringify(this.border())})`;
+  }
+  if (typeof this.args() !== 'undefined') {
+    str += `.args(${JSON.stringify(this.args())})`;
+  }
+  if (typeof this.renderer() !== 'undefined') {
+    str += `.renderer('${this.renderer()}')`;
+  }
+  if (typeof this.render() !== 'undefined') {
+    str += `.render(${this.render()})`;
+  }
+  if (typeof this.click() !== 'undefined') {
+    str += `.click(${this.click()})`;
+  }
+  if (typeof this.hover() !== 'undefined') {
+    str += `.hover(${this.hover()})`;
+  }
+  return str;
+};
+
+WOQLViewRule.prototype.json = function (mjson) {
+  if (!mjson) {
+    const json = {};
+    if (this.pattern) json.pattern = this.pattern.json();
+    json.rule = this.rule;
+    return json;
+  }
+  this.rule = mjson.rule || {};
+  if (mjson.pattern) this.pattern.setPattern(mjson.pattern);
+  return this;
+};
+
+WOQLViewRule.prototype.size = function (size) {
+  if (typeof size === 'undefined') {
+    return this.rule.size;
+  }
+  this.rule.size = size;
+  return this;
+};
+
+WOQLViewRule.prototype.color = function (color) {
+  if (typeof color === 'undefined') {
+    return this.rule.color;
+  }
+  this.rule.color = color;
+  return this;
+};
+
+WOQLViewRule.prototype.icon = function (json) {
+  if (json) {
+    this.rule.icon = json;
+    return this;
+  }
+  return this.rule.icon;
+};
+
+WOQLViewRule.prototype.text = function (json) {
+  if (json) {
+    this.rule.text = json;
+    return this;
+  }
+  return this.rule.text;
+};
+
+WOQLViewRule.prototype.border = function (json) {
+  if (json) {
+    this.rule.border = json;
+    return this;
+  }
+  return this.rule.border;
+};
+
+WOQLViewRule.prototype.renderer = function (rend) {
+  if (typeof rend === 'undefined') {
+    return this.rule.renderer;
+  }
+  this.rule.renderer = rend;
+  return this;
+};
+
+WOQLViewRule.prototype.render = function (func) {
+  if (typeof func === 'undefined') {
+    return this.rule.render;
+  }
+  this.rule.render = func;
+  return this;
+};
+
+WOQLViewRule.prototype.click = function (onClick) {
+  if (onClick) {
+    this.rule.click = onClick;
+    return this;
+  }
+  return this.rule.click;
+};
+
+WOQLViewRule.prototype.hover = function (onHover) {
+  if (onHover) {
+    this.rule.hover = onHover;
+    return this;
+  }
+  return this.rule.hover;
+};
+
+WOQLViewRule.prototype.hidden = function (hidden) {
+  if (typeof hidden === 'undefined') {
+    return this.rule.hidden;
+  }
+  this.rule.hidden = hidden;
+  return this;
+};
+
+WOQLViewRule.prototype.args = function (args) {
+  if (typeof args === 'undefined') {
+    return this.rule.args;
+  }
+  this.rule.args = args;
+  return this;
+};
+
+module.exports = { WOQLViewRule, ViewConfig };

package/lib/viewer/woqlChart.js

@@ -0,0 +1,17 @@
+const WOQLChartConfig = require('./chartConfig');
+
+function WOQLChart(client, config) {
+  this.client = client;
+  this.config = (config || new WOQLChartConfig());
+  return this;
+}
+
+WOQLChart.prototype.options = function (config) {
+  this.config = config;
+  return this;
+};
+
+WOQLChart.prototype.setResult = function (res) {
+  this.result = res;
+  return this;
+};

package/lib/viewer/woqlChooser.js

@@ -0,0 +1,171 @@
+/* eslint-disable consistent-return */
+/* eslint-disable no-plusplus */
+/* eslint-disable camelcase */
+/* eslint-disable no-undef */
+const WOQLChooserConfig = require('./chooserConfig');
+const UTILS = require('../utils');
+const { WOQLRule } = require('./woqlRule');
+
+/**
+ * @typedef {Object} WOQLClient
+ */
+
+/**
+ * Very simple implementation of a WOQL backed chooser
+ * Makes a drop down from a WOQL query - configuration tells it which columns to use...
+ * @param {WOQLClient} client
+ * @param {WOQLChooserConfig} config
+ * @returns {WOQLChooser}
+ */
+function WOQLChooser(client, config) {
+  this.client = client;
+  this.config = (config || new WOQLChooserConfig());
+  this.selected = false;
+  this.cursor = 0;
+  return this;
+}
+
+WOQLChooser.prototype.options = function (config) {
+  this.config = config;
+  return this;
+};
+
+WOQLChooser.prototype.set = function (id) {
+  if (this.selected !== id) {
+    this.selected = id;
+    const ch = this.config.change;
+    if (ch) ch(id);
+  }
+};
+
+/*
+ * Sets up the required variables from the result / config
+ */
+WOQLChooser.prototype.setResult = function (result) {
+  this.result = result;
+  this.choices = [];
+  let rows = 0;
+  const variables = result.getVariableList();
+  if (!this.config.values() && variables.length) {
+    this.config.values(variables[0]);
+  }
+  // sort it
+  if (this.config.sort()) {
+    this.result.sort(this.config.sort(), this.config.direction());
+  }
+  // eslint-disable-next-line no-cond-assign
+  while (row = this.result.next()) {
+    if (row && this.includeRow(row, this.result.cursor)) {
+      this.choices.push(this.rowToChoice(row, rows++));
+    }
+  }
+  return this;
+};
+
+WOQLChooser.prototype.includeRow = function (row, index) {
+  const matched_rules = new WOQLRule().matchRow(this.config.rules, row, index, 'hidden');
+  for (let i = 0; i < matched_rules.length; i++) {
+    if (matched_rules[i].rule.hidden) return false;
+  }
+  return true;
+};
+
+WOQLChooser.prototype.rowToChoice = function (row, rownum) {
+  const choice = {
+    id: this.getRowID(row),
+  };
+  choice.label = this.getLabelFromBinding(row, rownum);
+  choice.title = this.getTitleFromBinding(row, rownum);
+  choice.selected = this.getSelectedFromBinding(row, rownum);
+  return choice;
+};
+
+WOQLChooser.prototype.getRowID = function (row) {
+  const rval = row[this.config.values()];
+  if (rval['@value']) return rval['@value'];
+  return rval;
+};
+
+WOQLChooser.prototype.getLabelFromBinding = function (row, rownum) {
+  const sp = this.getSpecialRenderer(row, rownum, 'label');
+  if (sp) return this.renderSpecial(sp, row, rownum);
+  if (this.config.labels()) {
+    if (row[this.config.labels()]) {
+      let lab = row[this.config.labels()];
+      if (lab['@value']) lab = lab['@value'];
+      if (lab !== 'system:unknown') return lab;
+    }
+  }
+  return UTILS.labelFromURL(this.getRowID(row));
+};
+
+WOQLChooser.prototype.getTitleFromBinding = function (row, rownum) {
+  const sp = this.getSpecialRenderer(row, rownum, 'title');
+  if (sp) return this.renderSpecial(sp, row, rownum);
+  if (this.config.titles()) {
+    if (row[this.config.titles()]) {
+      let lab = row[this.config.titles()];
+      if (lab['@value']) lab = lab['@value'];
+      if (lab !== 'system:unknown') return lab;
+    }
+  }
+  return false;
+};
+
+WOQLChooser.prototype.getSelectedFromBinding = function (row, rownum) {
+  const matched_rules = new WOQLRule().matchRow(this.config.rules, row, rownum, 'selected');
+  if (matched_rules && matched_rules.length) {
+    return matched_rules[matched_rules.length - 1].rule.selected;
+  }
+  return false;
+};
+
+WOQLChooser.prototype.render = function () {
+  if (this.renderer) return this.renderer.render(this);
+};
+
+WOQLChooser.prototype.setRenderer = function (rend) {
+  this.renderer = rend;
+  return this;
+};
+
+WOQLChooser.prototype.getSpecialRenderer = function (row, index, type) {
+  const matched_rules = new WOQLRule().matchRow(this.config.rules, row, index, type);
+  for (let i = 0; i < matched_rules.length; i++) {
+    if (matched_rules[i].rule[type]) return matched_rules[i].rule[type];
+  }
+  return false;
+};
+
+WOQLChooser.prototype.renderSpecial = function (rule, row) {
+  if (rule && typeof rule === 'function') {
+    return rule(row);
+  }
+  if (rule && typeof rule === 'string') {
+    return rule;
+  }
+};
+
+WOQLChooser.prototype.count = function () {
+  return this.result.count();
+};
+
+WOQLChooser.prototype.first = function () {
+  this.cursor = 0;
+  return this.choices[this.cursor];
+};
+
+WOQLChooser.prototype.next = function () {
+  const res = this.choices[this.cursor];
+  this.cursor++;
+  return res;
+};
+
+WOQLChooser.prototype.prev = function () {
+  if (this.cursor > 0) {
+    this.cursor--;
+    return this.choices[this.cursor];
+  }
+};
+
+module.exports = WOQLChooser;

package/lib/viewer/woqlGraph.js

@@ -0,0 +1,295 @@
+/* eslint-disable guard-for-in */
+/* eslint-disable no-continue */
+/* eslint-disable no-redeclare */
+/* eslint-disable block-scoped-var */
+/* eslint-disable no-var */
+/* eslint-disable vars-on-top */
+/* eslint-disable camelcase */
+/* eslint-disable no-param-reassign */
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable no-plusplus */
+const WOQLGraphConfig = require('./graphConfig');
+const UTILS = require('../utils');
+const { WOQLRule } = require('./woqlRule');
+
+function WOQLGraph(client, config) {
+  this.client = client;
+  this.config = (config || new WOQLGraphConfig());
+  this.nodes = [];
+  this.edges = [];
+}
+
+/* "nodes": [
+    {
+      "id": 1,
+      "name": "A"
+    },
+    {
+      "id": 2,
+      "name": "B"
+    },
+    {
+      "id": 3,
+      "name": "C"
+    }
+]
+
+"link" :[
+  {
+      "source": 1,
+      "target": 2
+    }
+] */
+
+WOQLGraph.prototype.options = function (config) {
+  this.config = config;
+  return this;
+};
+
+WOQLGraph.prototype.setResult = function (result) {
+  this.result = result;
+  this.calculateVariableTypes(result);
+};
+
+WOQLGraph.prototype.calculateVariableTypes = function () {
+  // var bindings = this.result.getBindings();
+  const bindings = this.result;
+  if (bindings && bindings.length) {
+    for (let i = 0; i < bindings.length; i++) {
+      this.extractFromBinding(bindings[i], i);
+    }
+  }
+  this.edges = this.combineEdges(this.edges);
+  this.nodes = this.combineNodes(this.nodes);
+};
+
+WOQLGraph.prototype.extractFromBinding = function (row, rownum) {
+  /*
+  * check if I have to add the row
+  */
+  if (this.includeRow(row, rownum)) {
+    // get all the nodes (ids - non literals) //
+    // see which nodes are excluded ...
+    const nodes = [];
+    // eslint-disable-next-line no-unused-vars
+    const lits = [];
+    for (const k in row) {
+      if (typeof row[k] === 'string') {
+        if (row[k] && row[k] !== 'system:unknown' && this.includeNode(k, row)) {
+          nodes.push(k);
+        }
+      } else if (row[k]['@value'] && this.includeLiteralNode(k, row)) {
+        nodes.push(k);
+      }
+    }
+    if (nodes.length === 0) return;
+    this.createEdgesFromIDs(nodes, row);
+    for (let i = 0; i < nodes.length; i++) {
+      let ndid = row[nodes[i]];
+      ndid = (ndid['@value'] ? ndid['@value'] : ndid);
+      this.addAdornedNode(ndid, nodes[i], row);
+    }
+  }
+};
+
+WOQLGraph.prototype.addAdornedEdge = function (source, target, ks, kt, row) {
+  source = (source['@value'] ? source['@value'] : source);
+  target = (target['@value'] ? target['@value'] : target);
+  const edge = {
+    type: 'link', target, source, text: target,
+  };
+  const matched_rules = new WOQLRule().matchEdge(this.config.rules, row, ks, kt);
+  let hid = false;
+  for (let i = 0; i < matched_rules.length; i++) {
+    const { rule } = matched_rules[i];
+    if (typeof rule.hidden !== 'undefined') {
+      hid = rule.hidden;
+    }
+    if (rule.size) {
+      edge.size = UTILS.getConfigValue(rule.size, row);
+    }
+    if (rule.text) {
+      edge.text = UTILS.getConfigValue(rule.text, row);
+    }
+    if (rule.color) {
+      edge.color = UTILS.getConfigValue(rule.color, row);
+    }
+    if (rule.icon) {
+      edge.icon = UTILS.getConfigValue(rule.icon, row);
+    }
+    if (rule.distance) {
+      edge.distance = UTILS.getConfigValue(rule.distance, row);
+    }
+    if (rule.arrow) {
+      edge.arrow = UTILS.getConfigValue(rule.arrow, row);
+    }
+    if (rule.symmetric) {
+      edge.symmetric = UTILS.getConfigValue(rule.symmetric, row);
+    }
+    if (rule.weight) {
+      edge.weight = UTILS.getConfigValue(rule.weight, row);
+    }
+  }
+  if (!hid) this.edges.push(edge);
+};
+
+/*
+* the rules' order are important
+*/
+
+WOQLGraph.prototype.addAdornedNode = function (nid, k, row) {
+  const node = { type: 'node', id: nid, nodetype: k };
+  const matched_rules = new WOQLRule().matchNode(this.config.rules, row, k, nid);
+  for (let i = 0; i < matched_rules.length; i++) {
+    const { rule } = matched_rules[i];
+    if (rule.size) {
+      node.radius = UTILS.getConfigValue(rule.size, row);
+    }
+    if (rule.color) {
+      node.color = UTILS.getConfigValue(rule.color, row);
+    }
+    if (rule.charge) {
+      node.charge = UTILS.getConfigValue(rule.charge, row);
+    }
+    if (rule.collisionRadius) {
+      node.collisionRadius = UTILS.getConfigValue(rule.collisionRadius, row);
+    }
+    if (rule.icon) {
+      node.icon = UTILS.getConfigValue(rule.icon, row);
+    }
+    if (rule.text) {
+      node.text = UTILS.getConfigValue(rule.text, row);
+    }
+    if (rule.border) {
+      node.border = UTILS.getConfigValue(rule.border, row);
+    }
+  }
+  if (!node.text) {
+    if (typeof row[k] === 'string') node.text = row[k];
+    else if (row[k]['@value']) node.text = row[k]['@value'];
+  }
+  this.nodes.push(node);
+};
+
+WOQLGraph.prototype.getLiteralOwner = function (nodes, v, row) {
+  const cs = this.config.source();
+  if (cs && row[cs]) {
+    return cs;
+  }
+  const edges = this.config.edges();
+  if (edges) {
+    for (let i = 0; i < edges.length; i++) {
+      if (edges[i][1] === v) {
+        return edges[i][0];
+      }
+    }
+    return false;
+  }
+  return nodes[0];
+};
+
+WOQLGraph.prototype.createEdgesFromIDs = function (nodes, row) {
+  if (nodes.length < 2) return;
+  const cs = this.config.source();
+  const es = this.config.edges();
+  if (!cs && es && es.length) {
+    for (var i = 0; i < es.length; i++) {
+      if (nodes.indexOf(es[i][0]) !== -1 && nodes.indexOf(es[i][1]) !== -1) {
+        this.addAdornedEdge(row[es[i][0]], row[es[i][1]], es[i][0], es[i][1], row);
+      }
+    }
+    return;
+  }
+  const s = (cs && nodes.indexOf(cs) !== -1) ? cs : nodes[0];
+  for (var i = 0; i < nodes.length; i++) {
+    if (nodes[i] === s) continue;
+    this.addAdornedEdge(row[s], row[nodes[i]], s, nodes[i], row);
+  }
+};
+
+WOQLGraph.prototype.getEdges = function () {
+  return this.edges;
+};
+
+WOQLGraph.prototype.combineNodes = function (nodes) {
+  const nnodes = {};
+  for (let i = 0; i < nodes.length; i++) {
+    const n = nodes[i];
+    if (this.nodes_referenced_by_edges.indexOf(n.id) === -1) continue;
+    if (typeof nnodes[n.id] === 'undefined') {
+      nnodes[n.id] = n;
+    } else {
+      for (const k in n) {
+        if (typeof nnodes[n.id][k] === 'undefined') {
+          nnodes[n.id][k] = n[k];
+        }
+      }
+    }
+  }
+  return Object.values(nnodes);
+};
+
+WOQLGraph.prototype.combineEdges = function (edges) {
+  this.nodes_referenced_by_edges = [];
+  const nedges = {};
+  for (let i = 0; i < edges.length; i++) {
+    const e = edges[i];
+    if (typeof nedges[e.source] === 'undefined') {
+      nedges[e.source] = {};
+    }
+    if (typeof nedges[e.source][e.target] === 'undefined') {
+      nedges[e.source][e.target] = e;
+    } else {
+      for (var k in e) {
+        if (typeof nedges[e.source][e.target][k] === 'undefined') nedges[e.source][e.target][k] = e[k];
+      }
+    }
+    if (this.nodes_referenced_by_edges.indexOf(e.source) === -1) {
+      this.nodes_referenced_by_edges.push(e.source);
+    }
+    if (this.nodes_referenced_by_edges.indexOf(e.target) === -1) {
+      this.nodes_referenced_by_edges.push(e.target);
+    }
+  }
+  const fedges = [];
+  for (var k in nedges) {
+    for (const k2 in nedges[k]) {
+      fedges.push(nedges[k][k2]);
+    }
+  }
+  return fedges;
+};
+
+WOQLGraph.prototype.getNodes = function () {
+  return this.nodes;
+};
+
+WOQLGraph.prototype.includeNode = function (v, row) {
+  const matched_rules = new WOQLRule().matchNode(this.config.rules, row, v, false, 'hidden');
+  for (let i = 0; i < matched_rules.length; i++) {
+    if (matched_rules[i].rule.hidden) return false;
+  }
+  return true;
+};
+
+/*
+* check if I have to visualise literals node
+*/
+WOQLGraph.prototype.includeLiteralNode = function (variableName, row) {
+  if (this.config.literals() === false) return false;
+  const matched_rules = new WOQLRule().matchNode(this.config.rules, row, variableName, false, 'hidden');
+  for (let i = 0; i < matched_rules.length; i++) {
+    if (matched_rules[i].rule.hidden) return false;
+  }
+  return true;
+};
+
+WOQLGraph.prototype.includeRow = function (row, num) {
+  const matched_rules = new WOQLRule().matchRow(this.config.rules, row, num, 'hidden');
+  for (let i = 0; i < matched_rules.length; i++) {
+    if (matched_rules[i].rule.hidden) return false;
+  }
+  return true;
+};
+
+module.exports = WOQLGraph;