@pol-studios/ui 1.0.0

package/dist/providers/index.js

@@ -0,0 +1,1927 @@
+"use client";
+
+// src/providers/auth/AuthContext.tsx
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+var AuthContext = createContext(null);
+AuthContext.displayName = "ComponentAuthContext";
+function AuthProvider({
+  children,
+  value
+}) {
+  return /* @__PURE__ */ jsx(AuthContext.Provider, { value, children });
+}
+function useComponentAuth() {
+  const context = useContext(AuthContext);
+  if (context === null) {
+    throw new Error(
+      "useComponentAuth must be used within an AuthProvider. Make sure to wrap your component tree with <AuthProvider value={...}>. You can create the value using an adapter like createPolDbHooksAuthAdapter()."
+    );
+  }
+  return context;
+}
+function useComponentAuthOptional() {
+  const context = useContext(AuthContext);
+  return context;
+}
+
+// src/providers/router/RouterContext.tsx
+import { createContext as createContext2, useContext as useContext2 } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var RouterContext = createContext2(null);
+function RouterProvider({ adapter, children }) {
+  return /* @__PURE__ */ jsx2(RouterContext.Provider, { value: adapter, children });
+}
+function useRouter() {
+  const context = useContext2(RouterContext);
+  if (!context) {
+    throw new Error("useRouter must be used within a RouterProvider. Make sure to wrap your app with <RouterProvider adapter={yourAdapter}>.");
+  }
+  return context;
+}
+function useNavigate() {
+  const router = useRouter();
+  return router.navigate;
+}
+function useLocation() {
+  const router = useRouter();
+  return router.useLocation();
+}
+function useParams() {
+  const router = useRouter();
+  return router.useParams();
+}
+function Link(props) {
+  const router = useRouter();
+  const LinkComponent = router.Link;
+  return /* @__PURE__ */ jsx2(LinkComponent, { ...props });
+}
+
+// src/providers/data/DataContext.tsx
+import { createContext as createContext3, useContext as useContext3, useMemo } from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var DataContext = createContext3(null);
+function DataProvider({
+  adapter,
+  isReady = true,
+  children
+}) {
+  const value = useMemo(
+    () => ({
+      adapter,
+      isReady
+    }),
+    [adapter, isReady]
+  );
+  return /* @__PURE__ */ jsx3(DataContext.Provider, { value, children });
+}
+function useDataAdapter() {
+  const context = useContext3(DataContext);
+  if (!context) {
+    throw new Error(
+      "useDataAdapter must be used within a DataProvider. Make sure to wrap your application with <DataProvider adapter={yourAdapter}>."
+    );
+  }
+  return context;
+}
+function useDataAdapterOptional() {
+  return useContext3(DataContext);
+}
+
+// src/providers/data/hooks/useDataQuery.ts
+import { useState, useEffect, useCallback, useRef, useMemo as useMemo2 } from "react";
+function useDataQuery(table, options = {}) {
+  const context = useDataAdapterOptional();
+  const adapter = context?.adapter;
+  const {
+    enabled = true,
+    filters,
+    sort,
+    pagination,
+    selectColumns,
+    realtime = false,
+    withCount = false,
+    cacheTime,
+    staleTime,
+    refetchOnWindowFocus,
+    refetchOnMount,
+    refetchInterval,
+    retry,
+    retryDelay,
+    transform,
+    onSuccess,
+    onError,
+    onSettled
+  } = options;
+  const [data, setData] = useState(void 0);
+  const [count, setCount] = useState(null);
+  const [error, setError] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [isFetching, setIsFetching] = useState(false);
+  const abortControllerRef = useRef(null);
+  const retryCountRef = useRef(0);
+  const retryTimeoutRef = useRef(null);
+  const unsubscribeRef = useRef(null);
+  const refetchIntervalRef = useRef(null);
+  const hasDataRef = useRef(false);
+  const onSuccessRef = useRef(onSuccess);
+  const onErrorRef = useRef(onError);
+  const onSettledRef = useRef(onSettled);
+  useEffect(() => {
+    onSuccessRef.current = onSuccess;
+    onErrorRef.current = onError;
+    onSettledRef.current = onSettled;
+  });
+  useEffect(() => {
+    hasDataRef.current = data !== void 0;
+  }, [data]);
+  const stableFilters = useMemo2(() => filters, [JSON.stringify(filters)]);
+  const stableSort = useMemo2(() => sort, [JSON.stringify(sort)]);
+  const stablePagination = useMemo2(() => pagination, [JSON.stringify(pagination)]);
+  const queryParams = {
+    filters,
+    sort,
+    pagination,
+    select: selectColumns
+  };
+  const fetchData = useCallback(async () => {
+    if (!adapter) {
+      const err = new Error("No DataAdapter available. Wrap your app with DataProvider.");
+      setError(err);
+      return { data: void 0, error: err };
+    }
+    if (!enabled) {
+      return { data: void 0, error: null };
+    }
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+    }
+    abortControllerRef.current = new AbortController();
+    setIsFetching(true);
+    if (!hasDataRef.current) {
+      setIsLoading(true);
+    }
+    try {
+      let result;
+      let totalCount = null;
+      if (withCount) {
+        const response = await adapter.getManyWithCount(table, queryParams);
+        result = response.data;
+        totalCount = response.count;
+      } else {
+        result = await adapter.getMany(table, queryParams);
+      }
+      setData(result);
+      setCount(totalCount);
+      setError(null);
+      retryCountRef.current = 0;
+      onSuccessRef.current?.(result);
+      onSettledRef.current?.(result, null);
+      return { data: result, error: null };
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error(String(err));
+      const shouldRetry = retry === true || typeof retry === "number" && retryCountRef.current < retry;
+      if (shouldRetry) {
+        retryCountRef.current++;
+        const delay = retryDelay ?? 1e3 * retryCountRef.current;
+        return new Promise((resolve) => {
+          retryTimeoutRef.current = setTimeout(async () => {
+            retryTimeoutRef.current = null;
+            const result = await fetchData();
+            resolve(result);
+          }, delay);
+        });
+      }
+      setError(error2);
+      onErrorRef.current?.(error2);
+      onSettledRef.current?.(void 0, error2);
+      return { data: void 0, error: error2 };
+    } finally {
+      setIsLoading(false);
+      setIsFetching(false);
+    }
+  }, [
+    adapter,
+    enabled,
+    table,
+    stableFilters,
+    stableSort,
+    stablePagination,
+    selectColumns,
+    withCount,
+    retry,
+    retryDelay
+  ]);
+  const refetch = useCallback(async () => {
+    const result = await fetchData();
+    return {
+      data: result.data,
+      error: result.error,
+      isLoading: false,
+      // After fetch completes, loading is false
+      isError: result.error !== null,
+      isSuccess: result.error === null && result.data !== void 0,
+      isFetching: false,
+      // After fetch completes, fetching is false
+      refetch
+    };
+  }, [fetchData]);
+  useEffect(() => {
+    if (enabled && adapter) {
+      fetchData();
+    }
+    return () => {
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+      }
+      if (retryTimeoutRef.current) {
+        clearTimeout(retryTimeoutRef.current);
+        retryTimeoutRef.current = null;
+      }
+    };
+  }, [fetchData, enabled, adapter]);
+  useEffect(() => {
+    if (!realtime || !enabled || !adapter?.subscribe) {
+      return;
+    }
+    const handleRealtimeChange = (payload) => {
+      setData((currentData) => {
+        if (!currentData) return currentData;
+        switch (payload.eventType) {
+          case "INSERT":
+            if (payload.new) {
+              return [...currentData, payload.new];
+            }
+            return currentData;
+          case "UPDATE":
+            if (payload.new) {
+              return currentData.map((item) => {
+                const itemId = item?.id;
+                const newId = payload.new?.id;
+                if (itemId && newId && itemId === newId) {
+                  return payload.new;
+                }
+                return item;
+              });
+            }
+            return currentData;
+          case "DELETE":
+            if (payload.old) {
+              const oldId = payload.old?.id;
+              if (oldId) {
+                return currentData.filter((item) => item?.id !== oldId);
+              }
+            }
+            return currentData;
+          default:
+            return currentData;
+        }
+      });
+    };
+    unsubscribeRef.current = adapter.subscribe(table, handleRealtimeChange, stableFilters);
+    return () => {
+      if (unsubscribeRef.current) {
+        unsubscribeRef.current();
+        unsubscribeRef.current = null;
+      }
+    };
+  }, [realtime, enabled, adapter, table, stableFilters]);
+  useEffect(() => {
+    if (!refetchInterval || !enabled) {
+      return;
+    }
+    refetchIntervalRef.current = setInterval(fetchData, refetchInterval);
+    return () => {
+      if (refetchIntervalRef.current) {
+        clearInterval(refetchIntervalRef.current);
+        refetchIntervalRef.current = null;
+      }
+    };
+  }, [refetchInterval, enabled, fetchData]);
+  useEffect(() => {
+    if (!refetchOnWindowFocus || !enabled) {
+      return;
+    }
+    const handleFocus = () => {
+      fetchData();
+    };
+    window.addEventListener("focus", handleFocus);
+    return () => {
+      window.removeEventListener("focus", handleFocus);
+    };
+  }, [refetchOnWindowFocus, enabled, fetchData]);
+  useEffect(() => {
+    if (refetchOnMount && enabled && adapter) {
+      fetchData();
+    }
+  }, [refetchOnMount, enabled, adapter, fetchData]);
+  return {
+    data,
+    count,
+    error,
+    isLoading,
+    isError: error !== null,
+    isSuccess: error === null && data !== void 0,
+    isFetching,
+    refetch
+  };
+}
+function useDataQueryById(table, id, options = {}) {
+  const context = useDataAdapterOptional();
+  const adapter = context?.adapter;
+  const { enabled = true, onSuccess, onError, onSettled, retry, retryDelay } = options;
+  const [data, setData] = useState(void 0);
+  const [error, setError] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [isFetching, setIsFetching] = useState(false);
+  const retryCountRef = useRef(0);
+  const onSuccessRef = useRef(onSuccess);
+  const onErrorRef = useRef(onError);
+  const onSettledRef = useRef(onSettled);
+  useEffect(() => {
+    onSuccessRef.current = onSuccess;
+    onErrorRef.current = onError;
+    onSettledRef.current = onSettled;
+  });
+  const fetchData = useCallback(async () => {
+    if (!adapter || !id || !enabled) {
+      return { data: void 0, error: null };
+    }
+    setIsFetching(true);
+    if (data === void 0) {
+      setIsLoading(true);
+    }
+    try {
+      const result = await adapter.getById(table, id);
+      setData(result);
+      setError(null);
+      retryCountRef.current = 0;
+      onSuccessRef.current?.(result);
+      onSettledRef.current?.(result, null);
+      return { data: result, error: null };
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error(String(err));
+      const shouldRetry = retry === true || typeof retry === "number" && retryCountRef.current < retry;
+      if (shouldRetry) {
+        retryCountRef.current++;
+        const delay = retryDelay ?? 1e3 * retryCountRef.current;
+        return new Promise((resolve) => {
+          setTimeout(async () => {
+            const result = await fetchData();
+            resolve(result);
+          }, delay);
+        });
+      }
+      setError(error2);
+      onErrorRef.current?.(error2);
+      onSettledRef.current?.(void 0, error2);
+      return { data: void 0, error: error2 };
+    } finally {
+      setIsLoading(false);
+      setIsFetching(false);
+    }
+  }, [adapter, id, enabled, table, retry, retryDelay]);
+  const refetch = useCallback(async () => {
+    const result = await fetchData();
+    return {
+      data: result.data ?? null,
+      error: result.error,
+      isLoading: false,
+      // After fetch completes, loading is false
+      isError: result.error !== null,
+      isSuccess: result.error === null && result.data !== void 0,
+      isFetching: false,
+      // After fetch completes, fetching is false
+      refetch
+    };
+  }, [fetchData]);
+  useEffect(() => {
+    if (enabled && adapter && id) {
+      fetchData();
+    }
+  }, [fetchData, enabled, adapter, id]);
+  return {
+    data: data ?? null,
+    error,
+    isLoading,
+    isError: error !== null,
+    isSuccess: error === null && data !== void 0,
+    isFetching,
+    refetch
+  };
+}
+
+// src/providers/data/hooks/useDataMutation.ts
+import { useState as useState2, useCallback as useCallback2, useRef as useRef2, useEffect as useEffect2 } from "react";
+var initialMutationState = () => ({
+  data: void 0,
+  error: null,
+  status: "idle"
+});
+function useDataMutation(table, options = {}) {
+  const context = useDataAdapterOptional();
+  const adapter = context?.adapter;
+  const { primaryKey = "id", ...mutationOptions } = options;
+  const [states, setStates] = useState2({
+    insert: initialMutationState(),
+    update: initialMutationState(),
+    remove: initialMutationState()
+  });
+  const insertContextRef = useRef2(void 0);
+  const updateContextRef = useRef2(void 0);
+  const removeContextRef = useRef2(void 0);
+  const onMutateRef = useRef2(mutationOptions.onMutate);
+  const onSuccessRef = useRef2(mutationOptions.onSuccess);
+  const onErrorRef = useRef2(mutationOptions.onError);
+  const onSettledRef = useRef2(mutationOptions.onSettled);
+  useEffect2(() => {
+    onMutateRef.current = mutationOptions.onMutate;
+    onSuccessRef.current = mutationOptions.onSuccess;
+    onErrorRef.current = mutationOptions.onError;
+    onSettledRef.current = mutationOptions.onSettled;
+  });
+  const insertReset = useCallback2(() => {
+    setStates((s) => ({ ...s, insert: initialMutationState() }));
+    insertContextRef.current = void 0;
+  }, []);
+  const insertMutateAsync = useCallback2(
+    async (data) => {
+      setStates((s) => ({
+        ...s,
+        insert: { ...s.insert, status: "loading", error: null }
+      }));
+      try {
+        if (!adapter) {
+          throw new Error("No DataAdapter available. Wrap your app with DataProvider.");
+        }
+        insertContextRef.current = await onMutateRef.current?.(data);
+        const result = await adapter.create(table, data);
+        setStates((s) => ({
+          ...s,
+          insert: { data: result, error: null, status: "success" }
+        }));
+        onSuccessRef.current?.(result, data, insertContextRef.current);
+        onSettledRef.current?.(result, null, data, insertContextRef.current);
+        return result;
+      } catch (err) {
+        const mutationError = err instanceof Error ? err : new Error(String(err));
+        setStates((s) => ({
+          ...s,
+          insert: { ...s.insert, error: mutationError, status: "error" }
+        }));
+        onErrorRef.current?.(mutationError, data, insertContextRef.current);
+        onSettledRef.current?.(void 0, mutationError, data, insertContextRef.current);
+        throw mutationError;
+      }
+    },
+    [adapter, table]
+  );
+  const insertMutate = useCallback2(
+    (data) => {
+      insertMutateAsync(data).catch(() => {
+      });
+    },
+    [insertMutateAsync]
+  );
+  const updateReset = useCallback2(() => {
+    setStates((s) => ({ ...s, update: initialMutationState() }));
+    updateContextRef.current = void 0;
+  }, []);
+  const updateMutateAsync = useCallback2(
+    async (data) => {
+      setStates((s) => ({
+        ...s,
+        update: { ...s.update, status: "loading", error: null }
+      }));
+      try {
+        if (!adapter) {
+          throw new Error("No DataAdapter available. Wrap your app with DataProvider.");
+        }
+        const { id, ...updateData } = data;
+        if (!id) {
+          throw new Error("Update requires an id field");
+        }
+        updateContextRef.current = await onMutateRef.current?.(data);
+        const result = await adapter.update(table, id, updateData);
+        setStates((s) => ({
+          ...s,
+          update: { data: result, error: null, status: "success" }
+        }));
+        onSuccessRef.current?.(result, data, updateContextRef.current);
+        onSettledRef.current?.(result, null, data, updateContextRef.current);
+        return result;
+      } catch (err) {
+        const mutationError = err instanceof Error ? err : new Error(String(err));
+        setStates((s) => ({
+          ...s,
+          update: { ...s.update, error: mutationError, status: "error" }
+        }));
+        onErrorRef.current?.(mutationError, data, updateContextRef.current);
+        onSettledRef.current?.(void 0, mutationError, data, updateContextRef.current);
+        throw mutationError;
+      }
+    },
+    [adapter, table]
+  );
+  const updateMutate = useCallback2(
+    (data) => {
+      updateMutateAsync(data).catch(() => {
+      });
+    },
+    [updateMutateAsync]
+  );
+  const removeReset = useCallback2(() => {
+    setStates((s) => ({ ...s, remove: initialMutationState() }));
+    removeContextRef.current = void 0;
+  }, []);
+  const removeMutateAsync = useCallback2(
+    async (id) => {
+      setStates((s) => ({
+        ...s,
+        remove: { ...s.remove, status: "loading", error: null }
+      }));
+      try {
+        if (!adapter) {
+          throw new Error("No DataAdapter available. Wrap your app with DataProvider.");
+        }
+        removeContextRef.current = await onMutateRef.current?.({ [primaryKey]: id });
+        await adapter.delete(table, id);
+        setStates((s) => ({
+          ...s,
+          remove: { data: void 0, error: null, status: "success" }
+        }));
+        onSuccessRef.current?.(void 0, { [primaryKey]: id }, removeContextRef.current);
+        onSettledRef.current?.(void 0, null, { [primaryKey]: id }, removeContextRef.current);
+      } catch (err) {
+        const mutationError = err instanceof Error ? err : new Error(String(err));
+        setStates((s) => ({
+          ...s,
+          remove: { ...s.remove, error: mutationError, status: "error" }
+        }));
+        onErrorRef.current?.(mutationError, { [primaryKey]: id }, removeContextRef.current);
+        onSettledRef.current?.(void 0, mutationError, { [primaryKey]: id }, removeContextRef.current);
+        throw mutationError;
+      }
+    },
+    [adapter, table, primaryKey]
+  );
+  const removeMutate = useCallback2(
+    (id) => {
+      removeMutateAsync(id).catch(() => {
+      });
+    },
+    [removeMutateAsync]
+  );
+  return {
+    insert: {
+      data: states.insert.data,
+      error: states.insert.error,
+      isLoading: states.insert.status === "loading",
+      isError: states.insert.status === "error",
+      isSuccess: states.insert.status === "success",
+      isIdle: states.insert.status === "idle",
+      mutate: insertMutate,
+      mutateAsync: insertMutateAsync,
+      reset: insertReset
+    },
+    update: {
+      data: states.update.data,
+      error: states.update.error,
+      isLoading: states.update.status === "loading",
+      isError: states.update.status === "error",
+      isSuccess: states.update.status === "success",
+      isIdle: states.update.status === "idle",
+      mutate: updateMutate,
+      mutateAsync: updateMutateAsync,
+      reset: updateReset
+    },
+    remove: {
+      data: states.remove.data,
+      error: states.remove.error,
+      isLoading: states.remove.status === "loading",
+      isError: states.remove.status === "error",
+      isSuccess: states.remove.status === "success",
+      isIdle: states.remove.status === "idle",
+      mutate: removeMutate,
+      mutateAsync: removeMutateAsync,
+      reset: removeReset
+    }
+  };
+}
+function useDataInsert(table, options = {}) {
+  const context = useDataAdapterOptional();
+  const adapter = context?.adapter;
+  const [data, setData] = useState2(void 0);
+  const [error, setError] = useState2(null);
+  const [status, setStatus] = useState2("idle");
+  const contextRef = useRef2(void 0);
+  const onMutateRef = useRef2(options.onMutate);
+  const onSuccessRef = useRef2(options.onSuccess);
+  const onErrorRef = useRef2(options.onError);
+  const onSettledRef = useRef2(options.onSettled);
+  useEffect2(() => {
+    onMutateRef.current = options.onMutate;
+    onSuccessRef.current = options.onSuccess;
+    onErrorRef.current = options.onError;
+    onSettledRef.current = options.onSettled;
+  });
+  const reset = useCallback2(() => {
+    setData(void 0);
+    setError(null);
+    setStatus("idle");
+    contextRef.current = void 0;
+  }, []);
+  const mutateAsync = useCallback2(
+    async (insertData) => {
+      setStatus("loading");
+      setError(null);
+      try {
+        if (!adapter) {
+          throw new Error("No DataAdapter available. Wrap your app with DataProvider.");
+        }
+        contextRef.current = await onMutateRef.current?.(insertData);
+        const result = await adapter.create(table, insertData);
+        setData(result);
+        setStatus("success");
+        onSuccessRef.current?.(result, insertData, contextRef.current);
+        onSettledRef.current?.(result, null, insertData, contextRef.current);
+        return result;
+      } catch (err) {
+        const mutationError = err instanceof Error ? err : new Error(String(err));
+        setError(mutationError);
+        setStatus("error");
+        onErrorRef.current?.(mutationError, insertData, contextRef.current);
+        onSettledRef.current?.(void 0, mutationError, insertData, contextRef.current);
+        throw mutationError;
+      }
+    },
+    [adapter, table]
+  );
+  const mutate = useCallback2(
+    (insertData) => {
+      mutateAsync(insertData).catch(() => {
+      });
+    },
+    [mutateAsync]
+  );
+  return {
+    data,
+    error,
+    isLoading: status === "loading",
+    isError: status === "error",
+    isSuccess: status === "success",
+    isIdle: status === "idle",
+    status,
+    mutate,
+    mutateAsync,
+    reset
+  };
+}
+function useDataUpdate(table, options = {}) {
+  const context = useDataAdapterOptional();
+  const adapter = context?.adapter;
+  const [data, setData] = useState2(void 0);
+  const [error, setError] = useState2(null);
+  const [status, setStatus] = useState2("idle");
+  const contextRef = useRef2(void 0);
+  const onMutateRef = useRef2(options.onMutate);
+  const onSuccessRef = useRef2(options.onSuccess);
+  const onErrorRef = useRef2(options.onError);
+  const onSettledRef = useRef2(options.onSettled);
+  useEffect2(() => {
+    onMutateRef.current = options.onMutate;
+    onSuccessRef.current = options.onSuccess;
+    onErrorRef.current = options.onError;
+    onSettledRef.current = options.onSettled;
+  });
+  const reset = useCallback2(() => {
+    setData(void 0);
+    setError(null);
+    setStatus("idle");
+    contextRef.current = void 0;
+  }, []);
+  const mutateAsync = useCallback2(
+    async (updateData) => {
+      setStatus("loading");
+      setError(null);
+      try {
+        if (!adapter) {
+          throw new Error("No DataAdapter available. Wrap your app with DataProvider.");
+        }
+        const { id, ...restData } = updateData;
+        contextRef.current = await onMutateRef.current?.(updateData);
+        const result = await adapter.update(table, id, restData);
+        setData(result);
+        setStatus("success");
+        onSuccessRef.current?.(result, updateData, contextRef.current);
+        onSettledRef.current?.(result, null, updateData, contextRef.current);
+        return result;
+      } catch (err) {
+        const mutationError = err instanceof Error ? err : new Error(String(err));
+        setError(mutationError);
+        setStatus("error");
+        onErrorRef.current?.(mutationError, updateData, contextRef.current);
+        onSettledRef.current?.(void 0, mutationError, updateData, contextRef.current);
+        throw mutationError;
+      }
+    },
+    [adapter, table]
+  );
+  const mutate = useCallback2(
+    (updateData) => {
+      mutateAsync(updateData).catch(() => {
+      });
+    },
+    [mutateAsync]
+  );
+  return {
+    data,
+    error,
+    isLoading: status === "loading",
+    isError: status === "error",
+    isSuccess: status === "success",
+    isIdle: status === "idle",
+    status,
+    mutate,
+    mutateAsync,
+    reset
+  };
+}
+function useDataDelete(table, options = {}) {
+  const context = useDataAdapterOptional();
+  const adapter = context?.adapter;
+  const [data, setData] = useState2(void 0);
+  const [error, setError] = useState2(null);
+  const [status, setStatus] = useState2("idle");
+  const contextRef = useRef2(void 0);
+  const onMutateRef = useRef2(options.onMutate);
+  const onSuccessRef = useRef2(options.onSuccess);
+  const onErrorRef = useRef2(options.onError);
+  const onSettledRef = useRef2(options.onSettled);
+  useEffect2(() => {
+    onMutateRef.current = options.onMutate;
+    onSuccessRef.current = options.onSuccess;
+    onErrorRef.current = options.onError;
+    onSettledRef.current = options.onSettled;
+  });
+  const reset = useCallback2(() => {
+    setData(void 0);
+    setError(null);
+    setStatus("idle");
+    contextRef.current = void 0;
+  }, []);
+  const mutateAsync = useCallback2(
+    async (id) => {
+      setStatus("loading");
+      setError(null);
+      try {
+        if (!adapter) {
+          throw new Error("No DataAdapter available. Wrap your app with DataProvider.");
+        }
+        contextRef.current = await onMutateRef.current?.(id);
+        await adapter.delete(table, id);
+        setData(void 0);
+        setStatus("success");
+        onSuccessRef.current?.(void 0, id, contextRef.current);
+        onSettledRef.current?.(void 0, null, id, contextRef.current);
+      } catch (err) {
+        const mutationError = err instanceof Error ? err : new Error(String(err));
+        setError(mutationError);
+        setStatus("error");
+        onErrorRef.current?.(mutationError, id, contextRef.current);
+        onSettledRef.current?.(void 0, mutationError, id, contextRef.current);
+        throw mutationError;
+      }
+    },
+    [adapter, table]
+  );
+  const mutate = useCallback2(
+    (id) => {
+      mutateAsync(id).catch(() => {
+      });
+    },
+    [mutateAsync]
+  );
+  return {
+    data,
+    error,
+    isLoading: status === "loading",
+    isError: status === "error",
+    isSuccess: status === "success",
+    isIdle: status === "idle",
+    status,
+    mutate,
+    mutateAsync,
+    reset
+  };
+}
+
+// src/providers/config/types.ts
+var DEFAULT_ROUTES = {
+  login: "/login",
+  signUp: "/sign-up",
+  forgotPassword: "/forgot-password",
+  home: "/",
+  notFound: "/404",
+  profile: "/profile",
+  settings: "/settings"
+};
+var DEFAULT_FEATURES = {
+  enableNotifications: true,
+  enableComments: true,
+  enableRealtime: false,
+  enableFileUploads: true,
+  enableDarkMode: true,
+  enableAnalytics: false,
+  enableSearch: true
+};
+var DEFAULT_THEME = {
+  defaultColorMode: "system",
+  borderRadius: "md"
+};
+var DEFAULT_LOCALIZATION = {
+  defaultLocale: "en-US",
+  supportedLocales: ["en-US"],
+  dateFormat: "MM/dd/yyyy",
+  timeFormat: "hh:mm a",
+  currency: "USD"
+};
+var DEFAULT_CONFIG = {
+  routes: DEFAULT_ROUTES,
+  features: DEFAULT_FEATURES,
+  theme: DEFAULT_THEME,
+  localization: DEFAULT_LOCALIZATION,
+  environment: "development"
+};
+
+// src/providers/config/ConfigContext.tsx
+import React3, { createContext as createContext4, useContext as useContext4, useMemo as useMemo3, useState as useState3 } from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+function deepMerge(target, source) {
+  if (target === null || typeof target !== "object" || Array.isArray(target)) {
+    return source ?? target;
+  }
+  const result = { ...target };
+  for (const key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      const sourceValue = source[key];
+      const targetValue = target[key];
+      if (sourceValue !== null && sourceValue !== void 0 && typeof sourceValue === "object" && !Array.isArray(sourceValue) && targetValue !== null && targetValue !== void 0 && typeof targetValue === "object" && !Array.isArray(targetValue)) {
+        result[key] = deepMerge(targetValue, sourceValue);
+      } else if (sourceValue !== void 0) {
+        result[key] = sourceValue;
+      }
+    }
+  }
+  return result;
+}
+var ConfigContext = createContext4(null);
+var ConfigActionsContext = createContext4(null);
+function ConfigProvider({ config, children }) {
+  const initialMergedConfig = useMemo3(() => {
+    if (!config) return DEFAULT_CONFIG;
+    return {
+      ...DEFAULT_CONFIG,
+      ...config,
+      routes: {
+        ...DEFAULT_ROUTES,
+        ...config.routes
+      },
+      features: {
+        ...DEFAULT_FEATURES,
+        ...config.features
+      },
+      theme: {
+        ...DEFAULT_THEME,
+        ...config.theme
+      },
+      localization: {
+        ...DEFAULT_LOCALIZATION,
+        ...config.localization
+      }
+    };
+  }, [config]);
+  const [configState, setConfigState] = useState3(initialMergedConfig);
+  React3.useEffect(() => {
+    setConfigState(initialMergedConfig);
+  }, [initialMergedConfig]);
+  const actions = useMemo3(() => ({
+    updateFeatureFlag: (key, value2) => {
+      setConfigState((prev) => ({
+        ...prev,
+        features: { ...prev.features, [key]: value2 }
+      }));
+    },
+    updateRoute: (key, path) => {
+      setConfigState((prev) => ({
+        ...prev,
+        routes: { ...prev.routes, [key]: path }
+      }));
+    },
+    updateConfig: (updates) => {
+      setConfigState((prev) => deepMerge(prev, updates));
+    },
+    resetConfig: () => {
+      setConfigState(initialMergedConfig);
+    }
+  }), [initialMergedConfig]);
+  const value = useMemo3(() => {
+    const isFeatureEnabled = (feature) => {
+      return configState.features?.[feature] ?? false;
+    };
+    const getRoute = (routeName) => {
+      return configState.routes[routeName] ?? "/";
+    };
+    return {
+      config: configState,
+      routes: configState.routes,
+      features: configState.features ?? DEFAULT_FEATURES,
+      isFeatureEnabled,
+      getRoute
+    };
+  }, [configState]);
+  return /* @__PURE__ */ jsx4(ConfigActionsContext.Provider, { value: actions, children: /* @__PURE__ */ jsx4(ConfigContext.Provider, { value, children }) });
+}
+function useComponentConfig() {
+  const context = useContext4(ConfigContext);
+  if (!context) {
+    throw new Error(
+      "useComponentConfig must be used within a ConfigProvider. Make sure to wrap your application with <ConfigProvider>."
+    );
+  }
+  return context;
+}
+function useComponentConfigOptional() {
+  const context = useContext4(ConfigContext);
+  if (!context) {
+    return {
+      config: DEFAULT_CONFIG,
+      routes: DEFAULT_ROUTES,
+      features: DEFAULT_FEATURES,
+      isFeatureEnabled: (feature) => DEFAULT_FEATURES[feature] ?? false,
+      getRoute: (routeName) => DEFAULT_ROUTES[routeName] ?? "/"
+    };
+  }
+  return context;
+}
+function useFeatureFlag(feature) {
+  const { isFeatureEnabled } = useComponentConfigOptional();
+  return isFeatureEnabled(feature);
+}
+function useRoute(routeName) {
+  const { getRoute } = useComponentConfigOptional();
+  return getRoute(routeName);
+}
+function useConfigActions() {
+  const context = useContext4(ConfigActionsContext);
+  if (!context) {
+    throw new Error(
+      "useConfigActions must be used within a ConfigProvider. Make sure to wrap your application with <ConfigProvider>."
+    );
+  }
+  return context;
+}
+function useConfigActionsOptional() {
+  const context = useContext4(ConfigActionsContext);
+  if (!context) {
+    return {
+      updateFeatureFlag: () => {
+      },
+      updateRoute: () => {
+      },
+      updateConfig: () => {
+      },
+      resetConfig: () => {
+      }
+    };
+  }
+  return context;
+}
+
+// src/providers/navigation/types.ts
+var DEFAULT_SIDEBAR_CONFIG = {
+  links: [],
+  collapsible: true,
+  defaultCollapsed: false,
+  expandedWidth: 256,
+  collapsedWidth: 64
+};
+var DEFAULT_SIDEBAR_STATE = {
+  isCollapsed: false,
+  isVisible: true,
+  activeLink: null,
+  expandedSections: []
+};
+
+// src/providers/navigation/SidebarRegistry.tsx
+import React4, {
+  createContext as createContext5,
+  useCallback as useCallback3,
+  useContext as useContext5,
+  useMemo as useMemo4,
+  useState as useState4
+} from "react";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var SidebarContext = createContext5(null);
+function SidebarProvider({
+  config,
+  initialState,
+  pathname,
+  children
+}) {
+  const mergedConfig = useMemo4(() => {
+    const baseConfig = {
+      ...DEFAULT_SIDEBAR_CONFIG,
+      ...config
+    };
+    if (baseConfig.links.length > 0 && "links" in baseConfig.links[0]) {
+      const normalizedLinks = baseConfig.links.map(
+        (section, index) => ({
+          ...section,
+          id: section.id ?? `section-${index}`
+        })
+      );
+      return { ...baseConfig, links: normalizedLinks };
+    }
+    return baseConfig;
+  }, [config]);
+  const [state, setState] = useState4(() => ({
+    ...DEFAULT_SIDEBAR_STATE,
+    ...initialState,
+    isCollapsed: initialState?.isCollapsed ?? mergedConfig.defaultCollapsed ?? false,
+    activeLink: pathname ?? initialState?.activeLink ?? null
+  }));
+  React4.useEffect(() => {
+    if (pathname !== void 0 && pathname !== state.activeLink) {
+      setState((prev) => ({ ...prev, activeLink: pathname }));
+    }
+  }, [pathname, state.activeLink]);
+  const actions = useMemo4(
+    () => ({
+      toggleCollapsed: () => setState((prev) => ({ ...prev, isCollapsed: !prev.isCollapsed })),
+      setCollapsed: (collapsed) => setState((prev) => ({ ...prev, isCollapsed: collapsed })),
+      toggleVisible: () => setState((prev) => ({ ...prev, isVisible: !prev.isVisible })),
+      setVisible: (visible) => setState((prev) => ({ ...prev, isVisible: visible })),
+      setActiveLink: (url) => setState((prev) => ({ ...prev, activeLink: url })),
+      toggleSection: (sectionId) => setState((prev) => ({
+        ...prev,
+        expandedSections: prev.expandedSections.includes(sectionId) ? prev.expandedSections.filter((id) => id !== sectionId) : [...prev.expandedSections, sectionId]
+      })),
+      expandSection: (sectionId) => setState((prev) => ({
+        ...prev,
+        expandedSections: prev.expandedSections.includes(sectionId) ? prev.expandedSections : [...prev.expandedSections, sectionId]
+      })),
+      collapseSection: (sectionId) => setState((prev) => ({
+        ...prev,
+        expandedSections: prev.expandedSections.filter(
+          (id) => id !== sectionId
+        )
+      }))
+    }),
+    []
+  );
+  const getAllLinks = useCallback3(() => {
+    const collectLinks = (links2) => {
+      return links2.flatMap((link) => [
+        link,
+        ...link.children ? collectLinks(link.children) : []
+      ]);
+    };
+    const links = mergedConfig.links;
+    if (links.length === 0) return [];
+    const firstItem = links[0];
+    if ("links" in firstItem) {
+      return links.flatMap(
+        (section) => collectLinks(section.links)
+      );
+    }
+    return collectLinks(links);
+  }, [mergedConfig.links]);
+  const isLinkActive = useCallback3(
+    (url) => {
+      if (!state.activeLink) return false;
+      return state.activeLink === url || url !== "/" && state.activeLink.startsWith(url);
+    },
+    [state.activeLink]
+  );
+  const getFilteredLinks = useCallback3(
+    (userAccess) => {
+      const filterLinks = (links2) => {
+        return links2.filter((link) => {
+          if (!link.userAccess) return true;
+          if (!userAccess) return false;
+          return userAccess.includes(link.userAccess);
+        }).map((link) => ({
+          ...link,
+          children: link.children ? filterLinks(link.children) : void 0
+        }));
+      };
+      const links = mergedConfig.links;
+      if (links.length === 0) return [];
+      const firstItem = links[0];
+      if ("links" in firstItem) {
+        return links.map((section) => ({
+          ...section,
+          links: filterLinks(section.links)
+        }));
+      }
+      return filterLinks(links);
+    },
+    [mergedConfig.links]
+  );
+  const value = useMemo4(
+    () => ({
+      config: mergedConfig,
+      state,
+      actions,
+      getAllLinks,
+      isLinkActive,
+      getFilteredLinks
+    }),
+    [mergedConfig, state, actions, getAllLinks, isLinkActive, getFilteredLinks]
+  );
+  return /* @__PURE__ */ jsx5(SidebarContext.Provider, { value, children });
+}
+function useSidebar() {
+  const context = useContext5(SidebarContext);
+  if (!context) {
+    throw new Error(
+      "useSidebar must be used within a SidebarProvider. Make sure to wrap your application with <SidebarProvider>."
+    );
+  }
+  return context;
+}
+function useSidebarOptional() {
+  return useContext5(SidebarContext);
+}
+function useSidebarState() {
+  const { state } = useSidebar();
+  return state;
+}
+function useSidebarActions() {
+  const { actions } = useSidebar();
+  return actions;
+}
+
+// src/providers/navigation/NavContext.tsx
+import { createContext as createContext6, useEffect as useEffect3, useState as useState5 } from "react";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var defaultNavContext = {
+  currentPage: { title: "", location: "" },
+  currentCallStack: /* @__PURE__ */ new Map(),
+  setCurrentPage: () => {
+  }
+};
+var NavContext = createContext6(defaultNavContext);
+function isChildPath(parentPath, childPath) {
+  const normalizedParent = parentPath?.endsWith("/") ? parentPath : parentPath + "/";
+  const normalizedChild = childPath?.endsWith("/") ? childPath : childPath + "/";
+  return normalizedChild.startsWith(normalizedParent);
+}
+function NavContextProvider({ children }) {
+  const [currentPage, setCurrentPage] = useState5({ title: "", location: "" });
+  const [currentCallStack, setCurrentCallStack] = useState5(/* @__PURE__ */ new Map());
+  useEffect3(() => {
+    setCurrentCallStack((prev) => {
+      const newMap = /* @__PURE__ */ new Map();
+      for (const [location, title] of prev.entries()) {
+        if (isChildPath(location, currentPage.location) && location !== "") {
+          newMap.set(location, title);
+        }
+      }
+      newMap.set(currentPage.location, currentPage.title);
+      return newMap;
+    });
+  }, [currentPage]);
+  return /* @__PURE__ */ jsx6(
+    NavContext.Provider,
+    {
+      value: {
+        currentPage,
+        currentCallStack,
+        setCurrentPage: (title, location) => setCurrentPage({ title, location })
+      },
+      children
+    }
+  );
+}
+
+// src/contexts/contexts/core/SelectedItemsContext.tsx
+import { createContext as createContext7, useEffect as useEffect4, useState as useState6 } from "react";
+import { isUsable } from "@pol-studios/utils";
+import { jsx as jsx7 } from "react/jsx-runtime";
+var defaultContextValue = {
+  Items: [],
+  SelectedItems: [],
+  AddItem: () => {
+  },
+  // Empty function as placeholder
+  RemoveItem: () => {
+  },
+  // Empty function as placeholder
+  SetSelectedItems: () => {
+  },
+  // Corrected function as placeholder
+  UpdateItem: () => {
+  }
+  // Corrected function as placeholder
+};
+function createSelectedItemsContext() {
+  const context = createContext7(defaultContextValue);
+  const Provider = ({ children, Items, initialSelectedItems = [] }) => {
+    const [selectedItems, setSelectedItems] = useState6(initialSelectedItems);
+    const [items, setItems] = useState6([]);
+    useEffect4(() => {
+      setItems(Items);
+    }, [Items]);
+    useEffect4(() => {
+      setSelectedItems(
+        (previousItems) => previousItems.map((x) => Items.find((i) => i.id == x.id)).filter((x) => x != null)
+      );
+    }, [Items]);
+    function addSelectedItem(item) {
+      setSelectedItems([...selectedItems, item]);
+    }
+    function removeSelectedItem(item) {
+      setSelectedItems(selectedItems.filter((x) => x !== item));
+    }
+    function updateItem(item, newProperties) {
+      if (isUsable(item)) {
+        const newValue = { ...item, ...newProperties ?? {} };
+        setItems(items.map((x) => x.id == item.id ? newValue : x));
+        setSelectedItems(selectedItems.map((x) => x.id == item.id ? newValue : x));
+      }
+    }
+    return /* @__PURE__ */ jsx7(
+      context.Provider,
+      {
+        value: {
+          Items: items,
+          SelectedItems: selectedItems,
+          AddItem: addSelectedItem,
+          RemoveItem: removeSelectedItem,
+          SetSelectedItems: setSelectedItems,
+          UpdateItem: updateItem
+        },
+        children
+      }
+    );
+  };
+  return { context, Provider };
+}
+
+// src/contexts/contexts/SelectedFixturesContext.tsx
+var {
+  context: SelectedFixturesContext,
+  Provider: SelectedFixturesProvider
+} = createSelectedItemsContext();
+
+// src/providers/notifications/types.ts
+var DEFAULT_STORAGE_KEY = "pol-notifications-unread";
+var DEFAULT_NOTIFICATION_CONFIG = {
+  basePath: "/notifications",
+  defaultRoute: "/notifications",
+  showToast: true,
+  toastDuration: 5e3,
+  maxDisplayCount: 50,
+  pollInterval: 3e4,
+  enableRealtime: false,
+  persistUnread: true,
+  storageKey: DEFAULT_STORAGE_KEY
+};
+var DEFAULT_NOTIFICATION_STATE = {
+  notifications: [],
+  unreadCount: 0,
+  isLoading: false,
+  error: null,
+  lastFetchedAt: null
+};
+
+// src/providers/notifications/NotificationRegistry.tsx
+import {
+  createContext as createContext8,
+  useCallback as useCallback4,
+  useContext as useContext6,
+  useEffect as useEffect5,
+  useMemo as useMemo5,
+  useState as useState7
+} from "react";
+import { jsx as jsx8 } from "react/jsx-runtime";
+function loadUnreadFromStorage(storageKey) {
+  try {
+    const stored = localStorage.getItem(storageKey);
+    if (stored) {
+      return new Set(JSON.parse(stored));
+    }
+  } catch (e) {
+    console.warn("Failed to load notifications from storage:", e);
+  }
+  return /* @__PURE__ */ new Set();
+}
+var MAX_PERSISTED_UNREAD_IDS = 500;
+function saveUnreadToStorage(storageKey, unreadIds) {
+  try {
+    const idsArray = [...unreadIds];
+    const limitedIds = idsArray.slice(-MAX_PERSISTED_UNREAD_IDS);
+    localStorage.setItem(storageKey, JSON.stringify(limitedIds));
+  } catch (e) {
+    console.warn("Failed to save notifications to storage:", e);
+  }
+}
+var NotificationContext = createContext8(
+  null
+);
+function NotificationProvider({
+  config,
+  handlers: initialHandlers = [],
+  navigate,
+  fetchFn,
+  markAsReadFn,
+  deleteFn,
+  children
+}) {
+  const mergedConfig = useMemo5(
+    () => ({
+      ...DEFAULT_NOTIFICATION_CONFIG,
+      ...config
+    }),
+    [config]
+  );
+  const storageKey = mergedConfig.storageKey ?? DEFAULT_STORAGE_KEY;
+  const persistEnabled = mergedConfig.persistUnread !== false;
+  const [handlers, setHandlers] = useState7(initialHandlers);
+  const [persistedUnreadIds, setPersistedUnreadIds] = useState7(
+    () => persistEnabled ? loadUnreadFromStorage(storageKey) : /* @__PURE__ */ new Set()
+  );
+  const [state, setState] = useState7(
+    DEFAULT_NOTIFICATION_STATE
+  );
+  useEffect5(() => {
+    if (persistEnabled) {
+      saveUnreadToStorage(storageKey, persistedUnreadIds);
+    }
+  }, [persistEnabled, storageKey, persistedUnreadIds]);
+  useEffect5(() => {
+    if (persistEnabled && state.notifications.length > 0) {
+      const unreadIds = new Set(
+        state.notifications.filter((n) => !n.isRead).map((n) => n.id)
+      );
+      setPersistedUnreadIds(unreadIds);
+    }
+  }, [persistEnabled, state.notifications]);
+  const clearPersistedData = useCallback4(() => {
+    try {
+      localStorage.removeItem(storageKey);
+    } catch (e) {
+      console.warn("Failed to clear persisted notifications:", e);
+    }
+    setPersistedUnreadIds(/* @__PURE__ */ new Set());
+  }, [storageKey]);
+  const registerHandler = useCallback4((handler) => {
+    setHandlers((prev) => {
+      const typesToAdd = Array.isArray(handler.types) ? handler.types : [handler.types];
+      const filtered = prev.filter((h) => {
+        const existingTypes = Array.isArray(h.types) ? h.types : [h.types];
+        return !existingTypes.some((t) => typesToAdd.includes(t));
+      });
+      return [...filtered, handler];
+    });
+  }, []);
+  const unregisterHandler = useCallback4((types) => {
+    const typesToRemove = Array.isArray(types) ? types : [types];
+    setHandlers(
+      (prev) => prev.filter((h) => {
+        const existingTypes = Array.isArray(h.types) ? h.types : [h.types];
+        return !existingTypes.some((t) => typesToRemove.includes(t));
+      })
+    );
+  }, []);
+  const getHandlers = useCallback4(() => handlers, [handlers]);
+  const findHandler = useCallback4(
+    (type) => {
+      return handlers.find((handler) => {
+        const handlerTypes = Array.isArray(handler.types) ? handler.types : [handler.types];
+        return handlerTypes.includes(type);
+      });
+    },
+    [handlers]
+  );
+  const getNotificationRoute = useCallback4(
+    (notification) => {
+      const handler = findHandler(notification.type);
+      if (!handler) {
+        return mergedConfig.defaultRoute ?? "/notifications";
+      }
+      const params = {
+        type: notification.type,
+        entityId: notification.entityId,
+        entityType: notification.entityType,
+        params: notification.metadata
+      };
+      if (handler.canHandle && !handler.canHandle(params)) {
+        return mergedConfig.defaultRoute ?? "/notifications";
+      }
+      return handler.getRoute(params);
+    },
+    [findHandler, mergedConfig.defaultRoute]
+  );
+  const actions = useMemo5(
+    () => ({
+      markAsRead: async (notificationId) => {
+        if (markAsReadFn) {
+          await markAsReadFn(notificationId);
+        }
+        setState((prev) => ({
+          ...prev,
+          notifications: prev.notifications.map(
+            (n) => n.id === notificationId ? { ...n, isRead: true } : n
+          ),
+          unreadCount: Math.max(0, prev.unreadCount - 1)
+        }));
+      },
+      markAllAsRead: async () => {
+        let currentUnreadIds = [];
+        setState((prev) => {
+          currentUnreadIds = prev.notifications.filter((n) => !n.isRead).map((n) => n.id);
+          return prev;
+        });
+        if (markAsReadFn && currentUnreadIds.length > 0) {
+          await Promise.all(currentUnreadIds.map((id) => markAsReadFn(id)));
+        }
+        setState((prev) => ({
+          ...prev,
+          notifications: prev.notifications.map((n) => ({
+            ...n,
+            isRead: true
+          })),
+          unreadCount: 0
+        }));
+      },
+      deleteNotification: async (notificationId) => {
+        if (deleteFn) {
+          await deleteFn(notificationId);
+        }
+        setState((prev) => {
+          const notification = prev.notifications.find(
+            (n) => n.id === notificationId
+          );
+          return {
+            ...prev,
+            notifications: prev.notifications.filter(
+              (n) => n.id !== notificationId
+            ),
+            unreadCount: notification && !notification.isRead ? Math.max(0, prev.unreadCount - 1) : prev.unreadCount
+          };
+        });
+      },
+      clearAll: async () => {
+        let currentNotificationIds = [];
+        setState((prev) => {
+          currentNotificationIds = prev.notifications.map((n) => n.id);
+          return prev;
+        });
+        if (deleteFn && currentNotificationIds.length > 0) {
+          await Promise.all(currentNotificationIds.map((id) => deleteFn(id)));
+        }
+        setState((prev) => ({
+          ...prev,
+          notifications: [],
+          unreadCount: 0
+        }));
+      },
+      fetchNotifications: async () => {
+        if (!fetchFn) {
+          return state.notifications;
+        }
+        setState((prev) => ({ ...prev, isLoading: true, error: null }));
+        try {
+          const notifications = await fetchFn();
+          const notificationsWithPersistedState = persistEnabled && persistedUnreadIds.size > 0 ? notifications.map((n) => ({
+            ...n,
+            isRead: persistedUnreadIds.has(n.id) ? false : n.isRead
+          })) : notifications;
+          const unreadCount = notificationsWithPersistedState.filter(
+            (n) => !n.isRead
+          ).length;
+          setState((prev) => ({
+            ...prev,
+            notifications: notificationsWithPersistedState,
+            unreadCount,
+            isLoading: false,
+            lastFetchedAt: /* @__PURE__ */ new Date()
+          }));
+          return notificationsWithPersistedState;
+        } catch (error) {
+          setState((prev) => ({
+            ...prev,
+            isLoading: false,
+            error
+          }));
+          throw error;
+        }
+      },
+      navigateToNotification: (notification) => {
+        const handler = findHandler(notification.type);
+        if (handler?.onClick) {
+          handler.onClick({
+            type: notification.type,
+            entityId: notification.entityId,
+            entityType: notification.entityType,
+            params: notification.metadata
+          });
+          return;
+        }
+        const route = getNotificationRoute(notification);
+        if (navigate) {
+          navigate(route);
+        } else {
+          window.location.href = route;
+        }
+      }
+    }),
+    [
+      state.notifications,
+      fetchFn,
+      markAsReadFn,
+      deleteFn,
+      findHandler,
+      getNotificationRoute,
+      navigate,
+      persistEnabled,
+      persistedUnreadIds
+    ]
+  );
+  const value = useMemo5(
+    () => ({
+      config: mergedConfig,
+      state,
+      actions,
+      getNotificationRoute,
+      registerHandler,
+      unregisterHandler,
+      getHandlers,
+      clearPersistedData
+    }),
+    [
+      mergedConfig,
+      state,
+      actions,
+      getNotificationRoute,
+      registerHandler,
+      unregisterHandler,
+      getHandlers,
+      clearPersistedData
+    ]
+  );
+  return /* @__PURE__ */ jsx8(NotificationContext.Provider, { value, children });
+}
+function useNotifications() {
+  const context = useContext6(NotificationContext);
+  if (!context) {
+    throw new Error(
+      "useNotifications must be used within a NotificationProvider. Make sure to wrap your application with <NotificationProvider>."
+    );
+  }
+  return context;
+}
+function useNotificationsOptional() {
+  return useContext6(NotificationContext);
+}
+function useNotificationActions() {
+  const { actions } = useNotifications();
+  return actions;
+}
+function useNotificationState() {
+  const { state } = useNotifications();
+  return state;
+}
+function useUnreadCount() {
+  const { state } = useNotifications();
+  return state.unreadCount;
+}
+
+// src/providers/notifications/handlers.ts
+var MAX_ROUTE_CACHE_SIZE = 100;
+function createAsyncHandler(config, supabase) {
+  const resolvedRoutes = /* @__PURE__ */ new Map();
+  return {
+    types: config.types,
+    canHandle: config.canHandle,
+    getRoute: (params) => {
+      const cacheKey = `${params.type}-${params.entityId}`;
+      const cached = resolvedRoutes.get(cacheKey);
+      if (cached) {
+        return cached;
+      }
+      return "/notifications";
+    },
+    onClick: async (params) => {
+      try {
+        const result = await config.resolveRoute(params, supabase);
+        if (result) {
+          const cacheKey = `${params.type}-${params.entityId}`;
+          if (resolvedRoutes.size >= MAX_ROUTE_CACHE_SIZE) {
+            const firstKey = resolvedRoutes.keys().next().value;
+            if (firstKey) resolvedRoutes.delete(firstKey);
+          }
+          resolvedRoutes.set(cacheKey, result.to);
+          let url = result.to;
+          if (result.params) {
+            for (const [key, value] of Object.entries(result.params)) {
+              url = url.replace(`$${key}`, String(value));
+            }
+          }
+          window.location.href = url;
+        }
+      } catch (error) {
+        console.error("Failed to navigate to notification:", error);
+        config.onError?.(error, params);
+      }
+    }
+  };
+}
+var commentEntityRoutes = {
+  EquipmentFixtureUnit: (entityId, projectDatabaseId) => ({
+    to: `/project-databases/${projectDatabaseId}/equipment-units/${entityId}/tag`,
+    params: { projectDatabaseId, equipmentUnitId: entityId }
+  }),
+  PunchListItem: (entityId, projectDatabaseId) => ({
+    to: `/project-databases/${projectDatabaseId}/punch-lists?punchListItemId=${entityId}`,
+    params: { projectDatabaseId }
+  })
+};
+function createPortalOneNotificationHandlers(supabase, navigate) {
+  const nav = navigate || ((url) => {
+    window.location.href = url;
+  });
+  return [
+    // Comment handler - resolves comment location from CommentSection
+    {
+      types: "Comment",
+      getRoute: () => "/notifications",
+      // Fallback, actual resolution is async
+      onClick: async (params) => {
+        try {
+          if (!params.entityId) return;
+          const comment = await supabase.from("Comment").select("*, CommentSection!inner(*)").eq("id", params.entityId).single();
+          if (!comment.data) {
+            console.log("Comment not found");
+            return;
+          }
+          const commentData = comment.data;
+          const route = await resolveCommentEntityRoute(
+            commentData.CommentSection.entityTableName,
+            commentData.CommentSection.entityId,
+            supabase
+          );
+          if (route) {
+            nav(route);
+          }
+        } catch (error) {
+          console.error("Failed to navigate to Comment notification:", error);
+        }
+      }
+    },
+    // CommentTag handler - resolves through Comment
+    {
+      types: "CommentTag",
+      getRoute: () => "/notifications",
+      // Fallback, actual resolution is async
+      onClick: async (params) => {
+        try {
+          if (!params.entityId) return;
+          const commentTag = await supabase.from("CommentTag").select("id, commentId").eq("id", params.entityId).single();
+          if (!commentTag.data) {
+            console.log("CommentTag not found");
+            return;
+          }
+          const tagData = commentTag.data;
+          const comment = await supabase.from("Comment").select("*, CommentSection!inner(*)").eq("id", tagData.commentId).single();
+          if (!comment.data) {
+            console.log("Comment not found");
+            return;
+          }
+          const commentData = comment.data;
+          const route = await resolveCommentEntityRoute(
+            commentData.CommentSection.entityTableName,
+            commentData.CommentSection.entityId,
+            supabase
+          );
+          if (route) {
+            nav(route);
+          }
+        } catch (error) {
+          console.error("Failed to navigate to CommentTag notification:", error);
+        }
+      }
+    }
+  ];
+}
+async function resolveCommentEntityRoute(entityTableName, entityId, supabase) {
+  switch (entityTableName) {
+    case "EquipmentFixtureUnit": {
+      const unit = await supabase.from("EquipmentFixtureUnit").select("*").eq("id", entityId).single();
+      if (!unit.data) {
+        console.log("Unit not found");
+        return null;
+      }
+      const unitData = unit.data;
+      return `/project-databases/${unitData.projectDatabaseId}/equipment-units/${entityId}/tag`;
+    }
+    case "PunchListItem": {
+      const punchList = await supabase.from("PunchListItem").select("*, PunchList!inner(*, PunchListPage!inner(*))").eq("id", entityId).maybeSingle();
+      if (!punchList.data) {
+        console.log("PunchList not found");
+        return null;
+      }
+      const punchData = punchList.data;
+      if (punchData.PunchList.PunchListPage.tableName === "ProjectDatabase") {
+        return `/project-databases/${punchData.PunchList.PunchListPage.entityId}/punch-lists?punchListItemId=${entityId}`;
+      }
+      return null;
+    }
+    default:
+      return null;
+  }
+}
+function convertLegacyHandler(types, legacyHandler, supabase, navigate, onError) {
+  const nav = navigate || ((url) => {
+    window.location.href = url;
+  });
+  return {
+    types,
+    getRoute: () => "/notifications",
+    // Fallback for sync access
+    onClick: async (params) => {
+      try {
+        if (!params.entityId) return;
+        const result = await legacyHandler(params.entityId, supabase);
+        if (result) {
+          let url = result.to;
+          if (result.params) {
+            for (const [key, value] of Object.entries(result.params)) {
+              url = url.replace(`$${key}`, String(value));
+            }
+          }
+          nav(url);
+        }
+      } catch (error) {
+        console.error("Failed to navigate to notification:", error);
+        onError?.(error, params);
+      }
+    }
+  };
+}
+
+// src/providers/alert/AlertContext.tsx
+import { createContext as createContext9, useContext as useContext7, useState as useState8 } from "react";
+import { jsx as jsx9 } from "react/jsx-runtime";
+var defaultAlertState = {
+  isOpen: false,
+  title: "",
+  description: "",
+  confirmTitle: "Confirm",
+  cancelTitle: "Cancel",
+  variant: "default",
+  onConfirm: () => {
+  },
+  onCancel: () => {
+  }
+};
+var defaultContextValue2 = {
+  showAlert: async () => false,
+  hideAlert: () => {
+  },
+  alertState: defaultAlertState
+};
+var AlertContext = createContext9(defaultContextValue2);
+var useAlert = () => {
+  const context = useContext7(AlertContext);
+  if (!context) {
+    throw new Error("useAlert must be used within an AlertProvider");
+  }
+  return { hideAlert: context.hideAlert, showAlert: context.showAlert };
+};
+var AlertProvider = ({ children }) => {
+  const [alertState, setAlertState] = useState8(defaultAlertState);
+  async function showAlert({
+    title,
+    description,
+    confirmTitle,
+    cancelTitle,
+    variant = "default"
+  }) {
+    const result = await new Promise(
+      (resolve) => setAlertState({
+        isOpen: true,
+        title,
+        description,
+        confirmTitle: confirmTitle || "Confirm",
+        cancelTitle: cancelTitle || "Cancel",
+        variant,
+        onConfirm: () => resolve(true),
+        onCancel: () => resolve(false)
+      })
+    );
+    return result;
+  }
+  const hideAlert = () => {
+    setAlertState({ ...alertState, isOpen: false });
+  };
+  return /* @__PURE__ */ jsx9(AlertContext.Provider, { value: { alertState, showAlert, hideAlert }, children });
+};
+
+// src/providers/PolComponentsProvider.tsx
+import { Fragment, jsx as jsx10 } from "react/jsx-runtime";
+function PolComponentsProvider({ config, children }) {
+  let content = children;
+  if (config.notifications) {
+    content = /* @__PURE__ */ jsx10(
+      NotificationProvider,
+      {
+        config: config.notifications.config,
+        handlers: config.notifications.handlers,
+        children: content
+      }
+    );
+  }
+  if (config.sidebar) {
+    content = /* @__PURE__ */ jsx10(SidebarProvider, { config: config.sidebar, children: content });
+  }
+  content = /* @__PURE__ */ jsx10(ConfigProvider, { config: config.config, children: content });
+  if (config.data) {
+    content = /* @__PURE__ */ jsx10(DataProvider, { adapter: config.data, children: content });
+  }
+  if (config.auth) {
+    content = /* @__PURE__ */ jsx10(AuthProvider, { value: config.auth, children: content });
+  }
+  content = /* @__PURE__ */ jsx10(RouterProvider, { adapter: config.router, children: content });
+  return /* @__PURE__ */ jsx10(Fragment, { children: content });
+}
+export {
+  AlertContext,
+  AlertProvider,
+  AuthContext,
+  AuthProvider,
+  ConfigActionsContext,
+  ConfigContext,
+  ConfigProvider,
+  DEFAULT_CONFIG,
+  DEFAULT_FEATURES,
+  DEFAULT_LOCALIZATION,
+  DEFAULT_NOTIFICATION_CONFIG,
+  DEFAULT_NOTIFICATION_STATE,
+  DEFAULT_ROUTES,
+  DEFAULT_SIDEBAR_CONFIG,
+  DEFAULT_SIDEBAR_STATE,
+  DEFAULT_STORAGE_KEY,
+  DEFAULT_THEME,
+  DataContext,
+  DataProvider,
+  Link,
+  NavContext,
+  NavContextProvider,
+  NotificationContext,
+  NotificationProvider,
+  PolComponentsProvider,
+  RouterContext,
+  RouterProvider,
+  SelectedFixturesContext,
+  SelectedFixturesProvider,
+  SidebarContext,
+  SidebarProvider,
+  commentEntityRoutes,
+  convertLegacyHandler,
+  createAsyncHandler,
+  createPortalOneNotificationHandlers,
+  useAlert,
+  useComponentAuth,
+  useComponentAuthOptional,
+  useComponentConfig,
+  useComponentConfigOptional,
+  useConfigActions,
+  useConfigActionsOptional,
+  useDataAdapter,
+  useDataAdapterOptional,
+  useDataDelete,
+  useDataInsert,
+  useDataMutation,
+  useDataQuery,
+  useDataQueryById,
+  useDataUpdate,
+  useFeatureFlag,
+  useLocation,
+  useNavigate,
+  useNotificationActions,
+  useNotificationState,
+  useNotifications,
+  useNotificationsOptional,
+  useParams,
+  useRoute,
+  useRouter,
+  useSidebar,
+  useSidebarActions,
+  useSidebarOptional,
+  useSidebarState,
+  useUnreadCount
+};