@teselagen/ui 0.3.76 → 0.3.77

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teselagen/ui",
-  "version": "0.3.76",
+  "version": "0.3.77",
   "main": "./src/index.js",
   "exports": {
     ".": {
@@ -21,7 +21,6 @@
     "buffer": "5.7.1",
     "color": "^3.2.1",
     "copy-to-clipboard": "^3.3.1",
-    "dayjs": "^1.10.4",
     "dom-scroll-into-view": "^2.0.1",
     "downloadjs": "^1.4.7",
     "fuse.js": "^6.6.2",
@@ -30,19 +29,15 @@
     "is-mobile": "^3.0.0",
     "jszip": "^3.10.1",
     "math-expression-evaluator": "^1.3.7",
-    "mobx": "^6.10.2",
-    "mobx-react": "^9.0.1",
     "mock-fs": "5.2.0",
     "nanoid": "^4.0.0",
     "papaparse": "^5.3.2",
     "prop-types": "^15.6.2",
-    "qs": "^6.9.6",
     "react": "18.2.0",
     "react-color": "^2.19.3",
     "react-dom": "18.2.0",
     "react-dropzone": "^11.4.2",
     "react-markdown": "8.0.7",
-    "react-redux": "^8.0.5",
     "react-rnd": "^10.2.4",
     "react-router-dom": "^4.3.1",
     "react-sortable-hoc": "^0.6.8",
@@ -54,8 +49,7 @@
     "remark-gfm": "^3.0.1",
     "tippy.js": "^6.3.7",
     "url-join": "^4.0.1",
-    "use-deep-compare-effect": "^1.6.1",
-    "write-excel-file": "^1.4.25"
+    "use-deep-compare-effect": "^1.6.1"
   },
   "license": "MIT"
 }

package/src/DataTable/dataTableEnhancer.js

@@ -15,6 +15,7 @@ import { viewColumn, openColumn } from "../DataTable/viewColumn";
 import pureNoFunc from "../utils/pureNoFunc";
 import tgFormValues from "../utils/tgFormValues";
 import getTableConfigFromStorage from "./utils/getTableConfigFromStorage";
+import computePresets from "./utils/computePresets";
 
 export default compose(
   // maybe we need this in some cases?
@@ -40,6 +41,7 @@ export default compose(
         ...ownProps.tableParams
       };
     }
