@teselagen/ui 0.7.34 → 0.7.36

package/src/DataTable/utils/getNewEntToSelect.js

@@ -1,25 +0,0 @@
-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/DataTable/utils/getRowCopyText.js

@@ -1,28 +0,0 @@
-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/DataTable/utils/getTableConfigFromStorage.js

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

package/src/DataTable/utils/handleCopyColumn.js

@@ -1,21 +0,0 @@
-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/DataTable/utils/handleCopyHelper.js

@@ -1,15 +0,0 @@
-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/DataTable/utils/handleCopyRows.js

@@ -1,23 +0,0 @@
-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/DataTable/utils/handleCopyTable.js

@@ -1,16 +0,0 @@
-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/DataTable/utils/index.js

@@ -1,55 +0,0 @@
-import { isEntityClean } from "./isEntityClean";
-import { getSelectedRowsFromEntities } from "./selection";
-import { removeCleanRows } from "./removeCleanRows";
-import { getIdOrCodeOrIndex } from "./getIdOrCodeOrIndex";
-import { getRecordsFromIdMap } from "./withSelectedEntities";
-import { formatPasteData } from "./formatPasteData";
-import { getFieldPathToField } from "./getFieldPathToField";
-import {
-  defaultParsePaste,
-  getEntityIdToEntity,
-  getFieldPathToIndex,
-  getNumberStrAtEnd,
-  stripNumberAtEnd
-} from "./utils";
-import { getAllRows } from "./getAllRows";
-import { getNewEntToSelect } from "./getNewEntToSelect";
-import { getLastSelectedEntity } from "./getLastSelectedEntity";
-import { getCellInfo } from "./getCellInfo";
-import { getCellCopyText } from "./getCellCopyText";
-import { getRowCopyText } from "./getRowCopyText";
-import { handleCopyHelper } from "./handleCopyHelper";
-import { handleCopyRows } from "./handleCopyRows";
-import { handleCopyColumn } from "./handleCopyColumn";
-import { isBottomRightCornerOfRectangle } from "./isBottomRightCornerOfRectangle";
-import { handleCopyTable } from "./handleCopyTable";
-import { PRIMARY_SELECTED_VAL } from "./primarySelectedValue";
-import { useTableEntities } from "./useTableEntities";
-
-export {
-  defaultParsePaste,
-  formatPasteData,
-  getAllRows,
-  getCellCopyText,
-  getCellInfo,
-  getEntityIdToEntity,
-  getFieldPathToIndex,
-  getFieldPathToField,
-  getIdOrCodeOrIndex,
-  getLastSelectedEntity,
-  getNewEntToSelect,
-  getNumberStrAtEnd,
-  getRecordsFromIdMap,
-  getRowCopyText,
-  getSelectedRowsFromEntities,
-  handleCopyColumn,
-  handleCopyHelper,
-  handleCopyRows,
-  handleCopyTable,
-  isBottomRightCornerOfRectangle,
-  isEntityClean,
-  PRIMARY_SELECTED_VAL,
-  removeCleanRows,
-  stripNumberAtEnd,
-  useTableEntities
-};

package/src/DataTable/utils/initializeHasuraWhereAndFilter.js

@@ -1,26 +0,0 @@
-export function initializeHasuraWhereAndFilter(
-  additionalFilter,
-  where = {},
-  currentParams
-) {
-  where._and = where._and || [];
-  where._or = where._or || [];
-  if (typeof additionalFilter === "function") {
-    const newWhere = additionalFilter(where, currentParams);
-    if (newWhere) {
-      where = {
-        ...where,
-        ...newWhere
-      };
-    }
-  } else if (typeof additionalFilter === "object")
-    where._and.push(additionalFilter);
-}
-
-export const addCustomColumnFilters = (where, fields, currentParams) => {
-  fields.forEach(field => {
-    const { customColumnFilter, filterDisabled } = field;
-    if (filterDisabled || !customColumnFilter) return;
-    customColumnFilter(where, currentParams);
-  });
-};

package/src/DataTable/utils/isBottomRightCornerOfRectangle.js

