@void-snippets/react 0.3.0 → 0.6.1

package/dist/index.mjs

@@ -6,19 +6,212 @@ import {
   useQueryClient
 } from "@tanstack/react-query";
 import { createDefaultAdapters } from "@void-snippets/core";
-var DEFAULT_PAGINATION = {
-  page: 1,
-  limit: 10
-};
+var DEFAULT_PAGINATION = { page: 1, limit: 10 };
+function toOperation(op) {
+  if (op.kind === "create") return { kind: "create", payload: op.payload, tempId: op.tempId };
+  if (op.kind === "update") return { kind: "update", _id: op._id, payload: op.payload };
+  return { kind: "remove", _id: op._id };
+}
+var _stacks = /* @__PURE__ */ new WeakMap();
+function getStack(client, prefix) {
+  if (!_stacks.has(client)) _stacks.set(client, /* @__PURE__ */ new Map());
+  const map = _stacks.get(client);
+  if (!map.has(prefix)) {
+    map.set(prefix, {
+      pendingOps: [],
+      effectiveBaseListSnapshots: [],
+      effectiveBaseInfiniteSnapshots: [],
+      effectiveBaseGet: /* @__PURE__ */ new Map()
+    });
+  }
+  return map.get(prefix);
+}
+function isListQueryKey(query) {
+  const key = query.queryKey;
+  return key.length === 2 && key[1] !== null && typeof key[1] === "object" && !Array.isArray(key[1]);
+}
+function generateTempId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+function patchPagination(pagination, delta) {
+  if (delta === 0) return pagination;
+  const newTotal = Math.max(0, pagination.totalDocuments + delta);
+  return {
+    ...pagination,
+    totalDocuments: newTotal,
+    totalPages: Math.ceil(newTotal / pagination.limit)
+  };
+}
+function applyUpdateToAllCaches(client, prefix, _id, payload, handler) {
+  client.setQueriesData(
+    { queryKey: [prefix], predicate: isListQueryKey },
+    (old) => old ? { ...old, items: handler(old.items, { _id, payload }) } : old
+  );
+  client.setQueriesData(
+    { queryKey: [prefix, "INFINITE"] },
+    (old) => old ? { ...old, pages: old.pages.map((p) => ({ ...p, items: handler(p.items, { _id, payload }) })) } : old
+  );
+}
+function applyRemoveFromAllCaches(client, prefix, _id, handler) {
+  client.setQueriesData(
+    { queryKey: [prefix], predicate: isListQueryKey },
+    (old) => {
+      if (!old) return old;
+      const newItems = handler(old.items, _id);
+      return { ...old, items: newItems, pagination: patchPagination(old.pagination, newItems.length - old.items.length) };
+    }
+  );
+  client.setQueriesData(
+    { queryKey: [prefix, "INFINITE"] },
+    (old) => old ? {
+      ...old,
+      pages: old.pages.map((p) => {
+        const newItems = handler(p.items, _id);
+        return { ...p, items: newItems, pagination: patchPagination(p.pagination, newItems.length - p.items.length) };
+      })
+    } : old
+  );
+}
+function applyCreateToAllCaches(client, prefix, payload, tempId, handler) {
+  client.setQueriesData(
+    { queryKey: [prefix], predicate: isListQueryKey },
+    (old) => {
+      if (!old) return old;
+      const newItems = handler(old.items, { payload, tempId });
+      return { ...old, items: newItems, pagination: patchPagination(old.pagination, newItems.length - old.items.length) };
+    }
+  );
+  client.setQueriesData(
+    { queryKey: [prefix, "INFINITE"] },
+    (old) => {
+      if (!old) return old;
+      return {
+        ...old,
+        pages: old.pages.map((p, i) => {
+          if (i !== 0) return p;
+          const newItems = handler(p.items, { payload, tempId });
+          return { ...p, items: newItems, pagination: patchPagination(p.pagination, newItems.length - p.items.length) };
+        })
+      };
+    }
+  );
+}
+function restoreEffectiveBase(client, prefix, stack) {
+  stack.effectiveBaseListSnapshots.forEach(([key, data]) => client.setQueryData(key, data));
+  stack.effectiveBaseInfiniteSnapshots.forEach(([key, data]) => client.setQueryData(key, data));
+  stack.effectiveBaseGet.forEach((data, idStr) => client.setQueryData([prefix, idStr], data));
+}
+function advanceEffectiveBase(stack, op, optimistic) {
+  if (op.kind === "update" && optimistic.update) {
+    stack.effectiveBaseListSnapshots = stack.effectiveBaseListSnapshots.map(
+      ([key, data]) => data ? [key, { ...data, items: optimistic.update(data.items, { _id: op._id, payload: op.payload }) }] : [key, data]
+    );
+    stack.effectiveBaseInfiniteSnapshots = stack.effectiveBaseInfiniteSnapshots.map(
+      ([key, data]) => data ? [key, { ...data, pages: data.pages.map((p) => ({ ...p, items: optimistic.update(p.items, { _id: op._id, payload: op.payload }) })) }] : [key, data]
+    );
+    const baseEntry = stack.effectiveBaseGet.get(String(op._id));
+    if (baseEntry !== void 0) {
+      const advanced = optimistic.updateSingle ? optimistic.updateSingle(baseEntry, op.payload) : { ...baseEntry, ...op.payload };
+      stack.effectiveBaseGet.set(String(op._id), advanced);
+    }
+    return;
+  }
+  if (op.kind === "remove" && optimistic.remove) {
+    stack.effectiveBaseListSnapshots = stack.effectiveBaseListSnapshots.map(([key, data]) => {
+      if (!data) return [key, data];
+      const newItems = optimistic.remove(data.items, op._id);
+      return [key, { ...data, items: newItems, pagination: patchPagination(data.pagination, newItems.length - data.items.length) }];
+    });
+    stack.effectiveBaseInfiniteSnapshots = stack.effectiveBaseInfiniteSnapshots.map(
+      ([key, data]) => data ? [
+        key,
+        {
+          ...data,
+          pages: data.pages.map((p) => {
+            const newItems = optimistic.remove(p.items, op._id);
+            return { ...p, items: newItems, pagination: patchPagination(p.pagination, newItems.length - p.items.length) };
+          })
+        }
+      ] : [key, data]
+    );
+    stack.effectiveBaseGet.delete(String(op._id));
+    return;
+  }
+}
+function replayPendingOps(client, prefix, stack, optimistic) {
+  for (const op of stack.pendingOps) {
+    if (op.kind === "update" && optimistic.update) {
+      applyUpdateToAllCaches(client, prefix, op._id, op.payload, optimistic.update);
+      const current = client.getQueryData([prefix, String(op._id)]);
+      if (current !== void 0) {
+        const updated = optimistic.updateSingle ? optimistic.updateSingle(current, op.payload) : { ...current, ...op.payload };
+        client.setQueryData([prefix, String(op._id)], updated);
+      }
+    } else if (op.kind === "remove" && optimistic.remove) {
+      applyRemoveFromAllCaches(client, prefix, op._id, optimistic.remove);
+      client.invalidateQueries({ queryKey: [prefix, String(op._id)], refetchType: "none" });
+    } else if (op.kind === "create" && optimistic.create) {
+      applyCreateToAllCaches(client, prefix, op.payload, op.tempId, optimistic.create);
+    }
+  }
+}
+function flushStack(client, prefix, stack) {
+  stack.pendingOps = [];
+  stack.effectiveBaseListSnapshots = [];
+  stack.effectiveBaseInfiniteSnapshots = [];
+  stack.effectiveBaseGet.clear();
+  client.invalidateQueries({ queryKey: [prefix] });
+}
+function handleOptimisticError(client, prefix, error, context, optimistic) {
+  if (!context) return;
+  const stack = getStack(client, prefix);
+  const failedOp = stack.pendingOps.find((op) => op.id === context.operationId);
+  stack.pendingOps = stack.pendingOps.filter((op) => op.id !== context.operationId);
+  restoreEffectiveBase(client, prefix, stack);
+  replayPendingOps(client, prefix, stack, optimistic);
+  if (failedOp && optimistic.onError) {
+    try {
+      optimistic.onError(error, toOperation(failedOp));
+    } catch {
+    }
+  }
+}
+function handleOptimisticSettled(client, prefix, error, context, optimistic) {
+  if (!context) {
+    client.invalidateQueries({ queryKey: [prefix] });
+    return;
+  }
+  const stack = getStack(client, prefix);
+  if (!error) {
+    const settledOp = stack.pendingOps.find((op) => op.id === context.operationId);
+    if (settledOp) {
+      advanceEffectiveBase(stack, settledOp, optimistic);
+      if (optimistic.onSuccess) {
+        try {
+          optimistic.onSuccess(toOperation(settledOp));
+        } catch {
+        }
+      }
+    }
+  }
+  stack.pendingOps = stack.pendingOps.filter((op) => op.id !== context.operationId);
+  if (stack.pendingOps.length === 0) {
+    flushStack(client, prefix, stack);
+  }
+}
 function createResourceHooks(queryKeyPrefix, apiService, options = {}) {
   const service = apiService;
   const {
     adapters = createDefaultAdapters(),
-    defaultParams = DEFAULT_PAGINATION
+    defaultParams = DEFAULT_PAGINATION,
+    optimistic
   } = options;
   return {
     // -------------------------------------------------------------------------
-    // useList — fixed generic shape: { list, isLoading, pagination, error, invalidate }
+    // useList
     // -------------------------------------------------------------------------
     useList: (params = defaultParams) => {
       var _a, _b, _c, _d, _e;
@@ -38,13 +231,17 @@ function createResourceHooks(queryKeyPrefix, apiService, options = {}) {
           totalPages: 0,
           totalDocuments: 0
         },
-        isLoading: query.isLoading || query.isFetching,
+        isLoading: query.isLoading,
+        isFetching: query.isFetching,
+        isRefetching: query.isRefetching,
+        isError: query.isError,
         error: query.error,
+        refetch: query.refetch,
         invalidate: () => queryClient.invalidateQueries({ queryKey: [queryKeyPrefix] })
       };
     },
     // -------------------------------------------------------------------------
-    // useGet — { item, isLoading, error, refetch }
+    // useGet
     // -------------------------------------------------------------------------
     useGet: (id, staleTime = 3e4) => {
       const query = useQuery({
@@ -58,46 +255,173 @@ function createResourceHooks(queryKeyPrefix, apiService, options = {}) {
       });
       return {
         item: query.data,
-        isLoading: query.isLoading || query.isFetching,
+        isLoading: query.isLoading,
+        isFetching: query.isFetching,
+        isRefetching: query.isRefetching,
+        isError: query.isError,
         error: query.error,
         refetch: query.refetch
       };
     },
     // -------------------------------------------------------------------------
-    // useMutations — create / update / remove (not delete — reserved keyword)
+    // useMutations
     // -------------------------------------------------------------------------
     useMutations: () => {
       const queryClient = useQueryClient();
       const invalidate = () => queryClient.invalidateQueries({ queryKey: [queryKeyPrefix] });
+      function captureBaseIfFirstOp(stack) {
+        if (stack.pendingOps.length === 0) {
+          stack.effectiveBaseListSnapshots = queryClient.getQueriesData({
+            queryKey: [queryKeyPrefix],
+            predicate: isListQueryKey
+          });
+          stack.effectiveBaseInfiniteSnapshots = queryClient.getQueriesData({
+            queryKey: [queryKeyPrefix, "INFINITE"]
+          });
+        }
+      }
       const createMutation = useMutation({
         mutationFn: async (payload) => {
           const raw = await service.create(payload);
           return adapters.fromSingle(raw);
         },
-        onSuccess: invalidate
+        onMutate: async (payload) => {
+          if (!(optimistic == null ? void 0 : optimistic.create)) return void 0;
+          await queryClient.cancelQueries({ queryKey: [queryKeyPrefix] });
+          const stack = getStack(
+            queryClient,
+            queryKeyPrefix
+          );
+          captureBaseIfFirstOp(stack);
+          const tempId = generateTempId();
+          const op = {
+            id: /* @__PURE__ */ Symbol(),
+            kind: "create",
+            payload,
+            tempId
+          };
+          stack.pendingOps.push(op);
+          try {
+            applyCreateToAllCaches(queryClient, queryKeyPrefix, payload, tempId, optimistic.create);
+          } catch {
+            stack.pendingOps = stack.pendingOps.filter((o) => o.id !== op.id);
+            throw new Error("[@void-snippets/react] Optimistic create setup failed.");
+          }
+          return { operationId: op.id };
+        },
+        onError: (_err, _vars, context) => {
+          if (!(optimistic == null ? void 0 : optimistic.create)) return;
+          handleOptimisticError(queryClient, queryKeyPrefix, _err, context, optimistic);
+        },
+        onSettled: (_data, error, _vars, context) => {
+          if (!(optimistic == null ? void 0 : optimistic.create)) {
+            invalidate();
+            return;
+          }
+          handleOptimisticSettled(queryClient, queryKeyPrefix, error != null ? error : null, context, optimistic);
+        }
       });
       const updateMutation = useMutation({
         mutationFn: async ({ _id, payload }) => {
           const raw = await service.update(_id, payload);
           return adapters.fromSingle(raw);
         },
-        onSuccess: invalidate
+        onMutate: async ({ _id, payload }) => {
+          if (!(optimistic == null ? void 0 : optimistic.update)) return void 0;
+          await queryClient.cancelQueries({ queryKey: [queryKeyPrefix] });
+          const stack = getStack(
+            queryClient,
+            queryKeyPrefix
+          );
+          captureBaseIfFirstOp(stack);
+          const currentSingle = queryClient.getQueryData([queryKeyPrefix, String(_id)]);
+          if (currentSingle !== void 0) {
+            stack.effectiveBaseGet.set(String(_id), currentSingle);
+          }
+          const op = {
+            id: /* @__PURE__ */ Symbol(),
+            kind: "update",
+            _id,
+            payload
+          };
+          stack.pendingOps.push(op);
+          try {
+            applyUpdateToAllCaches(queryClient, queryKeyPrefix, _id, payload, optimistic.update);
+            if (currentSingle !== void 0) {
+              const updated = optimistic.updateSingle ? optimistic.updateSingle(currentSingle, payload) : { ...currentSingle, ...payload };
+              queryClient.setQueryData([queryKeyPrefix, String(_id)], updated);
+            }
+          } catch {
+            stack.pendingOps = stack.pendingOps.filter((o) => o.id !== op.id);
+            throw new Error("[@void-snippets/react] Optimistic update setup failed.");
+          }
+          return { operationId: op.id };
+        },
+        onError: (_err, _vars, context) => {
+          if (!(optimistic == null ? void 0 : optimistic.update)) return;
+          handleOptimisticError(queryClient, queryKeyPrefix, _err, context, optimistic);
+        },
+        onSettled: (_data, error, _vars, context) => {
+          if (!(optimistic == null ? void 0 : optimistic.update)) {
+            invalidate();
+            return;
+          }
+          handleOptimisticSettled(queryClient, queryKeyPrefix, error != null ? error : null, context, optimistic);
+        }
       });
       const removeMutation = useMutation({
         mutationFn: async (_id) => {
           const raw = await service.delete(_id);
           return adapters.fromSingle(raw);
         },
-        onSuccess: invalidate
+        onMutate: async (_id) => {
+          if (!(optimistic == null ? void 0 : optimistic.remove)) return void 0;
+          await queryClient.cancelQueries({ queryKey: [queryKeyPrefix] });
+          const stack = getStack(
+            queryClient,
+            queryKeyPrefix
+          );
+          captureBaseIfFirstOp(stack);
+          const currentSingle = queryClient.getQueryData([queryKeyPrefix, String(_id)]);
+          if (currentSingle !== void 0) {
+            stack.effectiveBaseGet.set(String(_id), currentSingle);
+          }
+          const op = {
+            id: /* @__PURE__ */ Symbol(),
+            kind: "remove",
+            _id
+          };
+          stack.pendingOps.push(op);
+          try {
+            applyRemoveFromAllCaches(queryClient, queryKeyPrefix, _id, optimistic.remove);
+            if (currentSingle !== void 0) {
+              queryClient.invalidateQueries({
+                queryKey: [queryKeyPrefix, String(_id)],
+                refetchType: "none"
+              });
+            }
+          } catch {
+            stack.pendingOps = stack.pendingOps.filter((o) => o.id !== op.id);
+            throw new Error("[@void-snippets/react] Optimistic remove setup failed.");
+          }
+          return { operationId: op.id };
+        },
+        onError: (_err, _vars, context) => {
+          if (!(optimistic == null ? void 0 : optimistic.remove)) return;
+          handleOptimisticError(queryClient, queryKeyPrefix, _err, context, optimistic);
+        },
+        onSettled: (_data, error, _vars, context) => {
+          if (!(optimistic == null ? void 0 : optimistic.remove)) {
+            invalidate();
+            return;
+          }
+          handleOptimisticSettled(queryClient, queryKeyPrefix, error != null ? error : null, context, optimistic);
+        }
       });
-      return {
-        create: createMutation,
-        update: updateMutation,
-        remove: removeMutation
-      };
+      return { create: createMutation, update: updateMutation, remove: removeMutation };
     },
     // -------------------------------------------------------------------------
-    // useInfinite — infinite scroll / load more
+    // useInfinite
     // -------------------------------------------------------------------------
     useInfinite: (params = defaultParams) => {
       return useInfiniteQuery({
@@ -121,15 +445,224 @@ function createResourceHooks(queryKeyPrefix, apiService, options = {}) {
   };
 }
 
+// src/socket/createSocketHooks.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+function createSocketHooks(socket) {
+  function useSocketEmit() {
+    const emit = useCallback(
+      (event, ...args) => {
+        if (!socket.connected) {
+          throw new Error(
+            `[@void-snippets/react] Cannot emit "${String(event)}" \u2014 socket is not connected.`
+          );
+        }
+        socket.emit(event, ...args);
+      },
+      []
+    );
+    const emitWithAck = useCallback(
+      (event, ...args) => {
+        if (!socket.connected) {
+          return Promise.reject(
+            new Error(
+              `[@void-snippets/react] Cannot emit "${String(event)}" \u2014 socket is not connected.`
+            )
+          );
+        }
+        return socket.emitWithAck(
+          event,
+          ...args
+        );
+      },
+      []
+    );
+    return { emit, emitWithAck };
+  }
+  function useSocketListener(event, handler, options) {
+    var _a;
+    const enabled = (_a = options == null ? void 0 : options.enabled) != null ? _a : true;
+    const savedHandler = useRef(handler);
+    useEffect(() => {
+      savedHandler.current = handler;
+    }, [handler]);
+    useEffect(() => {
+      if (!enabled) return;
+      const listener = ((...args) => {
+        savedHandler.current(...args);
+      });
+      socket.on(event, listener);
+      return () => {
+        socket.off(event, listener);
+      };
+    }, [event, enabled]);
+  }
+  function useSocketConnection() {
+    const [isConnected, setIsConnected] = useState(socket.connected);
+    const [isConnecting, setIsConnecting] = useState(false);
+    const [socketId, setSocketId] = useState(socket.id);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+      function onConnect() {
+        setIsConnected(true);
+        setIsConnecting(false);
+        setSocketId(socket.id);
+        setError(null);
+      }
+      function onDisconnect() {
+        setIsConnected(false);
+        setIsConnecting(false);
+        setSocketId(void 0);
+      }
+      function onConnectError(err) {
+        setIsConnected(false);
+        setIsConnecting(false);
+        setError(err);
+      }
+      function onReconnectAttempt() {
+        setIsConnecting(true);
+      }
+      function onReconnectFailed() {
+        setIsConnecting(false);
+        setError(
+          new Error(
+            "[@void-snippets/react] Socket reconnection failed \u2014 maximum attempts exceeded."
+          )
+        );
+      }
+      socket.on("connect", onConnect);
+      socket.on("disconnect", onDisconnect);
+      socket.on("connect_error", onConnectError);
+      socket.io.on("reconnect_attempt", onReconnectAttempt);
+      socket.io.on("reconnect_failed", onReconnectFailed);
+      return () => {
+        socket.off("connect", onConnect);
+        socket.off("disconnect", onDisconnect);
+        socket.off("connect_error", onConnectError);
+        socket.io.off("reconnect_attempt", onReconnectAttempt);
+        socket.io.off("reconnect_failed", onReconnectFailed);
+      };
+    }, []);
+    const connect = useCallback(() => {
+      if (!socket.connected) {
+        setIsConnecting(true);
+        socket.connect();
+      }
+    }, []);
+    const disconnect = useCallback(() => {
+      socket.disconnect();
+    }, []);
+    return {
+      isConnected,
+      isConnecting,
+      socketId,
+      error,
+      connect,
+      disconnect
+    };
+  }
+  return {
+    useSocketEmit,
+    useSocketListener,
+    useSocketConnection
+  };
+}
+
+// src/routing/createRouteContract.ts
+import { generatePath } from "react-router";
+import { useSearchParams } from "react-router";
+function isRouteDefinition(node) {
+  if (node === null || typeof node !== "object") return false;
+  const n = node;
+  return typeof n["path"] === "string" && "_search" in n && typeof n["search"] === "function";
+}
+function defineRoute(path, config) {
+  const definition = {
+    ...config,
+    path,
+    // Phantom anchor — undefined at runtime, typed as `never` for the base definition.
+    // The search<S>() method changes this to `S` at the TypeScript level only.
+    _search: void 0,
+    search() {
+      return definition;
+    }
+  };
+  return definition;
+}
+function createRouteContract(tree) {
+  const result = {};
+  for (const key in tree) {
+    const node = tree[key];
+    if (isRouteDefinition(node)) {
+      const {
+        _search: _phantom,
+        search: _searchFn,
+        ...metadata
+      } = node;
+      result[key] = {
+        ...metadata,
+        // Preserve the phantom anchor on the ProcessedRoute for useTypedSearchParams.
+        _search: void 0,
+        build(options = {}) {
+          const { params, search } = options;
+          const pathname = params ? generatePath(
+            node.path,
+            Object.fromEntries(
+              Object.entries(params).map(([k, v]) => [k, String(v)])
+            )
+          ) : node.path;
+          if (search) {
+            const defined = Object.entries(search).filter(
+              ([, v]) => v !== void 0 && v !== null
+            );
+            if (defined.length > 0) {
+              const qs = new URLSearchParams(
+                defined.map(([k, v]) => [k, String(v)])
+              ).toString();
+              return `${pathname}?${qs}`;
+            }
+          }
+          return pathname;
+        }
+      };
+    } else {
+      result[key] = createRouteContract(node);
+    }
+  }
+  return result;
+}
+function useTypedSearchParams(_route) {
+  const [searchParams, setSearchParams] = useSearchParams();
+  const search = Object.fromEntries(searchParams.entries());
+  function setSearch(update) {
+    setSearchParams((prev) => {
+      const next = Object.fromEntries(prev.entries());
+      for (const [k, v] of Object.entries(
+        update
+      )) {
+        if (v === void 0 || v === null) {
+          delete next[k];
+        } else {
+          next[k] = String(v);
+        }
+      }
+      return next;
+    });
+  }
+  function clearSearch() {
+    setSearchParams({});
+  }
+  return { search, setSearch, clearSearch };
+}
+
 // src/hooks/useAlertMessage.ts
-import { useCallback, useState } from "react";
+import { useCallback as useCallback2, useState as useState2 } from "react";
 function useAlertMessage(autoHideDuration = 3e3) {
-  const [alert, setAlert] = useState({
+  const [alert, setAlert] = useState2({
     message: null,
     type: "info",
     isVisible: false
   });
-  const showAlert = useCallback(
+  const showAlert = useCallback2(
     (message, type = "info") => {
       setAlert({ message, type, isVisible: true });
       if (autoHideDuration) {
@@ -140,31 +673,31 @@ function useAlertMessage(autoHideDuration = 3e3) {
     },
     [autoHideDuration]
   );
-  const hideAlert = useCallback(() => {
+  const hideAlert = useCallback2(() => {
     setAlert((prev) => ({ ...prev, isVisible: false }));
   }, []);
   return { alert, showAlert, hideAlert };
 }
 
 // src/hooks/useAsyncState.ts
-import { useCallback as useCallback2, useMemo, useState as useState2 } from "react";
+import { useCallback as useCallback3, useMemo, useState as useState3 } from "react";
 import { catchError } from "@void-snippets/core";
 function useAsyncState(initialData = null) {
-  const [state, setState] = useState2({
+  const [state, setState] = useState3({
     data: initialData,
     status: "idle",
     error: null
   });
-  const setData = useCallback2((data) => {
+  const setData = useCallback3((data) => {
     setState({ data, status: "success", error: null });
   }, []);
-  const setError = useCallback2((error) => {
+  const setError = useCallback3((error) => {
     setState((prev) => ({ ...prev, error, status: "error" }));
   }, []);
-  const reset = useCallback2(() => {
+  const reset = useCallback3(() => {
     setState({ data: initialData, status: "idle", error: null });
   }, [initialData]);
-  const execute = useCallback2(
+  const execute = useCallback3(
     async (asyncFn, options) => {
       var _a, _b;
       setState((prev) => ({ ...prev, status: "pending", error: null }));
@@ -192,10 +725,10 @@ function useAsyncState(initialData = null) {
 }
 
 // src/hooks/useCallTimer.ts
-import { useEffect, useState as useState3 } from "react";
+import { useEffect as useEffect2, useState as useState4 } from "react";
 function useCallTimer(startedAt) {
-  const [duration, setDuration] = useState3("00:00");
-  useEffect(() => {
+  const [duration, setDuration] = useState4("00:00");
+  useEffect2(() => {
     if (!startedAt) {
       setDuration("00:00");
       return;
@@ -212,27 +745,27 @@ function useCallTimer(startedAt) {
 }
 
 // src/hooks/useModal.ts
-import { useCallback as useCallback3, useState as useState4 } from "react";
+import { useCallback as useCallback4, useState as useState5 } from "react";
 function useModal() {
-  const [isOpen, setIsOpen] = useState4(false);
-  const [data, setData] = useState4(null);
-  const [isLoading, setIsLoading] = useState4(false);
-  const openCreateModal = useCallback3(() => {
+  const [isOpen, setIsOpen] = useState5(false);
+  const [data, setData] = useState5(null);
+  const [isLoading, setIsLoading] = useState5(false);
+  const openCreateModal = useCallback4(() => {
     setIsOpen(true);
     setData(null);
   }, []);
-  const openEditModal = useCallback3((editData) => {
+  const openEditModal = useCallback4((editData) => {
     setIsOpen(true);
     setData(editData);
   }, []);
-  const setLoading = useCallback3((loading) => {
+  const setLoading = useCallback4((loading) => {
     setIsLoading(loading);
   }, []);
-  const closeModal = useCallback3(() => {
+  const closeModal = useCallback4(() => {
     setIsOpen(false);
     setData(null);
   }, []);
-  const setModal = useCallback3((open, editData) => {
+  const setModal = useCallback4((open, editData) => {
     setIsOpen(open);
     setData(editData != null ? editData : null);
   }, []);
@@ -249,18 +782,18 @@ function useModal() {
 }
 
 // src/hooks/usePagination.ts
-import { useCallback as useCallback4, useState as useState5 } from "react";
+import { useCallback as useCallback5, useState as useState6 } from "react";
 function usePagination(initialPage = 1, initialLimit = 10) {
-  const [page, setPage] = useState5(initialPage);
-  const [limit, setLimit] = useState5(initialLimit);
-  const onPaginationChange = useCallback4(
+  const [page, setPage] = useState6(initialPage);
+  const [limit, setLimit] = useState6(initialLimit);
+  const onPaginationChange = useCallback5(
     (newPage, newLimit) => {
       setPage(newPage);
       setLimit(newLimit);
     },
     []
   );
-  const resetPagination = useCallback4(() => {
+  const resetPagination = useCallback5(() => {
     setPage(1);
   }, []);
   return {
@@ -275,10 +808,14 @@ function usePagination(initialPage = 1, initialLimit = 10) {
 }
 export {
   createResourceHooks,
+  createRouteContract,
+  createSocketHooks,
+  defineRoute,
   useAlertMessage,
   useAsyncState,
   useCallTimer,
   useModal,
-  usePagination
+  usePagination,
+  useTypedSearchParams
 };
 //# sourceMappingURL=index.mjs.map