@pol-studios/db 1.0.10 → 1.0.12

package/dist/with-auth/index.js

@@ -0,0 +1,1221 @@
+import {
+  UserMetadataContextProvider,
+  useLiveChangesIndicator,
+  useSetUserMetadata,
+  useUserMetadataState,
+  useUserMetadataValue,
+  userMetadataContext
+} from "../chunk-LNJ3WF7V.js";
+import "../chunk-SM73S2DY.js";
+import "../chunk-NSIAAYW3.js";
+import {
+  useAuth,
+  useSetupAuth
+} from "../chunk-DJ6VLEAL.js";
+import {
+  useDbQuery
+} from "../chunk-WGDJ4IXR.js";
+import {
+  useDbUpsert
+} from "../chunk-ZVBHWU7O.js";
+import "../chunk-HAWJTZCK.js";
+import {
+  getSupabaseUrl
+} from "../chunk-GC3TBUWE.js";
+import "../chunk-J4ZVCXZ4.js";
+import {
+  isNullOrWhitespace,
+  isUsable,
+  newUuid
+} from "../chunk-OQ7U6EQ3.js";
+import "../chunk-H6365JPC.js";
+import "../chunk-3PJTNH2L.js";
+import {
+  useSupabase
+} from "../chunk-5EFDS7SR.js";
+import "../chunk-P4UZ7IXC.js";
+
+// src/hooks/useConsent.ts
+import { useCallback, useMemo } from "react";
+function useConsent() {
+  const supabase = useSupabase();
+  const {
+    user
+  } = useSetupAuth();
+  const consentsQuery = useDbQuery(supabase.schema("core").from("ConsentRecord").select("*").eq("userId", user?.id ?? "").order("createdAt", {
+    ascending: false
+  }), {
+    enabled: isUsable(user),
+    crossOrganization: true
+  });
+  const consents = useMemo(() => {
+    if (!consentsQuery.data) return [];
+    return consentsQuery.data;
+  }, [consentsQuery.data]);
+  const consentSummary = useMemo(() => {
+    const latestByType = /* @__PURE__ */ new Map();
+    for (const consent of consents) {
+      if (!latestByType.has(consent.consentType)) {
+        latestByType.set(consent.consentType, consent);
+      }
+    }
+    return Array.from(latestByType.values()).map((record) => ({
+      consentType: record.consentType,
+      consentGiven: record.consentGiven,
+      consentVersion: record.consentVersion,
+      consentedAt: record.createdAt
+    }));
+  }, [consents]);
+  const recordConsent = useCallback(async (type, version, given, options) => {
+    if (!user?.id) {
+      console.error("Cannot record consent: user not authenticated");
+      return null;
+    }
+    try {
+      const userAgent = typeof window !== "undefined" ? window.navigator.userAgent : null;
+      const {
+        data,
+        error
+      } = await supabase.schema("core").from("ConsentRecord").insert({
+        userId: user.id,
+        consentType: type,
+        consentVersion: version,
+        consentGiven: given,
+        consentText: options?.consentText ?? null,
+        ipAddress: options?.ipAddress ?? null,
+        userAgent
+      }).select().single();
+      if (error) {
+        console.error("Error recording consent:", error);
+        return null;
+      }
+      consentsQuery.refetch();
+      return data;
+    } catch (err) {
+      console.error("Error recording consent:", err);
+      return null;
+    }
+  }, [supabase, user?.id, consentsQuery]);
+  const withdrawConsent = useCallback(async (type_0, version_0) => {
+    return recordConsent(type_0, version_0, false);
+  }, [recordConsent]);
+  const hasActiveConsent = useCallback((type_1) => {
+    const summary = consentSummary.find((s) => s.consentType === type_1);
+    return summary?.consentGiven ?? false;
+  }, [consentSummary]);
+  const getLatestConsent = useCallback((type_2) => {
+    return consents.find((c) => c.consentType === type_2);
+  }, [consents]);
+  return {
+    recordConsent,
+    consents,
+    consentSummary,
+    withdrawConsent,
+    hasActiveConsent,
+    getLatestConsent,
+    isLoading: consentsQuery.isLoading,
+    error: consentsQuery.error,
+    refetch: consentsQuery.refetch
+  };
+}
+async function recordConsentForUser(supabase, userId, type, version, given, options) {
+  try {
+    const userAgent = typeof window !== "undefined" ? window.navigator.userAgent : null;
+    const {
+      data,
+      error
+    } = await supabase.schema("core").from("ConsentRecord").insert({
+      userId,
+      consentType: type,
+      consentVersion: version,
+      consentGiven: given,
+      consentText: options?.consentText ?? null,
+      ipAddress: options?.ipAddress ?? null,
+      userAgent
+    }).select().single();
+    if (error) {
+      console.error("Error recording consent:", error);
+      return null;
+    }
+    return data;
+  } catch (err) {
+    console.error("Error recording consent:", err);
+    return null;
+  }
+}
+var useConsent_default = useConsent;
+
+// src/hooks/useAccountDeletion.ts
+import { c as _c } from "react/compiler-runtime";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+var DELETION_STATUS_KEY = ["accountDeletionStatus"];
+function useAccountDeletion() {
+  const $ = _c(56);
+  const supabase = useSupabase();
+  const queryClient = useQueryClient();
+  const {
+    user
+  } = useAuth();
+  let t0;
+  if ($[0] !== supabase) {
+    t0 = async () => {
+      const {
+        data,
+        error
+      } = await supabase.schema("core").rpc("get_deletion_status");
+      if (error) {
+        throw new Error(error.message);
+      }
+      return data;
+    };
+    $[0] = supabase;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const t1 = !!user;
+  let t2;
+  if ($[2] !== t0 || $[3] !== t1) {
+    t2 = {
+      queryKey: DELETION_STATUS_KEY,
+      queryFn: t0,
+      enabled: t1,
+      staleTime: 3e5,
+      refetchOnWindowFocus: true
+    };
+    $[2] = t0;
+    $[3] = t1;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  const statusQuery = useQuery(t2);
+  let t3;
+  if ($[5] !== supabase) {
+    t3 = async (reason) => {
+      const {
+        data: data_0,
+        error: error_0
+      } = await supabase.schema("core").rpc("request_account_deletion", {
+        p_reason: reason
+      });
+      if (error_0) {
+        throw new Error(error_0.message);
+      }
+      return data_0;
+    };
+    $[5] = supabase;
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  let t4;
+  if ($[7] !== queryClient) {
+    t4 = (data_1) => {
+      if (data_1.success) {
+        queryClient.invalidateQueries({
+          queryKey: DELETION_STATUS_KEY
+        });
+      }
+    };
+    $[7] = queryClient;
+    $[8] = t4;
+  } else {
+    t4 = $[8];
+  }
+  let t5;
+  if ($[9] !== t3 || $[10] !== t4) {
+    t5 = {
+      mutationFn: t3,
+      onSuccess: t4
+    };
+    $[9] = t3;
+    $[10] = t4;
+    $[11] = t5;
+  } else {
+    t5 = $[11];
+  }
+  const requestMutation = useMutation(t5);
+  let t6;
+  if ($[12] !== supabase) {
+    t6 = async () => {
+      const {
+        data: data_2,
+        error: error_1
+      } = await supabase.schema("core").rpc("cancel_account_deletion");
+      if (error_1) {
+        throw new Error(error_1.message);
+      }
+      return data_2;
+    };
+    $[12] = supabase;
+    $[13] = t6;
+  } else {
+    t6 = $[13];
+  }
+  let t7;
+  if ($[14] !== queryClient) {
+    t7 = (data_3) => {
+      if (data_3.success) {
+        queryClient.invalidateQueries({
+          queryKey: DELETION_STATUS_KEY
+        });
+      }
+    };
+    $[14] = queryClient;
+    $[15] = t7;
+  } else {
+    t7 = $[15];
+  }
+  let t8;
+  if ($[16] !== t6 || $[17] !== t7) {
+    t8 = {
+      mutationFn: t6,
+      onSuccess: t7
+    };
+    $[16] = t6;
+    $[17] = t7;
+    $[18] = t8;
+  } else {
+    t8 = $[18];
+  }
+  const cancelMutation = useMutation(t8);
+  let t9;
+  if ($[19] !== requestMutation) {
+    t9 = async (reason_0) => requestMutation.mutateAsync(reason_0);
+    $[19] = requestMutation;
+    $[20] = t9;
+  } else {
+    t9 = $[20];
+  }
+  const requestDeletion = t9;
+  let t10;
+  if ($[21] !== cancelMutation) {
+    t10 = async () => cancelMutation.mutateAsync();
+    $[21] = cancelMutation;
+    $[22] = t10;
+  } else {
+    t10 = $[22];
+  }
+  const cancelDeletion = t10;
+  let t11;
+  if ($[23] !== queryClient) {
+    t11 = () => {
+      queryClient.invalidateQueries({
+        queryKey: DELETION_STATUS_KEY
+      });
+    };
+    $[23] = queryClient;
+    $[24] = t11;
+  } else {
+    t11 = $[24];
+  }
+  const refreshStatus = t11;
+  const status = statusQuery.data;
+  const request = status?.request;
+  const t12 = request?.status === "pending";
+  const t13 = request?.status === "cancelled";
+  const t14 = request?.status === "completed";
+  const t15 = request?.daysRemaining ?? null;
+  let t16;
+  if ($[25] !== request) {
+    t16 = request?.scheduledDeletionAt ? new Date(request.scheduledDeletionAt) : null;
+    $[25] = request;
+    $[26] = t16;
+  } else {
+    t16 = $[26];
+  }
+  let t17;
+  if ($[27] !== request) {
+    t17 = request?.requestedAt ? new Date(request.requestedAt) : null;
+    $[27] = request;
+    $[28] = t17;
+  } else {
+    t17 = $[28];
+  }
+  let t18;
+  if ($[29] !== request) {
+    t18 = request?.cancelledAt ? new Date(request.cancelledAt) : null;
+    $[29] = request;
+    $[30] = t18;
+  } else {
+    t18 = $[30];
+  }
+  const t19 = request?.reason ?? null;
+  let t20;
+  if ($[31] !== request || $[32] !== t12 || $[33] !== t13 || $[34] !== t14 || $[35] !== t15 || $[36] !== t16 || $[37] !== t17 || $[38] !== t18 || $[39] !== t19) {
+    t20 = {
+      deletionRequest: request,
+      isPendingDeletion: t12,
+      isCancelledDeletion: t13,
+      isCompletedDeletion: t14,
+      daysRemaining: t15,
+      scheduledDeletionAt: t16,
+      requestedAt: t17,
+      cancelledAt: t18,
+      reason: t19
+    };
+    $[31] = request;
+    $[32] = t12;
+    $[33] = t13;
+    $[34] = t14;
+    $[35] = t15;
+    $[36] = t16;
+    $[37] = t17;
+    $[38] = t18;
+    $[39] = t19;
+    $[40] = t20;
+  } else {
+    t20 = $[40];
+  }
+  const computedValues = t20;
+  let t21;
+  if ($[41] !== cancelDeletion || $[42] !== cancelMutation.data || $[43] !== cancelMutation.error || $[44] !== cancelMutation.isPending || $[45] !== computedValues || $[46] !== refreshStatus || $[47] !== requestDeletion || $[48] !== requestMutation.data || $[49] !== requestMutation.error || $[50] !== requestMutation.isPending || $[51] !== statusQuery.data || $[52] !== statusQuery.error || $[53] !== statusQuery.isError || $[54] !== statusQuery.isLoading) {
+    t21 = {
+      deletionStatus: statusQuery.data,
+      isLoading: statusQuery.isLoading,
+      isError: statusQuery.isError,
+      error: statusQuery.error,
+      ...computedValues,
+      requestDeletion,
+      cancelDeletion,
+      refreshStatus,
+      isRequesting: requestMutation.isPending,
+      isCancelling: cancelMutation.isPending,
+      requestError: requestMutation.error,
+      cancelError: cancelMutation.error,
+      requestResult: requestMutation.data,
+      cancelResult: cancelMutation.data
+    };
+    $[41] = cancelDeletion;
+    $[42] = cancelMutation.data;
+    $[43] = cancelMutation.error;
+    $[44] = cancelMutation.isPending;
+    $[45] = computedValues;
+    $[46] = refreshStatus;
+    $[47] = requestDeletion;
+    $[48] = requestMutation.data;
+    $[49] = requestMutation.error;
+    $[50] = requestMutation.isPending;
+    $[51] = statusQuery.data;
+    $[52] = statusQuery.error;
+    $[53] = statusQuery.isError;
+    $[54] = statusQuery.isLoading;
+    $[55] = t21;
+  } else {
+    t21 = $[55];
+  }
+  return t21;
+}
+
+// src/hooks/useUserStatus.ts
+import { c as _c2 } from "react/compiler-runtime";
+import { useMutation as useMutation2, useQuery as useQuery2, useQueryClient as useQueryClient2 } from "@tanstack/react-query";
+var USER_STATUS_KEY = (userId) => ["userStatus", userId];
+function useUserStatus(targetUserId) {
+  const $ = _c2(58);
+  const supabase = useSupabase();
+  const queryClient = useQueryClient2();
+  const {
+    user
+  } = useAuth();
+  const userId = targetUserId ?? user?.id;
+  const t0 = userId ?? "";
+  let t1;
+  if ($[0] !== t0) {
+    t1 = USER_STATUS_KEY(t0);
+    $[0] = t0;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  let t2;
+  if ($[2] !== supabase || $[3] !== userId) {
+    t2 = async () => {
+      const {
+        data,
+        error
+      } = await supabase.schema("core").rpc("get_user_status", {
+        p_user_id: userId
+      });
+      if (error) {
+        throw new Error(error.message);
+      }
+      return data;
+    };
+    $[2] = supabase;
+    $[3] = userId;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  const t3 = !!userId;
+  let t4;
+  if ($[5] !== t1 || $[6] !== t2 || $[7] !== t3) {
+    t4 = {
+      queryKey: t1,
+      queryFn: t2,
+      enabled: t3,
+      staleTime: 3e5,
+      refetchOnWindowFocus: true
+    };
+    $[5] = t1;
+    $[6] = t2;
+    $[7] = t3;
+    $[8] = t4;
+  } else {
+    t4 = $[8];
+  }
+  const statusQuery = useQuery2(t4);
+  let t5;
+  if ($[9] !== supabase) {
+    t5 = async (t62) => {
+      const {
+        userId: userId_0,
+        reason
+      } = t62;
+      const {
+        data: data_0,
+        error: error_0
+      } = await supabase.schema("core").rpc("archive_user", {
+        p_user_id: userId_0,
+        p_reason: reason ?? void 0
+      });
+      if (error_0) {
+        throw new Error(error_0.message);
+      }
+      return data_0;
+    };
+    $[9] = supabase;
+    $[10] = t5;
+  } else {
+    t5 = $[10];
+  }
+  let t6;
+  if ($[11] !== queryClient) {
+    t6 = (data_1, variables) => {
+      if (data_1.success) {
+        queryClient.invalidateQueries({
+          queryKey: USER_STATUS_KEY(variables.userId)
+        });
+      }
+    };
+    $[11] = queryClient;
+    $[12] = t6;
+  } else {
+    t6 = $[12];
+  }
+  let t7;
+  if ($[13] !== t5 || $[14] !== t6) {
+    t7 = {
+      mutationFn: t5,
+      onSuccess: t6
+    };
+    $[13] = t5;
+    $[14] = t6;
+    $[15] = t7;
+  } else {
+    t7 = $[15];
+  }
+  const archiveMutation = useMutation2(t7);
+  let t8;
+  if ($[16] !== supabase) {
+    t8 = async (userId_1) => {
+      const {
+        data: data_2,
+        error: error_1
+      } = await supabase.schema("core").rpc("unarchive_user", {
+        p_user_id: userId_1
+      });
+      if (error_1) {
+        throw new Error(error_1.message);
+      }
+      return data_2;
+    };
+    $[16] = supabase;
+    $[17] = t8;
+  } else {
+    t8 = $[17];
+  }
+  let t9;
+  if ($[18] !== queryClient) {
+    t9 = (data_3, userId_2) => {
+      if (data_3.success) {
+        queryClient.invalidateQueries({
+          queryKey: USER_STATUS_KEY(userId_2)
+        });
+      }
+    };
+    $[18] = queryClient;
+    $[19] = t9;
+  } else {
+    t9 = $[19];
+  }
+  let t10;
+  if ($[20] !== t8 || $[21] !== t9) {
+    t10 = {
+      mutationFn: t8,
+      onSuccess: t9
+    };
+    $[20] = t8;
+    $[21] = t9;
+    $[22] = t10;
+  } else {
+    t10 = $[22];
+  }
+  const unarchiveMutation = useMutation2(t10);
+  let t11;
+  if ($[23] !== archiveMutation) {
+    t11 = async (userId_3, reason_0) => archiveMutation.mutateAsync({
+      userId: userId_3,
+      reason: reason_0
+    });
+    $[23] = archiveMutation;
+    $[24] = t11;
+  } else {
+    t11 = $[24];
+  }
+  const archiveUser = t11;
+  let t12;
+  if ($[25] !== unarchiveMutation) {
+    t12 = async (userId_4) => unarchiveMutation.mutateAsync(userId_4);
+    $[25] = unarchiveMutation;
+    $[26] = t12;
+  } else {
+    t12 = $[26];
+  }
+  const unarchiveUser = t12;
+  let t13;
+  if ($[27] !== queryClient || $[28] !== userId) {
+    t13 = () => {
+      if (userId) {
+        queryClient.invalidateQueries({
+          queryKey: USER_STATUS_KEY(userId)
+        });
+      }
+    };
+    $[27] = queryClient;
+    $[28] = userId;
+    $[29] = t13;
+  } else {
+    t13 = $[29];
+  }
+  const refreshStatus = t13;
+  let t14;
+  if ($[30] !== queryClient) {
+    t14 = (userIdToInvalidate) => {
+      queryClient.invalidateQueries({
+        queryKey: USER_STATUS_KEY(userIdToInvalidate)
+      });
+    };
+    $[30] = queryClient;
+    $[31] = t14;
+  } else {
+    t14 = $[31];
+  }
+  const invalidateUserStatus = t14;
+  const statusData = statusQuery.data;
+  const t15 = statusData?.exists ?? false;
+  const t16 = statusData?.status;
+  const t17 = statusData?.isActive ?? false;
+  const t18 = statusData?.status === "archived";
+  const t19 = statusData?.status === "suspended";
+  let t20;
+  if ($[32] !== statusData) {
+    t20 = statusData?.archivedAt ? new Date(statusData.archivedAt) : null;
+    $[32] = statusData;
+    $[33] = t20;
+  } else {
+    t20 = $[33];
+  }
+  const t21 = statusData?.archivedBy ?? null;
+  let t22;
+  if ($[34] !== t15 || $[35] !== t16 || $[36] !== t17 || $[37] !== t18 || $[38] !== t19 || $[39] !== t20 || $[40] !== t21) {
+    t22 = {
+      exists: t15,
+      status: t16,
+      isActive: t17,
+      isArchived: t18,
+      isSuspended: t19,
+      archivedAt: t20,
+      archivedBy: t21
+    };
+    $[34] = t15;
+    $[35] = t16;
+    $[36] = t17;
+    $[37] = t18;
+    $[38] = t19;
+    $[39] = t20;
+    $[40] = t21;
+    $[41] = t22;
+  } else {
+    t22 = $[41];
+  }
+  const computedValues = t22;
+  let t23;
+  if ($[42] !== archiveMutation.data || $[43] !== archiveMutation.error || $[44] !== archiveMutation.isPending || $[45] !== archiveUser || $[46] !== computedValues || $[47] !== invalidateUserStatus || $[48] !== refreshStatus || $[49] !== statusQuery.data || $[50] !== statusQuery.error || $[51] !== statusQuery.isError || $[52] !== statusQuery.isLoading || $[53] !== unarchiveMutation.data || $[54] !== unarchiveMutation.error || $[55] !== unarchiveMutation.isPending || $[56] !== unarchiveUser) {
+    t23 = {
+      statusData: statusQuery.data,
+      isLoading: statusQuery.isLoading,
+      isError: statusQuery.isError,
+      error: statusQuery.error,
+      ...computedValues,
+      archiveUser,
+      unarchiveUser,
+      refreshStatus,
+      invalidateUserStatus,
+      isArchiving: archiveMutation.isPending,
+      isUnarchiving: unarchiveMutation.isPending,
+      archiveError: archiveMutation.error,
+      unarchiveError: unarchiveMutation.error,
+      archiveResult: archiveMutation.data,
+      unarchiveResult: unarchiveMutation.data
+    };
+    $[42] = archiveMutation.data;
+    $[43] = archiveMutation.error;
+    $[44] = archiveMutation.isPending;
+    $[45] = archiveUser;
+    $[46] = computedValues;
+    $[47] = invalidateUserStatus;
+    $[48] = refreshStatus;
+    $[49] = statusQuery.data;
+    $[50] = statusQuery.error;
+    $[51] = statusQuery.isError;
+    $[52] = statusQuery.isLoading;
+    $[53] = unarchiveMutation.data;
+    $[54] = unarchiveMutation.error;
+    $[55] = unarchiveMutation.isPending;
+    $[56] = unarchiveUser;
+    $[57] = t23;
+  } else {
+    t23 = $[57];
+  }
+  return t23;
+}
+
+// src/hooks/useDataExport.ts
+import { c as _c3 } from "react/compiler-runtime";
+import { useMutation as useMutation3, useQuery as useQuery3, useQueryClient as useQueryClient3 } from "@tanstack/react-query";
+function useDataExport() {
+  const $ = _c3(35);
+  const supabase = useSupabase();
+  const auth = useAuth();
+  const queryClient = useQueryClient3();
+  let t0;
+  if ($[0] !== auth.user.id) {
+    t0 = ["dataExportHistory", auth.user.id];
+    $[0] = auth.user.id;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  let t1;
+  if ($[2] !== auth.user.id || $[3] !== supabase) {
+    t1 = async () => {
+      const {
+        data,
+        error
+      } = await supabase.rpc("get_data_export_history", {
+        p_user_id: auth.user.id
+      });
+      if (error) {
+        throw new Error(`Failed to fetch export history: ${error.message}`);
+      }
+      return data || [];
+    };
+    $[2] = auth.user.id;
+    $[3] = supabase;
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  let t2;
+  if ($[5] !== t0 || $[6] !== t1) {
+    t2 = {
+      queryKey: t0,
+      queryFn: t1,
+      staleTime: 3e5
+    };
+    $[5] = t0;
+    $[6] = t1;
+    $[7] = t2;
+  } else {
+    t2 = $[7];
+  }
+  const historyQuery = useQuery3(t2);
+  let t3;
+  if ($[8] !== auth.user.id || $[9] !== supabase) {
+    t3 = async () => {
+      const {
+        data: data_0,
+        error: error_0
+      } = await supabase.rpc("export_user_personal_data", {
+        p_user_id: auth.user.id
+      });
+      if (error_0) {
+        throw new Error(`Failed to export personal data: ${error_0.message}`);
+      }
+      if (!data_0) {
+        throw new Error("No data returned from export");
+      }
+      return data_0;
+    };
+    $[8] = auth.user.id;
+    $[9] = supabase;
+    $[10] = t3;
+  } else {
+    t3 = $[10];
+  }
+  let t4;
+  if ($[11] !== auth.user.id || $[12] !== queryClient) {
+    t4 = () => {
+      queryClient.invalidateQueries({
+        queryKey: ["dataExportHistory", auth.user.id]
+      });
+    };
+    $[11] = auth.user.id;
+    $[12] = queryClient;
+    $[13] = t4;
+  } else {
+    t4 = $[13];
+  }
+  let t5;
+  if ($[14] !== t3 || $[15] !== t4) {
+    t5 = {
+      mutationFn: t3,
+      onSuccess: t4
+    };
+    $[14] = t3;
+    $[15] = t4;
+    $[16] = t5;
+  } else {
+    t5 = $[16];
+  }
+  const exportMutation = useMutation3(t5);
+  let t6;
+  if ($[17] !== exportMutation) {
+    t6 = async () => exportMutation.mutateAsync();
+    $[17] = exportMutation;
+    $[18] = t6;
+  } else {
+    t6 = $[18];
+  }
+  const exportMyData = t6;
+  let t7;
+  if ($[19] !== auth.user.id || $[20] !== queryClient || $[21] !== supabase) {
+    t7 = (data_1, filename) => {
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+      const defaultFilename = `my-data-${timestamp}.json`;
+      const finalFilename = filename || defaultFilename;
+      const jsonString = JSON.stringify(data_1, null, 2);
+      const blob = new Blob([jsonString], {
+        type: "application/json"
+      });
+      const url = URL.createObjectURL(blob);
+      const link = document.createElement("a");
+      link.href = url;
+      link.download = finalFilename;
+      document.body.appendChild(link);
+      link.click();
+      document.body.removeChild(link);
+      URL.revokeObjectURL(url);
+      if (data_1.exportMetadata?.exportId) {
+        supabase.rpc("increment_export_download_count", {
+          p_export_id: data_1.exportMetadata.exportId
+        }).then(() => {
+          queryClient.invalidateQueries({
+            queryKey: ["dataExportHistory", auth.user.id]
+          });
+        });
+      }
+    };
+    $[19] = auth.user.id;
+    $[20] = queryClient;
+    $[21] = supabase;
+    $[22] = t7;
+  } else {
+    t7 = $[22];
+  }
+  const downloadAsJson = t7;
+  let t8;
+  if ($[23] !== historyQuery.data) {
+    t8 = () => historyQuery.data || [];
+    $[23] = historyQuery.data;
+    $[24] = t8;
+  } else {
+    t8 = $[24];
+  }
+  const getExportHistory = t8;
+  let t9;
+  if ($[25] !== auth.user.id || $[26] !== queryClient) {
+    t9 = () => {
+      queryClient.invalidateQueries({
+        queryKey: ["dataExportHistory", auth.user.id]
+      });
+    };
+    $[25] = auth.user.id;
+    $[26] = queryClient;
+    $[27] = t9;
+  } else {
+    t9 = $[27];
+  }
+  const refreshHistory = t9;
+  let t10;
+  if ($[28] !== downloadAsJson || $[29] !== exportMutation || $[30] !== exportMyData || $[31] !== getExportHistory || $[32] !== historyQuery || $[33] !== refreshHistory) {
+    t10 = {
+      exportMyData,
+      exportMutation,
+      downloadAsJson,
+      historyQuery,
+      getExportHistory,
+      refreshHistory,
+      isExporting: exportMutation.isPending,
+      isLoadingHistory: historyQuery.isLoading
+    };
+    $[28] = downloadAsJson;
+    $[29] = exportMutation;
+    $[30] = exportMyData;
+    $[31] = getExportHistory;
+    $[32] = historyQuery;
+    $[33] = refreshHistory;
+    $[34] = t10;
+  } else {
+    t10 = $[34];
+  }
+  return t10;
+}
+var useDataExport_default = useDataExport;
+
+// src/useBackgroundTask.tsx
+import { c as _c4 } from "react/compiler-runtime";
+import { useToast } from "@pol-studios/hooks/toast";
+function useBackgroundTask() {
+  const $ = _c4(12);
+  const supabase = useSupabase();
+  const {
+    user
+  } = useAuth();
+  const {
+    toast
+  } = useToast();
+  let t0;
+  if ($[0] !== supabase || $[1] !== toast || $[2] !== user) {
+    t0 = async function startTask2(request) {
+      if (user == null) {
+        return;
+      }
+      const taskResponse = await supabase.schema("core").from("Task").insert({
+        payload: request.body,
+        handlerId: request.handlerId,
+        title: request.title,
+        description: request.description,
+        createdBy: user.id,
+        payloadLength: JSON.stringify(request.body).length
+      }).select();
+      const task = taskResponse.data?.[0];
+      if (isUsable(task) === false) {
+        return;
+      }
+      toast({
+        title: `Task Started: ${request.title}`
+      });
+    };
+    $[0] = supabase;
+    $[1] = toast;
+    $[2] = user;
+    $[3] = t0;
+  } else {
+    t0 = $[3];
+  }
+  const startTask = t0;
+  let t1;
+  if ($[4] !== supabase) {
+    t1 = async function retryTask2(taskId) {
+      const response = await supabase.functions.invoke("trigger-update", {
+        body: {
+          taskId,
+          action: "retry"
+        }
+      });
+      console.log(response.data);
+      if (response.error) {
+        throw response.error;
+      }
+      return response.data.id;
+    };
+    $[4] = supabase;
+    $[5] = t1;
+  } else {
+    t1 = $[5];
+  }
+  const retryTask = t1;
+  let t2;
+  if ($[6] !== supabase) {
+    t2 = async function cancelTask2(taskId_0) {
+      await supabase.functions.invoke("trigger-update", {
+        body: {
+          taskId: taskId_0,
+          action: "cancel"
+        }
+      });
+    };
+    $[6] = supabase;
+    $[7] = t2;
+  } else {
+    t2 = $[7];
+  }
+  const cancelTask = t2;
+  let t3;
+  if ($[8] !== cancelTask || $[9] !== retryTask || $[10] !== startTask) {
+    t3 = {
+      startTask,
+      retryTask,
+      cancelTask
+    };
+    $[8] = cancelTask;
+    $[9] = retryTask;
+    $[10] = startTask;
+    $[11] = t3;
+  } else {
+    t3 = $[11];
+  }
+  return t3;
+}
+
+// src/useUserMetadata.tsx
+import { c as _c5 } from "react/compiler-runtime";
+function useUserMetadata(key) {
+  const $ = _c5(16);
+  const supabase = useSupabase();
+  const {
+    user
+  } = useAuth();
+  let t0;
+  if ($[0] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t0 = {
+      invalidateTables: ["UserMetadata"]
+    };
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  const upsertMutation = useDbUpsert("UserMetadata", t0);
+  let t1;
+  if ($[1] !== key || $[2] !== supabase || $[3] !== user?.id) {
+    t1 = supabase.from("UserMetadata").select().eq("userId", user?.id).eq("key", key).maybeSingle();
+    $[1] = key;
+    $[2] = supabase;
+    $[3] = user?.id;
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  let t2;
+  if ($[5] !== user) {
+    t2 = isUsable(user);
+    $[5] = user;
+    $[6] = t2;
+  } else {
+    t2 = $[6];
+  }
+  let t3;
+  if ($[7] !== t2) {
+    t3 = {
+      crossOrganization: true,
+      enabled: t2
+    };
+    $[7] = t2;
+    $[8] = t3;
+  } else {
+    t3 = $[8];
+  }
+  const lastOpenRequest = useDbQuery(t1, t3);
+  let t4;
+  if ($[9] !== key || $[10] !== upsertMutation || $[11] !== user) {
+    t4 = async function setMetadata2(value) {
+      const newValue = {
+        userId: user.id,
+        key,
+        value
+      };
+      await upsertMutation.mutateAsync(newValue);
+    };
+    $[9] = key;
+    $[10] = upsertMutation;
+    $[11] = user;
+    $[12] = t4;
+  } else {
+    t4 = $[12];
+  }
+  const setMetadata = t4;
+  let t5;
+  if ($[13] !== lastOpenRequest || $[14] !== setMetadata) {
+    t5 = [lastOpenRequest, setMetadata];
+    $[13] = lastOpenRequest;
+    $[14] = setMetadata;
+    $[15] = t5;
+  } else {
+    t5 = $[15];
+  }
+  return t5;
+}
+
+// src/storage/useStorageUpload.ts
+import { c as _c6 } from "react/compiler-runtime";
+import { useMutation as useMutation4 } from "@tanstack/react-query";
+import { Upload } from "tus-js-client";
+async function uploadFileWithMetadata(supabase, bucketName, filePath, file, metadata, onProgress) {
+  const {
+    data: {
+      session
+    }
+  } = await supabase.auth.getSession();
+  if (!session) {
+    throw new Error("User must be logged in to upload files");
+  }
+  const contentType = "type" in file ? file.type : metadata.contentType ?? "application/octet-stream";
+  return new Promise((resolve, reject) => {
+    const upload = new Upload(file, {
+      endpoint: `${getSupabaseUrl()}/storage/v1/upload/resumable`,
+      retryDelays: [0, 3e3, 5e3, 1e4, 2e4],
+      headers: {
+        authorization: `Bearer ${session.access_token}`,
+        "x-upsert": "true"
+      },
+      uploadDataDuringCreation: true,
+      removeFingerprintOnSuccess: true,
+      metadata: {
+        bucketName,
+        objectName: filePath,
+        contentType,
+        cacheControl: "3600",
+        // Custom metadata gets stored in storage.objects.metadata
+        ...Object.fromEntries(Object.entries(metadata).map(([k, v]) => [k, String(v)]))
+      },
+      chunkSize: 6 * 1024 * 1024,
+      // 6MB - required by Supabase
+      onError: (error) => {
+        console.error("Upload failed:", error);
+        reject(error);
+      },
+      onProgress,
+      onSuccess: () => {
+        resolve();
+      }
+    });
+    upload.findPreviousUploads().then((previousUploads) => {
+      if (previousUploads.length) {
+        upload.resumeFromPreviousUpload(previousUploads[0]);
+      }
+      upload.start();
+    });
+  });
+}
+function useStorageUpload(options) {
+  const $ = _c6(3);
+  const {
+    bucketId
+  } = options;
+  const supabase = useSupabase();
+  let t0;
+  if ($[0] !== bucketId || $[1] !== supabase) {
+    t0 = {
+      mutationFn: async (input) => {
+        const {
+          file,
+          fileName,
+          directory,
+          metadata: t1,
+          onUploadProgress
+        } = input;
+        const metadata = t1 === void 0 ? {} : t1;
+        const originalFileName = fileName ?? ("name" in file ? file.name : "") ?? ("fileName" in file ? file.fileName : "file");
+        if (isNullOrWhitespace(originalFileName)) {
+          throw new Error("File must have a valid name");
+        }
+        const extension = originalFileName.split(".").pop() ?? "";
+        const uniqueFileName = `${newUuid()}.${extension}`;
+        const path = directory ? `${directory}/14/${uniqueFileName}` : `14/${uniqueFileName}`;
+        const contentType = "type" in file ? file.type.split("/").pop()?.toUpperCase() ?? "Unknown" : extension.toUpperCase();
+        const uploadMetadata = {
+          processingStatus: "None",
+          contentType,
+          originalFileName,
+          ...metadata
+        };
+        await uploadFileWithMetadata(supabase, bucketId, path, file, uploadMetadata, onUploadProgress);
+        return {
+          path,
+          bucketId,
+          originalFileName,
+          contentType
+        };
+      }
+    };
+    $[0] = bucketId;
+    $[1] = supabase;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  return useMutation4(t0);
+}
+function useStorageUploadWithEntity(options) {
+  const $ = _c6(6);
+  let updateEntity;
+  let uploadOptions;
+  if ($[0] !== options) {
+    const {
+      pathField,
+      updateEntity: t02,
+      ...t1
+    } = options;
+    updateEntity = t02;
+    uploadOptions = t1;
+    $[0] = options;
+    $[1] = updateEntity;
+    $[2] = uploadOptions;
+  } else {
+    updateEntity = $[1];
+    uploadOptions = $[2];
+  }
+  const uploadMutation = useStorageUpload(uploadOptions);
+  let t0;
+  if ($[3] !== updateEntity || $[4] !== uploadMutation) {
+    t0 = {
+      mutationFn: async (input) => {
+        const {
+          entity,
+          ...uploadInput
+        } = input;
+        const result = await uploadMutation.mutateAsync(uploadInput);
+        await updateEntity(entity, result.path);
+        return result;
+      }
+    };
+    $[3] = updateEntity;
+    $[4] = uploadMutation;
+    $[5] = t0;
+  } else {
+    t0 = $[5];
+  }
+  return useMutation4(t0);
+}
+export {
+  UserMetadataContextProvider,
+  recordConsentForUser,
+  useAccountDeletion,
+  useBackgroundTask,
+  useConsent_default as useConsent,
+  useDataExport_default as useDataExport,
+  useLiveChangesIndicator,
+  useSetUserMetadata,
+  useStorageUpload,
+  useStorageUploadWithEntity,
+  useUserMetadata,
+  useUserMetadataState,
+  useUserMetadataValue,
+  useUserStatus,
+  userMetadataContext
+};
+//# sourceMappingURL=index.js.map