@builttocreate/engine-utils 2.10.1 → 2.11.0-1828.beta.0

package/dist/fieldHelper.js

@@ -4,7 +4,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.isTargetOptionDeleted = exports.isFieldEmpty = exports.handleMultiSelectOptionToggle = exports.getTemplateWithLookups = exports.getMultiSelectFieldValue = exports.getImportFieldValues = exports.getDefaultOption = exports.getDefaultFieldValuesFromTemplate = exports.getChartFieldValue = exports["default"] = void 0;
+exports.isTargetOptionDeleted = exports.isFieldEmpty = exports.handleMultiSelectOptionToggle = exports.getTemplateWithLookups = exports.getMultiSelectFieldValue = exports.getImportFieldValues = exports.getDefaultOption = exports.getDefaultFieldValuesFromTemplate = exports.getChartFieldValue = exports.flattenSchemaTree = exports["default"] = void 0;
 var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
@@ -298,6 +298,45 @@ var isTargetOptionDeleted = exports.isTargetOptionDeleted = function isTargetOpt
   var result = !(undeletedOptions.length > 0);
   return result;
 };
+
+/**
+ *
+ * Flattens a nested schema tree into an array of objects and adds a depth property to each object.
+ *
+ * @param {Object} schemaObj
+ * @returns {Array} // An array of objects with the schema's id, depth, and other properties.
+ */
+var flattenSchemaTree = exports.flattenSchemaTree = function flattenSchemaTree(schemaObj) {
+  var flattened = [];
+
+  // Recursive function to traverse the tree.
+  function traverse(schemaId, depth, parentId) {
+    var node = schemaObj[schemaId];
+    if (!node) return;
+
+    // Create a new object that includes the schema's id and its depth.
+    flattened.push(_objectSpread({
+      id: schemaId,
+      parentId: parentId,
+      depth: depth
+    }, node));
+
+    // If the node has children, traverse them with increased depth.
+    if (node.children && node.children.length > 0) {
+      node.children.forEach(function (childId) {
+        return traverse(childId, depth + 1, schemaId);
+      });
+    }
+  }
+
+  // Find and traverse each root node.
+  Object.keys(schemaObj).forEach(function (schemaId) {
+    if (schemaObj[schemaId].root) {
+      traverse(schemaId, 0);
+    }
+  });
+  return flattened;
+};
 var _default = exports["default"] = {
   getDefaultOption: getDefaultOption,
   getChartFieldValue: getChartFieldValue,

package/dist/generateReadableId.js

@@ -0,0 +1,167 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateReadableId = generateReadableId;
+exports.generateReadableTableColumnId = generateReadableTableColumnId;
+exports.getFieldPositionsCount = getFieldPositionsCount;
+exports.getFieldsCount = getFieldsCount;
+exports.getViewsFieldPositionsCount = getViewsFieldPositionsCount;
+/**
+* Counts fields of a specific type in an array of fields
+*
+* @param {Array} fields - Array of fields that have a .type property
+* @param {String} type - The field type to count
+* @returns {Number} - Count of fields matching the type
+*/
+function countFieldsByType(fields, type) {
+  if (!fields || !Array.isArray(fields)) return 0;
+  return fields.filter(function (field) {
+    return field && field.type === type;
+  }).length;
+}
+
+/**
+* Counts field positions of a specific type in document fields
+*
+* @param {Array} fields - Array of fields
+* @param {String} type - Field type to count
+* @returns {Number} - Count of fields matching the type
+*/
+function getFieldsCount(fields, type) {
+  if (!fields || !Array.isArray(fields)) {
+    console.warn('getFieldsCount: fields parameter is missing or not an array');
+    return 0;
+  }
+  return countFieldsByType(fields, type);
+}
+
+/**
+* Counts field positions of a specific type in an array of pages
+*
+* @param {Array} pages - Array of pages with fieldPositions
+* @param {String} type - Field type to count
+* @returns {Number} - Count of fieldPositions matching the type
+*/
+function getFieldPositionsCount(pages, type) {
+  if (!pages || !Array.isArray(pages)) {
+    return 0;
+  }
+  if (!pages.length) return 0;
+  var count = 0;
+  pages.forEach(function (page) {
+    if (page && page.fieldPositions) {
+      count += countFieldsByType(page.fieldPositions, type);
+    }
+  });
+  return count;
+}
+
+/**
+* Counts field positions in views
+*
+* @param {Array} views - Array of views with pages with fieldPositions
+* @param {String} type - Field type to count
+* @returns {Number} - Count of fieldPositions in views matching the type
+*/
+function getViewsFieldPositionsCount(views, type) {
+  if (!views || !Array.isArray(views)) {
+    return 0;
+  }
+  if (!views.length) return 0;
+  var count = 0;
+  views.forEach(function (view) {
+    if (view && view.pages && view.pages.length) {
+      count += getFieldPositionsCount(view.pages, type);
+    }
+  });
+  return count;
+}
+
+/**
+* Gets the next field ID for a specific type by counting existing fields
+* and incrementing. It is built to support any combination of the parameters.
+*
+* But it is recommended to use it with all 3 parts if possible.
+*
+* @param {Object} parts - Object containing fields, pages, and views
+* @param {Array} parts.fields - Array of fields
+* @param {Array} parts.pages - Array of pages with fieldPositions
+* @param {Array} parts.views - Array of views with pages
+* @param {String} type - The field type to count
+* @param {String} prefix - An optional prefix to add to the ID
+* @returns {String} - An ID in the format "prefix{type}{count+1}" (e.g. "text3")
+*/
+function generateReadableId(parts, type) {
+  var splitterId = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+  var fields = parts === null || parts === void 0 ? void 0 : parts.fields;
+  var pages = parts === null || parts === void 0 ? void 0 : parts.pages;
+  var views = parts === null || parts === void 0 ? void 0 : parts.views;
+  if (!type) throw new Error('generateReadableId: type is required');
+
+  // Check if all three parameters are missing
+  if (!fields && !pages && !views) {
+    throw new Error('generateReadableId: at least one of fields, pages, or views is required');
+  }
+  if (!fields) console.warn('generateReadableId: fields parameter is missing');
+
+  // Note: leaving for now until we allow targeting fieldPositions
+  // if (pages) count += getFieldPositionsCount(pages, type);
+  // if (views && views.length > 1) count += getViewsFieldPositionsCount(views, type);
+
+  var count = fields.length ? getFieldsCount(fields, type) : 0;
+  var readableId = "".concat(type).concat(splitterId).concat(count + 1);
+  while (hasDuplicateId(fields, readableId)) {
+    count++;
+    readableId = "".concat(type).concat(splitterId).concat(count + 1);
+  }
+  return readableId;
+}
+function hasDuplicateId(items, targetId) {
+  return items.some(function (item) {
+    return item._id === targetId;
+  });
+}
+
+/**
+* Generates a readable table column ID by counting existing columns
+*
+* @param {String} tableId - The ID of the table (used as prefix)
+* @param {Array} tableColumns - Array of table column objects
+* @returns {String} - An ID in the format "{tableId}Column{count+1}" (e.g. "table1Column1")
+*/
+function generateReadableTableColumnId(tableId, tableColumns, columnId) {
+  //Add logic that ensures that created Id is not a duplicate
+  if (!tableId) throw new Error('generateReadableTableColumnId: tableId is required');
+  if (!columnId) throw new Error('generateReadableTableColumnId: columnId is required');
+  if (!tableColumns || !Array.isArray(tableColumns)) {
+    console.warn('generateReadableTableColumnId: tableColumns parameter is missing or not an array');
+    return "".concat(tableId, "Column1");
+  }
+  var counts = {};
+  var generatedId = null;
+
+  //Filter out undefined and null values from tableColumns
+  var validColumns = tableColumns.filter(function (column) {
+    return column !== undefined && column !== null;
+  });
+  validColumns.forEach(function (col) {
+    var type = (col.type || 'unknown').toLowerCase();
+    counts[type] = (counts[type] || 0) + 1;
+    var readableId = "".concat(type).concat(counts[type]);
+    if (col._id === columnId) {
+      /**
+       * If the generatedReadableId is already present in the tableColumns,
+        * we need to increment the count until we find a unique ID.
+        * This ensures that the new column ID is unique.
+        */
+      while (hasDuplicateId(validColumns, readableId)) {
+        counts[type]++;
+        readableId = "".concat(type).concat(counts[type]);
+      }
+      generatedId = readableId;
+    }
+  });
+  return generatedId;
+}

package/dist/index.js

@@ -31,6 +31,18 @@ Object.defineProperty(exports, "generateObjectId", {
     return _generateObjectId["default"];
   }
 });
