@teselagen/ui 0.3.77 → 0.3.79

package/src/DataTable/index.js

@@ -29,8 +29,7 @@ import {
   times,
   some,
   isFunction,
-  every,
-  uniq
+  every
 } from "lodash";
 import joinUrl from "url-join";
 
@@ -45,8 +44,7 @@ import {
   Popover,
   Intent,
   Callout,
-  Tooltip,
-  Divider
+  Tooltip
 } from "@blueprintjs/core";
 import classNames from "classnames";
 import scrollIntoView from "dom-scroll-into-view";
@@ -59,6 +57,7 @@ import ReactMarkdown from "react-markdown";
 import immer, { produceWithPatches, enablePatches, applyPatches } from "immer";
 import papaparse from "papaparse";
 import remarkGfm from "remark-gfm";
+
 import TgSelect from "../TgSelect";
 import { withHotkeys } from "../utils/hotkeyUtils";
 import InfoHelper from "../InfoHelper";
@@ -75,6 +74,7 @@ import SearchBar from "./SearchBar";
 import DisplayOptions from "./DisplayOptions";
 import DisabledLoadingComponent from "./DisabledLoadingComponent";
 import SortableColumns from "./SortableColumns";
+import computePresets from "./utils/computePresets";
 import dataTableEnhancer from "./dataTableEnhancer";
 import defaultProps from "./defaultProps";
 
@@ -86,16 +86,10 @@ import { CellDragHandle } from "./CellDragHandle";
 import { nanoid } from "nanoid";
 import { SwitchField } from "../FormComponents";
 import { validateTableWideErrors } from "./validateTableWideErrors";
-import {
-  editCellHelper,
-  getCellAlphaNumHelper,
-  getColLetFromIndex,
-  replaceFormulaRanges
-} from "./editCellHelper";
+import { editCellHelper } from "./editCellHelper";
 import { getCellVal } from "./getCellVal";
 import { getVals } from "./getVals";
 import { throwFormError } from "../throwFormError";
-import showConfirmationDialog from "../showConfirmationDialog";
 enablePatches();
 
 const PRIMARY_SELECTED_VAL = "main_cell";
@@ -227,10 +221,8 @@ class DataTable extends React.Component {
           reduxFormEntitiesUndoRedoStack.currentVersion
         ].inversePatches
       );
-      this.buildDepGraph(nextState);
       const { newEnts, validationErrors } =
         this.formatAndValidateEntities(nextState);
