@teselagen/ui 0.7.35 → 0.7.36

package/src/DataTable/utils/rowClick.js

@@ -1,181 +0,0 @@
-import { isEmpty, forEach, range } from "lodash-es";
-import { getSelectedRowsFromEntities } from "./selection";
-import { getIdOrCodeOrIndex } from "./getIdOrCodeOrIndex";
-import { getRecordsFromIdMap } from "./withSelectedEntities";
-
-export default function rowClick(
-  e,
-  rowInfo,
-  entities,
-  {
-    reduxFormSelectedEntityIdMap,
-    isSingleSelect,
-    noSelect,
-    onRowClick,
-    isEntityDisabled,
-    withCheckboxes,
-    onDeselect,
-    onSingleRowSelect,
-    onMultiRowSelect,
-    noDeselectAll,
-    onRowSelect,
-    change
-  }
-) {
-  const entity = rowInfo.original;
-  onRowClick(e, entity, rowInfo);
-  if (noSelect || isEntityDisabled(entity)) return;
-  const rowId = getIdOrCodeOrIndex(entity, rowInfo.index);
-  if (rowId === undefined) return;
-  const ctrl = e.metaKey || e.ctrlKey || (withCheckboxes && !e.shiftKey);
-  const oldIdMap = reduxFormSelectedEntityIdMap || {};
-  const rowSelected = oldIdMap[rowId];
-  let newIdMap = {
-    [rowId]: {
-      time: Date.now(),
-      entity
-    }
-  };
-
-  if (isSingleSelect) {
-    if (rowSelected) newIdMap = {};
-  } else if (rowSelected && e.shiftKey) return;
-  else if (rowSelected && ctrl) {
-    newIdMap = {
-      ...oldIdMap
-    };
-    delete newIdMap[rowId];
-  } else if (rowSelected) {
-    newIdMap = {};
-  } else if (ctrl) {
-    newIdMap = {
-      ...oldIdMap,
-      ...newIdMap
-    };
-  } else if (e.shiftKey && !isEmpty(oldIdMap)) {
-    newIdMap = {
-      [rowId]: {
-        entity,
-        time: Date.now()
-      }
-    };
-    const currentlySelectedRowIndices = getSelectedRowsFromEntities(
-      entities,
-      oldIdMap
-    );
-    if (currentlySelectedRowIndices.length) {
-      let timeToBeat = {
-        id: null,
-        time: null
-      };
-      forEach(oldIdMap, ({ time }, key) => {
-        if (time && time > timeToBeat.time)
-          timeToBeat = {
-            id: key,
-            time
-          };
-      });
-      const mostRecentlySelectedIndex = entities.findIndex((e, i) => {
-        let id = getIdOrCodeOrIndex(e, i);
-        if (!id && id !== 0) id = "";
-        return id.toString() === timeToBeat.id;
-      });
-
-      if (mostRecentlySelectedIndex !== -1) {
-        const highRange =
-          rowInfo.index < mostRecentlySelectedIndex
-            ? mostRecentlySelectedIndex - 1
-            : rowInfo.index;
-        const lowRange =
-          rowInfo.index > mostRecentlySelectedIndex
-            ? mostRecentlySelectedIndex + 1
-            : rowInfo.index;
-        range(lowRange, highRange + 1).forEach(i => {
-          if (isEntityDisabled && isEntityDisabled(entities[i])) {
-            return;
-          }
-          const recordId = entities[i] && getIdOrCodeOrIndex(entities[i], i);
-          if (recordId || recordId === 0)
-            // newIdMap[recordId] = { entity: entities[i] };
-            newIdMap[recordId] = { entity: entities[i], time: Date.now() };
-        });
-        newIdMap = {
-          ...oldIdMap,
-          ...newIdMap
-        };
-        if (newIdMap[rowId]) {
-          //the entity we just clicked on should have the "freshest" time
-          newIdMap[rowId].time = Date.now() + 1;
-        }
-      }
-    }
-  }
-
-  finalizeSelection({
-    idMap: newIdMap,
-    entities,
-    props: {
-      onDeselect,
-      onSingleRowSelect,
-      onMultiRowSelect,
-      noDeselectAll,
-      onRowSelect,
-      noSelect,
-      change
-    }
-  });
-}
-
-export function changeSelectedEntities({ idMap, entities = [], change }) {
-  const newIdMap = { ...idMap };
-  const entityIdToIndex = {};
-  entities.forEach((e, i) => {
-    entityIdToIndex[getIdOrCodeOrIndex(e, 0)] = i;
-  });
-  // we want to store the index of the entity so that it can be used to preserve order in selection
-  Object.keys(newIdMap).forEach(key => {
-    if (!newIdMap[key]) return;
-    const rowIndex =
-      entityIdToIndex[getIdOrCodeOrIndex(newIdMap[key].entity, 0)];
-    newIdMap[key] = {
-      ...newIdMap[key],
-      rowIndex: rowIndex === undefined ? 10000000 : rowIndex
-    };
-  });
-
-  change("reduxFormSelectedEntityIdMap", newIdMap);
-}
-
-export function finalizeSelection({
-  idMap,
-  entities,
-  props: {
-    onDeselect,
-    onSingleRowSelect,
-    onMultiRowSelect,
-    noDeselectAll,
-    onRowSelect,
-    noSelect,
-    change
-  }
-}) {
-  if (noSelect) return;
-  if (
-    noDeselectAll &&
-    Object.keys(idMap).filter(id => {
-      return idMap[id];
-    }).length === 0
-  ) {
-    return;
-  }
-
-  changeSelectedEntities({ idMap, entities, change });
-  const selectedRecords = getRecordsFromIdMap(idMap);
-  onRowSelect(selectedRecords);
-
-  selectedRecords.length === 0
-    ? onDeselect()
-    : selectedRecords.length > 1
-      ? onMultiRowSelect(selectedRecords)
-      : onSingleRowSelect(selectedRecords[0]);
-}