@@ -1,20 +0,0 @@
-export const isBottomRightCornerOfRectangle = ({
-  cellId,
-  selectionGrid,
-  lastRowIndex,
-  lastCellIndex,
-  entityMap,
-  pathToIndex
-}) => {
-  selectionGrid.forEach(row => {
-    // remove undefineds from start of row
-    while (row[0] === undefined && row.length) row.shift();
-  });
-  const [rowId, cellPath] = cellId.split(":");
-  const ent = entityMap[rowId];
-  if (!ent) return;
-  const { i } = ent;
-  const cellIndex = pathToIndex[cellPath];
-  const isBottomRight = i === lastRowIndex && cellIndex === lastCellIndex;
-  return isBottomRight;
-};

package/src/DataTable/utils/isEntityClean.js

@@ -1,15 +0,0 @@
-export function isEntityClean(e) {
-  if (typeof e !== "object" || e === null) {
-    return true; // or return false depending on what you want for non-object inputs
-  }
-  let isClean = true;
-  for (const [key, val] of Object.entries(e)) {
-    if (key === "id") continue;
-    if (key === "_isClean") continue;
-    if (val) {
-      isClean = false;
-      break;
-    }
-  }
-  return isClean;
-}

package/src/DataTable/utils/primarySelectedValue.js

@@ -1 +0,0 @@
-export const PRIMARY_SELECTED_VAL = "main_cell";

package/src/DataTable/utils/queryParams.js

