@teselagen/ui 0.7.33-beta.1 → 0.7.33-beta.2

package/src/filterLocalEntitiesToHasura.js

@@ -0,0 +1,216 @@
+import {
+  isEmpty,
+  every,
+  some,
+  isEqual,
+  isString,
+  isNull,
+  isArray,
+  includes,
+  isObject,
+  has,
+  orderBy
+} from "lodash-es";
+
+export function filterLocalEntitiesToHasura(
+  records,
+  { where, order_by, limit, offset, isInfinite } = {}
+) {
+  let filteredRecords = [...records];
+
+  // Apply where clause if it exists
+  if (where) {
+    filteredRecords = applyWhereClause(filteredRecords, where);
+  }
+
+  // Apply order_by if it exists
+  if (order_by) {
+    filteredRecords = applyOrderBy(filteredRecords, order_by);
+  }
+
+  // Store the complete filtered and ordered records for pagination info
+  const allFilteredRecords = [...filteredRecords];
+
+  // Apply limit and offset
+  if (!isInfinite && offset !== undefined) {
+    filteredRecords = filteredRecords.slice(offset);
+  }
+
+  if (!isInfinite && limit !== undefined) {
+    filteredRecords = filteredRecords.slice(0, limit);
+  }
+
+  // For consistency, always return an object with entities, entitiesAcrossPages, and entityCount
+  return {
+    entities: filteredRecords,
+    entitiesAcrossPages: allFilteredRecords,
+    entityCount: allFilteredRecords.length
+  };
+}
+
+function applyWhereClause(records, where) {
+  function applyFilter(record, filter) {
+    if (isEmpty(filter)) {
+      return true; // No filter, all records pass
+    }
+
+    for (const key in filter) {
+      if (key === "_and") {
+        if (!every(filter[key], subFilter => applyFilter(record, subFilter))) {
+          return false;
+        }
+      } else if (key === "_or") {
+        if (!some(filter[key], subFilter => applyFilter(record, subFilter))) {
+          return false;
+        }
+      } else if (key === "_not") {
+        if (applyFilter(record, filter[key])) {
+          return false;
+        }
+      } else {
+        const value = record[key];
+        const conditions = filter[key];
+
+        for (const operator in conditions) {
+          const conditionValue = conditions[operator];
+
+          // Handle range conditions (_gt/_lt or _gte/_lte combinations)
+          if (operator === "_gt" && conditions._lt) {
+            if (!(value > conditionValue && value < conditions._lt))
+              return false;
+            continue;
+          }
+          if (operator === "_gte" && conditions._lte) {
+            if (!(value >= conditionValue && value <= conditions._lte))
+              return false;
+            continue;
+          }
+
+          switch (operator) {
+            case "_eq":
+              if (!isEqual(value, conditionValue)) return false;
+              break;
+            case "_neq":
+              if (isEqual(value, conditionValue)) return false;
+              break;
+            case "_gt":
+              if (!(value > conditionValue)) return false;
+              break;
+            case "_gte":
+              if (!(value >= conditionValue)) return false;
+              break;
+            case "_lt":
+              if (!(value < conditionValue)) return false;
+              break;
+            case "_lte":
+              if (!(value <= conditionValue)) return false;
+              break;
+            case "_like":
+              if (
+                !isString(value) ||
+                !new RegExp(conditionValue.replace(/%/g, ".*")).test(value)
+              )
+                return false;
+              break;
+            case "_ilike":
+              if (
+                !isString(value) ||
+                !new RegExp(conditionValue.replace(/%/g, ".*"), "i").test(value)
+              )
+                return false;
+              break;
+            case "_nlike":
+              if (
+                !isString(value) ||
+                new RegExp(conditionValue.replace(/%/g, ".*")).test(value)
+              )
+                return false;
+              break;
+            case "_nilike":
+              if (
+                !isString(value) ||
+                new RegExp(conditionValue.replace(/%/g, ".*"), "i").test(value)
+              )
+                return false;
+              break;
+            case "_starts_with":
+              if (!isString(value) || !value.startsWith(conditionValue))
+                return false;
+              break;
+            case "_ends_with":
+              if (!isString(value) || !value.endsWith(conditionValue))
+                return false;
+              break;
+            case "_is_null":
+              if (
+                (conditionValue && !isNull(value)) ||
+                (!conditionValue && isNull(value))
+              )
+                return false;
+              break;
+            case "_contains":
+              if (
+                !isArray(value) ||
+                !every(conditionValue, item => includes(value, item))
+              )
+                return false;
+              break;
+            case "_contained_in":
+              if (
+                !isArray(value) ||
+                !every(value, item => includes(conditionValue, item))
+              )
+                return false;
+              break;
+            case "_has_key":
+              if (!isObject(value) || !has(value, conditionValue)) return false;
+              break;
+            case "_has_keys_any":
+              if (
+                !isObject(value) ||
+                !some(conditionValue, item => has(value, item))
+              )
+                return false;
+              break;
+            case "_has_keys_all":
+              if (
+                !isObject(value) ||
+                !every(conditionValue, item => has(value, item))
+              )
+                return false;
+              break;
+            case "_similar":
+              if (
+                !isString(value) ||
+                !new RegExp(conditionValue.replace(/%/g, ".*")).test(value)
+              )
+                return false;
+              break;
+            default:
+              if (operator.startsWith("_")) {
+                console.warn(`Unsupported operator: ${operator}`);
+                return false;
+              } else {
+                console.warn(`Unsupported operator: ${operator}`);
+                return false;
+              }
+          }
+        }
+      }
+    }
+
+    return true;
+  }
+
+  return records.filter(record => applyFilter(record, where));
+}
+
+function applyOrderBy(records, order_by) {
+  const keys = Object.keys(order_by);
+  if (keys.length > 0) {
+    const field = keys[0];
+    const direction = order_by[field] === "asc" ? "asc" : "desc";
+    return orderBy(records, [field], [direction]);
+  }
+  return records;
+}