+Object.defineProperty(exports, "generateReadableId", {
+  enumerable: true,
+  get: function get() {
+    return _generateReadableId.generateReadableId;
+  }
+});
+Object.defineProperty(exports, "generateReadableTableColumnId", {
+  enumerable: true,
+  get: function get() {
+    return _generateReadableId.generateReadableTableColumnId;
+  }
+});
 exports.paginationHelper = exports.joyDocHelper = void 0;
 Object.defineProperty(exports, "reduxApiMiddleware", {
   enumerable: true,
@@ -45,6 +57,12 @@ Object.defineProperty(exports, "validateObjectId", {
     return _validateObjectId["default"];
   }
 });
+Object.defineProperty(exports, "validateReadableId", {
+  enumerable: true,
+  get: function get() {
+    return _validateReadableId["default"];
+  }
+});
 var tableHelper = _interopRequireWildcard(require("./tableHelper"));
 exports.tableHelper = tableHelper;
 var chartHelper = _interopRequireWildcard(require("./chartHelper"));
@@ -66,6 +84,8 @@ var _changedKeys = _interopRequireDefault(require("./changedKeys"));
 var _Roles = _interopRequireDefault(require("./constants/Roles"));
 var _generateObjectId = _interopRequireDefault(require("./generateObjectId"));
 var _validateObjectId = _interopRequireDefault(require("./validateObjectId"));
+var _generateReadableId = require("./generateReadableId");
+var _validateReadableId = _interopRequireDefault(require("./validateReadableId"));
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
 var _default = exports["default"] = {
   fileHelper: fileHelper,
@@ -81,5 +101,8 @@ var _default = exports["default"] = {
   roleHelper: roleHelper,
   Roles: _Roles["default"],
   generateObjectId: _generateObjectId["default"],
-  validateObjectId: _validateObjectId["default"]
+  validateObjectId: _validateObjectId["default"],
+  generateReadableId: _generateReadableId.generateReadableId,
+  generateReadableTableColumnId: _generateReadableId.generateReadableTableColumnId,
+  validateReadableId: _validateReadableId["default"]
 };

package/dist/joyDocHelper.js

@@ -9,6 +9,7 @@ var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _generateObjectId = _interopRequireDefault(require("./generateObjectId"));
 var _validateObjectId = _interopRequireDefault(require("./validateObjectId"));
+var _generateReadableId = require("./generateReadableId");
 var _PageLayoutModes = _interopRequireDefault(require("./constants/PageLayoutModes"));
 var _FieldPresentationModes = _interopRequireDefault(require("./constants/FieldPresentationModes"));
 var _DocumentTypes = _interopRequireDefault(require("./constants/DocumentTypes"));
@@ -18,6 +19,7 @@ var _FieldDisplayTypes = _interopRequireDefault(require("./constants/FieldDispla
 var _FileViews = _interopRequireDefault(require("./constants/FileViews"));
 var _FormStyleOptions = _interopRequireDefault(require("./constants/FormStyleOptions"));
 var _tableHelper = require("./tableHelper");
+var _validateReadableId = _interopRequireDefault(require("./validateReadableId"));
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 /**
@@ -81,10 +83,48 @@ var getDefaultJoyDoc = exports.getDefaultJoyDoc = function getDefaultJoyDoc() {
     identifier: "doc_".concat(id),
     name: 'New Doc',
     files: [getDefaultJoyDocFile(fileDefaults, pageDefaults)],
-    fields: []
+    fields: [],
+    formulas: []
   }, defaults);
 };
 
+/**
+ * If existing _id is a valid ObjectId, keep it
+ * Otherwise, generate a readable ID using the field type
+ * with as much data as we are given to determine the proper count.
+ *
+ * @param {String} existingId - The existing ID to check
+ * @param {String} type - The field type for generating readable IDs
+ * @param {Object} doc - The document context for readable ID generation
+ * @param {Object} generatedIdCounts - Object to track generated ID counts within this operation
+ * @returns {String} - Either the existing ObjectId or a new readable ID
+ */
+var getFieldId = function getFieldId(existingId, type, doc) {
+  // If existing ID is a valid ObjectId or readableId, maintain it
+  //Note: readableId validation is already done when it's being generated
+
+  if (existingId && (0, _validateObjectId["default"])(existingId)) {
+    return existingId;
+  }
+  if (existingId) return existingId;
+
+  // Otherwise, generate a readable ID
+  if (type) {
+    // Get the base count from existing fields
+    var baseCount = 0;
+    if (doc.fields) baseCount += (0, _generateReadableId.getFieldsCount)(doc.fields, type);
+
+    // Note: leaving for now until we allow targeting fieldPositions
+    //  if (doc.pages) baseCount += getFieldPositionsCount(getAllPages(doc), type);
+    //  if (doc.views && doc.views.length > 1) baseCount += getViewsFieldPositionsCount(getAllViews(doc), type);
+
+    return "".concat(type).concat(baseCount + 1);
+  }
+
+  // Fallback to ObjectId if we can't generate readable ID
+  return (0, _generateObjectId["default"])();
+};
+
 /**
  * Get Clean JoyDoc Format
  *
@@ -105,32 +145,52 @@ var getCleanedJoyDoc = exports.getCleanedJoyDoc = function getCleanedJoyDoc(doc)
     nextDoc = _removeOrphanedFields.nextDoc;
 
   /**
-   * Step 1.1: Replace doc._id if it is not valid
+   * Step 1.1: Replace doc._id if it is not valid (always use objectId for documents)
    */
   if (nextDoc._id && !(0, _validateObjectId["default"])(nextDoc._id)) nextDoc._id = (0, _generateObjectId["default"])();
+
+  /**
+   * Step 1.2: Clean field IDs using simplified approach
+   */
+  if (nextDoc.fields && nextDoc.fields.length > 0) {
+    nextDoc.fields = nextDoc.fields.map(function (field) {
+      var nextField = _objectSpread({}, field);
+
+      // Clean field _id using simplified approach
+      nextField._id = getFieldId(field._id, field.type, nextDoc);
+
+      // Clean table field rowOrder
+      if (field.type === _FieldTypes["default"].table) {
+        var cleanedRoworder = (0, _tableHelper.getCleanedRowOrder)(field.rowOrder, field.value);
+        nextField.rowOrder = cleanedRoworder;
+      }
+      return nextField;
+    });
+  }
   if (nextDoc.files && nextDoc.files.length > 0) {
     nextDoc.files = nextDoc.files.map(function (file) {
       var _nextFile$views;
       var nextFile = _objectSpread({}, file);
 
       /**
-      * Step 1.2: Replace files[x]._id if it is not valid
+      * Step 1.3: Replace files[x]._id if it is not a valid ObjectId or valid readable ID
       */
-      if (nextFile._id && !(0, _validateObjectId["default"])(nextFile._id)) nextFile._id = (0, _generateObjectId["default"])();
+
+      if (nextFile._id && !(0, _validateObjectId["default"])(nextFile._id) && !(0, _validateReadableId["default"])(nextFile._id)) nextFile._id = (0, _generateObjectId["default"])();
 
       /**
-      * Step 1.3: Replace page ids and field ids if they are not valid
+      * Step 1.4: Replace page ids and field ids if they are not valid
       */
-      nextFile.pages = getCleanedJoyDocPages(nextFile.pages);
+      nextFile.pages = getCleanedJoyDocPages(nextFile.pages, nextDoc);
       nextFile.pageOrder = cleanPageOrder(getPageOrder(nextFile.pageOrder, nextFile.pages), nextFile.pages);
 
       /**
-      * Step 1.4: Replace view page ids and field ids if they are not valid
+      * Step 1.5: Replace view page ids and field ids if they are not valid
       */
       if ((nextFile === null || nextFile === void 0 || (_nextFile$views = nextFile.views) === null || _nextFile$views === void 0 ? void 0 : _nextFile$views.length) > 0) {
         nextFile.views = nextFile.views.map(function (view) {
           var nextView = _objectSpread({}, view);
-          nextView.pages = getCleanedJoyDocPages(nextView.pages);
+          nextView.pages = getCleanedJoyDocPages(nextView.pages, nextDoc);
           nextView.pageOrder = cleanPageOrder(getPageOrder(nextView.pageOrder, nextView.pages), nextView.pages);
           return nextView;
         });
@@ -140,21 +200,6 @@ var getCleanedJoyDoc = exports.getCleanedJoyDoc = function getCleanedJoyDoc(doc)
   } else {
     nextDoc.files = [getDefaultJoyDocFile()];
   }
-
-  /**
-   * Logic below is used to clean the table field rowOrder by removing the
-   * deletedRowIds / duplicateRowIds from the rowOrder.
-   **/
-  if (nextDoc.fields && nextDoc.fields.length > 0) {
-    nextDoc.fields = nextDoc.fields.map(function (field) {
-      var nextField = _objectSpread({}, field);
-      if (field.type === _FieldTypes["default"].table) {
-        var cleanedRoworder = (0, _tableHelper.getCleanedRowOrder)(field.rowOrder, field.value);
-        nextField.rowOrder = cleanedRoworder;
-      }
-      return nextField;
-    });
-  }
   return nextDoc;
 };
 
@@ -168,12 +213,27 @@ var removeOrphanedFieldsFromJoydoc = exports.removeOrphanedFieldsFromJoydoc = fu
   var nextDoc = _objectSpread({}, doc);
   var associatedFieldIdLookup = {};
   nextDoc === null || nextDoc === void 0 || (_nextDoc$files = nextDoc.files) === null || _nextDoc$files === void 0 || _nextDoc$files.forEach(function (file) {
-    var _file$views;
+    var _file$header, _file$footer, _file$pages, _file$views;
+    /**
+     * Header 
+     */
+    if (file.header) (_file$header = file.header) === null || _file$header === void 0 || (_file$header = _file$header.fieldPositions) === null || _file$header === void 0 || _file$header.forEach(function (fieldPosition) {
+      return associatedFieldIdLookup[fieldPosition.field] = true;
+    });
+
+    /**
+     * Footer
+     */
+    if (file.footer) (_file$footer = file.footer) === null || _file$footer === void 0 || (_file$footer = _file$footer.fieldPositions) === null || _file$footer === void 0 || _file$footer.forEach(function (fieldPosition) {
+      return associatedFieldIdLookup[fieldPosition.field] = true;
+    });
+
     /**
      * Primary view
      */
-    file.pages.forEach(function (page) {
-      page === null || page === void 0 || page.fieldPositions.forEach(function (fieldPosition) {
+    (_file$pages = file.pages) === null || _file$pages === void 0 || _file$pages.forEach(function (page) {
+      var _page$fieldPositions;
+      page === null || page === void 0 || (_page$fieldPositions = page.fieldPositions) === null || _page$fieldPositions === void 0 || _page$fieldPositions.forEach(function (fieldPosition) {
         return associatedFieldIdLookup[fieldPosition.field] = true;
       });
     });
@@ -184,7 +244,8 @@ var removeOrphanedFieldsFromJoydoc = exports.removeOrphanedFieldsFromJoydoc = fu
     (_file$views = file.views) === null || _file$views === void 0 || _file$views.forEach(function (view) {
       var _view$pages;
       view === null || view === void 0 || (_view$pages = view.pages) === null || _view$pages === void 0 || _view$pages.forEach(function (page) {
-        page === null || page === void 0 || page.fieldPositions.forEach(function (fieldPosition) {
+        var _page$fieldPositions2;
+        page === null || page === void 0 || (_page$fieldPositions2 = page.fieldPositions) === null || _page$fieldPositions2 === void 0 || _page$fieldPositions2.forEach(function (fieldPosition) {
           return associatedFieldIdLookup[fieldPosition.field] = true;
         });
       });
@@ -215,25 +276,31 @@ var removeOrphanedFieldsFromJoydoc = exports.removeOrphanedFieldsFromJoydoc = fu
  * 1. Valid page inside document file.pages array.
  * 2. All id's in pages and fieldPositions are valid format
  *
- * @param {Object} doc
+ * @param {Array} pages
+ * @param {Object} doc - The full document (needed for readableId generation)
  * @returns {Object}
  */
-var getCleanedJoyDocPages = exports.getCleanedJoyDocPages = function getCleanedJoyDocPages(pages) {
+var getCleanedJoyDocPages = exports.getCleanedJoyDocPages = function getCleanedJoyDocPages(pages, doc) {
   if ((pages === null || pages === void 0 ? void 0 : pages.length) > 0) {
     return pages.map(function (page) {
       /**
-      * Step 1: Replace pages[x]._id if it is not valid
+      * Step 1: Replace pages[x]._id if it is not valid (always use objectId for pages)
       */
       var nextPage = _objectSpread({}, page);
-      if (nextPage._id && !(0, _validateObjectId["default"])(nextPage._id)) nextPage._id = (0, _generateObjectId["default"])();
+      if (nextPage._id && !(0, _validateObjectId["default"])(nextPage._id) && !(0, _validateReadableId["default"])(nextPage._id)) nextPage._id = (0, _generateObjectId["default"])();
       if (nextPage.fieldPositions && nextPage.fieldPositions.length > 0) {
         nextPage.fieldPositions = nextPage.fieldPositions.map(function (fieldPosition) {
           /**
           * Step 1.2: Replace fieldPosition _id and field reference if they are not valid
+          * Use simplified approach: respect ObjectIds, otherwise generate readable IDs
           */
           var nextFieldPosition = _objectSpread({}, fieldPosition);
-          if (nextFieldPosition._id && !(0, _validateObjectId["default"])(nextFieldPosition._id)) nextFieldPosition._id = (0, _generateObjectId["default"])();
-          if (nextFieldPosition.field && !(0, _validateObjectId["default"])(nextFieldPosition.field)) nextFieldPosition.field = (0, _generateObjectId["default"])();
+
+          // Clean fieldPosition _id
+          nextFieldPosition._id = nextFieldPosition._id && ((0, _validateObjectId["default"])(nextFieldPosition._id) || (0, _validateReadableId["default"])(nextFieldPosition._id)) ? nextFieldPosition._id : (0, _generateObjectId["default"])();
+
+          // Clean fieldPosition.field reference
+          nextFieldPosition.field = getFieldId(nextFieldPosition.field, fieldPosition.type, doc);
           return nextFieldPosition;
         });
       } else {
@@ -387,6 +454,7 @@ var getDocumentFromTemplate = exports.getDocumentFromTemplate = function getDocu
 var duplicateDocumentPage = exports.duplicateDocumentPage = function duplicateDocumentPage(doc, fileId, pageId) {
   var _nextDoc$fields;
   var pageDefaults = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  var config = arguments.length > 4 ? arguments[4] : undefined;
   var changelogInfo = {
     primaryPages: {
       targetIndex: 0,
@@ -395,6 +463,7 @@ var duplicateDocumentPage = exports.duplicateDocumentPage = function duplicateDo
     viewPages: [],
     fields: []
   };
+  var useReadableIds = (config === null || config === void 0 ? void 0 : config.useReadableIds) || false;
   var nextDoc = JSON.parse(JSON.stringify(doc));
   var fileIndex = nextDoc.files.findIndex(function (file) {
     return file._id === fileId;
@@ -402,7 +471,7 @@ var duplicateDocumentPage = exports.duplicateDocumentPage = function duplicateDo
   var newPageId = (0, _generateObjectId["default"])();
   var fieldLookup = {};
   (_nextDoc$fields = nextDoc.fields) === null || _nextDoc$fields === void 0 || _nextDoc$fields.forEach(function (field) {
-    if (field.file === fileId) fieldLookup[field._id] = field;
+    fieldLookup[field._id] = field;
   });
 
   /**
@@ -434,6 +503,7 @@ var duplicateDocumentPage = exports.duplicateDocumentPage = function duplicateDo
   var newFieldsLookupByOldId = {};
   var duplicatedFields = [];
   fieldIdsToDuplicate.forEach(function (fieldId) {
+    var _nextDoc$files$fileIn, _nextDoc$files$fileIn2;
     /**
      * Why do we check if a new field has already been created?
      *
@@ -444,9 +514,22 @@ var duplicateDocumentPage = exports.duplicateDocumentPage = function duplicateDo
      */
     if (newFieldsLookupByOldId[fieldId]) return;
     var field = fieldLookup[fieldId];
+
+    // Skip if field not found in lookup
+    if (!field) return;
+
+    // Generate readable ID using current fields plus already duplicated fields
+    var allFields = [].concat((0, _toConsumableArray2["default"])(nextDoc.fields), (0, _toConsumableArray2["default"])(duplicatedFields));
     var duplicateField = _objectSpread(_objectSpread({}, field), {}, {
-      _id: (0, _generateObjectId["default"])()
+      _id: useReadableIds ? (0, _generateReadableId.generateReadableId)({
+        fields: allFields,
+        pages: (_nextDoc$files$fileIn = nextDoc.files[fileIndex]) === null || _nextDoc$files$fileIn === void 0 ? void 0 : _nextDoc$files$fileIn.pages,
+        views: (_nextDoc$files$fileIn2 = nextDoc.files[fileIndex]) === null || _nextDoc$files$fileIn2 === void 0 ? void 0 : _nextDoc$files$fileIn2.views
+      }, field.type) : (0, _generateObjectId["default"])()
     });
+
+    // Remove formulas property when duplicating
+    delete duplicateField.formulas;
     duplicatedFields.push(duplicateField);
 
     /**

package/dist/tableHelper.js

@@ -256,14 +256,10 @@ var handleMoveColumnRight = exports.handleMoveColumnRight = function handleMoveC
  * @return {Object}
  */
 var getDefaultColumnOption = exports.getDefaultColumnOption = function getDefaultColumnOption(value) {
-  var color = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
   return {
     _id: (0, _generateObjectId["default"])(),
     value: value || 'Option',
-    deleted: false,
-    styles: {
-      backgroundColor: color
-    }
+    deleted: false
   };
 };
 
@@ -422,7 +418,7 @@ var getDefaultDropdownColumn = exports.getDefaultDropdownColumn = function getDe
  */
 var getDefaultMultiSelectColumn = exports.getDefaultMultiSelectColumn = function getDefaultMultiSelectColumn() {
   var defaults = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var options = defaults.options || [getDefaultColumnOption('Option 1', '#f0f0f0'), getDefaultColumnOption('Option 2', '#f0f0f0'), getDefaultColumnOption('Option 3', '#f0f0f0')];
+  var options = defaults.options || [getDefaultColumnOption('Option 1'), getDefaultColumnOption('Option 2'), getDefaultColumnOption('Option 3')];
   return _objectSpread({
     _id: (0, _generateObjectId["default"])(),
     type: _FieldTableColumnTypes["default"].multiSelect,
@@ -761,6 +757,7 @@ var generateTableLookup = exports.generateTableLookup = function generateTableLo
     if (!(row !== null && row !== void 0 && row.cells)) console.warn("Missing 'cells' in row: ".concat(row._id));
     tableColumns.forEach(function (column) {
       if (!column.operand) return;
+      // eslint-disable-next-line no-console
       if (!row) console.warn("Row via column ".concat(column === null || column === void 0 ? void 0 : column._id, " is undefined."));
       var cellKey = "".concat(column.operand).concat(rowIndex + 1);
       var cellRawValue = row && row !== null && row !== void 0 && row.cells && row.cells[column._id] ? row.cells[column._id] : undefined;

package/dist/validateReadableId.js

@@ -0,0 +1,192 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _fieldHelper = require("./fieldHelper");
+var _FieldTypes = _interopRequireDefault(require("./constants/FieldTypes"));
+// Check if value follows a valid readableId pattern for use in JavaScript formulas
+// Note to test this please run npm test src/validateReadableId.test.js
+
+// JavaScript reserved words and future reserved words
+var JS_RESERVED_WORDS = new Set([
+// ES6 Keywords
+'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', 'default', 'delete', 'do', 'else', 'export', 'extends', 'finally', 'for', 'function', 'if', 'import', 'in', 'instanceof', 'new', 'return', 'super', 'switch', 'this', 'throw', 'try', 'typeof', 'var', 'void', 'while', 'with', 'yield',
+// ES6 Future Reserved Words
+'enum', 'implements', 'interface', 'let', 'package', 'private', 'protected', 'public', 'static', 'await', 'async',
+// Literals
+'null', 'true', 'false', 'undefined', 'NaN', 'Infinity']);
+
+// Common Excel function names (subset of most commonly used)
+var EXCEL_FUNCTIONS = new Set([
+// Math functions
+'sum', 'average', 'count', 'max', 'min', 'round', 'roundup', 'rounddown', 'ceiling', 'floor', 'abs', 'sign', 'sqrt', 'power', 'exp', 'ln', 'log', 'log10', 'mod', 'quotient', 'product', 'sumif', 'countif', 'averageif', 'sumifs', 'countifs', 'averageifs', 'maxifs', 'minifs', 'subtotal', 'aggregate', 'rand', 'randbetween', 'pi', 'degrees', 'radians', 'fact', 'combin', 'permut', 'gcd', 'lcm', 'mround', 'multinomial', 'seriessum', 'sqrtpi', 'sumproduct', 'sumsq', 'sumx2my2', 'sumx2py2', 'sumxmy2',
+// Text functions
+'concatenate', 'concat', 'left', 'right', 'mid', 'len', 'lower', 'upper', 'proper', 'trim', 'substitute', 'replace', 'find', 'search', 'text', 'value', 'clean', 'code', 'char', 'exact', 'rept', 'fixed', 'dollar', 'textjoin', 'textbefore', 'textafter', 'textsplit', 'unichar', 'unicode',
+// Date functions
+'date', 'today', 'now', 'year', 'month', 'day', 'hour', 'minute', 'second', 'weekday', 'weeknum', 'datedif', 'datevalue', 'timevalue', 'days', 'days360', 'edate', 'eomonth', 'networkdays', 'workday', 'isoweeknum', 'yearfrac',
+// Logical functions
+'if', 'and', 'or', 'not', 'xor', 'iferror', 'ifna', 'ifs', 'switch', 'true', 'false',
+// Lookup functions
+'vlookup', 'hlookup', 'lookup', 'match', 'index', 'choose', 'offset', 'indirect', 'row', 'column', 'rows', 'columns', 'transpose', 'unique', 'filter', 'sort', 'sortby', 'xlookup', 'xmatch',
+// Statistical functions
+'median', 'mode', 'stdev', 'var', 'correl', 'forecast', 'trend', 'growth', 'linest', 'logest', 'slope', 'intercept', 'pearson', 'rsq', 'steyx', 'kurt', 'skew', 'rank', 'percentile', 'quartile', 'percentrank', 'large', 'small', 'standardize', 'ztest', 'ttest', 'ftest', 'chisq', 'norm', 'lognorm', 'expon', 'gamma', 'beta', 'binom', 'poisson', 'weibull', 'hypgeom', 'negbinom', 'geomean', 'harmean', 'devsq', 'avedev', 'confidence',
+// Financial functions
+'pv', 'fv', 'pmt', 'rate', 'nper', 'irr', 'npv', 'mirr', 'xirr', 'xnpv', 'sln', 'syd', 'ddb', 'vdb', 'ipmt', 'ppmt', 'cumipmt', 'cumprinc', 'price', 'yield', 'duration', 'mduration', 'disc', 'intrate', 'received', 'accrint', 'accrintm', 'coupdaybs', 'coupdays', 'coupdaysnc', 'coupncd', 'coupnum', 'couppcd', 'tbilleq', 'tbillprice', 'tbillyield',
+// Information functions
+'isblank', 'iserror', 'isna', 'isnumber', 'istext', 'islogical', 'isref', 'isformula', 'cell', 'info', 'type', 'na', 'error', 'iseven', 'isodd', 'n', 'sheet', 'sheets',
+// Database functions
+'dsum', 'daverage', 'dcount', 'dcounta', 'dmax', 'dmin', 'dproduct', 'dstdev', 'dstdevp', 'dvar', 'dvarp', 'dget',
+// Engineering functions
+'convert', 'bin2dec', 'bin2hex', 'bin2oct', 'dec2bin', 'dec2hex', 'dec2oct', 'hex2bin', 'hex2dec', 'hex2oct', 'oct2bin', 'oct2dec', 'oct2hex', 'complex', 'imabs', 'imaginary', 'imargument', 'imconjugate', 'imcos', 'imdiv', 'imexp', 'imln', 'imlog10', 'imlog2', 'impower', 'improduct', 'imreal', 'imsin', 'imsqrt', 'imsub', 'imsum', 'delta', 'erf', 'erfc', 'gestep', 'besseli', 'besselj', 'besselk', 'bessely',
+// Array functions (newer)
+'sequence', 'randarray', 'tocol', 'torow', 'wrapcols', 'wraprows', 'take', 'drop', 'expand', 'choosecols', 'chooserows', 'vstack', 'hstack']);
+
+// JavaScript built-in object methods and properties
+var JS_BUILTIN_NAMES = new Set([
+// Number methods
+'parseFloat', 'parseInt', 'isFinite', 'isInteger', 'isNaN', 'isSafeInteger', 'toExponential', 'toFixed', 'toPrecision', 'toString', 'valueOf',
+// String methods
+'charAt', 'charCodeAt', 'codePointAt', 'concat', 'endsWith', 'includes', 'indexOf', 'lastIndexOf', 'localeCompare', 'match', 'matchAll', 'normalize', 'padEnd', 'padStart', 'repeat', 'replace', 'replaceAll', 'search', 'slice', 'split', 'startsWith', 'substring', 'toLocaleLowerCase', 'toLocaleUpperCase', 'toLowerCase', 'toUpperCase', 'trim', 'trimEnd', 'trimStart', 'length',
+// Array methods
+'from', 'isArray', 'of', 'concat', 'copyWithin', 'entries', 'every', 'fill', 'filter', 'find', 'findIndex', 'flat', 'flatMap', 'forEach', 'includes', 'indexOf', 'join', 'keys', 'lastIndexOf', 'map', 'pop', 'push', 'reduce', 'reduceRight', 'reverse', 'shift', 'slice', 'some', 'sort', 'splice', 'unshift', 'values',
+// Object methods
+'assign', 'create', 'defineProperties', 'defineProperty', 'entries', 'freeze', 'fromEntries', 'getOwnPropertyDescriptor', 'getOwnPropertyDescriptors', 'getOwnPropertyNames', 'getOwnPropertySymbols', 'getPrototypeOf', 'hasOwnProperty', 'is', 'isExtensible', 'isFrozen', 'isSealed', 'keys', 'preventExtensions', 'propertyIsEnumerable', 'seal', 'setPrototypeOf', 'values',
+// Global properties
+'constructor', 'prototype', '__proto__']);
+
+// Custom reserved words from the spec
+var CUSTOM_RESERVED_WORDS = new Set([
+// Booleans
+'checked', 'unchecked', 'enabled', 'disabled', 'on', 'off', 'yes', 'no',
+// Self referencing
+'current', 'self'
+
+// Note: 'index' is already in EXCEL_FUNCTIONS, so it's not included here to avoid duplicate warnings
+]);
+
+// Common JoyDoc properties (based on the codebase analysis)
+var JOYDOC_PROPERTIES = new Set(['_id', 'identifier', 'name', 'type', 'files', 'fields', 'pages', 'pageOrder', 'fieldPositions', 'value', 'file', 'field', 'views', 'source', 'template', 'createdOn', 'updatedOn', 'deleted', 'width', 'height', 'rowHeight', 'cols', 'layout', 'presentation', 'padding', 'styles', 'margin', 'rowOrder', 'columnOrder', 'columns', 'rows', 'options', 'required', 'readOnly', 'disabled', 'hidden', 'validation', 'formula', 'format', 'placeholder', 'defaultValue', 'minValue', 'maxValue', 'minLength', 'maxLength', 'pattern', 'title', 'description', 'displayType', 'x', 'y', 'w', 'h']);
+
+// Field types from FieldTypes.js
+// Note: These are removed from validation because generateReadableId uses them as prefixes
+// e.g., "text1", "number1", etc. The bare field type names should be allowed.
+
+/**
+ * Validates if a string can be used as a JavaScript identifier
+ * and doesn't conflict with reserved words
+ *
+ * @param {*} readableId - The ID to validate
+ * @returns {boolean} - True if valid, false otherwise
+ */
+var _default = exports["default"] = function _default(readableId, fields, tableColumns, fieldId) {
+  // Must be a non-empty string
+  if (typeof readableId !== 'string' || readableId.length === 0) {
+    console.warn("validateReadableId: Invalid input - expected non-empty string, got ".concat(typeof readableId === 'string' ? 'empty string' : (0, _typeof2["default"])(readableId)));
+    return false;
+  }
+
+  // Must not be parseable as a number (but check for Infinity as a special case)
+  if (readableId !== 'Infinity' && !isNaN(readableId)) {
+    console.warn("validateReadableId: \"".concat(readableId, "\" is invalid - cannot be a numeric value"));
+    return false;
+  }
+
+  // Must match the pattern: start with letter or underscore, followed by letters, numbers, or underscores
+  var identifierPattern = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+  if (!identifierPattern.test(readableId)) {
+    if (/^[0-9]/.test(readableId)) {
+      console.warn("validateReadableId: \"".concat(readableId, "\" is invalid - identifiers cannot start with a number"));
+    } else if (/[^a-zA-Z0-9_]/.test(readableId)) {
+      var invalidChars = readableId.match(/[^a-zA-Z0-9_]/g);
+      console.warn("validateReadableId: \"".concat(readableId, "\" is invalid - contains invalid characters: ").concat((0, _toConsumableArray2["default"])(new Set(invalidChars)).join(', ')));
+    } else {
+      console.warn("validateReadableId: \"".concat(readableId, "\" is invalid - must start with a letter or underscore and contain only letters, numbers, and underscores"));
+    }
+    return false;
+  }
+
+  // Convert to lowercase for case-insensitive checking
+  var lowercaseId = readableId.toLowerCase();
+
+  // Check in order of precedence:
+
+  // 1. JavaScript reserved words (highest priority)
+  if (JS_RESERVED_WORDS.has(readableId) || JS_RESERVED_WORDS.has(lowercaseId)) {
+    console.warn("validateReadableId: \"".concat(readableId, "\" is invalid - it's a JavaScript reserved word"));
+    return false;
+  }
+
+  // 2. JavaScript built-in names
+  if (JS_BUILTIN_NAMES.has(readableId)) {
+    console.warn("validateReadableId: \"".concat(readableId, "\" is invalid - it's a JavaScript built-in method or property"));
+    return false;
+  }
+
+  // 3. JoyDoc properties
+  if (JOYDOC_PROPERTIES.has(readableId)) {
+    console.warn("validateReadableId: \"".concat(readableId, "\" is invalid - it's a JoyDoc property name"));
+    return false;
+  }
+
+  // 4. Custom reserved words (lower priority than JoyDoc since 'index' can be more specific)
+  if (CUSTOM_RESERVED_WORDS.has(lowercaseId)) {
+    console.warn("validateReadableId: \"".concat(readableId, "\" is invalid - it's a reserved word (boolean/self-referencing term)"));
+    return false;
+  }
+
+  // 5. Excel functions (lowest priority since it has many general terms)
+  if (EXCEL_FUNCTIONS.has(lowercaseId)) {
+    console.warn("validateReadableId: \"".concat(readableId, "\" is invalid - it's an Excel function name"));
+    return false;
+  }
+
+  //6. Check for duplicates in readableIds
+
+  if (Array.isArray(fields)) {
+    //DuplicateId check for fieldIds
+    var duplicateField = fields.find(function (field) {
+      return field._id === readableId;
+    });
+    if (duplicateField) {
+      console.warn("validateReadableId: \"".concat(readableId, "\" is invalid - it already exists in fields"));
+      return false;
+    }
+
+    /**
+     * DuplicateId check for nested tables of collection fields
+     * When readableIds for nestedTables are passed in, we need the fieldId to retrieve the collection fields that houses the nestedTable
+     */
+    if (fieldId) {
+      var targetField = fields.find(function (field) {
+        return field._id === fieldId;
+      });
+      if ((targetField === null || targetField === void 0 ? void 0 : targetField.type) === _FieldTypes["default"].collection) {
+        var flattenedSchema = (0, _fieldHelper.flattenSchemaTree)(targetField.schema);
+        var readableIdExists = flattenedSchema.some(function (schema) {
+          return schema.id === readableId;
+        });
+        if (readableIdExists) {
+          console.warn("validateReadableId: \"".concat(readableId, "\" is invalid - it already exists in fields"));
+          return false;
+        }
+      }
+    }
+  }
+
+  //DuplicateId check for columnIds
+  if (tableColumns && Array.isArray(tableColumns)) {
+    var duplicateColumnId = tableColumns.find(function (column) {
+      return column._id === readableId;
+    });
+    if (duplicateColumnId) {
+      console.warn("validateReadableId: \"".concat(readableId, "\" is invalid - it already exists in fields"));
+      return false;
+    }
+  }
+  return true;
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@builttocreate/engine-utils",
-  "version": "2.10.1",
-  "description": "Utility library for common logic shared across web and mobile",
+  "version": "2.11.0-1828.beta.0",
+  "description": "Utility library for   common logic shared across web and mobile",
   "main": "dist/index.js",
   "files": [
     "dist/**/*",
@@ -30,7 +30,7 @@
   },
   "homepage": "https://github.com/zionlabs/engine-utils#readme",
   "devDependencies": {
-    "@babel/cli": "^7.12.10",
+    "@babel/cli": "^7.27.2",
     "@babel/core": "^7.12.10",
     "@babel/plugin-proposal-class-properties": "^7.12.1",
     "@babel/plugin-transform-regenerator": "^7.12.1",
@@ -48,6 +48,7 @@
   },
   "dependencies": {
     "@babel/polyfill": "^7.12.1",
+    "@builttocreate/engine-utils": "2.11.0-beta.7",
     "@builttocreate/hot-formula-parser": "^5.0.1",
     "cross-env": "^7.0.3",
     "moment": "^2.29.4"