@builttocreate/engine-utils 1.0.0

package/README.md

@@ -0,0 +1,2 @@
+# engine-utils
+Utility library for common logic shared across web and mobile

package/dist/chartHelper.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDefaultLinePoint = exports.getDefaultLine = void 0;
+
+var _shortid = _interopRequireDefault(require("shortid"));
+
+var getDefaultLine = function getDefaultLine() {
+  /**
+  * Why do we add more than 1 points by default to the new line?
+  *
+  * There is bug with victory-native that will throw an error if
+  * there aren't two data points in the array.
+  */
+  return {
+    _id: _shortid["default"].generate(),
+    deleted: false,
+    title: '',
+    description: '',
+    points: [getDefaultLinePoint(), getDefaultLinePoint(), getDefaultLinePoint()]
+  };
+};
+
+exports.getDefaultLine = getDefaultLine;
+
+var getDefaultLinePoint = function getDefaultLinePoint() {
+  return {
+    _id: _shortid["default"].generate(),
+    label: '',
+    y: 0,
+    x: 0
+  };
+};
+
+exports.getDefaultLinePoint = getDefaultLinePoint;

package/dist/constants/FieldTableColumnTypes.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var text = 'text';
+var dropdown = 'dropdown';
+var _default = {
+  text: text,
+  dropdown: dropdown
+};
+exports["default"] = _default;

package/dist/constants/FieldTableCustomColumnIds.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var rowMenu = 'rowMenu';
+var rowNumber = 'rowNumber';
+var _default = {
+  rowMenu: rowMenu,
+  rowNumber: rowNumber
+};
+exports["default"] = _default;

package/dist/constants/FieldTypes.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+// Display Fields
+var uniqueId = 'uniqueId';
+var image = 'image';
+var richText = 'richText'; // Data Fields
+
+var text = 'text';
+var textarea = 'textarea';
+var number = 'number';
+var dropdown = 'dropdown';
+var multiSelect = 'multiSelect';
+var date = 'date';
+var signature = 'signature';
+var list = 'list';
+var user = 'user';
+var task = 'task';
+var table = 'table';
+var inputGroup = 'inputGroup';
+var chart = 'chart';
+var types = {
+  uniqueId: uniqueId,
+  image: image,
+  richText: richText,
+  text: text,
+  textarea: textarea,
+  number: number,
+  date: date,
+  signature: signature,
+  list: list,
+  user: user,
+  task: task,
+  table: table,
+  inputGroup: inputGroup,
+  chart: chart,
+  multiSelect: multiSelect,
+  dropdown: dropdown
+};
+types.all = Object.keys(types);
+types.titles = {
+  uniqueId: 'Auto Number',
+  image: 'Image',
+  richText: 'Rich Text',
+  text: 'Short Text',
+  textarea: 'Long Text',
+  number: 'Number',
+  date: 'Date',
+  signature: 'Signature',
+  user: 'User',
+  table: 'Table Field',
+  inputGroup: 'Field Group',
+  chart: 'Performance Chart',
+  multiSelect: 'Checkbox',
+  dropdown: 'Dropdown'
+};
+var _default = types;
+exports["default"] = _default;

package/dist/constants/Table.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.inputGroupFieldTypes = exports.viewTypes = exports.operandLetters = void 0;
+var operandLetters = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'AA', 'AB', 'AC', 'AD', 'AE', 'AF', 'AG', 'AH', 'AI', 'AJ', 'AK', 'AL', 'AM', 'AN', 'AO', 'AP', 'AQ', 'AR', 'AS', 'AT', 'AU', 'AV', 'AW', 'AX', 'AY', 'AZ'];
+exports.operandLetters = operandLetters;
+var viewTypes = {
+  list: 'list',
+  table: 'table'
+};
+exports.viewTypes = viewTypes;
+var inputGroupFieldTypes = {
+  inputGroupRowHeader: 'inputGroupRowHeader',
+  inputGroupDropdownCell: 'inputGroupDropdownCell',
+  inputGroupTextCell: 'inputGroupTextCell',
+  inputGroupFooter: 'inputGroupFooter'
+};
+exports.inputGroupFieldTypes = inputGroupFieldTypes;
+var _default = {
+  operandLetters: operandLetters,
+  viewTypes: viewTypes,
+  inputGroupFieldTypes: inputGroupFieldTypes
+};
+exports["default"] = _default;