-
       change("reduxFormEntities", newEnts);
       this.updateValidation(newEnts, validationErrors);
       change("reduxFormEntitiesUndoRedoStack", {
@@ -253,10 +245,8 @@ class DataTable extends React.Component {
         entities,
         reduxFormEntitiesUndoRedoStack[nextV].patches
       );
-      this.buildDepGraph(nextState);
       const { newEnts, validationErrors } =
         this.formatAndValidateEntities(nextState);
-
       change("reduxFormEntities", newEnts);
       this.updateValidation(newEnts, validationErrors);
       change("reduxFormEntitiesUndoRedoStack", {
@@ -409,16 +399,15 @@ class DataTable extends React.Component {
   };
   formatAndValidateEntities = (
     entities,
-    { useDefaultValues, indexToStartAt, depGraphToUse } = {}
+    { useDefaultValues, indexToStartAt } = {}
   ) => {
-    const { schema, allowFormulas } = this.props;
+    const { schema } = this.props;
     const editableFields = schema.fields.filter(f => !f.isNotEditable);
     const validationErrors = {};
-    const updateGroup = {};
-    const depGraph = depGraphToUse || this.depGraph;
+
     const newEnts = immer(entities, entities => {
       entities.forEach((e, index) => {
-        editableFields.forEach((columnSchema, colIndex) => {
+        editableFields.forEach(columnSchema => {
           if (useDefaultValues) {
             if (e[columnSchema.path] === undefined) {
               if (isFunction(columnSchema.defaultValue)) {
@@ -430,18 +419,15 @@ class DataTable extends React.Component {
             }
           }
           //mutative
-          const { errors } = editCellHelper({
-            _cellAlphaNum: getCellAlphaNumHelper(colIndex, index),
-            allowFormulas,
-            updateGroup,
-            depGraph,
-            entities,
+          const { error } = editCellHelper({
             entity: e,
-            schema,
             columnSchema,
             newVal: e[columnSchema.path]
           });
-          Object.assign(validationErrors, errors);
+          if (error) {
+            const rowId = getIdOrCodeOrIndex(e, index);
+            validationErrors[`${rowId}:${columnSchema.path}`] = error;
+          }
         });
       });
     });
@@ -450,43 +436,6 @@ class DataTable extends React.Component {
       validationErrors
     };
   };
-  buildDepGraph = ents => {
-    const { schema, allowFormulas } = this.props;
-    if (!allowFormulas) return;
-    const depGraph = {};
-    schema.fields.forEach((field, fi) => {
-      if (field.allowFormulas) {
-        ents.forEach((ent, i) => {
-          const val = ent[field.path];
-          const formula =
-            val &&
-            (val.formula || (typeof val === "string" && val[0] === "=" && val));
-          if (formula) {
-            const { replacedFormula } = replaceFormulaRanges({
-              formula,
-              entities: ents,
-              schema
-            });
-            const deps = replacedFormula.match(/[A-Z]+[0-9]+/gi);
-            if (deps) {
-              deps.forEach(_dep => {
-                const dep = _dep.toUpperCase();
-
-                if (!depGraph[dep]) {
-                  depGraph[dep] = [];
-                }
-                // convert the field index to a letter
-                const fieldLetter = getColLetFromIndex(fi);
-                depGraph[dep].push(`${fieldLetter}${i + 1}`);
-              });
-            }
-          }
-        });
-      }
-    });
-    this.depGraph = depGraph;
-  };
-
   formatAndValidateTableInitial = () => {
     const {
       _origEntities,
@@ -495,11 +444,10 @@ class DataTable extends React.Component {
       change,
       reduxFormCellValidation
     } = this.props;
-    const ents =
+    const { newEnts, validationErrors } = this.formatAndValidateEntities(
       initialEntities ||
-      (entities && entities.length ? entities : _origEntities);
-    this.buildDepGraph(ents);
-    const { newEnts, validationErrors } = this.formatAndValidateEntities(ents);
+        (entities && entities.length ? entities : _origEntities)
+    );
     change("reduxFormEntities", newEnts);
     const toKeep = {};
     //on the initial load we want to keep any async table wide errors
@@ -523,7 +471,7 @@ class DataTable extends React.Component {
       setShowForcedHidden
     } = this.props;
     isCellEditable && this.formatAndValidateTableInitial();
-    this.updateFromProps({}, this.props);
+    this.updateFromProps({}, computePresets(this.props));
     document.addEventListener("paste", this.handlePaste);
 
     if (!entities.length && !isLoading && !showForcedHiddenColumns) {
@@ -551,7 +499,7 @@ class DataTable extends React.Component {
     //   }
     // }
 
-    this.updateFromProps(oldProps, this.props);
+    this.updateFromProps(computePresets(oldProps), computePresets(this.props));
 
     // comment in to test what is causing re-render
     // Object.entries(this.props).forEach(
@@ -567,7 +515,7 @@ class DataTable extends React.Component {
   handleRowMove = (type, shiftHeld) => e => {
     e.preventDefault();
     e.stopPropagation();
-    const props = this.props;
+    const props = computePresets(this.props);
     const {
       noSelect,
       entities,
@@ -637,7 +585,9 @@ class DataTable extends React.Component {
     });
   };
   handleCopyHotkey = e => {
-    const { isCellEditable, reduxFormSelectedEntityIdMap } = this.props;
+    const { isCellEditable, reduxFormSelectedEntityIdMap } = computePresets(
+      this.props
+    );
 
     if (isCellEditable) {
       this.handleCopySelectedCells(e);
@@ -665,10 +615,9 @@ class DataTable extends React.Component {
       reduxFormCellValidation,
       change,
       schema,
-      entities,
-      allowFormulas
-    } = this.props;
-    const updateGroup = {};
+      entities
+    } = computePresets(this.props);
+
     if (isCellEditable) {
       if (isEmpty(reduxFormSelectedCells)) return;
       try {
@@ -681,8 +630,6 @@ class DataTable extends React.Component {
           toPaste = e.clipboardData.getData("text/plain");
         }
         const jsonToPaste = e.clipboardData.getData("application/json");
-        let hasReplace = false;
-
         try {
           const pastedJson = [];
           JSON.parse(jsonToPaste).forEach(row => {
@@ -703,14 +650,6 @@ class DataTable extends React.Component {
             pasteData = pasteData.slice(1);
           }
         } catch (e) {
-          if (toPaste.includes("=") && allowFormulas) {
-            // replace any commas inside brackets with %%comma%% so that we can parse it out later
-            toPaste = toPaste.replace(/\(([^)]+)\)/g, match => {
-              hasReplace = true;
-              const toRet = match.replace(/,/g, "%%comma%%");
-              return toRet;
-            });
-          }
           if (toPaste.includes(",")) {
             //try papaparsing it out as a csv if it contains commas
             try {
@@ -726,19 +665,11 @@ class DataTable extends React.Component {
           }
         }
         pasteData = pasteData.length ? pasteData : defaultParsePaste(toPaste);
-        if (hasReplace) {
-          // put the commas back in
 
-          pasteData = pasteData.map(row => {
-            return row.map(cell => {
-              return cell.replace(/%%comma%%/g, ",");
-            });
-          });
-        }
         if (!pasteData || !pasteData.length) return;
 
         if (pasteData.length === 1 && pasteData[0].length === 1) {
-          let newCellValidate = {
+          const newCellValidate = {
             ...reduxFormCellValidation
           };
           // single paste value, fill all cells with value
@@ -750,29 +681,25 @@ class DataTable extends React.Component {
 
               const entity = entityIdToEntity[rowId].e;
               delete entity._isClean;
-              const { errors } = editCellHelper({
-                allowFormulas,
-                updateGroup,
-                depGraph: this.depGraph,
-                entities,
+              const { error } = editCellHelper({
                 entity,
                 path,
                 schema,
                 newVal: formatPasteData({ newVal, path, schema })
               });
-              newCellValidate = {
-                ...newCellValidate,
-                ...errors
-              };
+              if (error) {
+                newCellValidate[cellId] = error;
+              } else {
+                delete newCellValidate[cellId];
+              }
             });
-            this.buildDepGraph(entities);
             this.updateValidation(entities, newCellValidate);
           });
         } else {
           // handle paste in same format
           const primarySelectedCell = this.getPrimarySelectedCellId();
           if (primarySelectedCell) {
-            let newCellValidate = {
+            const newCellValidate = {
               ...reduxFormCellValidation
             };
 
@@ -801,11 +728,7 @@ class DataTable extends React.Component {
                       delete entity._isClean;
                       const path = indexToPath[cellIndexToChange];
                       if (path) {
-                        const { errors } = editCellHelper({
-                          allowFormulas,
-                          updateGroup,
-                          depGraph: this.depGraph,
-                          entities,
+                        const { error } = editCellHelper({
                           entity,
                           path,
                           schema,
@@ -819,16 +742,16 @@ class DataTable extends React.Component {
                         if (!newSelectedCells[cellId]) {
                           newSelectedCells[cellId] = true;
                         }
-                        newCellValidate = {
-                          ...newCellValidate,
-                          ...errors
-                        };
+                        if (error) {
+                          newCellValidate[cellId] = error;
+                        } else {
+                          delete newCellValidate[cellId];
+                        }
                       }
                     }
                   }
                 });
               });
-              this.buildDepGraph(entities);
               this.updateValidation(entities, newCellValidate);
             });
             change("reduxFormSelectedCells", newSelectedCells);
@@ -847,7 +770,7 @@ class DataTable extends React.Component {
       isSingleSelect,
       isCellEditable,
       schema
-    } = this.props;
+    } = computePresets(this.props);
     if (isSingleSelect) return;
     e.preventDefault();
 
@@ -873,17 +796,17 @@ class DataTable extends React.Component {
       finalizeSelection({
         idMap: newIdMap,
         entities,
-        props: this.props
+        props: computePresets(this.props)
       });
     }
   };
   updateValidationHelper = () => {
-    const { entities, reduxFormCellValidation } = this.props;
+    const { entities, reduxFormCellValidation } = computePresets(this.props);
     this.updateValidation(entities, reduxFormCellValidation);
   };
 
   updateValidation = (entities, newCellValidate) => {
-    const { change, schema } = this.props;
+    const { change, schema } = computePresets(this.props);
     const tableWideErr = validateTableWideErrors({
       entities,
       schema,
@@ -898,15 +821,12 @@ class DataTable extends React.Component {
       reduxFormSelectedCells,
       reduxFormCellValidation,
       schema,
-      entities,
-      allowFormulas
-    } = this.props;
-    let newCellValidate = {
+      entities
+    } = computePresets(this.props);
+    const newCellValidate = {
       ...reduxFormCellValidation
     };
     if (isEmpty(reduxFormSelectedCells)) return;
-    const updateGroup = {};
-
     const rowIds = [];
     this.updateEntitiesHelper(entities, entities => {
       const entityIdToEntity = getEntityIdToEntity(entities);
@@ -915,22 +835,18 @@ class DataTable extends React.Component {
         rowIds.push(rowId);
         const entity = entityIdToEntity[rowId].e;
         delete entity._isClean;
-        const { errors } = editCellHelper({
-          allowFormulas,
-          updateGroup,
-          depGraph: this.depGraph,
-          entities,
+        const { error } = editCellHelper({
           entity,
           path,
           schema,
           newVal: ""
         });
-        newCellValidate = {
-          ...newCellValidate,
-          ...errors
-        };
+        if (error) {
+          newCellValidate[cellId] = error;
+        } else {
+          delete newCellValidate[cellId];
+        }
       });
-      this.buildDepGraph(entities);
       this.updateValidation(entities, newCellValidate);
     });
   };
@@ -940,17 +856,16 @@ class DataTable extends React.Component {
     this.handleCopyHotkey(e);
   };
 
-  getCellCopyText = (cellWrapper, isFormulaCopy) => {
-    // note - all copy/download functions use this helper to get the text to copy
+  getCellCopyText = cellWrapper => {
     const text = cellWrapper && cellWrapper.getAttribute("data-copy-text");
-    const formula = cellWrapper && cellWrapper.getAttribute("data-formula");
     const jsonText = cellWrapper && cellWrapper.getAttribute("data-copy-json");
+
     const textContent = text || cellWrapper.textContent || "";
-    return [(isFormulaCopy && formula) || textContent, jsonText];
+    return [textContent, jsonText];
   };
 
-  handleCopyColumn = ({ e, cellWrapper, selectedRecords, opts }) => {
-    const specificColumn = cellWrapper.getAttribute("data-column");
+  handleCopyColumn = (e, cellWrapper, selectedRecords) => {
+    const specificColumn = cellWrapper.getAttribute("data-test");
     let rowElsToCopy = getAllRows(e);
     if (!rowElsToCopy) return;
     if (selectedRecords) {
@@ -963,21 +878,17 @@ class DataTable extends React.Component {
     if (!rowElsToCopy) return;
     this.handleCopyRows(rowElsToCopy, {
       specificColumn,
-      onFinishMsg: "Column Copied",
-      ...opts
+      onFinishMsg: "Column Copied"
     });
   };
   handleCopyRows = (
     rowElsToCopy,
-    { specificColumn, onFinishMsg, isDownload, isFormulaCopy } = {}
+    { specificColumn, onFinishMsg, isDownload } = {}
   ) => {
     let textToCopy = [];
     const jsonToCopy = [];
     forEach(rowElsToCopy, rowEl => {
-      const [t, j] = this.getRowCopyText(rowEl, {
-        specificColumn,
-        isFormulaCopy
-      });
+      const [t, j] = this.getRowCopyText(rowEl, { specificColumn });
       textToCopy.push(t);
       jsonToCopy.push(j);
     });
@@ -998,7 +909,6 @@ class DataTable extends React.Component {
       this.props;
     const [nextState, patches, inversePatches] = produceWithPatches(ents, fn);
     if (!inversePatches.length) return;
-
     const thatNewNew = [...nextState];
     thatNewNew.isDirty = true;
     change("reduxFormEntities", thatNewNew);
@@ -1014,7 +924,7 @@ class DataTable extends React.Component {
     });
   };
 
-  getRowCopyText = (rowEl, { specificColumn, isFormulaCopy } = {}) => {
+  getRowCopyText = (rowEl, { specificColumn } = {}) => {
     //takes in a row element
     if (!rowEl) return [];
     const textContent = [];
@@ -1028,11 +938,11 @@ class DataTable extends React.Component {
       }
       if (
         specificColumn &&
-        cellChild.getAttribute("data-column") !== specificColumn
+        cellChild.getAttribute("data-test") !== specificColumn
       ) {
         return [];
       }
-      const [t, j] = this.getCellCopyText(cellChild, isFormulaCopy);
+      const [t, j] = this.getCellCopyText(cellChild);
       textContent.push(t);
       jsonText.push(j);
     });
@@ -1041,15 +951,10 @@ class DataTable extends React.Component {
   };
 
   handleCopyHelper = (stringToCopy, jsonToCopy, message) => {
-    const jToC = JSON.stringify(jsonToCopy);
-    if (window.Cypress) {
-      window.Cypress.__savedClipboardData = stringToCopy;
-      window.Cypress.__savedClipboardDataJson = jToC;
-    }
     !window.Cypress &&
       copy(stringToCopy, {
         onCopy: clipboardData => {
-          clipboardData.setData("application/json", jToC);
+          clipboardData.setData("application/json", JSON.stringify(jsonToCopy));
         },
         // keep this so that pasting into spreadsheets works.
         format: "text/plain"
@@ -1059,10 +964,9 @@ class DataTable extends React.Component {
     }
   };
 
-  handleCopyTable = (e, opts = {}) => {
+  handleCopyTable = (e, opts) => {
     try {
-      let allRowEls = getAllRows(e);
-      if (opts.noHeader) allRowEls = [...allRowEls].slice(1);
+      const allRowEls = getAllRows(e);
       if (!allRowEls) return;
       this.handleCopyRows(allRowEls, {
         ...opts,
@@ -1073,12 +977,15 @@ class DataTable extends React.Component {
       window.toastr.error("Error copying rows.");
     }
   };
-  handleCopySelectedCells = (e, opts) => {
-    const { entities = [], reduxFormSelectedCells, schema } = this.props;
+  handleCopySelectedCells = e => {
+    const {
+      entities = [],
+      reduxFormSelectedCells,
+      schema
+    } = computePresets(this.props);
     // if the current selection is consecutive cells then copy with
     // tabs between. if not then just select primary selected cell
-    const getEmptyMsg = () => window.toastr.warning("No text to copy");
-    if (isEmpty(reduxFormSelectedCells)) return getEmptyMsg();
+    if (isEmpty(reduxFormSelectedCells)) return;
     const pathToIndex = getFieldPathToIndex(schema);
     const entityIdToEntity = getEntityIdToEntity(entities);
     const selectionGrid = [];
@@ -1101,7 +1008,7 @@ class DataTable extends React.Component {
         selectionGrid[eInfo.i][cellIndex] = true;
       }
     });
-    if (firstRowIndex === undefined) return getEmptyMsg();
+    if (firstRowIndex === undefined) return;
     const allRows = getAllRows(e);
     let fullCellText = "";
     const fullJson = [];
@@ -1115,7 +1022,7 @@ class DataTable extends React.Component {
       } else {
         const jsonRow = [];
         // ignore header
-        let [rowCopyText, json] = this.getRowCopyText(allRows[i + 1], opts);
+        let [rowCopyText, json] = this.getRowCopyText(allRows[i + 1]);
         rowCopyText = rowCopyText.split("\t");
         times(row.length, i => {
           const cell = row[i];
@@ -1128,17 +1035,13 @@ class DataTable extends React.Component {
         fullJson.push(jsonRow);
       }
     });
-    if (!fullCellText) return getEmptyMsg();
+    if (!fullCellText) return window.toastr.warning("No text to copy");
 
-    this.handleCopyHelper(
-      fullCellText,
-      fullJson,
-      `Selected cell${Object.values(reduxFormSelectedCells).length === 1 ? "" : "s"} copied`
-    );
+    this.handleCopyHelper(fullCellText, fullJson, "Selected cells copied");
   };
 
-  handleCopySelectedRows = (selectedRecords, e, opts) => {
-    const { entities = [] } = this.props;
+  handleCopySelectedRows = (selectedRecords, e) => {
+    const { entities = [] } = computePresets(this.props);
     const idToIndex = entities.reduce((acc, e, i) => {
       acc[e.id || e.code] = i;
       return acc;
@@ -1158,8 +1061,7 @@ class DataTable extends React.Component {
       const rowEls = rowNumbersToCopy.map(i => allRowEls[i]);
 
       this.handleCopyRows(rowEls, {
-        onFinishMsg: "Selected rows copied",
-        ...opts
+        onFinishMsg: "Selected rows copied"
       });
     } catch (error) {
       console.error(`error:`, error);
@@ -1198,7 +1100,7 @@ class DataTable extends React.Component {
       moveColumnPersist,
       syncDisplayOptionsToDb,
       change
-    } = this.props;
+    } = computePresets(this.props);
     let moveColumnPersistToUse = moveColumnPersist;
     if (moveColumnPersist && withDisplayOptions && !syncDisplayOptionsToDb) {
       //little hack to make localstorage changes get reflected in UI (we force an update to get the enhancers to run again :)
@@ -1236,7 +1138,7 @@ class DataTable extends React.Component {
   ));
 
   addEntitiesToSelection = entities => {
-    const propPresets = this.props;
+    const propPresets = computePresets(this.props);
     const { isEntityDisabled, reduxFormSelectedEntityIdMap } = propPresets;
     const idMap = reduxFormSelectedEntityIdMap || {};
     const newIdMap = cloneDeep(idMap) || {};
@@ -1254,7 +1156,7 @@ class DataTable extends React.Component {
 
   render() {
     const { fullscreen } = this.state;
-    const propPresets = this.props;
+    const propPresets = computePresets(this.props);
     const {
       extraClasses,
       className,
@@ -1577,13 +1479,16 @@ class DataTable extends React.Component {
                 // if (isArrowKey && e.target?.tagName !== "INPUT") {
                 const isTabKey = e.keyCode === 9;
                 // const isEnter = e.keyCode === 13;
+                // console.log(`onKeydown datatable inner`);
+                // console.log(`isEnter:`, isEnter)
                 const isArrowKey = e.keyCode >= 37 && e.keyCode <= 40;
+                // console.log(`e.target?.tagName:`,e.target?.tagName)
                 if (
                   (isArrowKey && e.target?.tagName !== "INPUT") ||
                   isTabKey
                   // || (isEnter && e.target?.tagName === "INPUT")
                 ) {
-                  const { schema, entities } = this.props;
+                  const { schema, entities } = computePresets(this.props);
                   const left = e.keyCode === 37;
                   const up = e.keyCode === 38;
                   const down = e.keyCode === 40 || e.keyCode === 13;
@@ -1681,8 +1586,7 @@ class DataTable extends React.Component {
                 const rowDisabled = isEntityDisabled(entity);
                 const isNum = e.keyCode >= 48 && e.keyCode <= 57;
                 const isLetter = e.keyCode >= 65 && e.keyCode <= 90;
-                const isEqlSign = e.keyCode === 187;
-                if (!isNum && !isLetter && !isEqlSign) return;
+                if (!isNum && !isLetter) return;
                 if (rowDisabled) return;
                 this.startCellEdit(cellId, { shouldSelectAll: true });
                 e.stopPropagation();
@@ -1818,7 +1722,7 @@ class DataTable extends React.Component {
                     finalizeSelection({
                       idMap: {},
                       entities,
-                      props: this.props
+                      props: computePresets(this.props)
                     });
                   }}
                 />
@@ -1977,7 +1881,7 @@ class DataTable extends React.Component {
       change,
       getRowClassName,
       isCellEditable
-    } = this.props;
+    } = computePresets(this.props);
     if (!rowInfo) {
       return {
         className: "no-row-data"
@@ -2009,7 +1913,7 @@ class DataTable extends React.Component {
         if (e.detail > 1) {
           return; //cancel multiple quick clicks
         }
-        rowClick(e, rowInfo, entities, this.props);
+        rowClick(e, rowInfo, entities, computePresets(this.props));
       },
       //row right click
       onContextMenu: e => {
@@ -2036,7 +1940,7 @@ class DataTable extends React.Component {
           finalizeSelection({
             idMap: newIdMap,
             entities,
-            props: this.props
+            props: computePresets(this.props)
           });
         }
         this.showContextMenu(e, newIdMap);
@@ -2066,7 +1970,7 @@ class DataTable extends React.Component {
       change,
       reduxFormSelectedCells = {},
       reduxFormEditingCell
-    } = this.props;
+    } = computePresets(this.props);
     const newSelectedCells = { ...reduxFormSelectedCells };
     newSelectedCells[cellId] = PRIMARY_SELECTED_VAL;
     //check if the cell is already selected and editing and if so, don't change it
@@ -2090,7 +1994,7 @@ class DataTable extends React.Component {
       reduxFormSelectedCells = {},
       isEntityDisabled,
       change
-    } = this.props;
+    } = computePresets(this.props);
     if (!isCellEditable) return {}; //only allow cell selection to do stuff here
     if (!rowInfo) return {};
     const entity = rowInfo.original;
@@ -2102,7 +2006,8 @@ class DataTable extends React.Component {
       cellIdToRight,
       cellIdBelow,
       cellIdToLeft,
-      rowDisabled
+      rowDisabled,
+      columnIndex
     } = getCellInfo({
       columnIndex: column.index,
       columnPath: column.path,
@@ -2122,18 +2027,18 @@ class DataTable extends React.Component {
       selectedRightBorder,
       selectedBottomBorder,
       selectedLeftBorder;
-    const isSelected = reduxFormSelectedCells[cellId];
-    if (isSelected) {
+    if (reduxFormSelectedCells[cellId]) {
       selectedTopBorder = !reduxFormSelectedCells[cellIdAbove];
       selectedRightBorder = !reduxFormSelectedCells[cellIdToRight];
       selectedBottomBorder = !reduxFormSelectedCells[cellIdBelow];
       selectedLeftBorder = !reduxFormSelectedCells[cellIdToLeft];
     }
-    const isPrimarySelected = isSelected === PRIMARY_SELECTED_VAL;
+    const isPrimarySelected =
+      reduxFormSelectedCells[cellId] === PRIMARY_SELECTED_VAL;
     const className = classNames({
-      isSelectedCell: isSelected,
+      isSelectedCell: reduxFormSelectedCells[cellId],
       isPrimarySelected,
-      isSecondarySelected: isSelected === true,
+      isSecondarySelected: reduxFormSelectedCells[cellId] === true,
       noSelectedTopBorder: !selectedTopBorder,
       isCleanRow: _isClean,
       noSelectedRightBorder: !selectedRightBorder,
@@ -2142,12 +2047,8 @@ class DataTable extends React.Component {
       isDropdownCell: column.type === "dropdown",
       isEditingCell: reduxFormEditingCell === cellId,
       hasCellError: !!err,
-      "no-data-tip": isSelected
+      "no-data-tip": reduxFormSelectedCells[cellId]
     });
-    const clickProps = {
-      isRowIndexColumn: column.isRowIndexColumn,
-      cellId
-    };
     return {
       onDoubleClick: () => {
         // cell double click
@@ -2159,12 +2060,7 @@ class DataTable extends React.Component {
         "data-no-child-data-tip": true
       }),
       onContextMenu: e => {
-        if (!isSelected) {
-          this.handleCellClick({
-            event: e,
-            ...clickProps
-          });
-        } else if (!isPrimarySelected) {
+        if (!isPrimarySelected) {
           const primaryCellId = this.getPrimarySelectedCellId();
           const newSelectedCells = { ...reduxFormSelectedCells };
           if (primaryCellId) {
@@ -2181,14 +2077,17 @@ class DataTable extends React.Component {
       onClick: event => {
         this.handleCellClick({
           event,
-          ...clickProps
+          cellId,
+          rowDisabled,
+          rowIndex,
+          columnIndex
         });
       },
       className
     };
   };
 
-  handleCellClick = ({ event, cellId, isRowIndexColumn }) => {
+  handleCellClick = ({ event, cellId }) => {
     if (!cellId) return;
     // cell click, cellclick
     const {
@@ -2198,7 +2097,7 @@ class DataTable extends React.Component {
       reduxFormEditingCell,
       reduxFormSelectedCells = {},
       isEntityDisabled
-    } = this.props;
+    } = computePresets(this.props);
     const [rowId, cellPath] = cellId.split(":");
     const entityMap = getEntityIdToEntity(entities);
     const { e: entity, i: rowIndex } = entityMap[rowId];
@@ -2207,36 +2106,10 @@ class DataTable extends React.Component {
     const rowDisabled = isEntityDisabled(entity);
 
     if (rowDisabled) return;
-
     let newSelectedCells = {
       ...reduxFormSelectedCells
     };
-    if (isRowIndexColumn) {
-      // it's like the whole row is being selected
-      let isThereAnUnselectedCell = false;
-      const allCellsInRow = {};
-      schema.fields.forEach(f => {
-        const toSelectId = `${rowId}:${f.path}`;
-        if (!reduxFormSelectedCells[toSelectId]) {
-          isThereAnUnselectedCell = true;
-        }
-        allCellsInRow[toSelectId] = true;
-      });
-      if (event.metaKey || event.shiftKey) {
-        if (isThereAnUnselectedCell) {
-          newSelectedCells = {
-            ...newSelectedCells,
-            ...allCellsInRow
-          };
-        } else {
-          forEach(allCellsInRow, (c, key) => {
-            delete newSelectedCells[key];
-          });
-        }
-      } else {
-        newSelectedCells = allCellsInRow;
-      }
-    } else if (newSelectedCells[cellId] && !event.shiftKey) {
+    if (newSelectedCells[cellId] && !event.shiftKey) {
       // don't deselect if editing
       if (reduxFormEditingCell === cellId) return;
       if (event.metaKey) {
@@ -2313,7 +2186,7 @@ class DataTable extends React.Component {
       noUserSelect,
       entities,
       isEntityDisabled
-    } = this.props;
+    } = computePresets(this.props);
     const checkedRows = getSelectedRowsFromEntities(
       entities,
       reduxFormSelectedEntityIdMap
@@ -2353,7 +2226,7 @@ class DataTable extends React.Component {
           finalizeSelection({
             idMap: newIdMap,
             entities,
-            props: this.props
+            props: computePresets(this.props)
           });
         }}
         /* eslint-enable react/jsx-no-bind */
@@ -2370,7 +2243,7 @@ class DataTable extends React.Component {
       noUserSelect,
       entities,
       isEntityDisabled
-    } = this.props;
+    } = computePresets(this.props);
     const checkedRows = getSelectedRowsFromEntities(
       entities,
       reduxFormSelectedEntityIdMap
@@ -2387,7 +2260,7 @@ class DataTable extends React.Component {
       <Checkbox
         disabled={noSelect || noUserSelect || isEntityDisabled(entity)}
         onClick={e => {
-          rowClick(e, row, entities, this.props);
+          rowClick(e, row, entities, computePresets(this.props));
         }}
         checked={isSelected}
       />
@@ -2399,11 +2272,8 @@ class DataTable extends React.Component {
       entities = [],
       change,
       schema,
-      reduxFormCellValidation,
-      allowFormulas
-    } = this.props;
-    const updateGroup = {};
-
+      reduxFormCellValidation
+    } = computePresets(this.props);
     const [rowId, path] = cellId.split(":");
     !doNotStopEditing && change("reduxFormEditingCell", null);
     this.updateEntitiesHelper(entities, entities => {
@@ -2411,33 +2281,22 @@ class DataTable extends React.Component {
         return getIdOrCodeOrIndex(e, i) === rowId;
       });
       delete entity._isClean;
-      const { errors } = editCellHelper({
-        allowFormulas,
-        updateGroup,
-        depGraph: this.depGraph,
-        entities,
+      const { error } = editCellHelper({
         entity,
         path,
         schema,
         newVal
       });
-      this.buildDepGraph(entities);
       this.updateValidation(entities, {
         ...reduxFormCellValidation,
-        ...errors
+        [cellId]: error
       });
     });
-    setTimeout(() => {
-      // do not try to refocus the table if another cell has already been selected
-      const isCellIdStillSelected = this.props.reduxFormSelectedCells[cellId];
-      if (isCellIdStillSelected) {
-        !doNotStopEditing && this.refocusTable();
-      }
-    }, 0);
+    !doNotStopEditing && this.refocusTable();
   };
 
   cancelCellEdit = () => {
-    const { change } = this.props;
+    const { change } = computePresets(this.props);
     change("reduxFormEditingCell", null);
     this.refocusTable();
   };
@@ -2451,7 +2310,9 @@ class DataTable extends React.Component {
   };
 
   isSelectionARectangle = () => {
-    const { entities, reduxFormSelectedCells, schema } = this.props;
+    const { entities, reduxFormSelectedCells, schema } = computePresets(
+      this.props
+    );
     if (
       reduxFormSelectedCells &&
       Object.keys(reduxFormSelectedCells).length > 1
@@ -2531,7 +2392,6 @@ class DataTable extends React.Component {
       isCellEditable,
       cellRenderer,
       withCheckboxes,
-      allowFormulas,
       SubComponent,
       shouldShowSubComponent,
       entities,
@@ -2543,7 +2403,7 @@ class DataTable extends React.Component {
       change,
       reduxFormSelectedCells,
       reduxFormEditingCell
-    } = this.props;
+    } = computePresets(this.props);
     const { columns } = this.state;
     if (!columns.length) {
       return columns;
@@ -2606,88 +2466,6 @@ class DataTable extends React.Component {
         }
       });
     }
-    if (allowFormulas) {
-      columnsToRender.push({
-        isRowIndexColumn: true,
-        Header: () => {
-          return (
-            <InfoHelper
-              content="Formulas"
-              isButton
-              minimal
-              small
-              style={{ padding: 2 }}
-              popoverProps={{
-                modifiers: {
-                  preventOverflow: { enabled: false },
-                  hide: { enabled: false }
-                }
-              }}
-              onClick={() => {
-                showConfirmationDialog({
-                  text: (
-                    <div
-                      style={{
-                        padding: 10,
-                        width: 500,
-                        overflow: "auto"
-                      }}
-                    >
-                      <h3>Formulas</h3>
-                      <div>
-                        <p>
-                          Formulas are supported in the following columns:
-                          <ul>
-                            {columns.map((c, i) => {
-                              if (c.allowFormulas) {
-                                return <li>{this.renderColumnHeader(c, i)}</li>;
-                              }
-                              return null;
-                            })}
-                          </ul>
-                        </p>
-                      </div>
-                    </div>
-                  ),
-                  confirmButtonText: "Ok",
-                  noCancelButton: true,
-                  canOutsideClickClose: true,
-                  canEscapeKeyClose: true
-                });
-              }}
-              // className={classNames("tg-expander-all")}
-              icon="help"
-            />
-          );
-        },
-        Cell: props => {
-          return (
-            <div
-              style={{
-                display: "flex",
-                justifyContent: "center",
-                width: "100%"
-              }}
-            >
-              {props.index + 1}
-            </div>
-          );
-        },
-        width: 35,
-        resizable: false,
-        getHeaderProps: () => {
-          return {
-            className: "tg-react-table-checkbox-header-container",
-            immovable: "true"
-          };
-        },
-        getProps: (p, b) => {
-          return {
-            className: `tg-row-index-${b.index}`
-          };
-        }
-      });
-    }
 
     if (withCheckboxes) {
       columnsToRender.push({
@@ -2709,10 +2487,10 @@ class DataTable extends React.Component {
       });
     }
 
-    columns.forEach((column, i) => {
+    columns.forEach(column => {
       const tableColumn = {
         ...column,
-        Header: this.renderColumnHeader(column, i),
+        Header: this.renderColumnHeader(column),
         accessor: column.path,
         getHeaderProps: () => ({
           // needs to be a string because it is getting passed
@@ -2735,17 +2513,6 @@ class DataTable extends React.Component {
           );
           return val;
         };
-      } else if (column.allowFormulas) {
-        tableColumn.Cell = row => {
-          const val = row.value;
-
-          if (!val) return "";
-          if (typeof val === "number") return val;
-          if (val.formula) {
-            return val.value;
-          }
-          return val;
-        };
       } else if (column.render) {
         tableColumn.Cell = row => {
           const val = column.render(row.value, row.original, row, this.props);
@@ -2799,20 +2566,14 @@ class DataTable extends React.Component {
         const [row] = args;
         const rowId = getIdOrCodeOrIndex(row.original, row.index);
         const cellId = `${rowId}:${row.column.path}`;
-        const alphaNum = getCellAlphaNumHelper(i, row.index);
         let val = oldFunc(...args);
         const oldVal = val;
         const text = this.getCopyTextForCell(val, row, column);
         const isBool = column.type === "boolean";
-        const fullValue = row.original?.[row.column.path];
         const dataTest = {
-          "data-column": column.path,
-          "data-test": "tgCell_" + column.path,
-          "data-cell-alpha": alphaNum,
-          ...(fullValue?.formula && {
-            "data-formula": fullValue.formula
-          })
+          "data-test": "tgCell_" + column.path
         };
+        const fullValue = row.original?.[row.column.path];
         if (isCellEditable && isBool) {
           val = (
             <Checkbox
@@ -2873,7 +2634,7 @@ class DataTable extends React.Component {
                   shouldSelectAll={reduxFormEditingCellSelectAll}
                   cancelEdit={this.cancelCellEdit}
                   isNumeric={column.type === "number"}
-                  initialValue={fullValue?.formula || text}
+                  initialValue={text}
                   finishEdit={newVal => {
                     this.finishCellEdit(cellId, newVal);
                   }}
@@ -2923,9 +2684,7 @@ class DataTable extends React.Component {
                       __strVal: fullValue,
                       __genSelCol: column.path
                     }
-                  : allowFormulas
-                    ? { __strVal: fullValue }
-                    : { __strVal: text }
+                  : { __strVal: text }
               )}
               title={title || undefined}
             >
@@ -3003,8 +2762,7 @@ class DataTable extends React.Component {
       schema,
       reduxFormCellValidation,
       change,
-      reduxFormSelectedCells,
-      allowFormulas
+      reduxFormSelectedCells
     } = this.props;
     const primaryCellId = this.getPrimarySelectedCellId();
     const [primaryRowId, primaryCellPath] = primaryCellId.split(":");
@@ -3014,8 +2772,7 @@ class DataTable extends React.Component {
     if (!allSelectedPaths) {
       allSelectedPaths = [primaryCellPath];
     }
-    const updateGroup = {};
-    const prevEnts = entities;
+
     this.updateEntitiesHelper(entities, entities => {
       let newReduxFormSelectedCells;
       if (selectedPaths) {
@@ -3028,11 +2785,10 @@ class DataTable extends React.Component {
         };
       }
 
-      let newCellValidate = {
+      const newCellValidate = {
         ...reduxFormCellValidation
       };
-      const entityMap = getEntityIdToEntity(prevEnts);
-      const updateAbleEntityMap = getEntityIdToEntity(entities);
+      const entityMap = getEntityIdToEntity(entities);
       const { e: selectedEnt } = entityMap[primaryRowId];
       const firstCellToSelectRowIndex =
         entityMap[cellsToSelect[0]?.split(":")[0]]?.i;
@@ -3081,8 +2837,7 @@ class DataTable extends React.Component {
             }
             if (incrementStart === undefined) {
               const draggingDown =
-                firstCellToSelectRowIndex >
-                selectionGrid?.[0]?.[cellIndexOfSelectedPath]?.rowIndex;
+                firstCellToSelectRowIndex > selectionGrid?.[0][0].rowIndex;
               if (selectedPaths && draggingDown) {
                 let checkIncrement;
                 let prefix;
@@ -3148,8 +2903,7 @@ class DataTable extends React.Component {
           const [rowId, cellPath] = cellId.split(":");
           if (cellPath !== selectedPath) return;
           newReduxFormSelectedCells[cellId] = true;
-          const { e: entityToUpdate, i: rowIndex } =
-            updateAbleEntityMap[rowId] || {};
+          const { e: entityToUpdate, i: rowIndex } = entityMap[rowId] || {};
           if (entityToUpdate) {
             delete entityToUpdate._isClean;
             let newVal;
@@ -3189,31 +2943,24 @@ class DataTable extends React.Component {
                 newVal = selectedCellVal;
               }
             }
-            const { errors } = editCellHelper({
-              allowFormulas,
-              updateGroup,
-              depGraph: this.depGraph,
-              entities,
+            const { error } = editCellHelper({
               entity: entityToUpdate,
               path: cellPath,
               schema,
               newVal
             });
-            newCellValidate = {
-              ...newCellValidate,
-              ...errors
-            };
+            newCellValidate[cellId] = error;
           }
         });
       });
-      this.buildDepGraph(entities);
+
       // select the new cells
       this.updateValidation(entities, newCellValidate);
       change("reduxFormSelectedCells", newReduxFormSelectedCells);
     });
   };
   getCopyTextForCell = (val, row = {}, column = {}) => {
-    const { cellRenderer } = this.props;
+    const { cellRenderer } = computePresets(this.props);
     // TODOCOPY we need a way to potentially omit certain columns from being added as a \t element (talk to taoh about this)
     let text = typeof val !== "string" ? row.value : val;
 
@@ -3265,7 +3012,9 @@ class DataTable extends React.Component {
   };
 
   addEditableTableEntities = incomingEnts => {
-    const { entities = [], reduxFormCellValidation } = this.props;
+    const { entities = [], reduxFormCellValidation } = computePresets(
+      this.props
+    );
 
     this.updateEntitiesHelper(entities, entities => {
       const newEntities = incomingEnts.map(e => ({
@@ -3288,7 +3037,7 @@ class DataTable extends React.Component {
       } else {
         entities.splice(entities.length, 0, ...newEnts);
       }
-      this.buildDepGraph(entities);
+
       this.updateValidation(entities, {
         ...reduxFormCellValidation,
         ...validationErrors
@@ -3296,7 +3045,8 @@ class DataTable extends React.Component {
     });
   };
   getEditableTableInfoAndThrowFormError = () => {
-    const { schema, reduxFormEntities, reduxFormCellValidation } = this.props;
+    const { schema, reduxFormEntities, reduxFormCellValidation } =
+      computePresets(this.props);
     const { entsToUse, validationToUse } = removeCleanRows(
       reduxFormEntities,
       reduxFormCellValidation
@@ -3325,11 +3075,9 @@ class DataTable extends React.Component {
   };
 
   insertRows = ({ above, numRows = 1, appendToBottom } = {}) => {
-    const {
-      entities = [],
-      reduxFormCellValidation,
-      allowFormulas
-    } = this.props;
+    const { entities = [], reduxFormCellValidation } = computePresets(
+      this.props
+    );
 
     const primaryCellId = this.getPrimarySelectedCellId();
     const [rowId] = primaryCellId?.split(":") || [];
@@ -3341,50 +3089,6 @@ class DataTable extends React.Component {
       });
       const insertIndex = above ? indexToInsert : indexToInsert + 1;
       const insertIndexToUse = appendToBottom ? entities.length : insertIndex;
-      let { newEnts, validationErrors } = this.formatAndValidateEntities(
-        newEntities,
-        {
-          useDefaultValues: true,
-          indexToStartAt: insertIndexToUse,
-          depGraphToUse: {}
-        }
-      );
-
-      newEnts = newEnts.map(e => ({
-        ...e,
-        _isClean: true
-      }));
-      allowFormulas &&
-        updateEntityFormulasToInsertDelete({
-          entities,
-          insertIndex: insertIndexToUse,
-          numEnts: newEnts.length
-        });
-
-      this.updateValidation(entities, {
-        ...reduxFormCellValidation,
-        ...validationErrors
-      });
-      // we need to make sure any entities with formulas are updated
-
-      entities.splice(insertIndexToUse, 0, ...newEnts);
-      this.buildDepGraph(entities);
-    });
-    this.refocusTable();
-  };
-  insertColumns = ({ toTheLeft, numColumns = 1, appendToEnd } = {}) => {
-    const { entities = [], reduxFormCellValidation } = this.props;
-
-    const primaryCellId = this.getPrimarySelectedCellId();
-    const [rowId] = primaryCellId?.split(":") || [];
-    this.updateEntitiesHelper(entities, entities => {
-      const newEntities = times(numColumns).map(() => ({ id: nanoid() }));
-
-      const indexToInsert = entities.findIndex((e, i) => {
-        return getIdOrCodeOrIndex(e, i) === rowId;
-      });
-      const insertIndex = toTheLeft ? indexToInsert : indexToInsert + 1;
-      const insertIndexToUse = appendToEnd ? entities.length : insertIndex;
       let { newEnts, validationErrors } = this.formatAndValidateEntities(
         newEntities,
         {
@@ -3412,11 +3116,10 @@ class DataTable extends React.Component {
       history,
       contextMenu,
       isCopyable,
-      allowFormulas,
       isCellEditable,
       entities = [],
       reduxFormSelectedCells = {}
-    } = this.props;
+    } = computePresets(this.props);
     let selectedRecords;
     if (isCellEditable) {
       const rowIds = {};
@@ -3443,44 +3146,43 @@ class DataTable extends React.Component {
         e.target.querySelector(".tg-cell-wrapper") ||
         e.target.closest(".tg-cell-wrapper");
       if (cellWrapper) {
-        copyMenuItems.push(opts => (
+        copyMenuItems.push(
           <MenuItem
             key="copyCell"
             onClick={() => {
               //TODOCOPY: we need to make sure that the cell copy is being used by the row copy.. right now we have 2 different things going on
               //do we need to be able to copy hidden cells? It seems like it should just copy what's on the page..?
-              this.handleCopySelectedCells(e, opts);
+              const specificColumn = cellWrapper.getAttribute("data-test");
+              this.handleCopyRows([cellWrapper.closest(".rt-tr")], {
+                specificColumn,
+                onFinishMsg: "Cell copied"
+              });
+              const [text, jsonText] = this.getCellCopyText(cellWrapper);
+              this.handleCopyHelper(text, jsonText);
             }}
-            text={`Cell${
-              Object.keys(reduxFormSelectedCells).length > 1 ? "s" : ""
-            }`}
+            text="Cell"
           />
-        ));
+        );
 
-        copyMenuItems.push(opts => (
+        copyMenuItems.push(
           <MenuItem
             key="copyColumn"
             onClick={() => {
-              this.handleCopyColumn({ e, cellWrapper, opts });
+              this.handleCopyColumn(e, cellWrapper);
             }}
-            text={selectedRecords.length > 1 ? "Single Column" : "Column"}
+            text="Column"
           />
-        ));
+        );
         if (selectedRecords.length > 1) {
-          copyMenuItems.push(opts => (
+          copyMenuItems.push(
             <MenuItem
               key="copyColumnSelected"
               onClick={() => {
-                this.handleCopyColumn({
-                  e,
-                  cellWrapper,
-                  selectedRecords,
-                  opts
-                });
+                this.handleCopyColumn(e, cellWrapper, selectedRecords);
               }}
-              text="Selected Columns"
+              text="Column (Selected)"
             />
-          ));
+          );
         }
       }
       if (selectedRecords.length === 0 || selectedRecords.length === 1) {
@@ -3490,48 +3192,38 @@ class DataTable extends React.Component {
           e.target.closest(".tg-cell-wrapper") ||
           e.target.closest(".rt-td");
         const row = cell.closest(".rt-tr");
-        copyMenuItems.push(opts => (
+        copyMenuItems.push(
           <MenuItem
             key="copySelectedRows"
             onClick={() => {
-              this.handleCopyRows([row], opts);
+              this.handleCopyRows([row]);
               // loop through each cell in the row
             }}
             text="Row"
           />
-        ));
+        );
       } else if (selectedRecords.length > 1) {
-        copyMenuItems.push(opts => (
+        copyMenuItems.push(
           <MenuItem
             key="copySelectedRows"
             onClick={() => {
-              this.handleCopySelectedRows(selectedRecords, e, opts);
+              this.handleCopySelectedRows(selectedRecords, e);
               // loop through each cell in the row
             }}
             text="Rows"
           />
-        ));
+        );
       }
-      copyMenuItems.push(opts => (
+      copyMenuItems.push(
         <MenuItem
           key="copyFullTableRows"
           onClick={() => {
-            this.handleCopyTable(e, opts);
+            this.handleCopyTable(e);
             // loop through each cell in the row
           }}
           text="Table"
         />
-      ));
-      copyMenuItems.push(opts => (
-        <MenuItem
-          key="copyFullTableRowsNoHeader"
-          onClick={() => {
-            this.handleCopyTable(e, { ...opts, noHeader: true });
-            // loop through each cell in the row
-          }}
-          text="Table Without Header"
-        />
-      ));
+      );
     }
     const selectedRowIds = Object.keys(reduxFormSelectedCells).map(cellId => {
       const [rowId] = cellId.split(":");
@@ -3543,39 +3235,11 @@ class DataTable extends React.Component {
         {itemsToRender}
         {copyMenuItems.length && (
           <MenuItem icon="clipboard" key="copyOpts" text="Copy">
-            {copyMenuItems.map(f => f())}
+            {copyMenuItems}
           </MenuItem>
         )}
-        {copyMenuItems.length && allowFormulas && (
-          <MenuItem
-            data-tip="This will copy the underlying formula (if there are any) instead of the evaluated value"
-            icon="clipboard"
-            key="copyOptsFormulas"
-            text="Copy Formula"
-          >
-            {copyMenuItems.map(f => f({ isFormulaCopy: true }))}
-          </MenuItem>
-        )}
-        <Divider></Divider>
         {isCellEditable && (
           <>
-            <MenuItem
-              icon="add-column-left"
-              text="Add Column Left"
-              key="addColumnLeft"
-              onClick={() => {
-                this.insertColumns({ toTheLeft: true });
-              }}
-            ></MenuItem>
-            <MenuItem
-              icon="add-column-right"
-              text="Add Column Right"
-              key="addColumnRight"
-              onClick={() => {
-                this.insertColumns({});
-              }}
-            ></MenuItem>
-            <Divider></Divider>
             <MenuItem
               icon="add-row-top"
               text="Add Row Above"
@@ -3594,15 +3258,14 @@ class DataTable extends React.Component {
             ></MenuItem>
             <MenuItem
               icon="remove"
-              text={`Remove Row${uniq(selectedRowIds).length > 1 ? "s" : ""}`}
+              text={`Remove Row${selectedRowIds.length > 1 ? "s" : ""}`}
               key="removeRow"
               onClick={() => {
                 const {
                   entities = [],
                   reduxFormCellValidation,
-                  reduxFormSelectedCells = {},
-                  allowFormulas
-                } = this.props;
+                  reduxFormSelectedCells = {}
+                } = computePresets(this.props);
                 const selectedRowIds = Object.keys(reduxFormSelectedCells).map(
                   cellId => {
                     const [rowId] = cellId.split(":");
@@ -3610,33 +3273,16 @@ class DataTable extends React.Component {
                   }
                 );
                 this.updateEntitiesHelper(entities, entities => {
-                  const deleteIndices = uniq(
-                    selectedRowIds
-                      .map(
-                        id =>
-                          entities.findIndex(
-                            (e, i) => getIdOrCodeOrIndex(e, i) === id
-                          ) + 1
-                      )
-                      .sort((a, b) => a - b)
+                  const ents = entities.filter(
+                    (e, i) => !selectedRowIds.includes(getIdOrCodeOrIndex(e, i))
                   );
-                  allowFormulas &&
-                    updateEntityFormulasToInsertDelete({
-                      entities,
-                      deleteIndices
-                    });
-
-                  deleteIndices.reverse().forEach(indexToRemove => {
-                    entities.splice(indexToRemove - 1, 1);
-                  });
-                  this.buildDepGraph(entities);
                   this.updateValidation(
-                    entities,
+                    ents,
                     omitBy(reduxFormCellValidation, (v, cellId) =>
                       selectedRowIds.includes(cellId.split(":")[0])
                     )
                   );
-                  // return ents;
+                  return ents;
                 });
                 this.refocusTable();
               }}
@@ -3648,7 +3294,7 @@ class DataTable extends React.Component {
     ContextMenu.show(menu, { left: e.clientX, top: e.clientY });
   };
 
-  renderColumnHeader = (column, index) => {
+  renderColumnHeader = column => {
     const {
       addFilters,
       setOrder,
@@ -3663,9 +3309,8 @@ class DataTable extends React.Component {
       compact,
       isCellEditable,
       extraCompact,
-      entities,
-      allowFormulas
-    } = this.props;
+      entities
+    } = computePresets(this.props);
     const {
       displayName,
       description,
@@ -3805,15 +3450,7 @@ class DataTable extends React.Component {
     }
 
     const columnTitleTextified = getTextFromEl(columnTitle);
-    let inner = renderTitleInner ? renderTitleInner : columnTitle;
-    const getLetterifiedColumnTitle = () => {
-      const letter = getColLetFromIndex(index);
-      if (inner?.toUpperCase() === letter) {
-        inner = letter;
-        return null;
-      }
-      return <div>{getColLetFromIndex(index)}:</div>;
-    };
+
     return (
       <div
         {...(description && {
@@ -3821,7 +3458,6 @@ class DataTable extends React.Component {
             <strong>${columnTitle}:</strong> <br>
             ${description} ${isUnique ? "<br>Must be unique" : ""}</div>`
         })}
-        data-column={column.path}
         data-test={columnTitleTextified}
         data-path={path}
         data-copy-text={columnTitleTextified}
@@ -3836,7 +3472,6 @@ class DataTable extends React.Component {
         {columnTitleTextified && !noTitle && (
           <React.Fragment>
             {maybeCheckbox}
-            {allowFormulas && getLetterifiedColumnTitle()}
             <span
               title={columnTitleTextified}
               className={classNames({
@@ -3848,7 +3483,7 @@ class DataTable extends React.Component {
                 display: "inline-block"
               }}
             >
-              {inner}{" "}
+              {renderTitleInner ? renderTitleInner : columnTitle}{" "}
             </span>
           </React.Fragment>
         )}
@@ -4144,7 +3779,6 @@ function endsWithNumber(str) {
 }
 
 function getNumberStrAtEnd(str) {
-  if (typeof str !== "string") str = str.toString();
   if (endsWithNumber(str)) {
     return str.match(/[0-9]+$/)[0];
   }
@@ -4179,13 +3813,7 @@ const formatPasteData = ({ schema, newVal, path }) => {
       newVal = undefined;
     }
   } else {
-    newVal = Object.hasOwn(newVal, "__strVal")
-      ? newVal.__strVal?.formula
-        ? newVal.__strVal.formula
-        : newVal.__strVal
-      : isEmpty(newVal)
-        ? undefined
-        : newVal;
+    newVal = Object.hasOwn(newVal, "__strVal") ? newVal.__strVal : newVal;
   }
   return newVal;
 };
@@ -4209,61 +3837,3 @@ export function removeCleanRows(reduxFormEntities, reduxFormCellValidation) {
   });
   return { entsToUse, validationToUse };
 }
-
-const updateEntityFormulasToInsertDelete = ({
-  entities,
-  deleteIndices,
-  insertIndex,
-  numEnts = 1
-}) => {
-  const isInsert = !deleteIndices;
-  entities.forEach(e => {
-    Object.values(e).forEach(v => {
-      if (v?.formula) {
-        // update the formula to shift the row numbers up or down as needed
-        v.formula = v.formula.replace(/([A-Z]+[0-9]+)/gi, match => {
-          const letter = match.replace(/[0-9]+/gi, "");
-          // update the match number
-          const num = Number(match.replace(/[A-Z]+/gi, ""));
-          if (isInsert) {
-            if (num > insertIndex) {
-              // if the insert index is above the match number then we need to add 1 to the row number
-              const newNum = num + numEnts;
-              return `${letter}${newNum}`;
-            }
-          } else {
-            let newNum = num;
-            deleteIndices.forEach(i => {
-              if (num > i) {
-                newNum = num - 1;
-              }
-            });
-            return `${letter}${newNum}`;
-          }
-          return match;
-        });
-        v.formula = v.formula.replace(/([0-9]+:[0-9]+)/gi, match => {
-          const [num1, num2] = match.split(":");
-          if (num1 === num2) {
-            const num = Number(num1);
-            if (isInsert) {
-              if (num > insertIndex) {
-                const newNum = num + numEnts;
-                return `${newNum}:${newNum}`;
-              }
-            } else {
-              let newNum = num;
-              deleteIndices.forEach(i => {
-                if (num > i) {
-                  newNum = num - 1;
-                }
-              });
-              return `${newNum}:${newNum}`;
-            }
-          }
-          return match;
-        });
-      }
-    });
-  });
-};