chem-generic-ui 0.1.15 → 0.1.18-alpha

package/dist/components/fields/GenPropertiesFields.js

@@ -333,6 +333,9 @@ var GenPropertiesSelect = function GenPropertiesSelect(opt) {
     label: opt.label,
     desc: opt.description
   });
+  var val = options.find(function (o) {
+    return o.value === opt.value;
+  }) || null;
   return /*#__PURE__*/_react.default.createElement(_reactBootstrap.FormGroup, null, fieldHeader, /*#__PURE__*/_react.default.createElement(_reactSelect.default, {
     isClearable: true,
     menuContainerStyle: {
@@ -341,7 +344,7 @@ var GenPropertiesSelect = function GenPropertiesSelect(opt) {
     name: opt.field,
     multi: false,
     options: options,
-    value: opt.value,
+    value: val,
     onChange: opt.onChange,
     className: className,
     disabled: opt.readOnly
@@ -593,6 +596,9 @@ var GenWFNext = function GenWFNext(opt) {
     label: opt.label,
     desc: opt.description
   });
+  var val = options.find(function (o) {
+    return o.value === opt.value;
+  }) || null;
   return /*#__PURE__*/_react.default.createElement(_reactBootstrap.FormGroup, null, fieldHeader, /*#__PURE__*/_react.default.createElement(_reactSelect.default, {
     menuContainerStyle: {
       position: 'absolute'
@@ -600,7 +606,7 @@ var GenWFNext = function GenWFNext(opt) {
     name: opt.field,
     multi: false,
     options: options,
-    value: opt.value,
+    value: val,
     onChange: opt.onChange,
     className: className,
     disabled: opt.readOnly

package/dist/components/layers/GenPropertiesLayer.js

@@ -216,11 +216,7 @@ var GenPropertiesLayer = /*#__PURE__*/function (_Component) {
           style = layer.style,
           label = layer.label;
       var bs = color || 'default';
-      var cl = (style || 'panel_generic_heading').replace('panel_generic_heading', 'panel_generic_heading_slim');
-      console.log('render');
-      console.log(layer);
-      console.log(label);
-      console.log(cl); // panel header color is based on input bs value
+      var cl = (style || 'panel_generic_heading').replace('panel_generic_heading', 'panel_generic_heading_slim'); // panel header color is based on input bs value
 
       var panelDnD = /*#__PURE__*/_react.default.createElement(_PanelDnD.default, {
         type: "gen_panel",

package/dist/components/layers/LayerModal.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _reactBootstrap = require("react-bootstrap");
+
+var _lodash = require("lodash");
+
+var _reactFontawesome = require("@fortawesome/react-fontawesome");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* eslint-disable react/forbid-prop-types */
+var block = function block(layer, fnAdd) {
+  return /*#__PURE__*/_react.default.createElement("div", {
+    className: "generic_layer_column"
+  }, /*#__PURE__*/_react.default.createElement("div", null, /*#__PURE__*/_react.default.createElement("div", null, /*#__PURE__*/_react.default.createElement("b", null, layer.label), /*#__PURE__*/_react.default.createElement("br", null), "(", layer.key, ")"), /*#__PURE__*/_react.default.createElement(_reactBootstrap.OverlayTrigger, {
+    delayShow: 1000,
+    placement: "top",
+    overlay: /*#__PURE__*/_react.default.createElement(_reactBootstrap.Tooltip, {
+      id: "_tooltip_layers"
+    }, "click to add layer")
+  }, /*#__PURE__*/_react.default.createElement(_reactBootstrap.Button, {
+    bsStyle: "primary",
+    onClick: function onClick(event) {
+      return fnAdd(event, layer);
+    }
+  }, /*#__PURE__*/_react.default.createElement(_reactFontawesome.FontAwesomeIcon, {
+    icon: "fas fa-plus"
+  })))));
+};
+
+var drawLayout = function drawLayout(layers, fnAdd) {
+  var layout = [];
+  layers.forEach(function (layer) {
+    layout.push( /*#__PURE__*/_react.default.createElement("div", {
+      key: layer.key
+    }, block(layer, fnAdd)));
+  });
+  return layout;
+};
+
+var LayerModal = function LayerModal(props) {
+  var show = props.show,
+      layers = props.layers,
+      fnClose = props.fnClose,
+      fnAdd = props.fnAdd;
+  if (!show) return null;
+  var sortedLayers = (0, _lodash.sortBy)(layers, ['position', 'wf_position']) || [];
+  if (sortedLayers.length < 1) return null;
+  var layout = drawLayout(sortedLayers, fnAdd);
+  return /*#__PURE__*/_react.default.createElement(_reactBootstrap.Modal, {
+    show: show,
+    onHide: fnClose
+  }, /*#__PURE__*/_react.default.createElement(_reactBootstrap.Modal.Header, {
+    closeButton: true
+  }, /*#__PURE__*/_react.default.createElement(_reactBootstrap.Modal.Title, null, "Choose Layer")), /*#__PURE__*/_react.default.createElement(_reactBootstrap.Modal.Body, null, /*#__PURE__*/_react.default.createElement("div", {
+    style: {
+      maxHeight: '80vh',
+      overflow: 'auto'
+    }
+  }, /*#__PURE__*/_react.default.createElement("div", {
+    className: "generic_grid"
+  }, layout))));
+};
+
+LayerModal.propTypes = {
+  show: _propTypes.default.bool.isRequired,
+  layers: _propTypes.default.object.isRequired,
+  fnClose: _propTypes.default.func.isRequired,
+  fnAdd: _propTypes.default.func.isRequired
+};
+var _default = LayerModal;
+exports.default = _default;

package/dist/components/models/Attachment.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _uuid = require("uuid");
+
+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); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+var Attachment = /*#__PURE__*/function () {
+  function Attachment(args) {
+    _classCallCheck(this, Attachment);
+
+    Object.assign(this, args);
+
+    if (!this.id) {
+      this.id = Attachment.buildID();
+    }
+  }
+
+  _createClass(Attachment, [{
+    key: "isNew",
+    get: function get() {
+      return this.is_new === true;
+    }
+  }, {
+    key: "serialize",
+    value: function serialize() {
+      return _get(_getPrototypeOf(Attachment.prototype), "serialize", this).call(this, {
+        filename: this.filename,
+        identifier: this.identifier,
+        file: this.file,
+        thumb: this.thumb,
+        content_type: this.content_type,
+        is_deleted: this.is_deleted,
+        id: this.id,
+        is_new: this.isNew || false
+      });
+    }
+  }], [{
+    key: "buildID",
+    value: function buildID() {
+      return (0, _uuid.v4)();
+    }
+  }, {
+    key: "fromFile",
+    value: function fromFile(file) {
+      return new Attachment({
+        file: file,
+        name: file.name,
+        filename: file.name,
+        identifier: file.id,
+        is_deleted: false
+      });
+    }
+  }]);
+
+  return Attachment;
+}();
+
+exports.default = Attachment;

package/dist/components/tools/collate.js

@@ -0,0 +1,103 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _lodash = require("lodash");
+
+var _utils = require("./utils");
+
+var _GenericSubField = _interopRequireDefault(require("../models/GenericSubField"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var collateValues = function collateValues(currentFields, previousFields, previousValues) {
+  var result = [];
+  var newSub = new _GenericSubField.default();
+  currentFields.map(function (e) {
+    return Object.assign(newSub, _defineProperty({}, e.id, ''));
+  });
+  var currentValuKeys = Object.keys(newSub);
+  var previousValueKeys = Object.keys(previousValues[0]);
+  var notInCurrent = previousValueKeys.filter(function (e) {
+    return !currentValuKeys.includes(e);
+  });
+  var currObj = {};
+  currentFields.map(function (c) {
+    if (c.type === 'text') return Object.assign(currObj, _defineProperty({}, c.id, ''));
+    return Object.assign(currObj, _defineProperty({}, c.id, {
+      value: '',
+      value_system: c.value_system
+    }));
+  });
+  previousValues.forEach(function (e) {
+    newSub = new _GenericSubField.default();
+    Object.assign(newSub, currObj, e);
+    notInCurrent.forEach(function (c) {
+      return delete newSub[c];
+    });
+    previousValueKeys.forEach(function (preKey) {
+      if (newSub[preKey] === undefined || preKey === 'id') return;
+      var curr = currentFields.find(function (f) {
+        return f.id === preKey;
+      });
+      var prev = previousFields.find(function (f) {
+        return f.id === preKey;
+      });
+
+      if (curr.type === 'drag_molecule') {
+        if (['text', 'system-defined', 'drag_sample'].includes(prev.type)) {
+          newSub[preKey] = {
+            value: undefined
+          };
+        }
+      }
+
+      if (curr.type === 'text') {
+        if (prev.type === 'system-defined') {
+          newSub[preKey] = newSub[preKey].value;
+        }
+
+        if (['drag_molecule', 'drag_sample'].includes(prev.type)) {
+          newSub[preKey] = '';
+        }
+      }
+
+      if (curr.type === 'system-defined') {
+        if (prev.type === 'system-defined' && curr.option_layers !== prev.option_layers) {
+          newSub[preKey].value_system = curr.value_system;
+        }
+
+        if (['text', 'drag_molecule', 'drag_sample'].includes(prev.type)) {
+          newSub[preKey] = {
+            value: '',
+            value_system: curr.value_system
+          };
+        }
+
+        newSub[preKey].value = (0, _utils.unitConversion)(curr.option_layer, newSub[preKey].value_system, newSub[preKey].value);
+      }
+    });
+    result.push(newSub);
+  });
+  return result;
+};
+
+var organizeSubValues = function organizeSubValues(cur, pre) {
+  var currentFields = (0, _lodash.cloneDeep)(cur.sub_fields || []);
+  var previousFields = (0, _lodash.cloneDeep)(pre.sub_fields || []);
+  var previousValues = (0, _lodash.cloneDeep)(pre.sub_values || []);
+
+  if (currentFields.length < 1 || previousFields.length < 1 || previousValues.length < 1) {
+    return [];
+  }
+
+  return collateValues(currentFields, previousFields, previousValues);
+};
+
+var _default = organizeSubValues;
+exports.default = _default;

package/dist/components/tools/orten.js

@@ -0,0 +1,294 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.removeFromObject = exports.reformCondFields = exports.orgLayerObject = exports.getWFNode = exports.getFlowLayer = exports.buildInitWF = exports.addToObject = void 0;
+
+var _lodash = require("lodash");
+
+var _uuid = require("uuid");
+
+/* eslint-disable no-param-reassign */
+
+/* eslint-disable import/prefer-default-export */
+var getWFNode = function getWFNode(_flow, nodeId) {
+  return _flow.elements.filter(function (e) {
+    return e.id === nodeId;
+  })[0];
+}; // full-flow, node id
+
+
+exports.getWFNode = getWFNode;
+
+var getFlowLayer = function getFlowLayer(templateFlow, nodeId, sourceLayer, sIdx) {
+  var flow = (0, _lodash.cloneDeep)(templateFlow);
+  var nd = flow.elements.filter(function (e) {
+    return e.id === nodeId;
+  }); // fetch node
+
+  if (nd.length < 1) return null;
+  var layer = nd[0].data.layer;
+  var ls = flow.elements.filter(function (e) {
+    return e.animated;
+  }); // lines
+
+  var ns = flow.elements.filter(function (e) {
+    return e.type === 'default' && e.data;
+  }); // nodes - Start - End
+
+  var ndNs = ls.filter(function (e) {
+    return e.source === nodeId;
+  }).map(function (e) {
+    return e.target;
+  }); // next nodes' id
+
+  var wfOpts = ns.filter(function (n) {
+    return ndNs.includes(n.id);
+  }).map(function (e) {
+    return {
+      key: e.id,
+      label: "".concat(e.data.layer.label, "(").concat(e.data.layer.key, ")")
+    };
+  }); // next nodes
+
+  if (wfOpts.length > 0) {
+    var position = (layer.fields || []).length + 1;
+    layer.fields.push({
+      type: 'wf-next',
+      default: '',
+      field: '_wf_next',
+      label: 'Next',
+      required: false,
+      sub_fields: [],
+      text_sub_fields: [],
+      position: position,
+      wf_options: wfOpts
+    });
+  }
+
+  layer.wf_info = {
+    node_id: nodeId,
+    source_layer: sourceLayer
+  };
+  layer.wf_position = sIdx + 1;
+  return layer;
+};
+
+exports.getFlowLayer = getFlowLayer;
+
+var orgLayerObject = function orgLayerObject() {
+  var _layers = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+
+  var layers = _layers;
+  return layers.reduce(function (alles, name) {
+    var all = alles;
+    var ok = Object.keys(all);
+
+    if (ok.includes(name.key)) {
+      var cnt = ok.filter(function (e) {
+        return e === name.key || e.startsWith("".concat(name.key, "."));
+      }).length;
+      var nName = "".concat(name.key, ".").concat(cnt);
+      name.key = nName;
+      all[nName] = name;
+    } else {
+      all[name.key] = name;
+    }
+
+    return all;
+  }, {});
+};
+
+exports.orgLayerObject = orgLayerObject;
+
+var reformCondFields = function reformCondFields(_layer, _oKey) {
+  var layer = _layer;
+  layer.fields.map(function (_f) {
+    var f = _f;
+    var conds = f.cond_fields; // no cond_fields
+
+    if (!conds || conds.length < 1 || conds.filter(function (o) {
+      return !o.field || o.field === '';
+    }).length === conds.length) return f;
+    conds = conds.filter(function (o) {
+      return o.layer === _oKey;
+    }); // no same layer, remove cond_fields
+
+    if (conds.length < 1) {
+      delete f.cond_fields;
+      return f;
+    } // rename layer
+
+
+    conds = conds.map(function (o) {
+      var n = o;
+      n.layer = layer.key;
+      return n;
+    });
+    f.cond_fields = conds;
+    return f;
+  });
+  return layer.fields;
+};
+
+exports.reformCondFields = reformCondFields;
+
+var addToObject = function addToObject(obj, key, addAfter) {
+  var temp = {};
+  var ok = Object.keys(obj);
+  Object.keys(obj).forEach(function (e) {
+    if (Object.prototype.hasOwnProperty.call(obj, e)) {
+      temp[e] = obj[e];
+
+      if (e === key) {
+        var srcPosition = temp[e].position;
+        var cnt = ok.filter(function (o) {
+          return o === addAfter.key || o.startsWith("".concat(addAfter.key, "."));
+        }).length;
+
+        if (cnt === 0) {
+          temp[addAfter.key] = addAfter;
+          temp[addAfter.key].position = srcPosition;
+        } else {
+          var oKey = addAfter.key;
+          temp["".concat(addAfter.key, ".").concat(cnt)] = addAfter;
+          temp["".concat(addAfter.key, ".").concat(cnt)].position = srcPosition;
+          temp["".concat(addAfter.key, ".").concat(cnt)].key = "".concat(addAfter.key, ".").concat(cnt);
+          temp[addAfter.key].fields = reformCondFields(addAfter, oKey);
+        }
+      }
+    }
+  });
+  if (Object.keys(obj).length === 0) temp[addAfter.key] = addAfter;
+  return temp;
+};
+
+exports.addToObject = addToObject;
+
+var traverseToRemove = function traverseToRemove(layers, rmKey) {
+  var rms = [];
+  Object.keys(layers).forEach(function (e) {
+    if (Object.prototype.hasOwnProperty.call(layers, e)) {
+      if (layers[e].key === rmKey) rms = rms.concat(rmKey);else if (layers[e].wf_info && layers[e].wf_info.source_layer === rmKey) {
+        rms = rms.concat(traverseToRemove(layers, layers[e].key));
+      }
+    }
+  });
+  return rms;
+};
+
+var removeFromObject = function removeFromObject() {
+  var _propertiesLayers = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+  var srcLayer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  var rmNode = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  var layers = _propertiesLayers;
+  var rmLayer = rmNode.data && rmNode.data.layer ? rmNode.data.layer.key : null;
+  if (!rmLayer) return [];
+  var rms = [];
+  Object.keys(layers).forEach(function (e) {
+    if (Object.prototype.hasOwnProperty.call(layers, e)) {
+      var wf = layers[e].wf_info;
+
+      if (wf && wf.source_layer === srcLayer && wf.node_id === rmNode.id) {
+        rms = rms.concat(traverseToRemove(layers, layers[e].key));
+      }
+    }
+  });
+  rms.forEach(function (e) {
+    return delete layers[e];
+  });
+  return layers;
+};
+
+exports.removeFromObject = removeFromObject;
+
+var buildInitWF = function buildInitWF(template) {
+  var orig = (0, _lodash.cloneDeep)(template);
+  var layers = orig.layers,
+      flow = orig.flow;
+  var sortedLayers = (0, _lodash.sortBy)(layers, function (l) {
+    return l.position;
+  });
+
+  if (flow && flow.elements.filter(function (e) {
+    return !['input', 'output'].includes(e.type).length > 0;
+  })) {
+    // id = 1 Start, id = 2 End
+    var nls = flow.elements; // nodes + lines
+
+    var ls = nls.filter(function (e) {
+      return e.animated;
+    }); // lines
+
+    var ns = nls.filter(function (e) {
+      return e.type === 'default' && e.data;
+    }); // nodes - Start - End
+
+    var nNs = ls.filter(function (e) {
+      return e.source === '1';
+    }).map(function (e) {
+      return e.target;
+    }); // get target ids from Start
+
+    var nextNodes = ns.filter(function (n) {
+      return nNs.includes(n.id);
+    }); // target nodes
+
+    var result = [];
+    sortedLayers.forEach(function (sortedLayer) {
+      var fLayer = sortedLayer;
+
+      if (fLayer.wf) {
+        var position = (fLayer.fields || []).length + 1;
+        var passen = nextNodes.filter(function (n) {
+          return n.data.layer.key === fLayer.key;
+        });
+        passen.forEach(function (pas) {
+          var nextOptions = ls.filter(function (e) {
+            return e.source === pas.id && e.source !== e.target;
+          }).map(function (e) {
+            return e.target;
+          });
+          var wfOpts = ns.filter(function (n) {
+            return nextOptions.includes(n.id);
+          }).map(function (e) {
+            return {
+              key: e.id,
+              label: "".concat(e.data.layer.label, "(").concat(e.data.layer.key, ")")
+            };
+          }); // next nodes
+
+          fLayer.fields.push({
+            type: 'wf-next',
+            default: '',
+            field: '_wf_next',
+            label: 'Next',
+            required: false,
+            sub_fields: [],
+            text_sub_fields: [],
+            position: position,
+            wf_options: wfOpts
+          });
+          fLayer.wf_info = {
+            node_id: pas.id
+          };
+          fLayer.wf_position = 1;
+          fLayer.wf_uuid = (0, _uuid.v4)();
+          result.push(fLayer);
+        });
+      } else {
+        result.push(fLayer);
+      }
+    });
+    var ll = orgLayerObject(result);
+    orig.layers = ll;
+  } else {
+    orig.layers = layers;
+  }
+
+  return orig;
+};
+
+exports.buildInitWF = buildInitWF;