chem-generic-ui 0.1.33 → 0.1.34

package/dist/components/table/TableRecord.js

@@ -0,0 +1,454 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _numeral = _interopRequireDefault(require("numeral"));
+
+var _GenericSubField = _interopRequireDefault(require("../models/GenericSubField"));
+
+var _GridBtn = require("./GridBtn");
+
+var _GridEntry = require("./GridEntry");
+
+var _UConverterRenderer = _interopRequireDefault(require("./UConverterRenderer"));
+
+var _utils = require("../tools/utils");
+
+var _DropRenderer = _interopRequireDefault(require("./DropRenderer"));
+
+var _DropTextRenderer = _interopRequireDefault(require("./DropTextRenderer"));
+
+var _DropLinkRenderer = _interopRequireDefault(require("./DropLinkRenderer"));
+
+var _SamOption = _interopRequireDefault(require("./SamOption"));
+
+var _DragDropItemTypes = _interopRequireDefault(require("../dnd/DragDropItemTypes"));
+
+var _SelectRenderer = _interopRequireDefault(require("./SelectRenderer"));
+
+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; }
+
+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 _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 } }); Object.defineProperty(subClass, "prototype", { writable: false }); 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); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } 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 _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+var TableRecord = /*#__PURE__*/function (_React$Component) {
+  _inherits(TableRecord, _React$Component);
+
+  var _super = _createSuper(TableRecord);
+
+  function TableRecord(props) {
+    var _this;
+
+    _classCallCheck(this, TableRecord);
+
+    _this = _super.call(this, props);
+    _this.delRow = _this.delRow.bind(_assertThisInitialized(_this));
+    _this.addRow = _this.addRow.bind(_assertThisInitialized(_this));
+    _this.moveRow = _this.moveRow.bind(_assertThisInitialized(_this));
+    _this.onCellChange = _this.onCellChange.bind(_assertThisInitialized(_this));
+    _this.onSelectClick = _this.onSelectClick.bind(_assertThisInitialized(_this));
+    _this.onUnitClick = _this.onUnitClick.bind(_assertThisInitialized(_this));
+    _this.onDrop = _this.onDrop.bind(_assertThisInitialized(_this));
+    _this.onChk = _this.onChk.bind(_assertThisInitialized(_this));
+    _this.getColumns = _this.getColumns.bind(_assertThisInitialized(_this));
+    return _this;
+  }
+
+  _createClass(TableRecord, [{
+    key: "onCellChange",
+    value: function onCellChange(params) {
+      var e = params.e,
+          columnDef = params.columnDef,
+          rowValue = params.rowValue;
+      var newValue = e.target.value;
+      var oldValue = rowValue[columnDef.field].value;
+      if (oldValue === newValue) return;
+
+      if (columnDef.type === 'text') {
+        rowValue[columnDef.field] = newValue;
+      }
+
+      if (columnDef.type === 'system-defined') {
+        if (isNaN(newValue)) return;
+        rowValue[columnDef.field].value = (0, _numeral.default)(newValue).value();
+      }
+
+      var opt = this.props.opt;
+      var subVals = opt.f_obj.sub_values || [];
+      var idx = subVals.findIndex(function (s) {
+        return s.id === rowValue.id;
+      });
+      subVals.splice(idx, 1, rowValue);
+      opt.f_obj.sub_values = subVals;
+      opt.onSubChange(0, 0, opt.f_obj, true);
+    }
+  }, {
+    key: "onSelectClick",
+    value: function onSelectClick(e, subField, node) {
+      var data = node.data;
+      var opt = this.props.opt;
+      var subVals = opt.f_obj.sub_values || [];
+      var subVal = subVals.find(function (s) {
+        return s.id === data.id;
+      });
+      subVal[subField.id] = {
+        value: e ? e.value : ''
+      };
+      var idx = subVals.findIndex(function (s) {
+        return s.id === data.id;
+      });
+      subVals.splice(idx, 1, subVal);
+      opt.f_obj.sub_values = subVals;
+      opt.onSubChange(subField, subField.id, opt.f_obj, true);
+    }
+  }, {
+    key: "onUnitClick",
+    value: function onUnitClick(subField, node) {
+      var data = node.data;
+      var opt = this.props.opt;
+      var subVals = opt.f_obj.sub_values || [];
+      var subVal = subVals.find(function (s) {
+        return s.id === data.id;
+      });
+      var units = (0, _utils.genUnits)(subField.option_layers);
+      var uIdx = units.findIndex(function (u) {
+        return u.key === subVal[subField.id].value_system;
+      });
+      if (uIdx < units.length - 1) uIdx += 1;else uIdx = 0;
+      var vs = units.length > 0 ? units[uIdx].key : '';
+      var v = (0, _utils.unitConversion)(subField.option_layers, vs, subVal[subField.id].value);
+      subVal[subField.id] = {
+        value: v,
+        value_system: vs
+      };
+      var idx = subVals.findIndex(function (s) {
+        return s.id === data.id;
+      });
+      subVals.splice(idx, 1, subVal);
+      opt.f_obj.sub_values = subVals;
+      opt.onSubChange(subField, subField.id, opt.f_obj, true);
+    }
+  }, {
+    key: "onDrop",
+    value: function onDrop(targetProps, targetOpt) {
+      var opt = this.props.opt;
+      var subField = targetOpt.sField;
+      var subVals = opt.f_obj.sub_values || [];
+      var subVal = subVals.find(function (s) {
+        return s.id === targetOpt.data.id;
+      });
+      subVal[subField.id] = {
+        value: targetProps
+      };
+      var idx = subVals.findIndex(function (s) {
+        return s.id === targetOpt.data.id;
+      });
+      subVals.splice(idx, 1, subVal);
+      opt.f_obj.sub_values = subVals;
+      opt.onSubChange(subField, subField.id, opt.f_obj, true);
+    }
+  }, {
+    key: "onChk",
+    value: function onChk(params) {
+      var node = params.node,
+          subField = params.subField,
+          crOpt = params.crOpt;
+      var opt = this.props.opt;
+      var subVals = opt.f_obj.sub_values || [];
+      var subVal = subVals.find(function (s) {
+        return s.id === node.data.id;
+      });
+      node.data[subField.id].value.cr_opt = crOpt;
+      subVal[subField.id] = {
+        value: node.data[subField.id].value
+      };
+      var idx = subVals.findIndex(function (s) {
+        return s.id === node.data.id;
+      });
+      subVals.splice(idx, 1, subVal);
+      opt.f_obj.sub_values = subVals;
+      opt.onSubChange(subField, subField.id, opt.f_obj, true);
+    }
+  }, {
+    key: "getColumns",
+    value: function getColumns() {
+      var _this2 = this;
+
+      var opt = this.props.opt;
+      var selectOptions = opt.selectOptions;
+      var sValues = opt.f_obj.sub_values || [];
+      var columnDefs = [];
+      (opt.f_obj.sub_fields || []).forEach(function (sF) {
+        var colDef = {
+          type: sF.type,
+          headerName: sF.col_name,
+          field: sF.id
+        };
+        var colDefExt = [];
+
+        if (sF.type === 'text') {
+          colDef = Object.assign({}, colDef, {
+            editable: true,
+            onCellChange: _this2.onCellChange
+          });
+        }
+
+        if (sF.type === 'select') {
+          var sOptions = selectOptions[sF.option_layers] && selectOptions[sF.option_layers].options || [];
+          sOptions = sOptions.map(function (op) {
+            return {
+              value: op.key,
+              name: op.key,
+              label: op.label
+            };
+          });
+          var cellParams = {
+            sField: sF,
+            onChange: _this2.onSelectClick,
+            sOptions: sOptions
+          };
+          colDef = Object.assign({}, colDef, {
+            cellRenderer: _SelectRenderer.default,
+            cellParams: cellParams,
+            onCellChange: _this2.onCellChange
+          });
+        }
+
+        if (sF.type === 'system-defined') {
+          var _cellParams = {
+            sField: sF,
+            onChange: _this2.onUnitClick
+          };
+          colDef = Object.assign({}, colDef, {
+            cellRenderer: _UConverterRenderer.default,
+            cellParams: _cellParams,
+            onCellChange: _this2.onCellChange
+          });
+        }
+
+        if (sF.type === 'drag_molecule') {
+          var _cellParams2 = {
+            sField: sF,
+            opt: opt,
+            onChange: _this2.onDrop
+          };
+          colDef = Object.assign({}, colDef, {
+            cellRenderer: _DropRenderer.default,
+            cellParams: _cellParams2,
+            onCellChange: _this2.onCellChange,
+            width: '5vw'
+          });
+          var conf = (sF.value || '').split(';') || [];
+          conf.forEach(function (c) {
+            var attr = _utils.molOptions.find(function (m) {
+              return m.value === c;
+            });
+
+            if (attr) {
+              var ext = {
+                colId: c,
+                editable: false,
+                type: 'text',
+                headerName: attr.label,
+                cellRenderer: _DropTextRenderer.default,
+                cellParams: {
+                  attr: attr,
+                  sField: sF
+                }
+              };
+              colDefExt.push(ext);
+            }
+          });
+        }
+
+        if (sF.type === 'drag_sample') {
+          var sOpt = sValues.filter(function (o) {
+            return o[sF.id] && o[sF.id].value && o[sF.id].value.is_new;
+          });
+          var _cellParams3 = {
+            sField: sF,
+            opt: opt,
+            onChange: _this2.onDrop
+          };
+          colDef = Object.assign({}, colDef, {
+            cellRenderer: _DropRenderer.default,
+            cellParams: _cellParams3,
+            onCellChange: _this2.onCellChange,
+            width: '5vw'
+          });
+          var addOption = {
+            colId: 'sam_option',
+            editable: false,
+            type: 'text',
+            headerName: '',
+            cellRenderer: _SamOption.default,
+            cellParams: {
+              sField: sF,
+              onChange: _this2.onChk
+            },
+            width: '3vw'
+          };
+          if (sOpt.length > 0) colDefExt.push(addOption);
+          var addLink = {
+            colId: 'sam_link',
+            editable: false,
+            type: 'text',
+            headerName: 'Short label',
+            cellRenderer: _DropLinkRenderer.default,
+            cellParams: {
+              sField: sF
+            },
+            width: '5vw'
+          };
+          colDefExt.push(addLink);
+
+          var _conf = (sF.value || '').split(';') || [];
+
+          _conf.forEach(function (c) {
+            var attr = _utils.samOptions.find(function (m) {
+              return m.value === c;
+            });
+
+            if (attr) {
+              var ext = {
+                colId: c,
+                editable: false,
+                type: 'text',
+                headerName: attr.label,
+                cellRenderer: _DropTextRenderer.default,
+                cellParams: {
+                  attr: attr,
+                  sField: sF
+                }
+              };
+              colDefExt.push(ext);
+            }
+          });
+        }
+
+        columnDefs.push(colDef);
+        if (colDefExt.length > 0) columnDefs = columnDefs.concat(colDefExt);
+      });
+      var act = {
+        type: 'button',
+        headerName: '',
+        colId: opt.f_obj.field,
+        headerComponent: _GridBtn.AddRowBtn,
+        headerParams: {
+          addRow: this.addRow
+        },
+        cellRenderer: _GridBtn.DelRowBtn,
+        cellParams: {
+          delRow: this.delRow
+        },
+        width: 'unset'
+      };
+      columnDefs.splice(0, 0, act);
+      var dtype = "".concat(_DragDropItemTypes.default.GENERIC_GRID, "_").concat(opt.layer.key, "_").concat(opt.f_obj.field);
+      var move = {
+        type: 'dnd',
+        field: opt.f_obj.field,
+        headerName: '',
+        colId: "".concat(opt.f_obj.field, "_dnd"),
+        headerComponent: _GridBtn.NullRowBtn,
+        cellRenderer: _GridBtn.DnDRowBtn,
+        cellParams: {
+          moveRow: this.moveRow,
+          field: opt.f_obj.field,
+          type: dtype
+        },
+        width: 'unset'
+      };
+      columnDefs.splice(0, 0, move);
+      return columnDefs;
+    }
+  }, {
+    key: "moveRow",
+    value: function moveRow(source, target) {
+      var opt = this.props.opt;
+      var alles = opt.f_obj.sub_values;
+      var sid = alles.findIndex(function (e) {
+        return e.id === source;
+      });
+      var tid = alles.findIndex(function (e) {
+        return e.id === target;
+      });
+      var temp = alles[sid];
+      alles[sid] = alles[tid];
+      alles[tid] = temp;
+      opt.onSubChange(0, 0, opt.f_obj, true);
+    }
+  }, {
+    key: "delRow",
+    value: function delRow(rowData) {
+      var opt = this.props.opt;
+      opt.f_obj.sub_values = opt.f_obj.sub_values.filter(function (s) {
+        return s.id !== rowData.id;
+      });
+      opt.onSubChange(0, 0, opt.f_obj, true);
+    }
+  }, {
+    key: "addRow",
+    value: function addRow() {
+      var opt = this.props.opt;
+      var subFields = opt.f_obj.sub_fields || [];
+      var newSub = new _GenericSubField.default();
+      subFields.map(function (e) {
+        if (e.type === 'text') return Object.assign(newSub, _defineProperty({}, e.id, ''));
+        return Object.assign(newSub, _defineProperty({}, e.id, {
+          value: '',
+          value_system: e.value_system
+        }));
+      });
+      opt.f_obj.sub_values = opt.f_obj.sub_values || [];
+      opt.f_obj.sub_values.push(newSub);
+      opt.onSubChange(0, 0, opt.f_obj, true);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var opt = this.props.opt;
+      if (opt.isSearchCriteria) return /*#__PURE__*/_react.default.createElement("div", null, "(This is a table)");
+      if ((opt.f_obj.sub_fields || []).length < 1) return null;
+      var columnDefs = this.getColumns();
+      return /*#__PURE__*/_react.default.createElement("div", null, (0, _GridEntry.ColumnHeader)(columnDefs), /*#__PURE__*/_react.default.createElement("div", null, (0, _GridEntry.NoRow)(opt.f_obj.sub_values)), /*#__PURE__*/_react.default.createElement("div", null, (opt.f_obj.sub_values || []).map(function (s) {
+        return (0, _GridEntry.ColumnRow)(columnDefs, s);
+      })));
+    }
+  }]);
+
+  return TableRecord;
+}(_react.default.Component);
+
+exports.default = TableRecord;
+TableRecord.propTypes = {
+  opt: _propTypes.default.object.isRequired
+};

package/dist/components/table/UConverterRenderer.js

@@ -0,0 +1,41 @@
+"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 _utils = require("../tools/utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* eslint-disable react/forbid-prop-types */
+var UConverterRenderer = function UConverterRenderer(props) {
+  var sField = props.sField,
+      onChange = props.onChange,
+      node = props.node;
+  if (sField.type !== 'system-defined') return null;
+  var data = node.data;
+  return /*#__PURE__*/_react.default.createElement(_reactBootstrap.Button, {
+    key: "ucr_".concat(data.id),
+    active: true,
+    onClick: function onClick() {
+      return onChange(sField, node);
+    },
+    bsStyle: "success"
+  }, (0, _utils.genUnitSup)((0, _utils.genUnit)(sField.option_layers, data[sField.id].value_system).label) || '');
+};
+
+UConverterRenderer.propTypes = {
+  sField: _propTypes.default.object.isRequired,
+  onChange: _propTypes.default.func.isRequired,
+  node: _propTypes.default.object.isRequired
+};
+var _default = UConverterRenderer;
+exports.default = _default;

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;