@teselagen/ui 0.7.33-beta.5 → 0.7.33-beta.7

package/DataTable/utils/queryParams.d.ts

@@ -31,9 +31,11 @@ export function getQueryParams({ currentParams, defaults, schema, isInfinite, en
     noOrderError: any;
     ownProps: any;
 }): {
-    entities: any[];
-    entitiesAcrossPages: any[];
-    entityCount: number;
+    page: any;
+    pageSize: any;
+    order: any[];
+    filters: any;
+    searchTerm: any;
 } | {
     variables: {
         where: {};

package/index.cjs.js

@@ -2951,7 +2951,18 @@ let clearMe;
         document.querySelectorAll(`.${id}`).forEach((elem) => {
           elem.classList.remove(id);
         });
-        el2.classList.add(id);
+        let targetEl = el2;
+        if (targetEl.disabled || targetEl.getAttribute("disabled") !== null) {
+          const parent2 = targetEl.parentElement;
+          if (parent2) {
+            parent2.classList.add(id);
+            targetEl = parent2;
+          } else {
+            el2.classList.add(id);
+          }
+        } else {
+          el2.classList.add(id);
+        }
         const inst = tippy(`.${id}`, __spreadValues(__spreadProps(__spreadValues({
           theme: "teselagen",
           plugins: [followCursor],
@@ -19414,9 +19425,8 @@ function tableQueryParamsToHasuraClauses({
       if (searchDisabled || field.filterDisabled || type2 === "color") return;
       const filterValue = searchTerm;
       if (type2 === "string" || type2 === "lookup") {
-        searchTermFilters.push({
-          [path2]: { _ilike: `%${filterValue}%` }
-        });
+        const o2 = set$1({}, path2, { _ilike: `%${filterValue}%` });
+        searchTermFilters.push(o2);
       } else if (type2 === "boolean") {
         let regex;
         try {
@@ -19425,19 +19435,16 @@ function tableQueryParamsToHasuraClauses({
         }
         if (regex) {
           if ("true".replace(regex, "") !== "true") {
-            searchTermFilters.push({
-              [path2]: { _eq: true }
-            });
+            const o2 = set$1({}, path2, { _eq: true });
+            searchTermFilters.push(o2);
           } else if ("false".replace(regex, "") !== "false") {
-            searchTermFilters.push({
-              [path2]: { _eq: false }
-            });
+            const o2 = set$1({}, path2, { _eq: false });
+            searchTermFilters.push(o2);
           }
         }
       } else if ((type2 === "number" || type2 === "integer") && !isNaN(filterValue)) {
-        searchTermFilters.push({
-          [path2]: { _eq: parseFloat(filterValue) }
-        });
+        const o2 = set$1({}, path2, { _eq: parseFloat(filterValue) });
+        searchTermFilters.push(o2);
       }
     });
     if (searchTermFilters.length > 0) {
@@ -19522,7 +19529,9 @@ function tableQueryParamsToHasuraClauses({
               },
               {
                 [filterOn]: {
-                  _gt: new Date(new Date(arrayFilterValue[1]).setHours(23, 59))
+                  _gt: new Date(
+                    new Date(arrayFilterValue[1]).setHours(23, 59)
+                  )
                 }
               }
             ]
@@ -19565,13 +19574,21 @@ function tableQueryParamsToHasuraClauses({
             ]
           };
         case "equalTo":
-          return { [filterOn]: { _eq: parseFloat(filterValue) } };
+          return {
+            [filterOn]: {
+              _eq: type2 === "number" || type2 === "integer" ? parseFloat(filterValue) : filterValue
+            }
+          };
         case "regex":
           return { [filterOn]: { _regex: filterValue } };
         default:
           console.warn(`Unsupported filter type: ${selectedFilter}`);
           return {};
       }
+    }).map((filter2) => {
+      const o2 = {};
+      set$1(o2, Object.keys(filter2)[0], filter2[Object.keys(filter2)[0]]);
+      return o2;
     });
     if (filterClauses.length > 0) {
       if (Object.keys(where).length > 0) {
@@ -19658,6 +19675,9 @@ function applyWhereClause(records, where) {
       } else {
         const value = record[key];
         const conditions = filter2[key];
+        if (isObject$2(value) && isObject$2(conditions) && !hasOperator(conditions)) {
+          return applyFilter(value, conditions);
+        }
         for (const operator in conditions) {
           const conditionValue = conditions[operator];
           if (operator === "_gt" && conditions._lt) {
@@ -19755,6 +19775,10 @@ function applyWhereClause(records, where) {
     return true;
   }
   __name(applyFilter, "applyFilter");
+  function hasOperator(obj) {
+    return Object.keys(obj).some((key) => key.startsWith("_"));
+  }
+  __name(hasOperator, "hasOperator");
   return records.filter((record) => applyFilter(record, where));
 }
 __name(applyWhereClause, "applyWhereClause");
@@ -20015,7 +20039,7 @@ function getQueryParams({
       }
     });
   }
-  const toReturn = {
+  let toRet = {
     //these are values that might be generally useful for the wrapped component
     page,
     pageSize: ownProps.controlled_pageSize || pageSize,
@@ -20034,16 +20058,16 @@ function getQueryParams({
   initializeHasuraWhereAndFilter(additionalFilter, where, currentParams);
   addCustomColumnFilters(where, schema.fields, currentParams);
   if (isLocalCall) {
-    const toRet = filterLocalEntitiesToHasura(entities, {
+    toRet = __spreadValues(__spreadValues({}, toRet), filterLocalEntitiesToHasura(entities, {
       where,
       order_by,
       limit,
       offset: offset3,
       isInfinite
-    });
+    }));
     return toRet;
   } else {
-    return __spreadProps(__spreadValues({}, toReturn), {
+    return __spreadProps(__spreadValues({}, toRet), {
       variables: {
         where,
         order_by,
@@ -50984,10 +51008,10 @@ const RenderCell = /* @__PURE__ */ __name(({
       return (_c = (_b = (_a2 = state.form) == null ? void 0 : _a2[formName]) == null ? void 0 : _b.values) == null ? void 0 : _c.reduxFormEditingCell;
     }
   );
-  const initialValue = reactRedux.useSelector(
+  const shouldEditableCellInputBeCleared = reactRedux.useSelector(
     (state) => {
       var _a2, _b, _c;
-      return (_c = (_b = (_a2 = state.form) == null ? void 0 : _a2[formName]) == null ? void 0 : _b.values) == null ? void 0 : _c.reduxFormInitialValue;
+      return (_c = (_b = (_a2 = state.form) == null ? void 0 : _a2[formName]) == null ? void 0 : _b.values) == null ? void 0 : _c.shouldEditableCellInputBeCleared;
     }
   );
   const [row] = args;
@@ -51040,7 +51064,7 @@ const RenderCell = /* @__PURE__ */ __name(({
           dataTest,
           cancelEdit: cancelCellEdit,
           isNumeric: column.type === "number",
-          initialValue: initialValue || text2,
+          initialValue: shouldEditableCellInputBeCleared ? void 0 : text2,
           finishEdit: /* @__PURE__ */ __name((newVal) => {
             finishCellEdit(cellId, newVal);
           }, "finishEdit")
@@ -56498,7 +56522,7 @@ const DataTable = /* @__PURE__ */ __name((_I) => {
             }) : !val;
           });
         }
-        if (noValsForField) {
+        if (noValsForField && entities.length) {
           return __spreadProps(__spreadValues({}, field), {
             isHidden: true,
             isForcedHidden: true
@@ -56898,8 +56922,12 @@ const DataTable = /* @__PURE__ */ __name((_I) => {
     }
   }, [selectedCells]);
   const startCellEdit = React.useCallback(
-    (cellId, initialValue) => {
-      change("reduxFormInitialValue", initialValue);
+    (cellId, shouldClear) => {
+      if (shouldClear) {
+        change("shouldEditableCellInputBeCleared", true);
+      } else {
+        change("shouldEditableCellInputBeCleared", false);
+      }
       change("reduxFormEditingCell", (prev) => {
         if (prev === cellId) return cellId;
         setSelectedCells((prev2) => {
@@ -58560,12 +58588,30 @@ const DataTable = /* @__PURE__ */ __name((_I) => {
           const rowDisabled = isEntityDisabled(entity);
           const isNum = (_g = e.code) == null ? void 0 : _g.startsWith("Digit");
           const isLetter = (_h = e.code) == null ? void 0 : _h.startsWith("Key");
-          if (!isNum && !isLetter) {
+          const allowedSpecialChars = [
+            "Minus",
+            "Equal",
+            "Backquote",
+            "BracketLeft",
+            "BracketRight",
+            "Backslash",
+            "IntlBackslash",
+            "Semicolon",
+            "Quote",
+            "Comma",
+            "Period",
+            "Slash",
+            "IntlRo",
+            "IntlYen",
+            "Space"
+          ];
+          const isSpecialChar = allowedSpecialChars.includes(e.code);
+          if (!isNum && !isLetter && !isSpecialChar) {
             return;
           }
           if (rowDisabled) return;
           e.stopPropagation();
-          startCellEdit(primarySelectedCellId, e.key);
+          startCellEdit(primarySelectedCellId, true);
         }, "onKeyDown")
       }),
       isCellEditable && entities.length > 50 && // test for this!!

package/index.es.js

@@ -2933,7 +2933,18 @@ let clearMe;
         document.querySelectorAll(`.${id}`).forEach((elem) => {
           elem.classList.remove(id);
         });
-        el2.classList.add(id);
+        let targetEl = el2;
+        if (targetEl.disabled || targetEl.getAttribute("disabled") !== null) {
+          const parent2 = targetEl.parentElement;
+          if (parent2) {
+            parent2.classList.add(id);
+            targetEl = parent2;
+          } else {
+            el2.classList.add(id);
+          }
+        } else {
+          el2.classList.add(id);
+        }
         const inst = tippy(`.${id}`, __spreadValues(__spreadProps(__spreadValues({
           theme: "teselagen",
           plugins: [followCursor],
@@ -19396,9 +19407,8 @@ function tableQueryParamsToHasuraClauses({
       if (searchDisabled || field.filterDisabled || type2 === "color") return;
       const filterValue = searchTerm;
       if (type2 === "string" || type2 === "lookup") {
-        searchTermFilters.push({
-          [path2]: { _ilike: `%${filterValue}%` }
-        });
+        const o2 = set$1({}, path2, { _ilike: `%${filterValue}%` });
+        searchTermFilters.push(o2);
       } else if (type2 === "boolean") {
         let regex;
         try {
@@ -19407,19 +19417,16 @@ function tableQueryParamsToHasuraClauses({
         }
         if (regex) {
           if ("true".replace(regex, "") !== "true") {
-            searchTermFilters.push({
-              [path2]: { _eq: true }
-            });
+            const o2 = set$1({}, path2, { _eq: true });
+            searchTermFilters.push(o2);
           } else if ("false".replace(regex, "") !== "false") {
-            searchTermFilters.push({
-              [path2]: { _eq: false }
-            });
+            const o2 = set$1({}, path2, { _eq: false });
+            searchTermFilters.push(o2);
           }
         }
       } else if ((type2 === "number" || type2 === "integer") && !isNaN(filterValue)) {
-        searchTermFilters.push({
-          [path2]: { _eq: parseFloat(filterValue) }
-        });
+        const o2 = set$1({}, path2, { _eq: parseFloat(filterValue) });
+        searchTermFilters.push(o2);
       }
     });
     if (searchTermFilters.length > 0) {
@@ -19504,7 +19511,9 @@ function tableQueryParamsToHasuraClauses({
               },
               {
                 [filterOn]: {
-                  _gt: new Date(new Date(arrayFilterValue[1]).setHours(23, 59))
+                  _gt: new Date(
+                    new Date(arrayFilterValue[1]).setHours(23, 59)
+                  )
                 }
               }
             ]
@@ -19547,13 +19556,21 @@ function tableQueryParamsToHasuraClauses({
             ]
           };
         case "equalTo":
-          return { [filterOn]: { _eq: parseFloat(filterValue) } };
+          return {
+            [filterOn]: {
+              _eq: type2 === "number" || type2 === "integer" ? parseFloat(filterValue) : filterValue
+            }
+          };
         case "regex":
           return { [filterOn]: { _regex: filterValue } };
         default:
           console.warn(`Unsupported filter type: ${selectedFilter}`);
           return {};
       }
+    }).map((filter2) => {
+      const o2 = {};
+      set$1(o2, Object.keys(filter2)[0], filter2[Object.keys(filter2)[0]]);
+      return o2;
     });
     if (filterClauses.length > 0) {
       if (Object.keys(where).length > 0) {
@@ -19640,6 +19657,9 @@ function applyWhereClause(records, where) {
       } else {
         const value = record[key];
         const conditions = filter2[key];
+        if (isObject$2(value) && isObject$2(conditions) && !hasOperator(conditions)) {
+          return applyFilter(value, conditions);
+        }
         for (const operator in conditions) {
           const conditionValue = conditions[operator];
           if (operator === "_gt" && conditions._lt) {
@@ -19737,6 +19757,10 @@ function applyWhereClause(records, where) {
     return true;
   }
   __name(applyFilter, "applyFilter");
+  function hasOperator(obj) {
+    return Object.keys(obj).some((key) => key.startsWith("_"));
+  }
+  __name(hasOperator, "hasOperator");
   return records.filter((record) => applyFilter(record, where));
 }
 __name(applyWhereClause, "applyWhereClause");
@@ -19997,7 +20021,7 @@ function getQueryParams({
       }
     });
   }
-  const toReturn = {
+  let toRet = {
     //these are values that might be generally useful for the wrapped component
     page,
     pageSize: ownProps.controlled_pageSize || pageSize,
@@ -20016,16 +20040,16 @@ function getQueryParams({
   initializeHasuraWhereAndFilter(additionalFilter, where, currentParams);
   addCustomColumnFilters(where, schema.fields, currentParams);
   if (isLocalCall) {
-    const toRet = filterLocalEntitiesToHasura(entities, {
+    toRet = __spreadValues(__spreadValues({}, toRet), filterLocalEntitiesToHasura(entities, {
       where,
       order_by,
       limit,
       offset: offset3,
       isInfinite
-    });
+    }));
     return toRet;
   } else {
-    return __spreadProps(__spreadValues({}, toReturn), {
+    return __spreadProps(__spreadValues({}, toRet), {
       variables: {
         where,
         order_by,
@@ -50966,10 +50990,10 @@ const RenderCell = /* @__PURE__ */ __name(({
       return (_c = (_b = (_a2 = state.form) == null ? void 0 : _a2[formName]) == null ? void 0 : _b.values) == null ? void 0 : _c.reduxFormEditingCell;
     }
   );
-  const initialValue = useSelector(
+  const shouldEditableCellInputBeCleared = useSelector(
     (state) => {
       var _a2, _b, _c;
-      return (_c = (_b = (_a2 = state.form) == null ? void 0 : _a2[formName]) == null ? void 0 : _b.values) == null ? void 0 : _c.reduxFormInitialValue;
+      return (_c = (_b = (_a2 = state.form) == null ? void 0 : _a2[formName]) == null ? void 0 : _b.values) == null ? void 0 : _c.shouldEditableCellInputBeCleared;
     }
   );
   const [row] = args;
@@ -51022,7 +51046,7 @@ const RenderCell = /* @__PURE__ */ __name(({
           dataTest,
           cancelEdit: cancelCellEdit,
           isNumeric: column.type === "number",
-          initialValue: initialValue || text2,
+          initialValue: shouldEditableCellInputBeCleared ? void 0 : text2,
           finishEdit: /* @__PURE__ */ __name((newVal) => {
             finishCellEdit(cellId, newVal);
           }, "finishEdit")
@@ -56480,7 +56504,7 @@ const DataTable = /* @__PURE__ */ __name((_I) => {
             }) : !val;
           });
         }
-        if (noValsForField) {
+        if (noValsForField && entities.length) {
           return __spreadProps(__spreadValues({}, field), {
             isHidden: true,
             isForcedHidden: true
@@ -56880,8 +56904,12 @@ const DataTable = /* @__PURE__ */ __name((_I) => {
     }
   }, [selectedCells]);
   const startCellEdit = useCallback(
-    (cellId, initialValue) => {
-      change$1("reduxFormInitialValue", initialValue);
+    (cellId, shouldClear) => {
+      if (shouldClear) {
+        change$1("shouldEditableCellInputBeCleared", true);
+      } else {
+        change$1("shouldEditableCellInputBeCleared", false);
+      }
       change$1("reduxFormEditingCell", (prev) => {
         if (prev === cellId) return cellId;
         setSelectedCells((prev2) => {
@@ -58542,12 +58570,30 @@ const DataTable = /* @__PURE__ */ __name((_I) => {
           const rowDisabled = isEntityDisabled(entity);
           const isNum = (_g = e.code) == null ? void 0 : _g.startsWith("Digit");
           const isLetter = (_h = e.code) == null ? void 0 : _h.startsWith("Key");
-          if (!isNum && !isLetter) {
+          const allowedSpecialChars = [
+            "Minus",
+            "Equal",
+            "Backquote",
+            "BracketLeft",
+            "BracketRight",
+            "Backslash",
+            "IntlBackslash",
+            "Semicolon",
+            "Quote",
+            "Comma",
+            "Period",
+            "Slash",
+            "IntlRo",
+            "IntlYen",
+            "Space"
+          ];
+          const isSpecialChar = allowedSpecialChars.includes(e.code);
+          if (!isNum && !isLetter && !isSpecialChar) {
             return;
           }
           if (rowDisabled) return;
           e.stopPropagation();
-          startCellEdit(primarySelectedCellId, e.key);
+          startCellEdit(primarySelectedCellId, true);
         }, "onKeyDown")
       }),
       isCellEditable && entities.length > 50 && // test for this!!

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teselagen/ui",
-  "version": "0.7.33-beta.5",
+  "version": "0.7.33-beta.7",
   "main": "./src/index.js",
   "type": "module",
   "exports": {

package/src/DataTable/RenderCell.js

@@ -32,8 +32,8 @@ export const RenderCell = ({
   const editingCell = useSelector(
     state => state.form?.[formName]?.values?.reduxFormEditingCell
   );
-  const initialValue = useSelector(
-    state => state.form?.[formName]?.values?.reduxFormInitialValue
+  const shouldEditableCellInputBeCleared = useSelector(
+    state => state.form?.[formName]?.values?.shouldEditableCellInputBeCleared
   );
 
   const [row] = args;
@@ -85,7 +85,7 @@ export const RenderCell = ({
           dataTest={dataTest}
           cancelEdit={cancelCellEdit}
           isNumeric={column.type === "number"}
-          initialValue={initialValue || text}
+          initialValue={shouldEditableCellInputBeCleared ? undefined : text}
           finishEdit={newVal => {
             finishCellEdit(cellId, newVal);
           }}

package/src/DataTable/index.js

@@ -603,7 +603,7 @@ const DataTable = ({
                 : !val;
           });
         }
-        if (noValsForField) {
+        if (noValsForField && entities.length) {
           return {
             ...field,
             isHidden: true,
@@ -1075,11 +1075,17 @@ const DataTable = ({
   }, [selectedCells]);
 
   const startCellEdit = useCallback(
-    (cellId, initialValue) => {
+    (cellId, shouldClear) => {
+      // console.log(`startCellEdit initialValue:`, initialValue)
       // This initial value is not needed if the event is propagated accordingly.
       // This is directly connected to the RenderCell component, which does set
       // the initial value.
-      change("reduxFormInitialValue", initialValue);
+      // change("shouldEditableCellInputBeCleared", undefined);
+      if (shouldClear) {
+        change("shouldEditableCellInputBeCleared", true);
+      } else {
+        change("shouldEditableCellInputBeCleared", false);
+      }
       change("reduxFormEditingCell", prev => {
         //check if the cell is already selected and editing and if so, don't change it
         if (prev === cellId) return cellId;
@@ -2955,12 +2961,30 @@ const DataTable = ({
               const rowDisabled = isEntityDisabled(entity);
               const isNum = e.code?.startsWith("Digit");
               const isLetter = e.code?.startsWith("Key");
-              if (!isNum && !isLetter) {
+              const allowedSpecialChars = [
+                "Minus",
+                "Equal",
+                "Backquote",
+                "BracketLeft",
+                "BracketRight",
+                "Backslash",
+                "IntlBackslash",
+                "Semicolon",
+                "Quote",
+                "Comma",
+                "Period",
+                "Slash",
+                "IntlRo",
+                "IntlYen",
+                "Space"
+              ];
+              const isSpecialChar = allowedSpecialChars.includes(e.code);
+              if (!isNum && !isLetter && !isSpecialChar) {
                 return;
               }
               if (rowDisabled) return;
               e.stopPropagation();
-              startCellEdit(primarySelectedCellId, e.key);
+              startCellEdit(primarySelectedCellId, true);
             }
           })}
         >

package/src/DataTable/utils/filterLocalEntitiesToHasura.js

@@ -77,6 +77,15 @@ function applyWhereClause(records, where) {
         const value = record[key];
         const conditions = filter[key];
 
+        // Handle nested object properties
+        if (
+          isObject(value) &&
+          isObject(conditions) &&
+          !hasOperator(conditions)
+        ) {
+          return applyFilter(value, conditions);
+        }
+
         for (const operator in conditions) {
           const conditionValue = conditions[operator];
 
@@ -208,6 +217,11 @@ function applyWhereClause(records, where) {
     return true;
   }
 
+  // Helper to check if an object contains any Hasura operators
+  function hasOperator(obj) {
+    return Object.keys(obj).some(key => key.startsWith("_"));
+  }
+
   return records.filter(record => applyFilter(record, where));
 }
 

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

@@ -297,6 +297,55 @@ describe("filterLocalEntitiesToHasura", () => {
     expect(result.entitiesAcrossPages).toEqual([records[0]]);
     expect(result.entityCount).toBe(1);
   });
+  it("should filter with nested filters in _and and _or properly ", () => {
+    const result = filterLocalEntitiesToHasura(
+      [
+        {
+          id: 1,
+          type: {
+            special: "01"
+          }
+        },
+        {
+          id: 2,
+          type: {
+            special: "02"
+          }
+        }
+      ],
+      {
+        where: {
+          _and: [
+            {
+              type: {
+                special: {
+                  _ilike: "%01%"
+                }
+              }
+            }
+          ],
+          _or: []
+        }
+      }
+    );
+    expect(result.entities).toEqual([
+      {
+        id: 1,
+        type: {
+          special: "01"
+        }
+      }
+    ]);
+    expect(result.entitiesAcrossPages).toEqual([
+      {
+        id: 1,
+        type: {
+          special: "01"
+        }
+      }
+    ]);
+    expect(result.entityCount).toBe(1);
+  });
 
   it("should handle empty where clause", () => {
     const result = filterLocalEntitiesToHasura(records, {});

package/src/DataTable/utils/queryParams.js

@@ -303,7 +303,7 @@ export function getQueryParams({
     });
   }
 
-  const toReturn = {
+  let toRet = {
     //these are values that might be generally useful for the wrapped component
     page,
     pageSize: ownProps.controlled_pageSize || pageSize,
@@ -325,17 +325,20 @@ export function getQueryParams({
   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
-    const toRet = filterLocalEntitiesToHasura(entities, {
-      where,
-      order_by,
-      limit,
-      offset,
-      isInfinite
-    });
+    toRet = {
+      ...toRet,
+      ...filterLocalEntitiesToHasura(entities, {
+        where,
+        order_by,
+        limit,
+        offset,
+        isInfinite
+      })
+    };
     return toRet;
   } else {
     return {
-      ...toReturn,
+      ...toRet,
       variables: {
         where,
         order_by,

package/src/DataTable/utils/tableQueryParamsToHasuraClauses.js

@@ -1,4 +1,4 @@
-import { camelCase } from "lodash-es";
+import { camelCase, set } from "lodash-es";
 
 export function tableQueryParamsToHasuraClauses({
   page,
@@ -23,9 +23,8 @@ export function tableQueryParamsToHasuraClauses({
       const filterValue = searchTerm; // No cleaning needed here, we're using _ilike
 
       if (type === "string" || type === "lookup") {
-        searchTermFilters.push({
-          [path]: { _ilike: `%${filterValue}%` }
-        });
+        const o = set({}, path, { _ilike: `%${filterValue}%` });
+        searchTermFilters.push(o);
       } else if (type === "boolean") {
         let regex;
         try {
@@ -35,22 +34,19 @@ export function tableQueryParamsToHasuraClauses({
         }
         if (regex) {
           if ("true".replace(regex, "") !== "true") {
-            searchTermFilters.push({
-              [path]: { _eq: true }
-            });
+            const o = set({}, path, { _eq: true });
+            searchTermFilters.push(o);
           } else if ("false".replace(regex, "") !== "false") {
-            searchTermFilters.push({
-              [path]: { _eq: false }
-            });
+            const o = set({}, path, { _eq: false });
+            searchTermFilters.push(o);
           }
         }
       } else if (
         (type === "number" || type === "integer") &&
         !isNaN(filterValue)
       ) {
-        searchTermFilters.push({
-          [path]: { _eq: parseFloat(filterValue) }
-        });
+        const o = set({}, path, { _eq: parseFloat(filterValue) });
+        searchTermFilters.push(o);
       }
     });
     if (searchTermFilters.length > 0) {
@@ -63,143 +59,157 @@ export function tableQueryParamsToHasuraClauses({
   }
 
   if (filters && filters.length > 0) {
-    const filterClauses = filters.map(filter => {
-      let { selectedFilter, filterOn, filterValue } = filter;
-      const fieldSchema = ccFields[filterOn] || {};
+    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);
-      }
+        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 (fieldSchema.normalizeFilter) {
-        filterValue = fieldSchema.normalizeFilter(
-          filterValue,
-          selectedFilter,
-          filterOn
-        );
-      }
+        if (type === "number" || type === "integer") {
+          filterValue = Array.isArray(filterValue)
+            ? filterValue.map(val => Number(val))
+            : Number(filterValue);
+        }
 
-      if (reference) {
-        filterOn = reference.sourceField;
-      } else {
-        filterOn = path || filterOn;
-      }
+        if (fieldSchema.normalizeFilter) {
+          filterValue = fieldSchema.normalizeFilter(
+            filterValue,
+            selectedFilter,
+            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))
+        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 "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 "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:
+                  type === "number" || type === "integer"
+                    ? parseFloat(filterValue)
+                    : filterValue
               }
-            ]
-          };
-        case "equalTo":
-          return { [filterOn]: { _eq: parseFloat(filterValue) } };
-        case "regex":
-          return { [filterOn]: { _regex: filterValue } };
-        default:
-          console.warn(`Unsupported filter type: ${selectedFilter}`);
-          return {};
-      }
-    });
+            };
+          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) {

package/src/autoTooltip.js

@@ -52,7 +52,23 @@ let clearMe;
           elem.classList.remove(id);
         });
 
-        el.classList.add(id);
+        // Check if element is disabled, if so use parent instead
+        let targetEl = el;
+        if (targetEl.disabled || targetEl.getAttribute("disabled") !== null) {
+          const parent = targetEl.parentElement;
+          if (parent) {
+            // Use the parent as the tooltip target
+            parent.classList.add(id);
+            targetEl = parent; // Change the tooltip target to parent
+          } else {
+            // No parent, keep using the original element
+            el.classList.add(id);
+          }
+        } else {
+          // Element not disabled, use it directly
+          el.classList.add(id);
+        }
+
         const inst = tippy(`.${id}`, {
           theme: "teselagen",
           plugins: [followCursor],
@@ -84,19 +100,12 @@ let clearMe;
                   requires: ["computeStyles"],
                   requiresIfExists: ["offset"],
                   fn({ state }) {
-                    // console.log(`state:`, state);
-                    // state.styles.popper.bottom = 20 + "px";
                     const customBoundary =
                       document.querySelector(dataAvoid) ||
                       document.querySelector(dataAvoidBackup);
 
                     if (!customBoundary) return;
                     const a = customBoundary.getBoundingClientRect();
-                    // console.log(
-                    //   `state.rects.reference.y:`,
-                    //   state.rects.reference.y
-                    // );
-                    // console.log(`a.top:`, a.top);
 
                     if (a.top < state.rects.reference.y) {
                       const b = Math.abs(
@@ -104,16 +113,6 @@ let clearMe;
                       );
                       state.styles.popper.bottom = b + "px";
                     }
-
-                    // const overflow = detectOverflow(state, {
-                    //   boundary: customBoundary,
-                    //   altBoundary: true
-                    // });
-                    // console.log(`overflow:`, overflow);
-                    // if (overflow.bottom > 0) {
-                    //   const a = Math.abs(overflow.bottom);
-                    //   state.styles.popper.bottom = a + "px";
-                    // }
                   }
                 }
               ]
@@ -199,3 +198,6 @@ function parentIncludesNoChildDataTip(el, count) {
   if (el.getAttribute("data-no-child-data-tip")) return true;
   return parentIncludesNoChildDataTip(el.parentElement, count + 1);
 }
+
+// Export the function to clear parent tooltips so it can be used elsewhere
+// export { clearParentTooltips };

package/src/utils/isBeingCalledExcessively.js

@@ -1,4 +1,5 @@
 const keyCount = {};
+// if this function is hit more than 20 times in a row in 2 seconds with the same uniqName then throw an error
 export const isBeingCalledExcessively = ({ uniqName }) => {
   if (process.env.NODE_ENV !== "development") {
     return;
@@ -6,19 +7,25 @@ export const isBeingCalledExcessively = ({ uniqName }) => {
   if (!uniqName) {
     throw new Error("uniqName is required");
   }
-  // if this function is hit more than 10 times in a row in 2 seconds with the same uniqName then throw an error
-  if (keyCount[uniqName + "_timeout"]) {
-    clearTimeout(keyCount[uniqName + "_timeout"]);
-  }
+  // Initialize the count if it doesn't exist
   keyCount[uniqName] = keyCount[uniqName] || 0;
   keyCount[uniqName]++;
 
-  keyCount[uniqName + "_timeout"] = setTimeout(() => {
-    keyCount[uniqName] = 0;
-  }, 2000);
+  // Only set the timeout if it doesn't exist already to ensure it runs exactly once every 2 seconds
+  if (!keyCount[uniqName + "_timeout"]) {
+    keyCount[uniqName + "_timeout"] = setTimeout(() => {
+      keyCount[uniqName] = 0;
+      keyCount[uniqName + "_timeout"] = null;
+    }, 2000);
+  }
 
   if (keyCount[uniqName] > 20) {
     keyCount[uniqName] = 0;
+    // Also clear the timeout when throwing an error
+    if (keyCount[uniqName + "_timeout"]) {
+      clearTimeout(keyCount[uniqName + "_timeout"]);
+      keyCount[uniqName + "_timeout"] = null;
+    }
     throw new Error(`isBeingCalledExcessively: ${uniqName}`);
   }
 };