@builttocreate/engine-utils 2.6.0-beta.21 → 2.6.0-beta.23

package/README.md

@@ -1,5 +1,6 @@
 # engine-utils
 
+Node: v18
 Package Manager: NPM
 
 Utility library for common logic shared across web and mobile

package/dist/constants/FormStyleOptions.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  displayInline: 'inline',
+  displayNone: 'none',
+  textTransformUpperCase: 'uppercase',
+  textTransformNone: 'none',
+  fontWeightBold: 'bold',
+  fontWeightNormal: 'normal',
+  fontStyleItalic: 'italic',
+  fontStyleNormal: 'normal',
+  textDecorationUnderline: 'underline',
+  textDecorationNone: 'none',
+  textOverflowEllipsis: 'ellipsis',
+  textOverflowNone: '',
+  textAlignLeft: 'left',
+  textAlignCenter: 'center',
+  textAlignRight: 'right'
+};
+exports["default"] = _default;

package/dist/joyDocHelper.js

@@ -5,7 +5,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.sortPages = exports.sortFieldPositionsByXAndYCoordinates = exports.mergeAssoicatedFieldPositionsForMobileView = exports.getPageOrder = exports.getMobileViewFromFile = exports.getDocumentFromTemplate = exports.getDefaultTemplate = exports.getDefaultJoyDocPage = exports.getDefaultJoyDocFile = exports.getDefaultJoyDoc = exports.getDefaultDocument = exports.getCleanedJoyDocPages = exports.getCleanedJoyDoc = exports.generateMobileViewPageFieldPositions = exports.generateMobileViewPage = exports.generateMobileViewFile = exports.duplicateDocumentPage = exports.duplicate = exports["default"] = exports.cleanPageOrder = void 0;
+exports.sortPages = exports.sortFieldPositionsByXAndYCoordinates = exports.mergeAssoicatedFieldPositionsForMobileView = exports.getPageOrder = exports.getMobileViewFromFile = exports.getDocumentFromTemplate = exports.getDefaultTemplate = exports.getDefaultJoyDocPage = exports.getDefaultJoyDocFile = exports.getDefaultJoyDoc = exports.getDefaultDocument = exports.getCleanedJoyDocPages = exports.getCleanedJoyDoc = exports.generateMobileViewPageFieldPositions = exports.generateMobileViewPage = exports.generateMobileViewFile = exports.formatTableFieldPositions = exports.duplicateDocumentPage = exports.duplicate = exports["default"] = exports.cleanPageOrder = void 0;
 
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 
@@ -27,6 +27,8 @@ var _FieldDisplayTypes = _interopRequireDefault(require("./constants/FieldDispla
 
 var _FileViews = _interopRequireDefault(require("./constants/FileViews"));
 
+var _FormStyleOptions = _interopRequireDefault(require("./constants/FormStyleOptions"));
+
 var _tableHelper = require("./tableHelper");
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
@@ -712,6 +714,7 @@ var generateMobileViewPageFieldPositions = function generateMobileViewPageFieldP
   var sortedFieldPositions = sortFieldPositionsByXAndYCoordinates(fieldPositions);
   sortedFieldPositions.forEach(function (joySpecFieldPosition) {
     var mobileFieldPositionData = _objectSpread(_objectSpread({}, joySpecFieldPosition), {}, {
+      titleDisplay: _FormStyleOptions["default"].displayInline,
       displayType: _FieldDisplayTypes["default"].original,
       height: joySpecFieldPosition.height * (originalRowHeight || 1),
       width: 1,
@@ -802,8 +805,149 @@ var sortFieldPositionsByXAndYCoordinates = function sortFieldPositionsByXAndYCoo
   });
   return sortedFieldPositions;
 };
+/**
+ * Formats individual table cell field positions that have already been merged with their associated field.
+ * This additional information is added and used for rendering the fieldPositions on the form.
+ *
+ * For instance, adds properties like columnType, calculatedCellValue, options, etc.
+ *
+ * @param {Array} fieldPositions
+ * @returns {Array}
+ */
+
 
 exports.sortFieldPositionsByXAndYCoordinates = sortFieldPositionsByXAndYCoordinates;
+
+var formatTableFieldPositions = function formatTableFieldPositions(fieldPositions) {
+  /**
+   * We only want to generate the table value calculated lookup for each table field once.
+   * We use these lookups because multiple table fieldPositions belonging to the same table
+   * field will all use the same table value calculated lookup.
+   */
+  var tableFieldLookups = {};
+  var tableFieldColumnLookups = {};
+  var nextFieldPositions = [];
+  (0, _toConsumableArray2["default"])(fieldPositions).forEach(function (fieldPosition) {
+    var nextFieldPosition = _objectSpread({}, fieldPosition);
+
+    if (fieldPosition.type === _FieldTypes["default"].table) {
+      var field = fieldPosition.field,
+          column = fieldPosition.column,
+          rowIndex = fieldPosition.rowIndex,
+          tableColumns = fieldPosition.tableColumns,
+          value = fieldPosition.value,
+          rowOrder = fieldPosition.rowOrder,
+          tableColumnOrder = fieldPosition.tableColumnOrder;
+      /**
+       * Value will include deleted rows as well. We are removing the deleted rows
+       * since we want to compute the cellValue and calculatedCellValue only
+       * with undeleted table rows
+       */
+
+      var rows = (0, _tableHelper.getRows)(value);
+      var nextRowOrder = (0, _tableHelper.getRowOrder)(rowOrder, value);
+
+      if (!tableFieldColumnLookups[field]) {
+        var fieldColumnLookup = {};
+        (0, _tableHelper.getColumns)((0, _tableHelper.sortColumns)(tableColumns, tableColumnOrder)).forEach(function (column) {
+          return fieldColumnLookup[column._id] = column;
+        });
+        tableFieldColumnLookups[field] = fieldColumnLookup;
+      }
+
+      if (!tableFieldLookups[field]) {
+        var fieldTableLookup = (0, _tableHelper.generateTableLookup)(rows, (0, _tableHelper.sortColumns)(tableColumns, tableColumnOrder));
+        tableFieldLookups[field] = fieldTableLookup;
+      }
+      /**
+       * Ensure each table field has a properly formatted rowOrder
+       */
+
+
+      if (!nextFieldPosition.rowOrder) nextFieldPosition.rowOrder = nextRowOrder;
+      /**
+       * Add calculated value lookup. For instance, { A1: '', B1: '', C1: '', ... }
+       */
+
+      if (!nextFieldPosition.calculatedValue) nextFieldPosition.calculatedValue = tableFieldLookups[field];
+      /**
+       * Individual Table Cell vs Entire Table
+       *
+       * Only add cellValue, calculatedCellValue, columnType, and column options to
+       * individually mapped table cell fieldPositions. Regular table fields (entire table)
+       * just simply use the fieldPositions.value parameter so we don't need the calculated
+       * values, etc.
+       *
+       * We determine an individual table cell fieldPosition vs an entire table
+       * fieldPosition by checking for column and rowIndex. Individual cells have
+       * column and rowIndex but regular tables do not.
+       *
+       * Note:
+       * rowIndex + 1 is used while calculating cell value since column operands
+       * start from 1 instead of zero in the table lookups
+       * (ie: [A1:{}, B1:{}] instead of [A0:{}, B0:{}])
+       *
+       * If tableRowIndex associated with a cell doesn't have a table row associated
+       * with it (ie rows[rowIndex] is undefined) it means that particular row is deleted
+       */
+
+      if (tableFieldLookups[field] && column && typeof rowIndex === 'number') {
+        var _rows$targetRowIndex;
+
+        /**
+         * What is the difference between rowIndex and targetRowIndex?
+         *
+         * - The rowIndex on the fieldPosition is the saved index of where the rowId lives inside of the rowOrder.
+         * - The targetRowIndex is the actual index of the row object inside the value (array of row data) of the field.
+         *
+         * We use the fieldPosition.rowIndex to get the rowId from the rowOrder. Then we use the rowId to locate
+         * the assoicated row object data in the value property. The rowOrder and value (rows) do not follow the same
+         * order. The rowOrder is updated when users insert rows, move rows up or down, etc. it manages where rows
+         * are at in the list and how they should be rendered. This is why the rowIndex uses the rowOrder.
+         */
+        var targetColumn = tableFieldColumnLookups[field][column];
+        var targetRowId = nextRowOrder[rowIndex];
+        var targetRowIndex = rows.findIndex(function (row) {
+          return row._id === targetRowId;
+        });
+        /**
+         * Add proper rowId to the field position so that it can be used
+         * inside the element for change handlers;
+         */
+
+        nextFieldPosition.rowId = targetRowId;
+        /**
+         * If rows[rowIndex] is undefined, it means the row that was present
+         * at the particular rowIndex was deleted
+        */
+
+        nextFieldPosition.cellValue = ((_rows$targetRowIndex = rows[targetRowIndex]) === null || _rows$targetRowIndex === void 0 ? void 0 : _rows$targetRowIndex.cells[column]) || ''; //targetColumn will appear as undefined if a column is deleted
+
+        if (targetColumn) {
+          nextFieldPosition.calculatedCellValue = tableFieldLookups[field]["".concat(targetColumn.operand).concat(targetRowIndex + 1)];
+          nextFieldPosition.columnType = targetColumn.type;
+          nextFieldPosition.options = targetColumn.options;
+          nextFieldPosition.columnIdentifier = targetColumn.identifier;
+          /**
+           * IMPORTANT NOTE: We only add individual table cell field position into
+           * the fieldPosition list if the associated column is not deleted.
+           */
+
+          nextFieldPositions.push(nextFieldPosition);
+        }
+      } else {
+        //Push table fields with original display type
+        nextFieldPositions.push(nextFieldPosition);
+      }
+    } else {
+      //Push other fields
+      nextFieldPositions.push(nextFieldPosition);
+    }
+  });
+  return nextFieldPositions;
+};
+
+exports.formatTableFieldPositions = formatTableFieldPositions;
 var _default = {
   getDefaultJoyDocPage: getDefaultJoyDocPage,
   getDefaultJoyDocFile: getDefaultJoyDocFile,
@@ -821,6 +965,7 @@ var _default = {
   mergeAssoicatedFieldPositionsForMobileView: mergeAssoicatedFieldPositionsForMobileView,
   generateMobileViewFile: generateMobileViewFile,
   generateMobileViewPage: generateMobileViewPage,
-  generateMobileViewPageFieldPositions: generateMobileViewPageFieldPositions
+  generateMobileViewPageFieldPositions: generateMobileViewPageFieldPositions,
+  formatTableFieldPositions: formatTableFieldPositions
 };
 exports["default"] = _default;

package/dist/tableHelper.js

@@ -698,7 +698,9 @@ var generateTableLookup = function generateTableLookup(rows, columns) {
       if (!column.operand) return;
       var cellKey = "".concat(column.operand).concat(rowIndex + 1);
       var cellRawValue = row.cells[column._id] ? row.cells[column._id] : undefined;
-      var cellValue = cellRawValue && typeof cellRawValue === 'string' ? cellRawValue.trim() : undefined;
+      var cellValue;
+      if (cellRawValue && typeof cellRawValue === 'string') cellValue = cellRawValue.trim();
+      if (cellRawValue && typeof cellRawValue === 'number') cellValue = cellRawValue.toString();
       var formulaCell = cellValue !== undefined && cellValue.charAt(0) === '=';
       var containsOperands = cellValue !== undefined && cellValue.match(/[A-Z]([0-9]{1,10})/gi);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@builttocreate/engine-utils",
-  "version": "2.6.0-beta.21",
+  "version": "2.6.0-beta.23",
   "description": "Utility library for common logic shared across web and mobile",
   "main": "dist/index.js",
   "files": [