package/src/DataTable/utils/selection.js

@@ -1,8 +0,0 @@
-import { getIdOrCodeOrIndex } from "./getIdOrCodeOrIndex";
-
-export const getSelectedRowsFromEntities = (entities, idMap) => {
-  if (!idMap) return [];
-  return entities.reduce((acc, entity, i) => {
-    return idMap[getIdOrCodeOrIndex(entity, i)] ? acc.concat(i) : acc;
-  }, []);
-};

package/src/DataTable/utils/tableQueryParamsToHasuraClauses.js

@@ -1,253 +0,0 @@
-import { camelCase, set } from "lodash-es";
-
-export function tableQueryParamsToHasuraClauses({
-  page,
-  pageSize,
-  searchTerm,
-  filters,
-  order,
-  schema, // Add schema as a parameter
-  additionalFilter
-}) {
-  const ccFields = getFieldsMappedByCCDisplayName(schema);
-  let where = {};
-  const order_by = {};
-  const limit = pageSize || 25;
-  const offset = page && pageSize ? (page - 1) * pageSize : 0;
-
-  if (searchTerm) {
-    const searchTermFilters = [];
-    schema.fields.forEach(field => {
-      const { type, path, searchDisabled } = field;
-      if (searchDisabled || field.filterDisabled || type === "color") return;
-      const filterValue = searchTerm; // No cleaning needed here, we're using _ilike
-
-      if (type === "string" || type === "lookup") {
-        const o = set({}, path, { _ilike: `%${filterValue}%` });
-        searchTermFilters.push(o);
-      } else if (type === "boolean") {
-        let regex;
-        try {
-          regex = new RegExp("^" + searchTerm, "ig");
-        } catch (error) {
-          //ignore
-        }
-        if (regex) {
-          if ("true".replace(regex, "") !== "true") {
-            const o = set({}, path, { _eq: true });
-            searchTermFilters.push(o);
-          } else if ("false".replace(regex, "") !== "false") {
-            const o = set({}, path, { _eq: false });
-            searchTermFilters.push(o);
-          }
-        }
-      } else if (
-        (type === "number" || type === "integer") &&
-        !isNaN(filterValue)
-      ) {
-        const o = set({}, path, { _eq: parseFloat(filterValue) });
-        searchTermFilters.push(o);
-      }
-    });
-    if (searchTermFilters.length > 0) {
-      if (Object.keys(where).length > 0) {
-        where = { _and: [where, { _or: searchTermFilters }] };
-      } else {
-        where = { _or: searchTermFilters };
-      }
-    }
-  }
-
-  if (filters && filters.length > 0) {
-    const filterClauses = filters
-      .map(filter => {
-        let { selectedFilter, filterOn, filterValue } = filter;
-        const fieldSchema = ccFields[filterOn] || {};
-
-        const { path, reference, type } = fieldSchema;
-        let stringFilterValue =
-          filterValue && filterValue.toString
-            ? filterValue.toString()
-            : filterValue;
-        if (stringFilterValue === false) {
-          // we still want to be able to search for the string "false" which will get parsed to false
-          stringFilterValue = "false";
-        } else {
-          stringFilterValue = stringFilterValue || "";
-        }
-        const arrayFilterValue = Array.isArray(filterValue)
-          ? filterValue
-          : stringFilterValue.split(";");
-
-        if (type === "number" || type === "integer") {
-          filterValue = Array.isArray(filterValue)
-            ? filterValue.map(val => Number(val))
-            : Number(filterValue);
-        }
-
-        if (fieldSchema.normalizeFilter) {
-          filterValue = fieldSchema.normalizeFilter(
-            filterValue,
-            selectedFilter,
-            filterOn
-          );
-        }
-
-        if (reference) {
-          filterOn = reference.sourceField;
-        } else {
-          filterOn = path || filterOn;
-        }
-        switch (selectedFilter) {
-          case "none":
-            return {};
-          case "startsWith":
-            return { [filterOn]: { _ilike: `${filterValue}%` } };
-          case "endsWith":
-            return { [filterOn]: { _ilike: `%${filterValue}` } };
-          case "contains":
-            return { [filterOn]: { _ilike: `%${filterValue}%` } };
-          case "notContains":
-            return { [filterOn]: { _not_ilike: `%${filterValue}%` } };
-          case "isExactly":
-            return { [filterOn]: { _eq: filterValue } };
-          case "isEmpty":
-            return {
-              _or: [
-                { [filterOn]: { _eq: "" } },
-                { [filterOn]: { _is_null: true } }
-              ]
-            };
-          case "notEmpty":
-            return {
-              _and: [
-                { [filterOn]: { _neq: "" } },
-                { [filterOn]: { _is_null: false } }
-              ]
-            };
-          case "inList":
-            return { [filterOn]: { _in: filterValue } };
-          case "notInList":
-            return { [filterOn]: { _nin: filterValue } };
-          case "true":
-            return { [filterOn]: { _eq: true } };
-          case "false":
-            return { [filterOn]: { _eq: false } };
-          case "dateIs":
-            return { [filterOn]: { _eq: filterValue } };
-          case "notBetween":
-            return {
-              _or: [
-                {
-                  [filterOn]: {
-                    _lt: new Date(arrayFilterValue[0])
-                  }
-                },
-                {
-                  [filterOn]: {
-                    _gt: new Date(
-                      new Date(arrayFilterValue[1]).setHours(23, 59)
-                    )
-                  }
-                }
-              ]
-            };
-          case "isBetween":
-            return {
-              [filterOn]: {
-                _gte: new Date(arrayFilterValue[0]),
-                _lte: new Date(new Date(arrayFilterValue[1]).setHours(23, 59))
-              }
-            };
-          case "isBefore":
-            return { [filterOn]: { _lt: new Date(filterValue) } };
-          case "isAfter":
-            return { [filterOn]: { _gt: new Date(filterValue) } };
-          case "greaterThan":
-            return { [filterOn]: { _gt: parseFloat(filterValue) } };
-          case "lessThan":
-            return { [filterOn]: { _lt: parseFloat(filterValue) } };
-          case "inRange":
-            return {
-              [filterOn]: {
-                _gte: parseFloat(arrayFilterValue[0]),
-                _lte: parseFloat(arrayFilterValue[1])
-              }
-            };
-          case "outsideRange":
-            return {
-              _or: [
-                {
-                  [filterOn]: {
-                    _lt: parseFloat(arrayFilterValue[0])
-                  }
-                },
-                {
-                  [filterOn]: {
-                    _gt: parseFloat(arrayFilterValue[1])
-                  }
-                }
-              ]
-            };
-          case "equalTo":
-            return { [filterOn]: { _eq: parseFloat(filterValue) } };
-          case "regex":
-            return { [filterOn]: { _regex: filterValue } };
-          default:
-            console.warn(`Unsupported filter type: ${selectedFilter}`);
-            return {};
-        }
-      })
-      .map(filter => {
-        const o = {};
-        set(o, Object.keys(filter)[0], filter[Object.keys(filter)[0]]);
-        return o;
-      });
-
-    if (filterClauses.length > 0) {
-      if (Object.keys(where).length > 0) {
-        where = { _and: [where, ...filterClauses] };
-      } else {
-        where = { _and: filterClauses };
-      }
-    }
-  }
-
-  if (order && order.length > 0) {
-    order.forEach(item => {
-      const field = item.startsWith("-") ? item.substring(1) : item;
-      const direction = item.startsWith("-") ? "desc" : "asc";
-      order_by[field] = direction;
-    });
-  }
-
-  if (additionalFilter) {
-    where = { _and: [where, additionalFilter] };
-  }
-  return { where, order_by, limit, offset };
-}
-
-/**
- * Takes a schema and returns an object with the fields mapped by their camelCased display name.
- * If the displayName is not set or is a jsx element, the path is used instead.
- * The same conversion must be done when using the result of this method
- */
-export function getFieldsMappedByCCDisplayName(schema) {
-  if (!schema || !schema.fields) return {};
-  return schema.fields.reduce((acc, field) => {
-    const ccDisplayName = getCCDisplayName(field);
-    acc[ccDisplayName] = field;
-    return acc;
-  }, {});
-}
-
-/**
- *
- * @param {object} field
- * @returns the camelCase display name of the field, to be used for filters, sorting, etc
- */
-export function getCCDisplayName(field) {
-  return camelCase(
-    typeof field.displayName === "string" ? field.displayName : field.path
-  );
-}