package/dist/fieldHelper.js

@@ -0,0 +1,54 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getMultiSelectFieldValue = exports.getChartFieldValue = void 0;
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+/**
+ * Get chart field line data
+ *
+ * @param (String|Object) value
+ */
+var getChartFieldValue = function getChartFieldValue(value) {
+  var parsedData = value || [];
+
+  if (value && typeof value === 'string') {
+    parsedData = JSON.parse(value);
+  }
+
+  if (parsedData && parsedData.length > 0) {
+    parsedData = parsedData.filter(function (line) {
+      return !line.deleted;
+    });
+  }
+
+  return (0, _toConsumableArray2["default"])(parsedData);
+};
+/**
+ * Get multiselect field value
+ *
+ * @param (String|Array) value
+ * @return Array
+ */
+
+
+exports.getChartFieldValue = getChartFieldValue;
+
+var getMultiSelectFieldValue = function getMultiSelectFieldValue(value) {
+  if (value && typeof value === 'string') {
+    return value.split(',');
+  } else if (value && (0, _typeof2["default"])(value) === 'object') {
+    return (0, _toConsumableArray2["default"])(value);
+  } else {
+    return [];
+  }
+};
+
+exports.getMultiSelectFieldValue = getMultiSelectFieldValue;

package/dist/index.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fieldHelper = exports.chartHelper = exports.tableHelper = exports["default"] = void 0;
+
+var tableHelper = _interopRequireWildcard(require("./tableHelper"));
+
+exports.tableHelper = tableHelper;
+
+var chartHelper = _interopRequireWildcard(require("./chartHelper"));
+
+exports.chartHelper = chartHelper;
+
+var fieldHelper = _interopRequireWildcard(require("./fieldHelper"));
+
+exports.fieldHelper = fieldHelper;
+var _default = {
+  tableHelper: tableHelper,
+  chartHelper: chartHelper,
+  fieldHelper: fieldHelper
+};
+exports["default"] = _default;

package/dist/tableHelper.js