package/src/formatPasteData.js

@@ -0,0 +1,16 @@
+import { getFieldPathToField } from "./getFieldPathToField";
+
+export const formatPasteData = ({ schema, newVal, path }) => {
+  const pathToField = getFieldPathToField(schema);
+  const column = pathToField[path];
+  if (column.type === "genericSelect") {
+    if (newVal?.__genSelCol === path) {
+      newVal = newVal.__strVal;
+    } else {
+      newVal = undefined;
+    }
+  } else {
+    newVal = Object.hasOwn(newVal, "__strVal") ? newVal.__strVal : newVal;
+  }
+  return newVal;
+};

package/src/getAllRows.js

@@ -0,0 +1,11 @@
+export const getAllRows = e => {
+  const el = e.target.querySelector(".data-table-container")
+    ? e.target.querySelector(".data-table-container")
+    : e.target.closest(".data-table-container");
+
+  const allRowEls = el.querySelectorAll(".rt-tr");
+  if (!allRowEls || !allRowEls.length) {
+    return;
+  }
+  return allRowEls;
+};

package/src/getCellCopyText.js

@@ -0,0 +1,7 @@
+export const getCellCopyText = cellWrapper => {
+  const text = cellWrapper && cellWrapper.getAttribute("data-copy-text");
+  const jsonText = cellWrapper && cellWrapper.getAttribute("data-copy-json");
+
+  const textContent = text || cellWrapper.textContent || "";
+  return [textContent, jsonText];
+};

package/src/getCellInfo.js