package/src/DataTable/utils/tableQueryParamsToHasuraClauses.test.js

@@ -1,206 +0,0 @@
-import { tableQueryParamsToHasuraClauses } from "./tableQueryParamsToHasuraClauses";
-
-describe("tableQueryParamsToHasuraClauses", () => {
-  const schema = {
-    fields: [
-      { path: "name", type: "string" },
-      { path: "age", type: "number" },
-      { path: "isActive", type: "boolean" },
-      { path: "email", type: "string" }
-    ]
-  };
-
-  it("should handle empty query params", () => {
-    const result = tableQueryParamsToHasuraClauses({});
-    expect(result).toEqual({
-      where: {},
-      order_by: {},
-      limit: 25,
-      offset: 0
-    });
-  });
-
-  it("should handle page and pageSize", () => {
-    const result = tableQueryParamsToHasuraClauses({ page: 2, pageSize: 10 });
-    expect(result).toEqual({
-      where: {},
-      order_by: {},
-      limit: 10,
-      offset: 10
-    });
-  });
-
-  it("should handle searchTerm with string fields", () => {
-    const result = tableQueryParamsToHasuraClauses({
-      searchTerm: "test",
-      schema
-    });
-    expect(result).toEqual({
-      where: {
-        _or: [{ name: { _ilike: "%test%" } }, { email: { _ilike: "%test%" } }]
-      },
-      order_by: {},
-      limit: 25,
-      offset: 0
-    });
-  });
-
-  it("should handle searchTerm with number fields", () => {
-    const result = tableQueryParamsToHasuraClauses({
-      searchTerm: "30",
-      schema
-    });
-    expect(result).toEqual({
-      where: {
-        _or: [
-          { name: { _ilike: "%30%" } },
-          { age: { _eq: 30 } },
-          { email: { _ilike: "%30%" } }
-        ]
-      },
-      order_by: {},
-      limit: 25,
-      offset: 0
-    });
-  });
-
-  it("should handle searchTerm with boolean fields", () => {
-    const result = tableQueryParamsToHasuraClauses({
-      searchTerm: "true",
-      schema
-    });
-    expect(result).toEqual({
-      where: {
-        _or: [
-          { name: { _ilike: "%true%" } },
-          { isActive: { _eq: true } },
-          { email: { _ilike: "%true%" } }
-        ]
-      },
-      order_by: {},
-      limit: 25,
-      offset: 0
-    });
-  });
-
-  it("should handle searchTerm with multiple field types", () => {
-    const result = tableQueryParamsToHasuraClauses({
-      searchTerm: "test",
-      schema
-    });
-    expect(result).toEqual({
-      where: {
-        _or: [{ name: { _ilike: "%test%" } }, { email: { _ilike: "%test%" } }]
-      },
-      order_by: {},
-      limit: 25,
-      offset: 0
-    });
-  });
-
-  it("should handle contains filter", () => {
-    const result = tableQueryParamsToHasuraClauses({
-      filters: [
-        {
-          selectedFilter: "contains",
-          filterOn: "name",
-          filterValue: "test"
-        }
-      ]
-    });
-    expect(result).toEqual({
-      where: { _and: [{ name: { _ilike: "%test%" } }] },
-      order_by: {},
-      limit: 25,
-      offset: 0
-    });
-  });
-
-  it("should handle equalTo filter for number", () => {
-    const result = tableQueryParamsToHasuraClauses({
-      filters: [
-        { selectedFilter: "equalTo", filterOn: "age", filterValue: "30" }
-      ],
-      schema
-    });
-    expect(result).toEqual({
-      where: { _and: [{ age: { _eq: 30 } }] },
-      order_by: {},
-      limit: 25,
-      offset: 0
-    });
-  });
-
-  it("should handle order", () => {
-    const result = tableQueryParamsToHasuraClauses({ order: ["name", "-age"] });
-    expect(result).toEqual({
-      where: {},
-      order_by: { name: "asc", age: "desc" },
-      limit: 25,
-      offset: 0
-    });
-  });
-
-  it("should combine all params", () => {
-    const result = tableQueryParamsToHasuraClauses({
-      page: 2,
-      pageSize: 10,
-      searchTerm: "test",
-      filters: [
-        {
-          selectedFilter: "greaterThan",
-          filterOn: "age",
-          filterValue: "30"
-        }
-      ],
-      order: ["name"],
-      schema
-    });
-    expect(result).toEqual({
-      where: {
-        _and: [
-          {
-            _or: [
-              { name: { _ilike: "%test%" } },
-              { email: { _ilike: "%test%" } }
-            ]
-          },
-          { age: { _gt: 30 } }
-        ]
-      },
-      order_by: { name: "asc" },
-      limit: 10,
-      offset: 10
-    });
-  });
-
-  it("should combine searchTerm and filters", () => {
-    const result = tableQueryParamsToHasuraClauses({
-      searchTerm: "test",
-      filters: [
-        {
-          selectedFilter: "greaterThan",
-          filterOn: "age",
-          filterValue: "30"
-        }
-      ],
-      schema
-    });
-    expect(result).toEqual({
-      where: {
-        _and: [
-          {
-            _or: [
-              { name: { _ilike: "%test%" } },
-              { email: { _ilike: "%test%" } }
-            ]
-          },
-          { age: { _gt: 30 } }
-        ]
-      },
-      order_by: {},
-      limit: 25,
-      offset: 0
-    });
-  });
-});