@@ -0,0 +1,584 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.generateInputGroupFields = exports.spreadOperandRange = exports.validFormulaString = exports.hasOperandRange = exports.hasCircularOperandReference = exports.resolveOperandValue = exports.getFormulaResult = exports.generateTableLookup = exports.generateTableFieldLookups = exports.generateRowTableLookup = exports.getCellOperand = exports.getTemplateColumnOperandLookup = exports.getColumnOperand = exports.getColumns = exports.getTableFieldRowOrder = exports.getRowMap = exports.sortRows = exports.getRows = exports.getDefaultRow = exports.getTableFieldLookupKey = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _shortid = _interopRequireDefault(require("shortid"));
+
+var _Table = _interopRequireWildcard(require("./constants/Table"));
+
+var _FieldTypes = _interopRequireDefault(require("./constants/FieldTypes"));
+
+var _FieldTableColumnTypes = _interopRequireDefault(require("./constants/FieldTableColumnTypes"));
+
+var _FieldTableCustomColumnIds = _interopRequireDefault(require("./constants/FieldTableCustomColumnIds"));
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var FormulaParser = require('hot-formula-parser').Parser;
+
+var parser = new FormulaParser();
+
+var getTableFieldLookupKey = function getTableFieldLookupKey(fieldId, rowIndex, columnId) {
+  return "".concat(fieldId, "-").concat(rowIndex, "-").concat(columnId);
+};
+
+exports.getTableFieldLookupKey = getTableFieldLookupKey;
+
+var getDefaultRow = function getDefaultRow() {
+  return {
+    _id: _shortid["default"].generate(),
+    deleted: false,
+    cells: {}
+  };
+};
+
+exports.getDefaultRow = getDefaultRow;
+
+var getRows = function getRows(rows) {
+  var parsedRows = rows;
+
+  if (typeof parsedRows === 'string') {
+    parsedRows = JSON.parse(parsedRows);
+  }
+
+  return parsedRows ? parsedRows.filter(function (row) {
+    return !row.deleted;
+  }) : [];
+};
+/**
+ * Sort rows based on rowOrder
+ */
+
+
+exports.getRows = getRows;
+
+var sortRows = function sortRows(rows, rowOrder) {
+  var rowLookup = {};
+  rows.forEach(function (row) {
+    return rowLookup[row._id] = row;
+  });
+  var validRows = [];
+  rowOrder.forEach(function (rowId) {
+    if (rowLookup[rowId]) validRows.push(rowLookup[rowId]);
+  });
+  return validRows;
+};
+/**
+ * Create a table row map for simple value lookup
+ *
+ * For instance:
+ * {
+ *    rowId: {columnId: value, columnId: value, ...},
+ *    rowId: {columnId: value, columnId: value, ...},
+ *    rowId: {columnId: value, columnId: value, ...}
+ * }
+ *
+ * @param {Array} rows
+ * @return {Object}
+ */
+
+
+exports.sortRows = sortRows;
+
+var getRowMap = function getRowMap() {
+  var rows = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var items = getRows(rows);
+  var rowMap = {};
+  items.forEach(function (row) {
+    return rowMap[row._id] = row.cells || {};
+  });
+  return rowMap;
+};
+/**
+ * Get row order for table field. If there isn't a row order set in the
+ * fieldSettings then it will default to the normal row array Ids.
+ *
+ * @param {String} fieldId
+ * @param {Object} fieldSettings
+ * @param {Array} rows
+ *
+ * @return {Array}
+ */
+
+
+exports.getRowMap = getRowMap;
+
+var getTableFieldRowOrder = function getTableFieldRowOrder(fieldId, fieldSettings, rows) {
+  var filteredRows = rows ? getRows(rows) : [];
+  return fieldSettings && fieldSettings[fieldId] && fieldSettings[fieldId].rowOrder ? (0, _toConsumableArray2["default"])(fieldSettings[fieldId].rowOrder) : filteredRows.map(function (row) {
+    return row._id;
+  });
+};
+/**
+ * Get table columns with added operands. Operands are the A, B, C, etc.
+ */
+
+
+exports.getTableFieldRowOrder = getTableFieldRowOrder;
+
+var getColumns = function getColumns(columns) {
+  var parsedColumns = columns;
+
+  if (typeof parsedColumns === 'string') {
+    parsedColumns = JSON.parse(parsedColumns);
+  }
+
+  return !parsedColumns ? [] : parsedColumns.filter(function (column) {
+    return !column.deleted;
+  }).map(function (column, i) {
+    var nextColumn = _objectSpread({}, column);
+
+    nextColumn.operand = getColumnOperand(i);
+    return nextColumn;
+  });
+};
+/**
+ * Return letter for a column index. For intance: A, B, C
+ *
+ * Used to create the table lookup operands: A1, B12, etc.
+ */
+
+
+exports.getColumns = getColumns;
+
+var getColumnOperand = function getColumnOperand(index) {
+  return String.fromCharCode(65 + index);
+};
+/**
+ * Get operand lookup for all table/inputGroup fields in a template.
+ *
+ * For instance: {
+ *   fieldId: { colId: 'A', colId: 'B', ...},
+ *   ....
+ * }
+ */
+
+
+exports.getColumnOperand = getColumnOperand;
+
+var getTemplateColumnOperandLookup = function getTemplateColumnOperandLookup(template) {
+  var operandLookup = {};
+  template.fields.forEach(function (field) {
+    if (field.type !== _FieldTypes["default"].table && field.type !== _FieldTypes["default"].inputGroup) return;
+    if (!operandLookup[field._id]) operandLookup[field._id] = {};
+    var columns = getColumns(field.tableColumns);
+    columns.forEach(function (col, colIndex) {
+      operandLookup[field._id][col._id] = getColumnOperand(colIndex);
+    });
+  });
+  return operandLookup;
+};
+/**
+ * Return operand for cell. For intance: A1, B2, C1
+ *
+ * @param {String} columnOperand //A, B, C, etc.
+ * @param {Number} rowIndex
+ */
+
+
+exports.getTemplateColumnOperandLookup = getTemplateColumnOperandLookup;
+
+var getCellOperand = function getCellOperand(columnOperand, rowIndex) {
+  return "".concat(columnOperand).concat(rowIndex);
+};
+/**
+ * Generate table lookup by rowIndex and column operand
+ *
+ * For instance:
+ * {
+ *    rowIndex: {A1: value, B1: value, ...},
+ *    rowIndex: {A2: value, B2: value, ...},
+ *    rowIndex: {A3: value, B3: value, ...},
+ *    ...
+ * }
+ *
+ * @param {Array} rows
+ * @param {Array} columns
+ * @param {Object} tableLookup
+ *
+ * @return {Object}
+
+ */
+
+
+exports.getCellOperand = getCellOperand;
+
+var generateRowTableLookup = function generateRowTableLookup(rows, columns, tableLookup) {
+  if (!rows || !columns || !tableLookup) return {};
+  var rowTableLookup = {};
+  rows.forEach(function (row, rowIndex) {
+    rowTableLookup[rowIndex] = {};
+    columns.forEach(function (column, columnIndex) {
+      var operand = getColumnOperand(columnIndex);
+      var cellOperand = getCellOperand(operand, rowIndex + 1);
+      rowTableLookup[rowIndex][cellOperand] = tableLookup[cellOperand];
+    });
+  });
+  return rowTableLookup;
+};
+/**
+ * Generate table lookups for each table field in template. It takes
+ * all table & inputGroup fields and generates a table lookup object for them.
+ *
+ * For instance if you have a template and doc like the ones below:
+ *
+ * template: {
+ *   fields: [
+ *     {_id: textFieldId, ...},
+ *     {_id: tableFieldId1, ...},
+ *     {_id: tableFieldId2, ...},
+ *     {_id: numberFieldId, ...},
+ *     ...
+ *   ]
+ * }
+ *
+ * returned object would be: {
+ *   tableFieldId1: { A1: value, B1: value, ...},
+ *   tableFieldId2: { A2: value, B2: value, ...},
+ *   ...
+ * }
+ */
+
+
+exports.generateRowTableLookup = generateRowTableLookup;
+
+var generateTableFieldLookups = function generateTableFieldLookups(doc, template) {
+  var tableFields = template.fields.filter(function (field) {
+    return (field.type === _FieldTypes["default"].table || field.type === _FieldTypes["default"].inputGroup) && !field.deleted;
+  });
+  var tableLookups = {};
+  tableFields.forEach(function (field) {
+    var docValue = doc.fields[field._id];
+    var rows = getRows(docValue);
+    var columns = getColumns(field.tableColumns);
+    var docFieldSettings = doc.fieldSettings || {};
+    var fieldSettings = docFieldSettings[field._id] || {};
+    var rowOrder = fieldSettings.rowOrder && fieldSettings.rowOrder.length !== 0 ? fieldSettings.rowOrder : rows.map(function (row) {
+      return row._id;
+    });
+    var validRows = sortRows(rows, rowOrder);
+    tableLookups[field._id] = generateTableLookup(validRows, columns);
+  });
+  return tableLookups;
+};
+/**
+ * Generate Lookup Operand Lookup Table for Table Data. Supports converting
+ * formula cells to the calculated value.
+ *
+ * Operand examples: A1, B12, C25, etc.
+ *
+ * @param {Array} rows
+ * @param {Array} columns
+ * @retuns {Object}
+ *
+ * Example return object:
+ * {
+ *   A1: 12,
+ *   B1: 1,
+ *   A2: 2,
+ *   B2: 4,
+ * }
+ *
+ */
+
+
+exports.generateTableFieldLookups = generateTableFieldLookups;
+
+var generateTableLookup = function generateTableLookup(rows, columns) {
+  var tableLookup = {};
+  var columnOptionsLookup = {};
+  var tableColumns = [];
+  var filteredColumns = columns.filter(function (column) {
+    return !column.deleted //Used by both web and mobile
+    && column._id !== _FieldTableCustomColumnIds["default"].rowMenu //Used on mobile
+    && column._id !== _FieldTableCustomColumnIds["default"].rowNumber; //Used on mobile
+  });
+  filteredColumns.forEach(function (column, i) {
+    var nextColumn = _objectSpread({}, column);
+
+    nextColumn.operand = String.fromCharCode(65 + i);
+    tableColumns.push(nextColumn);
+
+    if (column.type === _FieldTableColumnTypes["default"].dropdown) {
+      columnOptionsLookup[column._id] = {};
+      column.options.forEach(function (option) {
+        columnOptionsLookup[column._id][option._id] = option.value;
+      });
+    }
+  });
+  var parsedRows = typeof rows === 'string' ? JSON.parse(rows) : rows;
+  var tableRows = parsedRows.filter(function (row) {
+    return !row.deleted;
+  });
+  var formulaCells = [];
+  tableRows.forEach(function (row, rowIndex) {
+    tableColumns.forEach(function (column) {
+      if (!column.operand) return;
+      var cellKey = "".concat(column.operand).concat(rowIndex + 1);
+      var cellValue = row.cells[column._id] ? row.cells[column._id].trim() : undefined;
+      var formulaCell = cellValue !== undefined && cellValue.charAt(0) === '=';
+      var containsOperands = cellValue !== undefined && cellValue.match(/[A-Z]([0-9]{1,10})/gi);
+
+      if (cellValue && column.type === _FieldTableColumnTypes["default"].dropdown) {
+        tableLookup[cellKey] = columnOptionsLookup[column._id][cellValue];
+      } else if (cellValue && formulaCell && containsOperands) {
+        formulaCells.push(cellKey);
+        tableLookup[cellKey] = cellValue;
+      } else if (cellValue) {
+        tableLookup[cellKey] = cellValue;
+      }
+    });
+  });
+  formulaCells.forEach(function (sourceOperand) {
+    var formula = tableLookup[sourceOperand];
+    var invalidFormulaError = validFormulaString(sourceOperand, formula);
+    if (invalidFormulaError) return tableLookup[sourceOperand] = invalidFormulaError;
+    getFormulaResult(sourceOperand, formula, tableLookup);
+  });
+  return tableLookup;
+};
+
+exports.generateTableLookup = generateTableLookup;
+
+var getFormulaResult = function getFormulaResult(sourceOperand, formula, tableLookup) {
+  formula = spreadOperandRange(formula);
+  var invalidFormulaError = validFormulaString(sourceOperand, formula);
+  if (invalidFormulaError) return tableLookup[sourceOperand] = invalidFormulaError;
+  var formulaOperands = formula.match(/[A-Z]([0-9]{1,10})/g);
+  if (!formulaOperands) return tableLookup[sourceOperand] = '*INVALID';
+  formulaOperands.forEach(function (operand) {
+    var operandValue = resolveOperandValue(sourceOperand, operand, tableLookup);
+    formula = formula.replace(operand, operandValue);
+  });
+  /**
+   * Add leading zeros to decimal numbers. hot-formula-parser throws an
+   * error if we try to parse non leading decimal numbers. For instace,
+   * a non leading decimal number is: .7 .001 etc. We convert these
+   * values to 0.7 & 0.001
+   */
+
+  var noLeadingZeroDecimalMatches = formula.match(/\D\./);
+
+  if (noLeadingZeroDecimalMatches && noLeadingZeroDecimalMatches.length > 0) {
+    noLeadingZeroDecimalMatches.forEach(function (val) {
+      var splitVals = val.split('');
+      var prefixCharacter = splitVals[0];
+      var newValue = "".concat(prefixCharacter, "0.");
+      formula = formula.replace(val, newValue);
+    });
+  }
+
+  formula = formula.replace('=', '');
+  var parsedValue = parser.parse(formula);
+  if (parsedValue.result) parsedValue.result = Math.round(100 * parsedValue.result) / 100;
+  tableLookup[sourceOperand] = parsedValue.result ? parsedValue.result.toString() : parsedValue.error;
+  return parsedValue;
+};
+/**
+ * Resolve operand value
+ * An operand is A1, B1, etc.
+ *
+ * @param sourceOperand //The cell that is requesting the value
+ * @param targetOperand //The cell you are trying to retrieve a value from
+ * @param tableLookup //The lookup of values contained in the table;
+ */
+
+
+exports.getFormulaResult = getFormulaResult;
+
+var resolveOperandValue = function resolveOperandValue(sourceOperand, targetOperand, tableLookup) {
+  var targetValue = tableLookup[targetOperand] && typeof tableLookup[targetOperand] === 'string' ? tableLookup[targetOperand].trim() : tableLookup[targetOperand]; // 1. If tableLookup doesn't have a value then return undefined
+
+  if (!targetValue) return 0; // 2. If tableLookup is already a number return the number value
+
+  if (typeof targetValue === 'number') return targetValue; // 3. If targetCell has circular reference return invalid.
+  //
+  //  A circular reference can occur when C1 reference B1 and B1 references C1.
+  //  It creates and infinite circular loop of trying to resovle a value
+  //  because they both depend on eachother.
+
+  if (sourceOperand && hasCircularOperandReference(targetValue, sourceOperand)) return '* INVALID - Circular Reference'; // 4. If targetCell has a formula value
+
+  if (targetValue !== undefined && targetValue.charAt(0) === '=') {
+    var result = getFormulaResult(sourceOperand, targetValue, tableLookup);
+    return result.result || result.error;
+  } // 5. If targetCell has a normal value or an already resolved
+  //   formula cell then just return the cell value
+
+
+  if (targetValue) return targetValue;
+};
+
+exports.resolveOperandValue = resolveOperandValue;
+
+var hasCircularOperandReference = function hasCircularOperandReference(targetValue, lookupOperand) {
+  var regExp = new RegExp(lookupOperand, 'gi');
+  var foundOperandReferences = targetValue.match(regExp);
+  return !!(foundOperandReferences && foundOperandReferences.length > 0);
+};
+
+exports.hasCircularOperandReference = hasCircularOperandReference;
+
+var hasOperandRange = function hasOperandRange(targetValue) {
+  return /[A-Z]([0-9]{1,10}):[A-Z]([0-9]{1,10})/gi.test(targetValue);
+};
+/**
+ * Check for any invalid patterns inside of the formula string
+ */
+
+
+exports.hasOperandRange = hasOperandRange;
+
+var validFormulaString = function validFormulaString(sourceOperand, formula) {
+  if (sourceOperand && hasCircularOperandReference(formula, sourceOperand)) {
+    return '*INVALID - Circular Reference';
+  }
+
+  var lowercaseOperands = formula.match(/[a-z]/g);
+
+  if (lowercaseOperands && lowercaseOperands.length > 0) {
+    return '*INVALID - Lowercase Letters Not Supported';
+  }
+};
+/**
+ * Spread the operand range into individual operands.
+ * For instance: SUM(A1:A4) turns into SUM(A1, A2, A3, A4);
+ */
+
+
+exports.validFormulaString = validFormulaString;
+
+var spreadOperandRange = function spreadOperandRange(targetValue) {
+  if (!hasOperandRange(targetValue)) return targetValue;
+  var operandRangeMatches = targetValue.match(/[A-Z]([0-9]{1,10}):[A-Z]([0-9]{1,10})/gi);
+  var operandRange = operandRangeMatches[0];
+  var operands = operandRange.split(':');
+  var operandA = operands[0];
+  var operandALetter = operandA.match(/[A-Z]+/gi) ? operandA.match(/[A-Z]+/gi)[0] : null;
+  var operandAIndex = operandA.match(/[0-9]+/gi) ? operandA.match(/[0-9]+/gi)[0] : null;
+  var operandB = operands[1];
+  var operandBLetter = operandB.match(/[A-Z]+/gi) ? operandB.match(/[A-Z]+/gi)[0] : null;
+  var operandBIndex = operandB.match(/[0-9]+/gi) ? operandB.match(/[0-9]+/gi)[0] : null; // If any values are missing return orignal targetValue
+
+  if (!operandALetter || !operandAIndex || !operandBLetter || !operandBIndex) return targetValue; // Handle row range.
+  // For instance: C1:C8
+
+  if (operandALetter === operandBLetter) {
+    var columnOperand = operandALetter;
+    var startIndex = parseInt(operandAIndex, 10);
+    var endIndex = parseInt(operandBIndex, 10);
+    var operandRangeValues = operandA;
+    var i = startIndex + 1;
+
+    while (i <= endIndex) {
+      operandRangeValues += ",".concat(columnOperand).concat(i);
+      i++;
+    }
+
+    targetValue = targetValue.replace(/[A-Z](\d{1,10}):[A-Z](\d{1,10})/gi, operandRangeValues);
+  } // Handle column range
+  // For instance, A1:D1
+  else {
+      var _startIndex = parseInt(_Table["default"].operandLetters.indexOf(operandALetter.toUpperCase()), 10);
+
+      var _endIndex = parseInt(_Table["default"].operandLetters.indexOf(operandBLetter.toUpperCase()), 10);
+
+      var _operandRangeValues = operandA;
+
+      var _i = _startIndex + 1;
+
+      while (_i <= _endIndex) {
+        var nextOperandLetter = _Table["default"].operandLetters[_i];
+        _operandRangeValues += ",".concat(nextOperandLetter).concat(operandAIndex);
+        _i++;
+      }
+
+      targetValue = targetValue.replace(/[A-Z](\d{1,10}):[A-Z](\d{1,10})/gi, _operandRangeValues);
+    }
+
+  return targetValue;
+};
+/**
+ * Primarily used for Mobile
+ *
+ * Get list of input group fields in an array formt.
+ * This breaks the rows and cells down to a single array.
+ *
+ * @param {Object} field
+ * @param {Array} columns
+ * @param {Array} rows
+ *
+ */
+
+
+exports.spreadOperandRange = spreadOperandRange;
+
+var generateInputGroupFields = function generateInputGroupFields(field, columns) {
+  var rows = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [getDefaultRow()];
+  var fieldSettings = arguments.length > 3 ? arguments[3] : undefined;
+  var tableReferences = [];
+  var tableColumns = getColumns(columns);
+  var tableRows = getRows(rows);
+  var rowOrder = getTableFieldRowOrder(field._id, fieldSettings, tableRows);
+  var sortedTableRows = sortRows(tableRows, rowOrder);
+  sortedTableRows.forEach(function (row, rowIndex) {
+    /**
+     * Step 1: Add InputGroup Row Header
+     */
+    tableReferences.push(_objectSpread(_objectSpread({}, field), {}, {
+      type: _Table.inputGroupFieldTypes.inputGroupRowHeader,
+      rowIndex: rowIndex,
+      row: row
+    }));
+    /**
+     * Step 2: Add Input Group Row Cells
+     */
+
+    tableColumns.forEach(function (column, columnIndex) {
+      tableReferences.push(_objectSpread(_objectSpread({}, field), {}, {
+        type: column.type === _FieldTableColumnTypes["default"].dropdown ? _Table.inputGroupFieldTypes.inputGroupDropdownCell : _Table.inputGroupFieldTypes.inputGroupTextCell,
+        rowIndex: rowIndex,
+        row: row,
+        columnIndex: columnIndex,
+        column: column,
+        docValue: row && row.cells ? row.cells[column._id] : ''
+      }));
+    });
+  });
+  return tableReferences;
+};
+
+exports.generateInputGroupFields = generateInputGroupFields;
+var _default = {
+  generateTableLookup: generateTableLookup,
+  generateRowTableLookup: generateRowTableLookup,
+  generateInputGroupFields: generateInputGroupFields,
+  getColumnOperand: getColumnOperand,
+  getCellOperand: getCellOperand,
+  getRows: getRows,
+  getDefaultRow: getDefaultRow,
+  getRowMap: getRowMap,
+  getColumns: getColumns,
+  getFormulaResult: getFormulaResult,
+  resolveOperandValue: resolveOperandValue,
+  hasCircularOperandReference: hasCircularOperandReference,
+  validFormulaString: validFormulaString,
+  hasOperandRange: hasOperandRange,
+  spreadOperandRange: spreadOperandRange,
+  getTableFieldLookupKey: getTableFieldLookupKey,
+  getTableFieldRowOrder: getTableFieldRowOrder
+};
+exports["default"] = _default;

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@builttocreate/engine-utils",
+  "version": "1.0.0",
+  "description": "Utility library for common logic shared across web and mobile",
+  "main": "dist/index.js",
+  "files": [
+    "dist/**/*",
+    "dist/*"
+  ],
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build-src": "NODE_ENV=production babel src --out-dir dist --extensions '.js,.jsx' --ignore 'src/testUtils/*','src/**/*.stories.js','src/**/*.test.js','src/lib/**/*.test.js','src/**/__snapshots__','src/**/__mocks__'",
+    "build": "npm run clean && npm run build-src",
+    "prepublish": "npm run build",
+    "test": "jest",
+    "test-watch": "jest --watch",
+    "lint": "npx eslint ./src --fix",
+    "coverage": "jest --coverage"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zionlabs/engine-utils.git"
+  },
+  "author": "Docspace Team",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/zionlabs/engine-utils/issues"
+  },
+  "homepage": "https://github.com/zionlabs/engine-utils#readme",
+  "devDependencies": {
+    "@babel/cli": "^7.12.10",
+    "@babel/core": "^7.12.10",
+    "@babel/plugin-proposal-class-properties": "^7.12.1",
+    "@babel/plugin-transform-regenerator": "^7.12.1",
+    "@babel/plugin-transform-runtime": "^7.12.10",
+    "@babel/preset-env": "^7.12.11",
+    "babel-eslint": "^10.1.0",
+    "eslint": "^7.18.0",
+    "eslint-config-airbnb": "^18.2.1",
+    "eslint-plugin-import": "^2.22.1",
+    "eslint-plugin-jsx-a11y": "^6.4.1",
+    "eslint-plugin-react": "^7.22.0",
+    "jest": "^26.6.3"
+  },
+  "dependencies": {
+    "@babel/polyfill": "^7.12.1",
+    "hot-formula-parser": "^4.0.0",
+    "shortid": "^2.2.16"
+  },
+  "jest": {
+    "verbose": true,
+    "moduleNameMapper": {
+      "\\.(jpg|jpeg|png|gif|eot|otf|webp|svg|ttf|woff|woff2|mp4|webm|wav|mp3|m4a|aac|oga)$": "<rootDir>/__mocks__/fileMock.js",
+      "\\.(css|less)$": "<rootDir>/__mocks__/styleMock.js"
+    }
+  }
+}