+    propsToUse = computePresets(propsToUse);
 
     const {
       schema,
@@ -126,8 +128,8 @@ export default compose(
               return field.render
                 ? !field.render(val, e)
                 : cellRenderer[field.path]
-                ? !cellRenderer[field.path](val, e)
-                : !val;
+                  ? !cellRenderer[field.path](val, e)
+                  : !val;
             });
           }
           if (noValsForField) {

package/src/DataTable/editCellHelper.js

@@ -1,25 +1,166 @@
-import { set } from "lodash";
+import { isString, set, toNumber } from "lodash";
 import { defaultValidators } from "./defaultValidators";
 import { defaultFormatters } from "./defaultFormatters";
+import { evaluate } from "mathjs";
+import getIdOrCodeOrIndex from "./utils/getIdOrCodeOrIndex";
 
 //(mutative) responsible for formatting and then validating the
+// const depGraph = {
+//   a1: ["a3"],
+//   a2: ["a1"],
+//   a3: [],
+//   b1: ["a1", "a2"],
+//   b2: ["a2"],
+//   b3: ["a3"]
+// };
 
 export const editCellHelper = ({
+  _cellAlphaNum,
+  updateGroup,
+  depGraph,
   entity,
   path,
   schema,
   columnSchema,
-  newVal
+  newVal,
+  entities,
+  nestLevel = 0,
+  depLevel = 0,
+  allowFormulas
 }) => {
   let nv = newVal;
+  if (nv?.formula) {
+    nv = nv.formula;
+  }
 
   const colSchema =
     columnSchema || schema?.fields?.find(({ path: p }) => p === path) || {};
   path = path || colSchema.path;
+  const cellAlphaNum =
+    _cellAlphaNum ||
+    getCellAlphaNum({
+      entities,
+      entity,
+      colSchema,
+      schema
+    });
+  if (
+    updateGroup[cellAlphaNum] !== undefined &&
+    updateGroup[cellAlphaNum] !== "__Currently&&Updating__"
+  ) {
+    // if the cell is already being updated, return the value
+    return { value: updateGroup[cellAlphaNum], errors: {} };
+  } else {
+    updateGroup[cellAlphaNum] = "__Currently&&Updating__";
+  }
+  const cellId = `${getIdOrCodeOrIndex(entity)}:${colSchema.path}`;
+  const oldVal = entity[path];
   const { format, validate, type } = colSchema;
-  let error;
-  if (nv === undefined && colSchema.defaultValue !== undefined)
+  let errors = {
+    __hasErrors: false
+  };
+  if (nv === undefined && colSchema.defaultValue !== undefined) {
     nv = colSchema.defaultValue;
+  }
+
+  let hasFormula = false;
+  if (colSchema.allowFormulas && typeof nv === "string" && nv[0] === "=") {
+    const ogFormula = nv;
+    // if the nv is missing a closing paren, add it
+    // count the number of open parens
+    // count the number of close parens
+    // if the number of open parens is greater than the number of close parens, add a close paren
+    const openParens = (nv.match(/\(/g) || []).length;
+    const closeParens = (nv.match(/\)/g) || []).length;
+    if (openParens > closeParens) {
+      nv = nv + ")";
+    }
+    // if the nv is a valid formula, evaluate it and evaluate any nested formulas
+    // if the nv is not a valid formula, return the error
+    // fill in any variables with their values
+    let error;
+    // if nv contains : then it is a range
+    // if (nv.includes(":")) {
+    // replace the range with the the values of the range
+    // get the start and end of the range
+    const { rangeErr, replacedFormula } = replaceFormulaRanges({
+      formula: nv,
+      schema,
+      entities
+    });
+    error = rangeErr;
+    nv = replacedFormula;
+    nv = nv.replace(/([A-Z]+[0-9]+)/gi, _match => {
+      const match = _match.toUpperCase();
+      if (updateGroup[match] === "__Currently&&Updating__") {
+        error = `Circular Loop Detected between ${cellAlphaNum} and ${match}`;
+        return "circular_loop_detected";
+      }
+      // match will equal E12 or B4 for example
+      const [letter, rowIndex] = match.split(/(\d+)/);
+      const entity = entities.find((e, i) => {
+        return i === rowIndex - 1;
+      });
+      const columns = schema.fields;
+      const letterIndex = lettersToNumber(letter);
+      const col = columns[letterIndex];
+      if (!col) {
+        return match;
+      }
+      const { path } = col;
+      if (!entity) return match;
+      let val = entity[path];
+      if (val === undefined || val === "") return 0;
+      if (val?.formula) {
+        val = val.formula;
+      }
+      if (isString(val) && val[0] === "=") {
+        // if the value is a formula, evaluate it
+        const { value, errors: _errors } = editCellHelper({
+          _cellAlphaNum: match,
+          updateGroup,
+          depGraph,
+          entity,
+          path,
+          schema,
+          columnSchema: col,
+          newVal: val,
+          entities,
+          nestLevel: nestLevel + 1
+        });
+        errors = mergeErrors(errors, _errors);
+        val = value?.formula ? value.value : value;
+      } else if (!isNaN(toNumber(val))) {
+        return val;
+      } else if (isString(val)) {
+        return 0;
+      }
+      return val;
+    });
+
+    const toEval = nv.slice(1);
+    try {
+      if (!error) {
+        nv = evaluate(toEval);
+        nv = {
+          formula: ogFormula,
+          value: `${nv}`
+        };
+      } else {
+        throw new Error(error);
+      }
+    } catch (e) {
+      nv = {
+        formula: ogFormula,
+        value: `#ERROR`,
+        error: e.message
+      };
+      errors[cellId] = e.message;
+      errors.__hasErrors = true;
+    }
+    hasFormula = nv;
+    nv = nv.value;
+  }
 
   if (format) {
     nv = format(nv, colSchema);
@@ -27,18 +168,173 @@ export const editCellHelper = ({
   if (defaultFormatters[type]) {
     nv = defaultFormatters[type](nv, colSchema);
   }
-  if (validate) {
-    error = validate(nv, colSchema, entity);
+  if (validate && !hasErrors(errors)) {
+    const error = validate(nv, colSchema, entity);
+    if (error) {
+      errors.__hasErrors = true;
+    }
+    errors[cellId] = error;
   }
-  if (!error) {
+  if (!hasErrors(errors)) {
     const validator =
       defaultValidators[type] ||
       type === "string" ||
       (type === undefined && defaultValidators.string);
     if (validator) {
-      error = validator(nv, colSchema);
+      const error = validator(nv, colSchema);
+      if (error) {
+        errors.__hasErrors = true;
+      }
+      errors[cellId] = error;
     }
   }
-  set(entity, path, nv);
-  return { entity, error };
+  const value = hasFormula || nv;
+  if (
+    // if the formula and its value is the same as it was, don't set it again otherwise it will be added to the undo/redo stack
+    !(
+      hasFormula &&
+      value.value === oldVal?.value &&
+      value.formula === oldVal?.formula
+    )
+  ) {
+    set(entity, path, value);
+  }
+  updateGroup[cellAlphaNum] = value;
+  if (allowFormulas && entities && entities.length) {
+    // go through the depGraph and update any cells that depend on this cell
+    const cellDepGraph = depGraph[cellAlphaNum];
+    if (cellDepGraph && cellDepGraph.length) {
+      cellDepGraph.forEach(depCellAlphaNum => {
+        if (depCellAlphaNum === cellAlphaNum) return;
+        if (updateGroup[depCellAlphaNum] === "__Currently&&Updating__") {
+          // if the cell is already being updated, return the value
+          return updateGroup[depCellAlphaNum];
+        }
+        const [depColLetter, depRowIndex] = depCellAlphaNum.split(/(\d+)/);
+        const depEntity = entities[depRowIndex - 1];
+        // if (!depEntity) debugger
+        // if (!depEntity) return
+        const depColIndex = depColLetter.charCodeAt(0) - 65;
+        const depColSchema = schema.fields[depColIndex];
+        const depPath = depColSchema.path;
+        const depNewVal = depEntity[depPath];
+
+        const { errors: _errors } = editCellHelper({
+          _cellAlphaNum: depCellAlphaNum,
+          allowFormulas,
+          updateGroup,
+          depGraph,
+          entity: depEntity,
+          path: depPath,
+          schema,
+          columnSchema: depColSchema,
+          newVal: depNewVal,
+          entities,
+          depLevel: depLevel + 1,
+          nestLevel: nestLevel
+        });
+        errors = mergeErrors(errors, _errors);
+      });
+    }
+  }
+  updateGroup[cellAlphaNum] = value?.formula ? value.value : value;
+  if (!hasErrors(errors)) {
+    errors[cellId] = undefined;
+  }
+  return { entity, errors, value };
 };
+
+function getCellAlphaNum({ entities, entity, colSchema, schema }) {
+  const rowIndex = entities.indexOf(entity);
+  const colIndex = schema.fields.indexOf(colSchema);
+  return getCellAlphaNumHelper(colIndex, rowIndex);
+}
+export function getCellAlphaNumHelper(colIndex, rowIndex) {
+  const colLetter = getColLetFromIndex(colIndex);
+  const cellAlphaNum = `${colLetter}${rowIndex + 1}`;
+  return cellAlphaNum;
+}
+
+const hasErrors = errors => {
+  return errors.__hasErrors;
+};
+
+export const getColLetFromIndex = index => {
+  if (index > 25)
+    return (
+      getColLetFromIndexHelper(index / 26 - 1) +
+      getColLetFromIndexHelper(index % 26)
+    );
+  return getColLetFromIndexHelper(index);
+};
+const getColLetFromIndexHelper = index => {
+  return String.fromCharCode(65 + index);
+};
+
+const lettersToNumber = letters => {
+  let n = 0;
+  for (let p = 0; p < letters.length; p++) {
+    n = letters[p].charCodeAt() - 64 + n * 26;
+  }
+  return n - 1;
+};
+
+export const replaceFormulaRanges = ({ formula, schema, entities }) => {
+  let error;
+  const replaced = formula
+    .toLowerCase()
+    .replaceAll("$", "")
+    .replace(/([A-Z]*[0-9]*:[A-Z]*[0-9]*)/gi, _match => {
+      // if (_match.includes(":")) {
+      // }
+      const match = _match.toUpperCase();
+      const [start, end] = match.split(":");
+      const [startLetter, _startRowIndex] = start.split(/(\d+)/);
+      const [endLetter, _endRowIndex] = end.split(/(\d+)/);
+      let startRowIndex = parseInt(_startRowIndex);
+      let endRowIndex = parseInt(_endRowIndex);
+      let toRet = "";
+
+      if (startLetter !== endLetter) {
+        error = `Ranges must be in the same column`;
+        return "range_in_different_columns";
+      }
+      if (!startLetter && !endLetter && _startRowIndex === _endRowIndex) {
+        // we have a range like 1:1
+        const rowIndex = startRowIndex;
+        const startColIndex = 1;
+        const endColIndex = schema.fields.length;
+        for (let i = startColIndex; i <= endColIndex; i++) {
+          const colLet = getColLetFromIndex(i - 1);
+          toRet += `${colLet}${rowIndex}${i === endColIndex ? "" : ","}`;
+        }
+        return toRet;
+      }
+      if (_startRowIndex === undefined && _endRowIndex === undefined) {
+        // we have a range like A:A
+        startRowIndex = 1;
+        endRowIndex = entities.length;
+      }
+      for (let j = startRowIndex; j <= endRowIndex; j++) {
+        toRet += `${startLetter}${j}${j === endRowIndex ? "" : ","}`;
+      }
+      return toRet;
+    });
+  return {
+    replacedFormula: replaced,
+    error
+  };
+};
+
+function mergeErrors(errors, _errors) {
+  let hasErrors = false;
+  if (_errors.__hasErrors || errors.__hasErrors) {
+    hasErrors = true;
+  }
+  errors = {
+    ...errors,
+    ..._errors,
+    __hasErrors: hasErrors
+  };
+  return errors;
+}

package/src/DataTable/getCellVal.js

@@ -1,4 +1,4 @@
-import { get } from "lodash";
+import { get, has } from "lodash";
 import { isString } from "lodash";
 import { isTruthy } from "./isTruthy";
 
@@ -16,5 +16,8 @@ export const getCellVal = (ent, path, col) => {
       selectedCellVal === "yes";
     selectedCellVal = isTruthy(selectedCellVal);
   }
+  if (has(selectedCellVal, "value")) {
+    return selectedCellVal.value;
+  }
   return selectedCellVal;
 };