@@ -1,350 +0,0 @@
-import queryString from "qs";
-import { uniqBy, clone, camelCase } from "lodash-es";
-import {
-  getFieldsMappedByCCDisplayName,
-  tableQueryParamsToHasuraClauses
-} from "./tableQueryParamsToHasuraClauses";
-import { filterLocalEntitiesToHasura } from "./filterLocalEntitiesToHasura";
-import {
-  addCustomColumnFilters,
-  initializeHasuraWhereAndFilter
-} from "./initializeHasuraWhereAndFilter";
-
-const defaultPageSizes = [5, 10, 15, 25, 50, 100, 200, 400];
-
-export { defaultPageSizes };
-
-export function getMergedOpts(topLevel = {}, instanceLevel = {}) {
-  const merged = {
-    ...topLevel,
-    ...instanceLevel
-  };
-  return {
-    formName: "tgDataTable",
-    ...merged,
-    pageSize: merged.controlled_pageSize || merged.pageSize,
-    defaults: {
-      pageSize: merged.controlled_pageSize || 25,
-      order: [], //[-name, statusCode] //an array of camelCase display names with - sign to denote reverse
-      searchTerm: "",
-      page: 1,
-      filters: [
-        //filters look like this:
-        // {
-        //   selectedFilter: 'textContains', //camel case
-        //   filterOn: ccDisplayName, //camel case display name if available and string, otherwise path
-        //   filterValue: 'thomas',
-        // }
-      ],
-      ...(topLevel.defaults || {}),
-      ...(instanceLevel.defaults || {})
-    }
-  };
-}
-
-function safeStringify(val) {
-  if (val !== null && typeof val === "object") {
-    return JSON.stringify(val);
-  }
-  return val;
-}
-
-function safeParse(val) {
-  try {
-    return JSON.parse(val);
-  } catch (e) {
-    return val;
-  }
-}
-
-export function getCurrentParamsFromUrl(location, isSimple) {
-  let { search } = location;
-  if (isSimple) {
-    search = window.location.href.split("?")[1] || "";
-  }
-
-  return parseFilters(queryString.parse(search, { ignoreQueryPrefix: true }));
-}
-
-export function setCurrentParamsOnUrl(newParams, replace, isSimple) {
-  const stringifiedFilters = stringifyFilters(newParams);
-  const search = `?${queryString.stringify(stringifiedFilters)}`;
-  if (isSimple) {
-    return window.location.replace(
-      `${window.location.href.split("?")[0]}${search}`
-    );
-  }
-  replace({
-    search
-  });
-}
-
-function stringifyFilters(newParams) {
-  let filters;
-  if (newParams.filters && newParams.filters.length) {
-    filters = newParams.filters.reduce(
-      (acc, { filterOn, selectedFilter, filterValue }, index) => {
-        acc +=
-          (index > 0 ? "::" : "") +
-          `${filterOn}__${camelCase(selectedFilter)}__${safeStringify(
-            Array.isArray(filterValue) ? filterValue.join(";") : filterValue
-          )}`;
-        return acc;
-      },
-      ""
-    );
-  }
-  let order;
-  if (newParams.order && newParams.order.length) {
-    order = newParams.order.reduce((acc, order, index) => {
-      acc += (index > 0 ? "___" : "") + order;
-      return acc;
-    }, "");
-  }
-  return {
-    ...newParams,
-    filters,
-    order
-  };
-}
-function parseFilters(newParams) {
-  return {
-    ...newParams,
-    order: newParams.order && newParams.order.split("___"),
-    filters:
-      newParams.filters &&
-      newParams.filters.split("::").map(filter => {
-        const splitFilter = filter.split("__");
-        const [filterOn, selectedFilter, filterValue] = splitFilter;
-        const parseFilterValue = filterValue => {
-          if (selectedFilter === "inList" || selectedFilter === "notInList") {
-            return filterValue.split(";");
-          }
-          if (
-            selectedFilter === "inRange" ||
-            selectedFilter === "outsideRange"
-          ) {
-            return filterValue.split(";").map(Number);
-          }
-          return safeParse(filterValue);
-        };
-        return {
-          filterOn,
-          selectedFilter,
-          filterValue: parseFilterValue(filterValue)
-        };
-      })
-  };
-}
-
-export function makeDataTableHandlers({
-  setNewParams,
-  defaults,
-  onlyOneFilter
-}) {
-  //all of these actions have currentParams bound to them as their last arg in withTableParams
-  const setSearchTerm = searchTerm => {
-    setNewParams(prev => ({
-      ...(prev ?? {}),
-      page: undefined, //set page undefined to return the table to page 1
-      searchTerm: searchTerm === defaults.searchTerm ? undefined : searchTerm
-    }));
-    onlyOneFilter && clearFilters();
-  };
-
-  const addFilters = newFilters => {
-    if (!newFilters) return;
-    setNewParams(prev => {
-      const filters = uniqBy(
-        [...newFilters, ...(onlyOneFilter ? [] : prev?.filters || [])],
-        "filterOn"
-      );
-      return {
-        ...(prev ?? {}),
-        page: undefined, //set page undefined to return the table to page 1
-        filters
-      };
-    });
-  };
-
-  const removeSingleFilter = filterOn =>
-    setNewParams(prev => {
-      const filters = prev?.filters
-        ? prev.filters.filter(filter => {
-            return filter.filterOn !== filterOn;
-          })
-        : undefined;
-      return { ...(prev ?? {}), filters };
-    });
-
-  const clearFilters = (additionalFilterKeys = []) => {
-    const toClear = {
-      filters: undefined,
-      searchTerm: undefined,
-      tags: undefined
-    };
-    additionalFilterKeys.forEach(key => {
-      toClear[key] = undefined;
-    });
-    setNewParams(toClear);
-  };
-
-  const setPageSize = pageSize =>
-    setNewParams(prev => ({
-      ...(prev ?? {}),
-      pageSize: pageSize === defaults.pageSize ? undefined : pageSize,
-      page: undefined //set page undefined to return the table to page 1
-    }));
-
-  const setOrder = (order, isRemove, shiftHeld) =>
-    setNewParams(prev => {
-      let newOrder = [];
-      if (shiftHeld) {
-        //first remove the old order
-        newOrder = [...(prev?.order || [])].filter(value => {
-          const shouldRemove =
-            value.replace(/^-/, "") === order.replace(/^-/, "");
-          return !shouldRemove;
-        });
-        //then, if we are adding, pop the order onto the array
-        if (!isRemove) {
-          newOrder.push(order);
-        }
-      } else {
-        if (isRemove) {
-          newOrder = [];
-        } else {
-          newOrder = [order];
-        }
-      }
-      return {
-        ...(prev ?? {}),
-        order: newOrder
-      };
-    });
-
-  const setPage = page => {
-    setNewParams(prev => ({
-      ...(prev ?? {}),
-      page: page === defaults.page ? undefined : page
-    }));
-  };
-
-  return {
-    setSearchTerm,
-    addFilters,
-    clearFilters,
-    removeSingleFilter,
-    setPageSize,
-    setPage,
-    setOrder,
-    setNewParams
-  };
-}
-
-export function getQueryParams({
-  currentParams,
-  // urlConnected,
-  defaults,
-  schema,
-  isInfinite,
-  entities,
-  isLocalCall,
-  additionalFilter,
-  doNotCoercePageSize,
-  noOrderError,
-  // isCodeModel,
-  ownProps
-}) {
-  Object.keys(currentParams).forEach(function (key) {
-    if (currentParams[key] === undefined) {
-      delete currentParams[key]; //we want to use the default value if any of these are undefined
-    }
-  });
-  const tableQueryParams = {
-    ...defaults,
-    ...currentParams
-  };
-  let { page, pageSize, searchTerm, filters, order } = tableQueryParams;
-  if (page <= 0 || isNaN(page)) {
-    page = undefined;
-  }
-  if (isInfinite) {
-    page = undefined;
-    pageSize = undefined;
-  }
-  if (pageSize !== undefined && !doNotCoercePageSize) {
-    //pageSize might come in as an unexpected number so we coerce it to be one of the nums in our pageSizes array
-    const closest = clone(window.tgPageSizes || defaultPageSizes).sort(
-      (a, b) => Math.abs(pageSize - a) - Math.abs(pageSize - b)
-    )[0];
-    pageSize = closest;
-  }
-
-  const cleanedOrder = [];
-  if (order && order.length) {
-    const ccFields = getFieldsMappedByCCDisplayName(schema);
-    order.forEach(orderVal => {
-      const ccDisplayName = orderVal.replace(/^-/gi, "");
-      const schemaForField = ccFields[ccDisplayName];
-      if (schemaForField) {
-        const { path } = schemaForField;
-        const reversed = ccDisplayName !== orderVal;
-        const prefix = reversed ? "-" : "";
-        cleanedOrder.push(prefix + path);
-      } else {
-        !noOrderError &&
-          console.error(
-            "No schema for field found!",
-            ccDisplayName,
-            JSON.stringify(schema.fields, null, 2)
-          );
-      }
-    });
-  }
-
-  let toRet = {
-    //these are values that might be generally useful for the wrapped component
-    page,
-    pageSize: ownProps.controlled_pageSize || pageSize,
-    order: cleanedOrder,
-    filters,
-    searchTerm
-  };
-
-  const { where, order_by, limit, offset } = tableQueryParamsToHasuraClauses({
-    page,
-    pageSize,
-    searchTerm,
-    filters,
-    order: cleanedOrder,
-    schema
-  });
-  initializeHasuraWhereAndFilter(additionalFilter, where, currentParams);
-  addCustomColumnFilters(where, schema.fields, currentParams);
-  if (isLocalCall) {
-    //if the table is local (aka not directly connected to a db) then we need to
-    //handle filtering/paging/sorting all on the front end
-    toRet = {
-      ...toRet,
-      ...filterLocalEntitiesToHasura(entities, {
-        where,
-        order_by,
-        limit,
-        offset,
-        isInfinite
-      })
-    };
-    return toRet;
-  } else {
-    return {
-      ...toRet,
-      variables: {
-        where,
-        order_by,
-        limit,
-        offset
-      }
-    };
-  }
-}

package/src/DataTable/utils/removeCleanRows.js

@@ -1,22 +0,0 @@
-import { isEntityClean } from "./isEntityClean";
-import { getIdOrCodeOrIndex } from "./getIdOrCodeOrIndex";
-
-export const removeCleanRows = (entities, cellValidation) => {
-  const toFilterOut = {};
-  const entsToUse = (entities || []).filter(e => {
-    if (!(e._isClean || isEntityClean(e))) return true;
-    else {
-      toFilterOut[getIdOrCodeOrIndex(e)] = true;
-      return false;
-    }
-  });
-
-  const validationToUse = {};
-  Object.entries(cellValidation || {}).forEach(([k, v]) => {
-    const [rowId] = k.split(":");
-    if (!toFilterOut[rowId]) {
-      validationToUse[k] = v;
-    }
-  });
-  return { entsToUse, validationToUse };
-};