@@ -0,0 +1,36 @@
+import { getIdOrCodeOrIndex } from "./getIdOrCodeOrIndex";
+
+export const getCellInfo = ({
+  columnIndex,
+  columnPath,
+  rowId,
+  schema,
+  entities,
+  rowIndex,
+  isEntityDisabled,
+  entity
+}) => {
+  const leftpath = schema.fields[columnIndex - 1]?.path;
+  const rightpath = schema.fields[columnIndex + 1]?.path;
+  const cellIdToLeft = leftpath && `${rowId}:${leftpath}`;
+  const cellIdToRight = rightpath && `${rowId}:${rightpath}`;
+  const rowAboveId =
+    entities[rowIndex - 1] &&
+    getIdOrCodeOrIndex(entities[rowIndex - 1], rowIndex - 1);
+  const rowBelowId =
+    entities[rowIndex + 1] &&
+    getIdOrCodeOrIndex(entities[rowIndex + 1], rowIndex + 1);
+  const cellIdAbove = rowAboveId && `${rowAboveId}:${columnPath}`;
+  const cellIdBelow = rowBelowId && `${rowBelowId}:${columnPath}`;
+
+  const cellId = `${rowId}:${columnPath}`;
+  const rowDisabled = isEntityDisabled(entity);
+  return {
+    cellId,
+    cellIdAbove,
+    cellIdToRight,
+    cellIdBelow,
+    cellIdToLeft,
+    rowDisabled
+  };
+};

package/src/getCellVal.js

@@ -0,0 +1,20 @@
+import { get } from "lodash-es";
+import { isString } from "lodash-es";
+import { isTruthy } from "./isTruthy";
+
+export const getCellVal = (ent, path, col) => {
+  const isBool = col?.type === "boolean";
+  let selectedCellVal = get(ent, path, "");
+  if (isBool) {
+    if (isString(selectedCellVal)) {
+      selectedCellVal = selectedCellVal.toLowerCase();
+    }
+    selectedCellVal =
+      selectedCellVal === "true" ||
+      selectedCellVal === true ||
+      selectedCellVal === 1 ||
+      selectedCellVal === "yes";
+    selectedCellVal = isTruthy(selectedCellVal);
+  }
+  return selectedCellVal;
+};

package/src/getDayjsFormatter.js

@@ -0,0 +1,35 @@
+import dayjs from "dayjs";
+import LocalizedFormat from "dayjs/plugin/localizedFormat";
+import localeData from "dayjs/plugin/localeData";
+
+dayjs.extend(localeData);
+dayjs.extend(LocalizedFormat);
+const userLocale = Intl.DateTimeFormat().resolvedOptions().locale;
+
+if (userLocale) {
+  const requireLocale = (newLocale, skipCall) => {
+    if (dayjs.locale() !== newLocale) {
+      try {
+        require(`dayjs/locale/${newLocale}.js`);
+        dayjs.locale(newLocale);
+      } catch (error) {
+        // error
+        if (!skipCall && newLocale.includes("-")) {
+          requireLocale(newLocale.split("-")[0], true);
+        }
+      }
+    }
+  };
+  const localeToUse = userLocale.toLowerCase();
+  requireLocale(localeToUse);
+}
+
+export default function getDayjsFormatter(format) {
+  return {
+    formatDate: date => dayjs(date).format(format),
+    parseDate: str => dayjs(str, format).toDate(),
+    placeholder: format?.toLowerCase().includes("l")
+      ? dayjs.Ls[dayjs.locale()]?.formats[format.toUpperCase()]
+      : format
+  };
+}

package/src/getFieldPathToField.js

@@ -0,0 +1,7 @@
+export const getFieldPathToField = schema => {
+  const fieldPathToField = {};
+  schema.fields.forEach(f => {
+    fieldPathToField[f.path] = f;
+  });
+  return fieldPathToField;
+};

package/src/getIdOrCodeOrIndex.js

@@ -0,0 +1,9 @@
+export const getIdOrCodeOrIndex = (record, rowIndex) => {
+  if (record.id || record.id === 0) {
+    return record.id;
+  } else if (record.code) {
+    return record.code;
+  } else {
+    return rowIndex;
+  }
+};

package/src/getLastSelectedEntity.js

@@ -0,0 +1,11 @@
+export const getLastSelectedEntity = idMap => {
+  let lastSelectedEnt;
+  let latestTime;
+  Object.values(idMap).forEach(({ time, entity }) => {
+    if (!latestTime || time > latestTime) {
+      lastSelectedEnt = entity;
+      latestTime = time;
+    }
+  });
+  return lastSelectedEnt;
+};

