@void-snippets/react 0.2.2 → 0.6.0

package/dist/index.mjs

@@ -6,50 +6,242 @@ 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;
-  const capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
-  const capPrefix = capitalize(queryKeyPrefix);
   return {
     // -------------------------------------------------------------------------
-    // useList — paginated list with invalidation helper
+    // useList
     // -------------------------------------------------------------------------
     useList: (params = defaultParams) => {
       var _a, _b, _c, _d, _e;
       const queryClient = useQueryClient();
-      const queryKey = [queryKeyPrefix, params];
       const query = useQuery({
-        queryKey,
+        queryKey: [queryKeyPrefix, params],
         queryFn: async () => {
           const raw = await service.list(params);
           return adapters.fromList(raw);
         }
       });
-      const items = (_b = (_a = query.data) == null ? void 0 : _a.items) != null ? _b : [];
-      const pagination = (_e = (_c = query.data) == null ? void 0 : _c.pagination) != null ? _e : {
-        page: 1,
-        limit: (_d = defaultParams.limit) != null ? _d : 10,
-        totalPages: 0,
-        totalDocuments: 0
-      };
       return {
-        [queryKeyPrefix]: items,
-        pagination,
-        [`is${capPrefix}Loading`]: query.isLoading || query.isFetching,
-        [`${queryKeyPrefix}Error`]: query.error,
-        [`invalidate${capPrefix}`]: () => queryClient.invalidateQueries({ queryKey: [queryKeyPrefix] })
+        list: (_b = (_a = query.data) == null ? void 0 : _a.items) != null ? _b : [],
+        pagination: (_e = (_c = query.data) == null ? void 0 : _c.pagination) != null ? _e : {
+          page: 1,
+          limit: (_d = defaultParams.limit) != null ? _d : 10,
+          totalPages: 0,
+          totalDocuments: 0
+        },
+        isLoading: query.isLoading,
+        isFetching: query.isFetching,
+        isRefetching: query.isRefetching,
+        isError: query.isError,
+        error: query.error,
+        refetch: query.refetch,
+        invalidate: () => queryClient.invalidateQueries({ queryKey: [queryKeyPrefix] })
       };
     },
     // -------------------------------------------------------------------------
-    // useGet — single item by id
+    // useGet
     // -------------------------------------------------------------------------
     useGet: (id, staleTime = 3e4) => {
       const query = useQuery({
@@ -62,47 +254,174 @@ function createResourceHooks(queryKeyPrefix, apiService, options = {}) {
         staleTime
       });
       return {
-        data: query.data,
-        isLoading: query.isLoading || query.isFetching,
+        item: query.data,
+        isLoading: query.isLoading,
+        isFetching: query.isFetching,
+        isRefetching: query.isRefetching,
+        isError: query.isError,
         error: query.error,
         refetch: query.refetch
       };
     },
     // -------------------------------------------------------------------------
-    // useMutations — create / update / delete with auto-invalidation
+    // 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 deleteMutation = useMutation({
+      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,
-        delete: deleteMutation
-      };
+      return { create: createMutation, update: updateMutation, remove: removeMutation };
     },
     // -------------------------------------------------------------------------