package/src/DataTable/utils/useTableEntities.js

@@ -1,38 +0,0 @@
-import { useCallback } from "react";
-import { useDispatch, useSelector } from "react-redux";
-import { change, initialize } from "redux-form";
-
-export const useTableEntities = tableFormName => {
-  const dispatch = useDispatch();
-  const selectTableEntities = useCallback(
-    (entities = []) => {
-      initialize(tableFormName, {}, true, {
-        keepDirty: true,
-        updateUnregisteredFields: true,
-        keepValues: true
-      });
-      const selectedEntityIdMap = {};
-      entities.forEach(entity => {
-        selectedEntityIdMap[entity.id] = {
-          entity,
-          time: Date.now()
-        };
-      });
-      dispatch(
-        change(
-          tableFormName,
-          "reduxFormSelectedEntityIdMap",
-          selectedEntityIdMap
-        )
-      );
-    },
-    [dispatch, tableFormName]
-  );
-
-  const { allOrderedEntities, selectedEntities } = useSelector(state => ({
-    allOrderedEntities: state.form?.[tableFormName]?.values?.allOrderedEntities,
-    selectedEntities:
-      state.form?.[tableFormName]?.values?.reduxFormSelectedEntityIdMap
-  }));
-  return { selectTableEntities, allOrderedEntities, selectedEntities };
-};