package/src/getNewEntToSelect.js

@@ -0,0 +1,25 @@
+export const getNewEntToSelect = ({
+  type,
+  lastSelectedIndex,
+  entities,
+  isEntityDisabled
+}) => {
+  let newIndexToSelect;
+  if (type === "up") {
+    newIndexToSelect = lastSelectedIndex - 1;
+  } else {
+    newIndexToSelect = lastSelectedIndex + 1;
+  }
+  const newEntToSelect = entities[newIndexToSelect];
+  if (!newEntToSelect) return;
+  if (isEntityDisabled && isEntityDisabled(newEntToSelect)) {
+    return getNewEntToSelect({
+      type,
+      lastSelectedIndex: newIndexToSelect,
+      entities,
+      isEntityDisabled
+    });
+  } else {
+    return newEntToSelect;
+  }
+};

package/src/getNewName.js

@@ -0,0 +1,31 @@
+export function getNewName(list, targetName) {
+  const usedNumbers = [];
+
+  for (let i = 0; i < list.length; i++) {
+    const currentName = list[i].name;
+    const baseName = currentName.replace(/\(\d+\)\.csv$/, ".csv");
+
+    if (baseName === targetName) {
+      const match = currentName.match(/\((\d+)\)\.csv$/);
+      if (match) {
+        usedNumbers[parseInt(match[1])] = true;
+      } else {
+        usedNumbers[0] = true;
+      }
+    }
+  }
+
+  let newName = targetName;
+  for (let i = 0; i <= usedNumbers.length; i++) {
+    if (!usedNumbers[i]) {
+      if (i === 0) {
+        newName = targetName;
+      } else {
+        newName = targetName.replace(".csv", `(${i}).csv`);
+      }
+      break;
+    }
+  }
+
+  return newName;
+}

package/src/getRowCopyText.js

@@ -0,0 +1,28 @@
+import { getCellCopyText } from "./getCellCopyText";
+import { flatMap } from "lodash-es";
+
+export const getRowCopyText = (rowEl, { specificColumn } = {}) => {
+  //takes in a row element
+  if (!rowEl) return [];
+  const textContent = [];
+  const jsonText = [];
+
+  for (const cellEl of rowEl.children) {
+    const cellChild = cellEl.querySelector(`[data-copy-text]`);
+    if (!cellChild) {
+      if (specificColumn) continue; //strip it
+      continue; //just leave it blank
+    }
+    if (
+      specificColumn &&
+      cellChild.getAttribute("data-test") !== specificColumn
+    ) {
+      continue;
+    }
+    const [t, j] = getCellCopyText(cellChild);
+    textContent.push(t);
+    jsonText.push(j);
+  }
+
+  return [flatMap(textContent).join("\t"), jsonText];
+};

package/src/getTableConfigFromStorage.js

@@ -0,0 +1,5 @@
+export default function getTableConfigFromStorage(formName) {
+  let tableConfig = window.localStorage.getItem(formName);
+  tableConfig = tableConfig && JSON.parse(tableConfig);
+  return tableConfig;
+}

package/src/getTextFromEl.js

@@ -0,0 +1,28 @@
+import React from "react";
+
+export default function getTextFromEl(el, options = {}) {
+  const { lowerCase } = options;
+  if (React.isValidElement(el)) {
+    return el && el.props && el.props.children
+      ? (el.props.children.reduce
+          ? el.props.children
+          : [el.props.children]
+        ).reduce((acc, child) => {
+          if (child && child.props && child.props.children) {
+            acc += getTextFromEl(child);
+          } else if (typeof child === "string") {
+            if (lowerCase) {
+              acc += child.toLowerCase();
+            } else {
+              acc += child;
+            }
+          } else if (typeof child === "number") {
+            acc += child + "";
+          }
+          return acc;
+        }, "")
+      : "";
+  } else {
+    return el;
+  }
+}

package/src/getVals.js

