@pol-studios/db 1.0.10 → 1.0.12

package/dist/{chunk-ZTSBF536.js → chunk-X3HZLNBV.js}

@@ -1,14 +1,14 @@
 import {
   getSupabaseUrl
-} from "./chunk-Y3INY2CS.js";
+} from "./chunk-GC3TBUWE.js";
 import {
   PostgrestParser
-} from "./chunk-JUVE3DWY.js";
+} from "./chunk-TKWR5AAY.js";
 import {
   isNullOrWhitespace,
   isUsable,
   omit
-} from "./chunk-O3K7R32P.js";
+} from "./chunk-OQ7U6EQ3.js";
 import {
   encode,
   useQuery
@@ -16,7 +16,7 @@ import {
 import {
   generateUUID,
   useSupabase
-} from "./chunk-AWFMICFV.js";
+} from "./chunk-5EFDS7SR.js";
 
 // src/query/select-parser.ts
 function tokenizeTopLevel(input) {
@@ -54,15 +54,23 @@ function parseColumnToken(token) {
       alias: aliasMatch[1]
     };
   }
-  return { name: token };
+  return {
+    name: token
+  };
 }
 function parseSelect(select) {
   const trimmed = select.trim();
   if (trimmed === "*") {
-    return { columns: "*", relations: [] };
+    return {
+      columns: "*",
+      relations: []
+    };
   }
   if (!trimmed) {
-    return { columns: "*", relations: [] };
+    return {
+      columns: "*",
+      relations: []
+    };
   }
   const result = {
     columns: [],
@@ -139,9 +147,7 @@ function hasRelation(parsed, relationName) {
   return parsed.relations.some((rel) => rel.name === relationName || rel.alias === relationName);
 }
 function getRelationSelect(parsed, relationName) {
-  return parsed.relations.find(
-    (rel) => rel.name === relationName || rel.alias === relationName
-  );
+  return parsed.relations.find((rel) => rel.name === relationName || rel.alias === relationName);
 }
 
 // src/query/relationship-resolver.ts
@@ -242,9 +248,7 @@ var RelationshipResolver = class {
     for (const schemaName of Object.keys(this.schema.schemas)) {
       const schemaDefinition = this.schema.schemas[schemaName];
       if (!schemaDefinition) continue;
-      for (const [otherTableName, otherTableSchema] of Object.entries(
-        schemaDefinition.tables
-      )) {
+      for (const [otherTableName, otherTableSchema] of Object.entries(schemaDefinition.tables)) {
         if (otherTableName === tableName) continue;
         for (const rel of otherTableSchema.relationships) {
           if (rel.referencedTable === tableName) {
@@ -265,10 +269,7 @@ var RelationshipResolver = class {
    * Get all relationships for a table (both directions).
    */
   getAllRelationships(tableName) {
-    return [
-      ...this.getForwardRelationships(tableName),
-      ...this.getReverseRelationships(tableName)
-    ];
+    return [...this.getForwardRelationships(tableName), ...this.getReverseRelationships(tableName)];
   }
   /**
    * Check if a relationship exists between two tables.
@@ -405,9 +406,7 @@ var SQLBuilder = class {
       }
     }
     if (options.orderBy && options.orderBy.length > 0) {
-      const orderClauses = options.orderBy.map(
-        (o) => `"${o.field}" ${o.direction.toUpperCase()}`
-      );
+      const orderClauses = options.orderBy.map((o) => `"${o.field}" ${o.direction.toUpperCase()}`);
       sql += ` ORDER BY ${orderClauses.join(", ")}`;
     }
     if (options.limit !== void 0) {
@@ -418,7 +417,10 @@ var SQLBuilder = class {
       sql += ` OFFSET ?`;
       params.push(options.offset);
     }
-    return { sql, params };
+    return {
+      sql,
+      params
+    };
   }
   /**
    * Build WHERE clauses from operator objects.
@@ -511,7 +513,10 @@ var SQLBuilder = class {
     }
     const placeholders = parentIds.map(() => "?").join(", ");
     const sql = `SELECT ${columnList} FROM "${table}" WHERE "${foreignKey}" IN (${placeholders})`;
-    return { sql, params: [...parentIds] };
+    return {
+      sql,
+      params: [...parentIds]
+    };
   }
   /**
    * Build column list ensuring the foreign key is included.
@@ -548,7 +553,10 @@ var SQLBuilder = class {
       columnList = columns.map((c) => c.alias ? `"${c.name}" AS "${c.alias}"` : `"${c.name}"`).join(", ");
     }
     const sql = `SELECT ${columnList} FROM "${table}" WHERE "${idColumn}" = ? LIMIT 1`;
-    return { sql, params: [id] };
+    return {
+      sql,
+      params: [id]
+    };
   }
   /**
    * Build an INSERT query.
@@ -581,9 +589,7 @@ var SQLBuilder = class {
    * @returns Built query
    */
   buildUpdateQuery(table, id, data, idColumn = "id") {
-    const columns = Object.keys(data).filter(
-      (k) => k !== idColumn && data[k] !== void 0
-    );
+    const columns = Object.keys(data).filter((k) => k !== idColumn && data[k] !== void 0);
     if (columns.length === 0) {
       throw new Error("No fields to update");
     }
@@ -605,7 +611,10 @@ var SQLBuilder = class {
    */
   buildDeleteQuery(table, id, idColumn = "id") {
     const sql = `DELETE FROM "${table}" WHERE "${idColumn}" = ?`;
-    return { sql, params: [id] };
+    return {
+      sql,
+      params: [id]
+    };
   }
   /**
    * Build a COUNT query.
@@ -634,7 +643,10 @@ var SQLBuilder = class {
         sql += ` WHERE ${whereClauses.join(" AND ")}`;
       }
     }
-    return { sql, params };
+    return {
+      sql,
+      params
+    };
   }
 };
 function createSQLBuilder() {
@@ -680,9 +692,7 @@ var ResultJoiner = class {
     if (relationship.type === "one-to-many") {
       return baseRecords.map((base) => {
         const baseId = base[relationship.referencedColumn];
-        const related = relatedRecords.filter(
-          (r) => r[relationship.foreignKey] === baseId
-        );
+        const related = relatedRecords.filter((r) => r[relationship.foreignKey] === baseId);
         return {
           ...base,
           [relationName]: related
@@ -807,7 +817,10 @@ var ResultJoiner = class {
    */
   removeRelation(records, relationName) {
     return records.map((record) => {
-      const { [relationName]: _removed, ...rest } = record;
+      const {
+        [relationName]: _removed,
+        ...rest
+      } = record;
       return rest;
     });
   }
@@ -823,7 +836,10 @@ var ResultJoiner = class {
   flattenRelation(records, relationName, prefix = "") {
     return records.map((record) => {
       const relation = record[relationName];
-      const { [relationName]: _removed, ...rest } = record;
+      const {
+        [relationName]: _removed,
+        ...rest
+      } = record;
       if (!relation) {
         return rest;
       }
@@ -832,7 +848,10 @@ var ResultJoiner = class {
         const fieldName = prefix ? `${prefix}_${key}` : `${relationName}_${key}`;
         flattenedRelation[fieldName] = value;
       }
-      return { ...rest, ...flattenedRelation };
+      return {
+        ...rest,
+        ...flattenedRelation
+      };
     });
   }
 };
@@ -867,18 +886,11 @@ var QueryExecutor = class {
       limit: options.limit,
       offset: options.offset
     });
-    const baseRecords = await this.db.getAll(
-      baseQuery.sql,
-      baseQuery.params
-    );
+    const baseRecords = await this.db.getAll(baseQuery.sql, baseQuery.params);
     if (baseRecords.length === 0 || parsed.relations.length === 0) {
       return baseRecords;
     }
-    const result = await this.queryAndJoinRelations(
-      table,
-      baseRecords,
-      parsed.relations
-    );
+    const result = await this.queryAndJoinRelations(table, baseRecords, parsed.relations);
     return result;
   }
   /**
@@ -892,27 +904,15 @@ var QueryExecutor = class {
   async executeById(table, id, options = {}) {
     const parsed = parseSelect(options.select ?? "*");
     const idColumn = this.resolver.getPrimaryKey(table);
-    const baseQuery = this.builder.buildByIdQuery(
-      table,
-      id,
-      parsed.columns,
-      idColumn
-    );
-    const records = await this.db.getAll(
-      baseQuery.sql,
-      baseQuery.params
-    );
+    const baseQuery = this.builder.buildByIdQuery(table, id, parsed.columns, idColumn);
+    const records = await this.db.getAll(baseQuery.sql, baseQuery.params);
     if (records.length === 0) {
       return null;
     }
     if (parsed.relations.length === 0) {
       return records[0];
     }
-    const result = await this.queryAndJoinRelations(
-      table,
-      records,
-      parsed.relations
-    );
+    const result = await this.queryAndJoinRelations(table, records, parsed.relations);
     return result[0];
   }
   /**
@@ -924,10 +924,7 @@ var QueryExecutor = class {
    */
   async count(table, options = {}) {
     const query = this.builder.buildCountQuery(table, options.where);
-    const result = await this.db.getAll(
-      query.sql,
-      query.params
-    );
+    const result = await this.db.getAll(query.sql, query.params);
     return result[0]?.count ?? 0;
   }
   /**
@@ -938,16 +935,53 @@ var QueryExecutor = class {
    * @returns The inserted record (re-fetched to get defaults)
    */
   async insert(table, data) {
+    if (__DEV__) {
+      console.log(`[QueryExecutor] insert called:`, {
+        table,
+        dataKeys: Object.keys(data),
+        hasId: "id" in data
+      });
+    }
     const idColumn = this.resolver.getPrimaryKey(table);
     if (!data[idColumn]) {
-      const [{ id }] = await this.db.getAll(
-        "SELECT uuid() as id"
-      );
-      data = { ...data, [idColumn]: id };
+      const [{
+        id
+      }] = await this.db.getAll("SELECT uuid() as id");
+      data = {
+        ...data,
+        [idColumn]: id
+      };
+      if (__DEV__) {
+        console.log(`[QueryExecutor] insert generated UUID:`, {
+          table,
+          id
+        });
+      }
     }
     const query = this.builder.buildInsertQuery(table, data);
+    if (__DEV__) {
+      console.log(`[QueryExecutor] insert executing SQL:`, {
+        table,
+        sql: query.sql,
+        paramCount: query.params.length
+      });
+    }
     await this.db.execute(query.sql, query.params);
+    if (__DEV__) {
+      console.log(`[QueryExecutor] insert SQL executed successfully:`, {
+        table,
+        id: data[idColumn]
+      });
+    }
     const result = await this.executeById(table, data[idColumn]);
+    if (__DEV__) {
+      console.log(`[QueryExecutor] insert completed:`, {
+        table,
+        operation: "insert",
+        resultId: result?.[idColumn] ?? data[idColumn],
+        refetchSucceeded: result !== null
+      });
+    }
     return result ?? data;
   }
   /**
@@ -959,14 +993,46 @@ var QueryExecutor = class {
    * @returns The updated record
    */
   async update(table, id, data) {
+    if (__DEV__) {
+      console.log(`[QueryExecutor] update called:`, {
+        table,
+        id,
+        dataKeys: Object.keys(data)
+      });
+    }
     const idColumn = this.resolver.getPrimaryKey(table);
     const query = this.builder.buildUpdateQuery(table, id, data, idColumn);
+    if (__DEV__) {
+      console.log(`[QueryExecutor] update executing SQL:`, {
+        table,
+        id,
+        sql: query.sql,
+        paramCount: query.params.length
+      });
+    }
     await this.db.execute(query.sql, query.params);
+    if (__DEV__) {
+      console.log(`[QueryExecutor] update SQL executed successfully:`, {
+        table,
+        id
+      });
+    }
     const result = await this.executeById(table, id);
+    if (__DEV__) {
+      console.log(`[QueryExecutor] update completed:`, {
+        table,
+        operation: "update",
+        id,
+        refetchSucceeded: result !== null
+      });
+    }
     if (result) {
       return result;
     }
-    return { ...data, [idColumn]: id };
+    return {
+      ...data,
+      [idColumn]: id
+    };
   }
   /**
    * Upsert a record (insert or update).
@@ -976,16 +1042,41 @@ var QueryExecutor = class {
    * @returns The upserted record
    */
   async upsert(table, data) {
+    if (__DEV__) {
+      console.log(`[QueryExecutor] upsert called:`, {
+        table,
+        dataKeys: Object.keys(data),
+        hasId: "id" in data,
+        idValue: data.id ?? "none"
+      });
+    }
     const idColumn = this.resolver.getPrimaryKey(table);
     let id = data[idColumn];
     if (!id) {
-      const [{ id: generatedId }] = await this.db.getAll(
-        "SELECT uuid() as id"
-      );
+      const [{
+        id: generatedId
+      }] = await this.db.getAll("SELECT uuid() as id");
       id = generatedId;
-      data = { ...data, [idColumn]: id };
+      data = {
+        ...data,
+        [idColumn]: id
+      };
+      if (__DEV__) {
+        console.log(`[QueryExecutor] upsert generated UUID:`, {
+          table,
+          id
+        });
+      }
     }
     const existing = await this.executeById(table, id);
+    if (__DEV__) {
+      console.log(`[QueryExecutor] upsert existence check:`, {
+        table,
+        id,
+        exists: existing !== null,
+        willPerform: existing ? "update" : "insert"
+      });
+    }
     if (existing) {
       return this.update(table, id, data);
     }
@@ -1015,9 +1106,7 @@ var QueryExecutor = class {
     for (const relation of relations) {
       const resolved = this.resolver.resolve(parentTable, relation.name);
       if (!resolved) {
-        console.warn(
-          `Could not resolve relationship: ${parentTable} -> ${relation.name}`
-        );
+        console.warn(`Could not resolve relationship: ${parentTable} -> ${relation.name}`);
         continue;
       }
       const parentIds = this.getParentIdsForRelation(parentRecords, resolved);
@@ -1029,23 +1118,11 @@ var QueryExecutor = class {
         continue;
       }
       const relQuery = this.buildRelatedQuery(relation, resolved, parentIds);
-      let relatedRecords = await this.db.getAll(
-        relQuery.sql,
-        relQuery.params
-      );
+      let relatedRecords = await this.db.getAll(relQuery.sql, relQuery.params);
       if (relation.relations.length > 0 && relatedRecords.length > 0) {
-        relatedRecords = await this.queryAndJoinRelations(
-          relation.name,
-          relatedRecords,
-          relation.relations
-        );
+        relatedRecords = await this.queryAndJoinRelations(relation.name, relatedRecords, relation.relations);
       }
-      result = this.joiner.join(
-        result,
-        relatedRecords,
-        resolved,
-        relation.alias ?? relation.name
-      );
+      result = this.joiner.join(result, relatedRecords, resolved, relation.alias ?? relation.name);
     }
     return result;
   }
@@ -1055,15 +1132,9 @@ var QueryExecutor = class {
   getParentIdsForRelation(parentRecords, resolved) {
     let parentIds;
     if (resolved.type === "one-to-many") {
-      parentIds = this.joiner.extractUniqueValues(
-        parentRecords,
-        resolved.referencedColumn
-      );
+      parentIds = this.joiner.extractUniqueValues(parentRecords, resolved.referencedColumn);
     } else {
-      parentIds = this.joiner.extractUniqueValues(
-        parentRecords,
-        resolved.foreignKey
-      );
+      parentIds = this.joiner.extractUniqueValues(parentRecords, resolved.foreignKey);
     }
     return parentIds;
   }
@@ -1073,12 +1144,7 @@ var QueryExecutor = class {
   buildRelatedQuery(relation, resolved, parentIds) {
     const filterColumn = resolved.type === "one-to-many" ? resolved.foreignKey : resolved.referencedColumn;
     const uniqueIds = Array.from(new Set(parentIds));
-    return this.builder.buildRelationQuery(
-      relation.name,
-      filterColumn,
-      uniqueIds,
-      relation.columns
-    );
+    return this.builder.buildRelationQuery(relation.name, filterColumn, uniqueIds, relation.columns);
   }
   /**
    * Get the relationship resolver (for advanced use).
@@ -1104,76 +1170,148 @@ function createQueryExecutor(db, schema) {
 }
 
 // src/query/useQuery.ts
-import { useMemo } from "react";
+import { c as _c } from "react/compiler-runtime";
 import { useDelayedValue } from "@pol-studios/hooks/state";
 function useQuery2(query, config) {
-  const queryKey = encode(query, false);
-  const queryKeyString = queryKey.join("-");
+  const $ = _c(5);
+  let t0;
+  if ($[0] !== query) {
+    const queryKey = encode(query, false);
+    t0 = queryKey.join("-");
+    $[0] = query;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const queryKeyString = t0;
   const debouncedKeyString = useDelayedValue(queryKeyString, 50);
   const isKeyStable = queryKeyString === debouncedKeyString;
   const effectiveEnabled = config?.enabled !== false && isKeyStable;
-  const request = useQuery(
-    query,
-    useMemo(() => omit({ retry: 1, ...config, enabled: effectiveEnabled }, ["queryKey"]), [config, effectiveEnabled])
-  );
+  let t1;
+  if ($[2] !== config || $[3] !== effectiveEnabled) {
+    t1 = omit({
+      retry: 1,
+      ...config,
+      enabled: effectiveEnabled
+    }, ["queryKey"]);
+    $[2] = config;
+    $[3] = effectiveEnabled;
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  const request = useQuery(query, t1);
   return request;
 }
 
 // src/query/usePartialQuery.ts
-import { useMemo as useMemo2 } from "react";
+import { c as _c2 } from "react/compiler-runtime";
 import { useSessionStorageState } from "@pol-studios/hooks/storage";
 function usePartialQuery(query, itemCountPerPage, config) {
-  const initialQuery = encode(query, false);
-  const id = useMemo2(
-    () => [
-      initialQuery[7],
-      initialQuery[8]
-    ].join("-"),
-    [
-      initialQuery[7],
-      initialQuery[8]
-    ]
-  );
+  const $ = _c2(28);
+  let t0;
+  if ($[0] !== query) {
+    t0 = encode(query, false);
+    $[0] = query;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const initialQuery = t0;
+  let t1;
+  if ($[2] !== initialQuery[7] || $[3] !== initialQuery[8]) {
+    t1 = [initialQuery[7], initialQuery[8]];
+    $[2] = initialQuery[7];
+    $[3] = initialQuery[8];
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  const id = t1.join("-");
   const [currentPage, setCurrentPage] = useSessionStorageState(id, 1);
-  const rangedQuery = useMemo2(
-    () => {
-      const page = currentPage ?? 1;
-      return query.range(
-        (page - 1) * itemCountPerPage,
-        page * itemCountPerPage - 1
-      );
-    },
-    [query, currentPage, itemCountPerPage]
-  );
+  const page = currentPage ?? 1;
+  const t2 = query;
+  let t3;
+  if ($[5] !== itemCountPerPage || $[6] !== page || $[7] !== t2) {
+    t3 = t2.range((page - 1) * itemCountPerPage, page * itemCountPerPage - 1);
+    $[5] = itemCountPerPage;
+    $[6] = page;
+    $[7] = t2;
+    $[8] = t3;
+  } else {
+    t3 = $[8];
+  }
+  const rangedQuery = t3;
   const baseQuery = useQuery2(rangedQuery, config);
-  const safeFetchNextPage = () => {
-    setCurrentPage((currentPage2) => currentPage2 + 1);
-  };
-  const fetchPreviousPage = () => {
-    setCurrentPage((currentPage2) => currentPage2 - 1);
-  };
-  const pageCount = Math.max(
-    Math.ceil(
-      (baseQuery.count ?? 0) / itemCountPerPage
-    ),
-    1
-  );
-  return {
-    ...baseQuery,
-    fetchPreviousPage,
-    fetchNextPage: safeFetchNextPage,
-    currentPage,
-    setCurrentPage,
-    data: baseQuery.data ? toPagedResponse(
-      baseQuery.data,
+  let t4;
+  if ($[9] !== setCurrentPage) {
+    t4 = () => {
+      setCurrentPage(_temp);
+    };
+    $[9] = setCurrentPage;
+    $[10] = t4;
+  } else {
+    t4 = $[10];
+  }
+  const safeFetchNextPage = t4;
+  let t5;
+  if ($[11] !== setCurrentPage) {
+    t5 = () => {
+      setCurrentPage(_temp2);
+    };
+    $[11] = setCurrentPage;
+    $[12] = t5;
+  } else {
+    t5 = $[12];
+  }
+  const fetchPreviousPage = t5;
+  const pageCount = Math.max(Math.ceil((baseQuery.count ?? 0) / itemCountPerPage), 1);
+  let t6;
+  if ($[13] !== baseQuery.count || $[14] !== baseQuery.data || $[15] !== currentPage || $[16] !== itemCountPerPage) {
+    t6 = baseQuery.data ? toPagedResponse(baseQuery.data, currentPage, baseQuery.count ?? baseQuery.data.length, itemCountPerPage) : null;
+    $[13] = baseQuery.count;
+    $[14] = baseQuery.data;
+    $[15] = currentPage;
+    $[16] = itemCountPerPage;
+    $[17] = t6;
+  } else {
+    t6 = $[17];
+  }
+  const t7 = currentPage < pageCount;
+  const t8 = currentPage > 1;
+  let t9;
+  if ($[18] !== baseQuery || $[19] !== currentPage || $[20] !== fetchPreviousPage || $[21] !== pageCount || $[22] !== safeFetchNextPage || $[23] !== setCurrentPage || $[24] !== t6 || $[25] !== t7 || $[26] !== t8) {
+    t9 = {
+      ...baseQuery,
+      fetchPreviousPage,
+      fetchNextPage: safeFetchNextPage,
       currentPage,
-      baseQuery.count ?? baseQuery.data.length,
-      itemCountPerPage
-    ) : null,
-    pageCount,
-    hasNextPage: currentPage < pageCount,
-    hasPreviousPage: currentPage > 1
-  };
+      setCurrentPage,
+      data: t6,
+      pageCount,
+      hasNextPage: t7,
+      hasPreviousPage: t8
+    };
+    $[18] = baseQuery;
+    $[19] = currentPage;
+    $[20] = fetchPreviousPage;
+    $[21] = pageCount;
+    $[22] = safeFetchNextPage;
+    $[23] = setCurrentPage;
+    $[24] = t6;
+    $[25] = t7;
+    $[26] = t8;
+    $[27] = t9;
+  } else {
+    t9 = $[27];
+  }
+  return t9;
+}
+function _temp2(currentPage_1) {
+  return currentPage_1 - 1;
+}
+function _temp(currentPage_0) {
+  return currentPage_0 + 1;
 }
 function toPagedResponse(results, currentPage, totalCount, itemPerPage) {
   const newPage = {
@@ -1187,15 +1325,8 @@ function toPagedResponse(results, currentPage, totalCount, itemPerPage) {
 }
 
 // src/query/useAdvancedQuery.ts
-import {
-  useEffect,
-  useMemo as useMemo3,
-  useRef,
-  useState
-} from "react";
-import {
-  useQuery as useQuery3
-} from "@tanstack/react-query";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { useQuery as useQuery3 } from "@tanstack/react-query";
 import { useSessionStorageState as useSessionStorageState2 } from "@pol-studios/hooks/storage";
 var normalizeFilter = (filter) => {
   const groupOp = filter.op || filter.operator;
@@ -1205,9 +1336,7 @@ var normalizeFilter = (filter) => {
       op: groupOp,
       not: filter.not || filter.inverted,
       // Support both 'not' and legacy 'inverted' for groups
-      filters: filter.filters.map(normalizeFilter).filter(
-        Boolean
-      )
+      filters: filter.filters.map(normalizeFilter).filter(Boolean)
     };
   }
   let operator = filter.op || filter.condition;
@@ -1222,10 +1351,7 @@ var normalizeFilter = (filter) => {
     operator = "contains";
   }
   if (!operator) {
-    console.error(
-      "Filter has undefined operator:",
-      JSON.stringify(filter, null, 2)
-    );
+    console.error("Filter has undefined operator:", JSON.stringify(filter, null, 2));
     return null;
   }
   if (filter.propertyName) {
@@ -1250,12 +1376,7 @@ var normalizeFilter = (filter) => {
   };
 };
 function useAdvancedFilterQuery(query, config) {
-  const filterKey = useMemo3(
-    () => config?.filterKey ?? window.location?.pathname,
-    [
-      config?.filterKey
-    ]
-  );
+  const filterKey = useMemo(() => config?.filterKey ?? window.location?.pathname, [config?.filterKey]);
   const [filterLayer, setFilterLayer] = useSessionStorageState2(filterKey, {
     id: "root",
     op: "AND",
@@ -1264,10 +1385,7 @@ function useAdvancedFilterQuery(query, config) {
     sort: [],
     isReady: isUsable(config?.searchByDefault) ? config.searchByDefault ? false : true : true
   });
-  const parser = useMemo3(
-    () => new PostgrestParser(query),
-    [query, config?.key]
-  );
+  const parser = useMemo(() => new PostgrestParser(query), [query, config?.key]);
   useEffect(() => {
     const searchParam = parser.searchParams.get("order");
     if (searchParam) {
@@ -1296,18 +1414,13 @@ function useAdvancedFilterQuery(query, config) {
           op: pre.op || "AND",
           filters: pre.filters || [],
           isReady: pre.isReady ?? true,
-          sort: [
-            ...(pre.sort || []).filter(
-              (old) => orders.some((o) => o.field === old.field) === false
-            ),
-            ...orders
-          ]
+          sort: [...(pre.sort || []).filter((old) => orders.some((o) => o.field === old.field) === false), ...orders]
         };
       });
     }
   }, [JSON.stringify(parser.searchParams), config?.key]);
   const encodedQueryKeyRef = useRef([]);
-  const encodedQueryKey = useMemo3(() => {
+  const encodedQueryKey = useMemo(() => {
     const newEncoded = encode(query, false);
     const newEncodedString = JSON.stringify(newEncoded);
     const oldEncodedString = JSON.stringify(encodedQueryKeyRef.current);
@@ -1322,18 +1435,7 @@ function useAdvancedFilterQuery(query, config) {
     filterLayerStringRef.current = currentFilterString;
   }
   const queryKeyRef = useRef([]);
-  const newKey = [
-    encodedQueryKey[0],
-    encodedQueryKey[1],
-    encodedQueryKey[2],
-    encodedQueryKey[3],
-    encodedQueryKey[4],
-    encodedQueryKey[5],
-    "count=" + (config?.count ?? ""),
-    encodedQueryKey[7],
-    encodedQueryKey[8],
-    filterLayerStringRef.current
-  ];
+  const newKey = [encodedQueryKey[0], encodedQueryKey[1], encodedQueryKey[2], encodedQueryKey[3], encodedQueryKey[4], encodedQueryKey[5], "count=" + (config?.count ?? ""), encodedQueryKey[7], encodedQueryKey[8], filterLayerStringRef.current];
   const newKeyString = JSON.stringify(newKey);
   const oldKeyString = JSON.stringify(queryKeyRef.current);
   if (oldKeyString !== newKeyString) {
@@ -1351,20 +1453,17 @@ function useAdvancedFilterQuery(query, config) {
   const isEnabled = config?.enabled == null || config?.enabled === void 0 ? true : config.enabled;
   const [extraData, setExtraData] = useState({});
   const queryResponse = useQuery3({
-    ...omit(
-      {
-        retry: 0,
-        // Changed from 1 to 0 to prevent retries
-        ...config ?? {},
-        // Override any config settings to prevent multiple executions
-        refetchOnMount: false,
-        refetchOnWindowFocus: false,
-        refetchOnReconnect: false,
-        structuralSharing: false,
-        enabled: filterLayer?.isReady && isEnabled
-      },
-      ["queryKey", "persister", "initialData"]
-    ),
+    ...omit({
+      retry: 0,
+      // Changed from 1 to 0 to prevent retries
+      ...config ?? {},
+      // Override any config settings to prevent multiple executions
+      refetchOnMount: false,
+      refetchOnWindowFocus: false,
+      refetchOnReconnect: false,
+      structuralSharing: false,
+      enabled: filterLayer?.isReady && isEnabled
+    }, ["queryKey", "persister", "initialData"]),
     queryKey: loadingKey,
     queryFn: async (props) => {
       if (!filterLayer) {
@@ -1375,27 +1474,22 @@ function useAdvancedFilterQuery(query, config) {
         const body = {
           ...filterLayer,
           filters: [...filterLayer.filters],
-          pagination: { ...filterLayer.pagination },
+          pagination: {
+            ...filterLayer.pagination
+          },
           sort: [...filterLayer.sort || []]
         };
         const currentKey = `${parser.schema}${parser.table}${parser.select}${JSON.stringify(omit(body, "pagination"))}`;
         const requiresEdgeForOrdering = false;
         const hasNaturalLanguageQuery = !!filterLayer.naturalLanguageQuery;
         if (filterLayer.filters.length == 0 && requiresEdgeForOrdering === false && !hasNaturalLanguageQuery) {
-          const result2 = await executeSupabaseQuery(
-            supabase,
-            body,
-            parser,
-            extraData,
-            props.signal,
-            config?.count
-          );
-          setExtraData((pre) => ({
-            ...omit(result2, "data"),
-            count: result2.count ? result2.count : pre.count,
+          const result = await executeSupabaseQuery(supabase, body, parser, extraData, props.signal, config?.count);
+          setExtraData((pre_0) => ({
+            ...omit(result, "data"),
+            count: result.count ? result.count : pre_0.count,
             key: currentKey
           }));
-          return result2;
+          return result;
         }
         searchParams.forEach(([k, v]) => {
           if (k.includes("offset")) {
@@ -1413,16 +1507,16 @@ function useAdvancedFilterQuery(query, config) {
             return;
           }
           if (v.includes(".") === false) return;
-          const values = v.split(".");
+          const values_0 = v.split(".");
           const column = k;
-          let rawCondition = values[0];
+          let rawCondition = values_0[0];
           let condition = "";
-          let value = values[1];
-          const inverted = values[0] === "not";
+          let value_0 = values_0[1];
+          const inverted = values_0[0] === "not";
           if (column == "select") return;
           if (rawCondition === "not") {
-            rawCondition = values[1];
-            value = values[2];
+            rawCondition = values_0[1];
+            value_0 = values_0[2];
           }
           switch (rawCondition) {
             case "eq":
@@ -1430,7 +1524,7 @@ function useAdvancedFilterQuery(query, config) {
               break;
             case "in":
               condition = "in";
-              value = value.slice(1, value.length - 1).split(",").filter((x) => isNullOrWhitespace(x) === false);
+              value_0 = value_0.slice(1, value_0.length - 1).split(",").filter((x_0) => isNullOrWhitespace(x_0) === false);
               break;
             case "lt":
               condition = "<";
@@ -1446,8 +1540,8 @@ function useAdvancedFilterQuery(query, config) {
               break;
             case "is":
               condition = "is";
-              if (value == "null") {
-                value = null;
+              if (value_0 == "null") {
+                value_0 = null;
               }
               break;
           }
@@ -1455,16 +1549,27 @@ function useAdvancedFilterQuery(query, config) {
             id: `filter_${column}_${Date.now()}`,
             field: column,
             op: condition,
-            value,
+            value: value_0,
             not: inverted,
             display: column
-          }, { filters: [...body.filters], op: body.op ?? "AND", id: "filterstate" }];
+          }, {
+            filters: [...body.filters],
+            op: body.op ?? "AND",
+            id: "filterstate"
+          }];
           body.op = "AND";
           const bodyCopy = JSON.parse(JSON.stringify(body));
-          bodyCopy.pagination = { page: 0, pageSize: 50 };
+          bodyCopy.pagination = {
+            page: 0,
+            pageSize: 50
+          };
           bodyCopy.isReady = true;
         });
-        const { data: { session } } = await supabase.auth.getSession();
+        const {
+          data: {
+            session
+          }
+        } = await supabase.auth.getSession();
         if (!session?.access_token) {
           throw new Error("No active session");
         }
@@ -1472,29 +1577,29 @@ function useAdvancedFilterQuery(query, config) {
         props.signal.addEventListener("abort", () => {
           controller.abort();
         });
-        const timeout = setTimeout(
-          () => controller.abort(),
-          config?.timeout ?? 15e3
-        );
-        let result = null;
-        let response2 = { error: null, data: null };
+        const timeout = setTimeout(() => controller.abort(), config?.timeout ?? 15e3);
+        let result_0 = null;
+        let response = {
+          error: null,
+          data: null
+        };
         try {
           const UI_ONLY_KEYS = /* @__PURE__ */ new Set(["info", "options", "display"]);
-          const filteredBody = JSON.parse(JSON.stringify(body, (key, value) => {
-            if (UI_ONLY_KEYS.has(key)) {
+          const filteredBody = JSON.parse(JSON.stringify(body, (key_0, value_1) => {
+            if (UI_ONLY_KEYS.has(key_0)) {
               return void 0;
             }
-            return value;
+            return value_1;
           }));
           filteredBody.filters = filteredBody.filters.map(normalizeFilter).filter(Boolean);
           const orParam = parser.searchParams.get("or");
           if (orParam) {
             const cleanedOrParam = orParam.replace(/^\(|\)$/g, "");
             const orConditions = cleanedOrParam.split(",");
-            const orFilters = orConditions.map((condition, idx) => {
-              const match = condition.match(/^(.+?)\.([^.]+)\.(.+)$/);
+            const orFilters = orConditions.map((condition_0, idx) => {
+              const match = condition_0.match(/^(.+?)\.([^.]+)\.(.+)$/);
               if (match) {
-                const [_, field, rawOp, value] = match;
+                const [_, field, rawOp, value_2] = match;
                 let op = rawOp.trim();
                 switch (op) {
                   case "eq":
@@ -1529,58 +1634,52 @@ function useAdvancedFilterQuery(query, config) {
                   id: `or-${idx}`,
                   field: field.trim(),
                   op,
-                  value: value.trim()
+                  value: value_2.trim()
                 };
               }
               return null;
             }).filter(Boolean);
             if (orFilters.length > 0) {
-              filteredBody.filters = [
-                ...filteredBody.filters,
-                {
-                  id: "base-or-group",
-                  op: "OR",
-                  filters: orFilters,
-                  pagination: void 0,
-                  sort: void 0,
-                  isReady: true
-                }
-              ];
+              filteredBody.filters = [...filteredBody.filters, {
+                id: "base-or-group",
+                op: "OR",
+                filters: orFilters,
+                pagination: void 0,
+                sort: void 0,
+                isReady: true
+              }];
             }
           }
-          const res = await fetch(
-            `${getSupabaseUrl()}/functions/v1/query?forceDenoVersion=2`,
-            {
-              method: "POST",
-              headers: {
-                "Content-Type": "application/json",
-                "Authorization": `Bearer ${session.access_token}`
+          const res = await fetch(`${getSupabaseUrl()}/functions/v1/query?forceDenoVersion=2`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "Authorization": `Bearer ${session.access_token}`
+            },
+            body: JSON.stringify({
+              table: parser.table,
+              schema: parser.schema,
+              select: parser.select,
+              filters: {
+                id: filteredBody.id || "root",
+                op: filteredBody.op || filteredBody.operator || "AND",
+                not: filteredBody.not || filteredBody.inverted,
+                // Support both 'not' and legacy 'inverted'
+                filters: filteredBody.filters || []
               },
-              body: JSON.stringify({
-                table: parser.table,
-                schema: parser.schema,
-                select: parser.select,
-                filters: {
-                  id: filteredBody.id || "root",
-                  op: filteredBody.op || filteredBody.operator || "AND",
-                  not: filteredBody.not || filteredBody.inverted,
-                  // Support both 'not' and legacy 'inverted'
-                  filters: filteredBody.filters || []
-                },
-                pagination: filteredBody.pagination,
-                sort: filteredBody.sort,
-                distinctOn: filteredBody.distinctOn,
-                naturalLanguageQuery: filteredBody.naturalLanguageQuery,
-                count: currentKey === extraData.key ? "" : config?.count ?? "",
-                debug: true
-              }),
-              signal: controller.signal
-            }
-          );
+              pagination: filteredBody.pagination,
+              sort: filteredBody.sort,
+              distinctOn: filteredBody.distinctOn,
+              naturalLanguageQuery: filteredBody.naturalLanguageQuery,
+              count: currentKey === extraData.key ? "" : config?.count ?? "",
+              debug: true
+            }),
+            signal: controller.signal
+          });
           if (!res.ok) {
             const errorData = await res.json();
-            const errorMessage = typeof errorData?.error === "string" ? errorData.error : errorData?.error?.message || errorData?.message || "An error occurred while processing your request";
-            throw new Error(errorMessage);
+            const errorMessage_0 = typeof errorData?.error === "string" ? errorData.error : errorData?.error?.message || errorData?.message || "An error occurred while processing your request";
+            throw new Error(errorMessage_0);
           }
           const data = await res.json();
           if (data.clarification) {
@@ -1592,45 +1691,57 @@ function useAdvancedFilterQuery(query, config) {
               error: void 0
             };
           }
-          result = data;
-          response2 = { error: null, data };
+          result_0 = data;
+          response = {
+            error: null,
+            data
+          };
         } catch (err) {
           if (err.name === "AbortError") {
             console.error("Fetch aborted/time-out");
-            response2 = { error: new Error("This query timed out"), data: null };
+            response = {
+              error: new Error("This query timed out"),
+              data: null
+            };
           } else if (err instanceof Error) {
-            response2 = { error: err, data: null };
+            response = {
+              error: err,
+              data: null
+            };
           } else {
             const errorMessage = err?.error || err?.message || String(err);
-            response2 = { error: new Error(errorMessage), data: null };
+            response = {
+              error: new Error(errorMessage),
+              data: null
+            };
           }
         } finally {
           clearTimeout(timeout);
         }
-        if (response2.error) {
-          throw response2.error;
-        } else if (response2.data?.error) {
-          throw new Error(response2.data.error);
+        if (response.error) {
+          throw response.error;
+        } else if (response.data?.error) {
+          throw new Error(response.data.error);
         }
-        if (result.clarification) {
+        if (result_0.clarification) {
           return {
             data: [],
             count: 0,
-            clarification: result.clarification,
+            clarification: result_0.clarification,
             error: void 0
           };
         }
-        setExtraData((pre) => ({
-          ...omit(result, "data"),
-          count: pre.key === currentKey ? pre.count : result.count,
+        setExtraData((pre_1) => ({
+          ...omit(result_0, "data"),
+          count: pre_1.key === currentKey ? pre_1.count : result_0.count,
           key: currentKey
         }));
         return {
-          ...result,
+          ...result_0,
           statusText: "",
-          status: result.data?.length > result.count ? 206 : 200,
-          error: response2.data?.error ?? null,
-          hasMore: result.data?.length < result.count ? true : false
+          status: result_0.data?.length > result_0.count ? 206 : 200,
+          error: response.data?.error ?? null,
+          hasMore: result_0.data?.length < result_0.count ? true : false
         };
       } catch (error) {
         if (error instanceof Error && error.name === "AbortError") {
@@ -1645,17 +1756,17 @@ function useAdvancedFilterQuery(query, config) {
       }
     }
   });
-  const response = {
+  const response_0 = {
     ...queryResponse,
     data: queryResponse.data?.data,
     count: extraData.count,
     clarification: queryResponse.data?.clarification
   };
   useEffect(() => {
-    if (queryResponse.isFetched && response.count == null) {
+    if (queryResponse.isFetched && response_0.count == null) {
       queryResponse.refetch();
     }
-  }, [response.count]);
+  }, [response_0.count]);
   useEffect(() => {
     if (queryResponse.data?.error == null) return;
     if (queryResponse.data?.error?.message?.includes(" does not exist")) {
@@ -1669,7 +1780,7 @@ function useAdvancedFilterQuery(query, config) {
       });
     }
   }, [queryResponse.data?.error]);
-  return [response, filterLayer, setFilterLayer];
+  return [response_0, filterLayer, setFilterLayer];
 }
 function isSearchableColumn(columnName) {
   return true;
@@ -1682,7 +1793,9 @@ async function executeSupabaseQuery(supabase, body, parser, extraData, signal, c
   });
   if (body.sort && Array.isArray(body.sort)) {
     body.sort.forEach((s) => {
-      query.order(s.field, { ascending: s.direction === "asc" });
+      query.order(s.field, {
+        ascending: s.direction === "asc"
+      });
     });
   }
   const from = searchParams.find((x) => x[0].includes("offset"))?.[1];
@@ -1697,7 +1810,7 @@ async function executeSupabaseQuery(supabase, body, parser, extraData, signal, c
       return;
     }
     if (k === "or") {
-      query.or(v.slice(1, v.length - 2));
+      query.or(v.slice(1, v.length - 1));
       return;
     }
     const values = v.split(".");
@@ -1705,6 +1818,7 @@ async function executeSupabaseQuery(supabase, body, parser, extraData, signal, c
     let rawCondition = values[0];
     let value = values[1];
     if (column == "select") return;
+    if (column == "order") return;
     if (v.includes(".") === false) return;
     if (rawCondition === "ilike" && !isSearchableColumn(column)) {
       return;
@@ -1734,10 +1848,8 @@ async function executeSupabaseQuery(supabase, body, parser, extraData, signal, c
 var useAdvancedQuery = useAdvancedFilterQuery;
 
 // src/query/useInfiniteQuery.ts
-import {
-  useInfiniteQuery as useTanstackInfiniteQuery
-} from "@tanstack/react-query";
-import { useMemo as useMemo4, useRef as useRef2 } from "react";
+import { useInfiniteQuery as useTanstackInfiniteQuery } from "@tanstack/react-query";
+import { useMemo as useMemo2, useRef as useRef2 } from "react";
 function useInfiniteQuery(query, countPerLoad, config) {
   const initialQueryKey = encode(query, false).join("-");
   const lastKnownQuery = useRef2(initialQueryKey);
@@ -1747,23 +1859,23 @@ function useInfiniteQuery(query, countPerLoad, config) {
     currentPageNumber.current = 1;
   }
   const isFetching = useRef2(false);
-  const queryKey = useMemo4(
-    () => encode(query, false),
-    [initialQueryKey, config?.crossOrganization]
-  );
+  const queryKey = useMemo2(() => encode(query, false), [initialQueryKey, config?.crossOrganization]);
   const getQuery = useTanstackInfiniteQuery({
     ...config,
     queryKey,
-    queryFn: async ({ pageParam, signal }) => {
+    queryFn: async ({
+      pageParam,
+      signal
+    }) => {
       let adjustableQuery = query;
       const pageNumber = pageParam;
       if (config?.onQuery && config?.enableOnQuery) {
-        config?.onQuery({ query: adjustableQuery, pageParam: pageNumber });
+        config?.onQuery({
+          query: adjustableQuery,
+          pageParam: pageNumber
+        });
       } else {
-        adjustableQuery = adjustableQuery.range(
-          (pageNumber - 1) * countPerLoad,
-          pageNumber * countPerLoad - 1
-        );
+        adjustableQuery = adjustableQuery.range((pageNumber - 1) * countPerLoad, pageNumber * countPerLoad - 1);
       }
       adjustableQuery = adjustableQuery.abortSignal(signal);
       updatedCache.current = false;
@@ -1776,119 +1888,209 @@ function useInfiniteQuery(query, countPerLoad, config) {
       }
     },
     initialPageParam: 1,
-    getNextPageParam: (response, allResponses, lastParam) => {
-      const pageParam = lastParam;
-      const resp = response;
+    getNextPageParam: (response_0, allResponses, lastParam) => {
+      const pageParam_0 = lastParam;
+      const resp = response_0;
       if (allResponses.length * countPerLoad >= (resp?.count ?? 0)) {
         return void 0;
       }
-      return pageParam + 1;
+      return pageParam_0 + 1;
     }
   });
   const updatedCache = useRef2(true);
-  return useMemo4(
-    () => {
-      const pages = getQuery.data?.pages;
-      return {
-        ...getQuery,
-        count: pages?.[pages.length - 1]?.count,
-        data: pages?.flatMap((x) => x.data ?? [])
-      };
-    },
-    [getQuery.data, currentPageNumber.current]
-  );
+  return useMemo2(() => {
+    const pages = getQuery.data?.pages;
+    return {
+      ...getQuery,
+      count: pages?.[pages.length - 1]?.count,
+      data: pages?.flatMap((x) => x.data ?? [])
+    };
+  }, [getQuery.data, currentPageNumber.current]);
 }
 
 // src/query/usePartialAdvancedQuery.ts
-import { useLayoutEffect, useMemo as useMemo5, useState as useState2 } from "react";
+import { c as _c3 } from "react/compiler-runtime";
+import { useLayoutEffect, useState as useState2 } from "react";
 import { useSessionStorageState as useSessionStorageState3 } from "@pol-studios/hooks/storage";
 function usePartialAdvancedQuery(query, itemCountPerPage, config) {
+  const $ = _c3(54);
   const initialQuery = encode(query, false);
   const [id, setId] = useState2(window.location.pathname);
-  const [currentPage, setCurrentPage] = useSessionStorageState3(
-    `${id}-currentPage`,
-    1
-  );
-  const rangedQuery = useMemo5(
-    () => {
-      const page = currentPage ?? 1;
-      return query.range(
-        (page - 1) * itemCountPerPage,
-        page * itemCountPerPage - 1
-      );
-    },
-    [query, currentPage, itemCountPerPage]
-  );
-  const [baseQuery, filter, setFilters] = useAdvancedFilterQuery(
-    rangedQuery,
-    {
+  const [currentPage, setCurrentPage] = useSessionStorageState3(`${id}-currentPage`, 1);
+  const page = currentPage ?? 1;
+  const t0 = query;
+  let t1;
+  if ($[0] !== itemCountPerPage || $[1] !== page || $[2] !== t0) {
+    t1 = t0.range((page - 1) * itemCountPerPage, page * itemCountPerPage - 1);
+    $[0] = itemCountPerPage;
+    $[1] = page;
+    $[2] = t0;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  const rangedQuery = t1;
+  const t2 = config?.filterKey;
+  const t3 = currentPage ?? 1;
+  let t4;
+  if ($[4] !== t3) {
+    t4 = t3.toString();
+    $[4] = t3;
+    $[5] = t4;
+  } else {
+    t4 = $[5];
+  }
+  let t5;
+  if ($[6] !== config || $[7] !== t2 || $[8] !== t4) {
+    t5 = {
       ...config,
-      filterKey: config?.filterKey,
+      filterKey: t2,
       count: "exact",
-      key: (currentPage ?? 1).toString()
-    }
-  );
-  const filterKey = JSON.stringify(omit(filter, ["pagination"]));
-  const select = initialQuery[4].split("&").find(
-    (x) => x.startsWith("select=")
-  );
-  useLayoutEffect(() => {
-    const newId = [
-      initialQuery[3],
-      select,
-      initialQuery[5],
-      initialQuery[6],
-      initialQuery[7],
-      initialQuery[8],
-      filterKey
-    ].join("-");
-    console.log({ newId, id });
-    setId(newId);
-  }, [
-    initialQuery[3],
-    select,
-    initialQuery[5],
-    initialQuery[6],
-    initialQuery[7],
-    initialQuery[8],
-    filterKey
-  ]);
-  const safeFetchNextPage = () => {
-    setCurrentPage((currentPage2) => (currentPage2 ?? 1) + 1);
-  };
-  const fetchPreviousPage = () => {
-    setCurrentPage((currentPage2) => (currentPage2 ?? 1) - 1);
-  };
-  const pageCount = Math.max(
-    Math.ceil(
-      (baseQuery.count ?? 0) / itemCountPerPage
-    ),
-    1
-  );
-  const request = {
-    ...baseQuery,
-    clarification: baseQuery.clarification,
-    // Explicitly pass through clarification
-    fetchPreviousPage,
-    fetchNextPage: safeFetchNextPage,
-    currentPage,
-    setCurrentPage,
-    data: baseQuery.data ? toPagedResponse2(
-      baseQuery.data,
-      currentPage ?? 1,
-      baseQuery.count ?? baseQuery.data.length,
-      itemCountPerPage
-    ) : null,
-    pageCount,
-    hasNextPage: (currentPage ?? 1) < pageCount,
-    hasPreviousPage: (currentPage ?? 1) > 1,
-    count: baseQuery.count ?? baseQuery.data?.length
-  };
-  return [
-    request,
-    filter,
-    setFilters
-  ];
+      key: t4
+    };
+    $[6] = config;
+    $[7] = t2;
+    $[8] = t4;
+    $[9] = t5;
+  } else {
+    t5 = $[9];
+  }
+  const [baseQuery, filter, setFilters] = useAdvancedFilterQuery(rangedQuery, t5);
+  let t6;
+  if ($[10] !== filter) {
+    t6 = JSON.stringify(omit(filter, ["pagination"]));
+    $[10] = filter;
+    $[11] = t6;
+  } else {
+    t6 = $[11];
+  }
+  const filterKey = t6;
+  const select = initialQuery[4].split("&").find(_temp4);
+  let t7;
+  if ($[12] !== filterKey || $[13] !== id || $[14] !== initialQuery[3] || $[15] !== initialQuery[5] || $[16] !== initialQuery[6] || $[17] !== initialQuery[7] || $[18] !== initialQuery[8] || $[19] !== select || $[20] !== setId) {
+    t7 = () => {
+      const newId = [initialQuery[3], select, initialQuery[5], initialQuery[6], initialQuery[7], initialQuery[8], filterKey].join("-");
+      console.log({
+        newId,
+        id
+      });
+      setId(newId);
+    };
+    $[12] = filterKey;
+    $[13] = id;
+    $[14] = initialQuery[3];
+    $[15] = initialQuery[5];
+    $[16] = initialQuery[6];
+    $[17] = initialQuery[7];
+    $[18] = initialQuery[8];
+    $[19] = select;
+    $[20] = setId;
+    $[21] = t7;
+  } else {
+    t7 = $[21];
+  }
+  let t8;
+  if ($[22] !== filterKey || $[23] !== initialQuery[3] || $[24] !== initialQuery[5] || $[25] !== initialQuery[6] || $[26] !== initialQuery[7] || $[27] !== initialQuery[8] || $[28] !== select) {
+    t8 = [initialQuery[3], select, initialQuery[5], initialQuery[6], initialQuery[7], initialQuery[8], filterKey];
+    $[22] = filterKey;
+    $[23] = initialQuery[3];
+    $[24] = initialQuery[5];
+    $[25] = initialQuery[6];
+    $[26] = initialQuery[7];
+    $[27] = initialQuery[8];
+    $[28] = select;
+    $[29] = t8;
+  } else {
+    t8 = $[29];
+  }
+  useLayoutEffect(t7, t8);
+  let t9;
+  if ($[30] !== setCurrentPage) {
+    t9 = () => {
+      setCurrentPage(_temp22);
+    };
+    $[30] = setCurrentPage;
+    $[31] = t9;
+  } else {
+    t9 = $[31];
+  }
+  const safeFetchNextPage = t9;
+  let t10;
+  if ($[32] !== setCurrentPage) {
+    t10 = () => {
+      setCurrentPage(_temp3);
+    };
+    $[32] = setCurrentPage;
+    $[33] = t10;
+  } else {
+    t10 = $[33];
+  }
+  const fetchPreviousPage = t10;
+  const pageCount = Math.max(Math.ceil((baseQuery.count ?? 0) / itemCountPerPage), 1);
+  let t11;
+  if ($[34] !== baseQuery.count || $[35] !== baseQuery.data || $[36] !== currentPage || $[37] !== itemCountPerPage) {
+    t11 = baseQuery.data ? toPagedResponse2(baseQuery.data, currentPage ?? 1, baseQuery.count ?? baseQuery.data.length, itemCountPerPage) : null;
+    $[34] = baseQuery.count;
+    $[35] = baseQuery.data;
+    $[36] = currentPage;
+    $[37] = itemCountPerPage;
+    $[38] = t11;
+  } else {
+    t11 = $[38];
+  }
+  const t12 = (currentPage ?? 1) < pageCount;
+  const t13 = (currentPage ?? 1) > 1;
+  const t14 = baseQuery.count ?? baseQuery.data?.length;
+  let t15;
+  if ($[39] !== baseQuery || $[40] !== currentPage || $[41] !== fetchPreviousPage || $[42] !== pageCount || $[43] !== safeFetchNextPage || $[44] !== setCurrentPage || $[45] !== t11 || $[46] !== t12 || $[47] !== t13 || $[48] !== t14) {
+    t15 = {
+      ...baseQuery,
+      clarification: baseQuery.clarification,
+      fetchPreviousPage,
+      fetchNextPage: safeFetchNextPage,
+      currentPage,
+      setCurrentPage,
+      data: t11,
+      pageCount,
+      hasNextPage: t12,
+      hasPreviousPage: t13,
+      count: t14
+    };
+    $[39] = baseQuery;
+    $[40] = currentPage;
+    $[41] = fetchPreviousPage;
+    $[42] = pageCount;
+    $[43] = safeFetchNextPage;
+    $[44] = setCurrentPage;
+    $[45] = t11;
+    $[46] = t12;
+    $[47] = t13;
+    $[48] = t14;
+    $[49] = t15;
+  } else {
+    t15 = $[49];
+  }
+  const request = t15;
+  let t16;
+  if ($[50] !== filter || $[51] !== request || $[52] !== setFilters) {
+    t16 = [request, filter, setFilters];
+    $[50] = filter;
+    $[51] = request;
+    $[52] = setFilters;
+    $[53] = t16;
+  } else {
+    t16 = $[53];
+  }
+  return t16;
+}
+function _temp3(currentPage_1) {
+  return (currentPage_1 ?? 1) - 1;
+}
+function _temp22(currentPage_0) {
+  return (currentPage_0 ?? 1) + 1;
+}
+function _temp4(x) {
+  return x.startsWith("select=");
 }
 function toPagedResponse2(results, currentPage, totalCount, itemPerPage) {
   const newPage = {
@@ -1924,4 +2126,4 @@ export {
   useInfiniteQuery,
   usePartialAdvancedQuery
 };
-//# sourceMappingURL=chunk-ZTSBF536.js.map
+//# sourceMappingURL=chunk-X3HZLNBV.js.map