-    // useInfinite — infinite scroll / load more
+    // useInfinite
     // -------------------------------------------------------------------------
     useInfinite: (params = defaultParams) => {
       return useInfiniteQuery({
@@ -125,7 +444,378 @@ 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 as useCallback2, useState as useState2 } from "react";
+function useAlertMessage(autoHideDuration = 3e3) {
+  const [alert, setAlert] = useState2({
+    message: null,
+    type: "info",
+    isVisible: false
+  });
+  const showAlert = useCallback2(
+    (message, type = "info") => {
+      setAlert({ message, type, isVisible: true });
+      if (autoHideDuration) {
+        setTimeout(() => {
+          setAlert((prev) => ({ ...prev, isVisible: false }));
+        }, autoHideDuration);
+      }
+    },
+    [autoHideDuration]
+  );
+  const hideAlert = useCallback2(() => {
+    setAlert((prev) => ({ ...prev, isVisible: false }));
+  }, []);
+  return { alert, showAlert, hideAlert };
+}
+
+// src/hooks/useAsyncState.ts
+import { useCallback as useCallback3, useMemo, useState as useState3 } from "react";
+import { catchError } from "@void-snippets/core";
+function useAsyncState(initialData = null) {
+  const [state, setState] = useState3({
+    data: initialData,
+    status: "idle",
+    error: null
+  });
+  const setData = useCallback3((data) => {
+    setState({ data, status: "success", error: null });
+  }, []);
+  const setError = useCallback3((error) => {
+    setState((prev) => ({ ...prev, error, status: "error" }));
+  }, []);
+  const reset = useCallback3(() => {
+    setState({ data: initialData, status: "idle", error: null });
+  }, [initialData]);
+  const execute = useCallback3(
+    async (asyncFn, options) => {
+      var _a, _b;
+      setState((prev) => ({ ...prev, status: "pending", error: null }));
+      const [err, res] = await catchError(asyncFn());
+      if (err) {
+        setState((prev) => ({ ...prev, status: "error", error: err }));
+        (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, err);
+        return [err, null];
+      }
+      setState({ data: res, status: "success", error: null });
+      (_b = options == null ? void 0 : options.onSuccess) == null ? void 0 : _b.call(options, res);
+      return [null, res];
+    },
+    []
+  );
+  const flags = useMemo(
+    () => ({
+      isLoading: state.status === "pending",
+      isSuccess: state.status === "success",
+      isError: state.status === "error"
+    }),
+    [state.status]
+  );
+  return { ...state, ...flags, setData, setError, reset, execute };
+}
+
+// src/hooks/useCallTimer.ts
+import { useEffect as useEffect2, useState as useState4 } from "react";
+function useCallTimer(startedAt) {
+  const [duration, setDuration] = useState4("00:00");
+  useEffect2(() => {
+    if (!startedAt) {
+      setDuration("00:00");
+      return;
+    }
+    const interval = setInterval(() => {
+      const diffInSeconds = Math.floor((Date.now() - startedAt) / 1e3);
+      const minutes = Math.floor(diffInSeconds / 60).toString().padStart(2, "0");
+      const seconds = (diffInSeconds % 60).toString().padStart(2, "0");
+      setDuration(`${minutes}:${seconds}`);
+    }, 1e3);
+    return () => clearInterval(interval);
+  }, [startedAt]);
+  return duration;
+}
+
+// src/hooks/useModal.ts
+import { useCallback as useCallback4, useState as useState5 } from "react";
+function useModal() {
+  const [isOpen, setIsOpen] = useState5(false);
+  const [data, setData] = useState5(null);
+  const [isLoading, setIsLoading] = useState5(false);
+  const openCreateModal = useCallback4(() => {
+    setIsOpen(true);
+    setData(null);
+  }, []);
+  const openEditModal = useCallback4((editData) => {
+    setIsOpen(true);
+    setData(editData);
+  }, []);
+  const setLoading = useCallback4((loading) => {
+    setIsLoading(loading);
+  }, []);
+  const closeModal = useCallback4(() => {
+    setIsOpen(false);
+    setData(null);
+  }, []);
+  const setModal = useCallback4((open, editData) => {
+    setIsOpen(open);
+    setData(editData != null ? editData : null);
+  }, []);
+  return {
+    isOpen,
+    data,
+    isLoading,
+    openCreateModal,
+    openEditModal,
+    setLoading,
+    closeModal,
+    setModal
+  };
+}
+
+// src/hooks/usePagination.ts
+import { useCallback as useCallback5, useState as useState6 } from "react";
+function usePagination(initialPage = 1, initialLimit = 10) {
+  const [page, setPage] = useState6(initialPage);
+  const [limit, setLimit] = useState6(initialLimit);
+  const onPaginationChange = useCallback5(
+    (newPage, newLimit) => {
+      setPage(newPage);
+      setLimit(newLimit);
+    },
+    []
+  );
+  const resetPagination = useCallback5(() => {
+    setPage(1);
+  }, []);
+  return {
+    page,
+    limit,
+    onPaginationChange,
+    resetPagination,
+    setPage,
+    setLimit,
+    queryParams: { page, limit }
+  };
+}
 export {
-  createResourceHooks
+  createResourceHooks,
+  createRouteContract,
+  createSocketHooks,
+  defineRoute,
+  useAlertMessage,
+  useAsyncState,
+  useCallTimer,
+  useModal,
+  usePagination,
+  useTypedSearchParams
 };
 //# sourceMappingURL=index.mjs.map