@@ -0,0 +1,8 @@
+import { isFunction } from "lodash-es";
+
+export function getVals(values) {
+  if (isFunction(values)) {
+    return values();
+  }
+  return values;
+}

package/src/handleCopyColumn.js

@@ -0,0 +1,21 @@
+import { getAllRows } from "./getAllRows";
+import { getIdOrCodeOrIndex } from "./getIdOrCodeOrIndex";
+import { handleCopyRows } from "./handleCopyRows";
+
+export const handleCopyColumn = (e, cellWrapper, selectedRecords) => {
+  const specificColumn = cellWrapper.getAttribute("data-test");
+  let rowElsToCopy = getAllRows(e);
+  if (!rowElsToCopy) return;
+  if (selectedRecords) {
+    const ids = selectedRecords.map(e => getIdOrCodeOrIndex(e)?.toString());
+    rowElsToCopy = Array.from(rowElsToCopy).filter(rowEl => {
+      const id = rowEl.closest(".rt-tr-group")?.getAttribute("data-test-id");
+      return id !== undefined && ids.includes(id);
+    });
+  }
+  if (!rowElsToCopy) return;
+  handleCopyRows(rowElsToCopy, {
+    specificColumn,
+    onFinishMsg: "Column Copied"
+  });
+};

package/src/handleCopyHelper.js

@@ -0,0 +1,15 @@
+import copy from "copy-to-clipboard";
+
+export const handleCopyHelper = (stringToCopy, jsonToCopy, message) => {
+  !window.Cypress &&
+    copy(stringToCopy, {
+      onCopy: clipboardData => {
+        clipboardData.setData("application/json", JSON.stringify(jsonToCopy));
+      },
+      // keep this so that pasting into spreadsheets works.
+      format: "text/plain"
+    });
+  if (message) {
+    window.toastr.success(message);
+  }
+};

package/src/handleCopyRows.js

@@ -0,0 +1,23 @@
+import download from "downloadjs";
+import { getRowCopyText } from "./getRowCopyText";
+import { handleCopyHelper } from "./handleCopyHelper";
+
+export const handleCopyRows = (
+  rowElsToCopy,
+  { specificColumn, onFinishMsg, isDownload } = {}
+) => {
+  let textToCopy = [];
+  const jsonToCopy = [];
+  rowElsToCopy.forEach(rowEl => {
+    const [t, j] = getRowCopyText(rowEl, { specificColumn });
+    textToCopy.push(t);
+    jsonToCopy.push(j);
+  });
+  textToCopy = textToCopy.filter(text => text).join("\n");
+  if (!textToCopy) return window.toastr.warning("No text to copy");
+  if (isDownload) {
+    download(textToCopy.replaceAll("\t", ","), "tableData.csv", "text/csv");
+  } else {
+    handleCopyHelper(textToCopy, jsonToCopy, onFinishMsg || "Row Copied");
+  }
+};

package/src/handleCopyTable.js

@@ -0,0 +1,16 @@
+import { getAllRows } from "./getAllRows";
+import { handleCopyRows } from "./handleCopyRows";
+
+export const handleCopyTable = (e, opts) => {
+  try {
+    const allRowEls = getAllRows(e);
+    if (!allRowEls) return;
+    handleCopyRows(allRowEls, {
+      ...opts,
+      onFinishMsg: "Table Copied"
+    });
+  } catch (error) {
+    console.error(`error:`, error);
+    window.toastr.error("Error copying rows.");
+  }
+};

package/src/handlerHelpers.js

@@ -0,0 +1,24 @@
+export const onEnterHelper = callback => ({
+  onKeyDown: event => {
+    if (event.key === "Enter") {
+      callback(event);
+    }
+  }
+});
+
+export const onBlurHelper = callback => ({
+  onBlur: event => {
+    callback(event);
+  }
+});
+
+export const onEnterOrBlurHelper = callback => ({
+  onKeyDown: function (event) {
+    if (event.key === "Enter") {
+      callback(event);
+    }
+  },
+  onBlur: function (event) {
+    callback(event);
+  }
+});