@jmruthers/pace-core 0.6.9 → 0.6.11

package/dist/chunk-4DDCYDQ3.js

@@ -1,544 +0,0 @@
-import { generateFilePath, generateUniqueFileName, extractFileMetadata, uploadFile, getPublicUrl, getSignedUrl, deleteFile, downloadFile, listFiles, archiveFile } from './chunk-MPBLMWVR.js';
-import { useOrganisationSecurity, usePublicPageContext } from './chunk-EF2UGZWY.js';
-import { useOrganisations } from './chunk-T5CVK4R3.js';
-import { assertOrganisationId } from './chunk-4SXLQIZO.js';
-import { createLogger, logger } from './chunk-TTRFSOKR.js';
-import { useForm } from 'react-hook-form';
-import { zodResolver } from '@hookform/resolvers/zod';
-import { useState, useMemo, useCallback, useEffect } from 'react';
-import { createClient } from '@supabase/supabase-js';
-import { useParams, useLocation } from 'react-router-dom';
-
-function useZodForm({
-  schema,
-  defaultValues,
-  mode = "onSubmit"
-}) {
-  return useForm({
-    resolver: zodResolver(schema),
-    defaultValues,
-    mode
-  });
-}
-function useFormDialog({
-  onOpenChange,
-  resetOnClose = true
-} = {}) {
-  const [isOpen, setIsOpen] = useState(false);
-  const [formData, setFormData] = useState(null);
-  const openDialog = (data = null) => {
-    setFormData(data);
-    setIsOpen(true);
-    onOpenChange?.(true);
-  };
-  const closeDialog = () => {
-    setIsOpen(false);
-    if (resetOnClose) {
-      setFormData(null);
-    }
-    onOpenChange?.(false);
-  };
-  const handleOpenChange = (open) => {
-    setIsOpen(open);
-    if (!open && resetOnClose) {
-      setFormData(null);
-    }
-    onOpenChange?.(open);
-  };
-  return {
-    isOpen,
-    formData,
-    openDialog,
-    closeDialog,
-    handleOpenChange
-  };
-}
-function useOrganisationPermissions(orgId) {
-  const {
-    selectedOrganisation,
-    getUserRole,
-    validateOrganisationAccess,
-    ensureOrganisationContext
-  } = useOrganisations();
-  const organisationSecurity = useOrganisationSecurity();
-  const superAdminContext = organisationSecurity.superAdminContext;
-  const organisationId = useMemo(() => {
-    if (orgId) {
-      return orgId;
-    }
-    try {
-      const currentOrg = ensureOrganisationContext();
-      return currentOrg.id;
-    } catch {
-      return "";
-    }
-  }, [orgId, ensureOrganisationContext]);
-  const userRole = useMemo(() => {
-    if (!organisationId) return "no_access";
-    const role = getUserRole(organisationId);
-    if (role === "org_admin" || role === "leader" || role === "member" || role === "supporter") {
-      return role;
-    }
-    return "no_access";
-  }, [organisationId, getUserRole]);
-  const hasOrganisationAccess = useMemo(() => {
-    if (!organisationId) return false;
-    return validateOrganisationAccess(organisationId);
-  }, [organisationId, validateOrganisationAccess]);
-  const permissions = useMemo(() => {
-    if (!hasOrganisationAccess || userRole === "no_access") {
-      return {
-        isOrgAdmin: false,
-        isSuperAdmin: false,
-        canModerate: false,
-        canManageMembers: false,
-        canManageSettings: false,
-        canManageEvents: false,
-        hasAdminPrivileges: false
-      };
-    }
-    const isOrgAdmin = userRole === "org_admin";
-    const isLeader = userRole === "leader";
-    const isSuperAdmin = superAdminContext.isSuperAdmin;
-    return {
-      isOrgAdmin,
-      isSuperAdmin,
-      canModerate: isSuperAdmin || isOrgAdmin || isLeader,
-      canManageMembers: isSuperAdmin || isOrgAdmin || isLeader,
-      // Leaders can manage members
-      canManageSettings: isSuperAdmin || isOrgAdmin,
-      canManageEvents: isSuperAdmin || isOrgAdmin || isLeader,
-      hasAdminPrivileges: isSuperAdmin || isOrgAdmin || isLeader
-      // Leaders have admin privileges
-    };
-  }, [hasOrganisationAccess, userRole]);
-  const hasPermission = useMemo(() => {
-    return (permission) => {
-      if (!hasOrganisationAccess || userRole === "no_access") {
-        return false;
-      }
-      if (userRole === "org_admin" || permission === "*") {
-        return true;
-      }
-      const rolePermissions = {
-        supporter: ["view_basic"],
-        member: ["view_basic", "view_details"],
-        leader: ["view_basic", "view_details", "moderate_content", "manage_events"],
-        org_admin: ["view_basic", "view_details", "moderate_content", "manage_events", "manage_members", "manage_settings"]
-      };
-      const userPermissions = rolePermissions[userRole] || [];
-      return userPermissions.includes(permission) || userPermissions.includes("*");
-    };
-  }, [hasOrganisationAccess, userRole]);
-  const getAllPermissions = useMemo(() => {
-    return () => {
-      if (!hasOrganisationAccess || userRole === "no_access") {
-        return [];
-      }
-      const rolePermissions = {
-        supporter: ["view_basic"],
-        member: ["view_basic", "view_details"],
-        leader: ["view_basic", "view_details", "moderate_content", "manage_events"],
-        org_admin: ["view_basic", "view_details", "moderate_content", "manage_events", "manage_members", "manage_settings"]
-      };
-      return rolePermissions[userRole] || [];
-    };
-  }, [hasOrganisationAccess, userRole]);
-  return useMemo(() => ({
-    userRole,
-    organisationId,
-    hasOrganisationAccess,
-    hasPermission,
-    getAllPermissions,
-    ...permissions
-  }), [userRole, organisationId, hasOrganisationAccess, hasPermission, getAllPermissions, permissions]);
-}
-
-// src/utils/storage/index.ts
-var StorageUtils = class {
-};
-StorageUtils.generateFilePath = generateFilePath;
-StorageUtils.generateUniqueFileName = generateUniqueFileName;
-StorageUtils.extractFileMetadata = extractFileMetadata;
-StorageUtils.uploadFile = uploadFile;
-StorageUtils.getPublicUrl = getPublicUrl;
-StorageUtils.getSignedUrl = getSignedUrl;
-StorageUtils.deleteFile = deleteFile;
-StorageUtils.downloadFile = downloadFile;
-StorageUtils.listFiles = listFiles;
-StorageUtils.archiveFile = archiveFile;
-var publicDataCache = /* @__PURE__ */ new Map();
-function usePublicEvent(eventCode, options = {}) {
-  const {
-    cacheTtl = 5 * 60 * 1e3,
-    // 5 minutes
-    enableCache = true
-  } = options;
-  const [event, setEvent] = useState(null);
-  const [isLoading, setIsLoading] = useState(true);
-  const [error, setError] = useState(null);
-  const publicPageContext = usePublicPageContext();
-  const environment = publicPageContext.environment;
-  const supabase = useMemo(() => {
-    if (typeof window === "undefined") return null;
-    if (!environment.supabaseUrl || !environment.supabaseKey) {
-      logger.warn("usePublicEvent", "Missing Supabase environment variables. Please ensure VITE_SUPABASE_URL and VITE_SUPABASE_PUBLISHABLE_KEY are set in your environment.");
-      return null;
-    }
-    return createClient(environment.supabaseUrl, environment.supabaseKey);
-  }, [environment.supabaseUrl, environment.supabaseKey]);
-  const fetchEvent = useCallback(async () => {
-    if (!eventCode || !supabase) {
-      setError(new Error("Invalid event code or Supabase client not available"));
-      setIsLoading(false);
-      return;
-    }
-    const cacheKey = `public_event_${eventCode}`;
-    if (enableCache) {
-      const cached = publicDataCache.get(cacheKey);
-      if (cached && Date.now() - cached.timestamp < cached.ttl) {
-        setEvent(cached.data);
-        setIsLoading(false);
-        setError(null);
-        return;
-      }
-    }
-    try {
-      setIsLoading(true);
-      setError(null);
-      const tableResponse = await supabase.from("core_events").select(`
-          event_id,
-          event_name,
-          event_date,
-          event_venue,
-          event_participants,
-          event_colours,
-          organisation_id,
-          event_days,
-          event_typicalunit,
-          event_rounddown,
-          event_youthmultiplier,
-          event_catering_email,
-          event_news,
-          event_billing,
-          event_email
-        `).eq("event_code", eventCode).eq("is_visible", true).not("organisation_id", "is", null).limit(1).single();
-      const tableData = tableResponse?.data;
-      const tableError = tableResponse?.error;
-      if (tableError) {
-        const errorMessage = tableError.message === "No rows found" || tableError.code === "PGRST116" ? "Event not found" : tableError?.message || "Failed to fetch event from table";
-        throw new Error(errorMessage);
-      }
-      if (!tableData) {
-        setEvent(null);
-        setError(new Error("Event not found"));
-        return;
-      }
-      const logoResponse = await supabase.from("core_file_references").select("file_path").eq("table_name", "core_events").eq("record_id", tableData.event_id).eq("is_public", true).eq("file_metadata->>category", "event_logos").limit(1).single();
-      const logoData = logoResponse?.data;
-      const eventData = {
-        ...tableData,
-        event_logo: logoData?.file_path || null
-      };
-      const transformedEvent = {
-        id: eventData.event_id,
-        event_id: eventData.event_id,
-        event_name: eventData.event_name,
-        event_code: eventCode,
-        event_date: eventData.event_date,
-        event_venue: eventData.event_venue,
-        event_participants: eventData.event_participants,
-        event_logo: eventData.event_logo,
-        event_colours: eventData.event_colours,
-        organisation_id: assertOrganisationId(eventData.organisation_id),
-        is_visible: true,
-        created_at: (/* @__PURE__ */ new Date()).toISOString(),
-        updated_at: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      setEvent(transformedEvent);
-      if (enableCache) {
-        publicDataCache.set(cacheKey, {
-          data: transformedEvent,
-          timestamp: Date.now(),
-          ttl: cacheTtl
-        });
-      }
-    } catch (err) {
-      logger.error("usePublicEvent", "Error fetching event:", err);
-      const error2 = err instanceof Error ? err : new Error("Unknown error occurred");
-      setError(error2);
-      setEvent(null);
-    } finally {
-      setIsLoading(false);
-    }
-  }, [eventCode, supabase, cacheTtl, enableCache]);
-  useEffect(() => {
-    fetchEvent();
-  }, [fetchEvent]);
-  const refetch = useCallback(async () => {
-    if (enableCache) {
-      const cacheKey = `public_event_${eventCode}`;
-      publicDataCache.delete(cacheKey);
-    }
-    await fetchEvent();
-  }, [fetchEvent, eventCode, enableCache]);
-  return {
-    event,
-    isLoading,
-    error,
-    refetch
-  };
-}
-function clearPublicEventCache() {
-  for (const [key] of publicDataCache) {
-    if (key.startsWith("public_event_")) {
-      publicDataCache.delete(key);
-    }
-  }
-}
-function getPublicEventCacheStats() {
-  const keys = Array.from(publicDataCache.keys()).filter((key) => key.startsWith("public_event_"));
-  return {
-    size: keys.length,
-    keys
-  };
-}
-var log = createLogger("usePublicEventLogo");
-var publicDataCache2 = /* @__PURE__ */ new Map();
-function defaultGenerateFallbackText(eventName) {
-  if (!eventName) return "EV";
-  return eventName.split(" ").map((word) => word.charAt(0).toUpperCase()).join("").substring(0, 3);
-}
-function usePublicEventLogo(eventId, eventName, organisationId, options) {
-  const {
-    cacheTtl = 30 * 60 * 1e3,
-    // 30 minutes
-    enableCache = true,
-    validateImage = true,
-    generateFallbackText = defaultGenerateFallbackText,
-    supabase
-  } = options;
-  const [logoUrl, setLogoUrl] = useState(null);
-  const [isLoading, setIsLoading] = useState(false);
-  const [error, setError] = useState(null);
-  const fallbackText = useMemo(() => {
-    return eventName ? generateFallbackText(eventName) : "EV";
-  }, [eventName, generateFallbackText]);
-  const fetchLogo = useCallback(async () => {
-    if (!eventId || !organisationId || !supabase) {
-      setLogoUrl(null);
-      setIsLoading(false);
-      return;
-    }
-    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-    if (!uuidRegex.test(organisationId)) {
-      log.warn("Invalid organisationId format (not a valid UUID):", organisationId);
-    }
-    const cacheKey = `public_logo_${eventId}_${organisationId}`;
-    if (enableCache) {
-      const cached = publicDataCache2.get(cacheKey);
-      if (cached && Date.now() - cached.timestamp < cached.ttl) {
-        setLogoUrl(cached.data);
-        setIsLoading(false);
-        setError(null);
-        return;
-      }
-    }
-    try {
-      setIsLoading(true);
-      setError(null);
-      const { data: logoData, error: queryError } = await supabase.from("core_file_references").select("file_path").eq("table_name", "core_events").eq("record_id", eventId).eq("is_public", true).eq("file_metadata->>category", "event_logos").limit(1).single();
-      if (queryError) {
-        if (queryError.code === "PGRST116") {
-          setLogoUrl(null);
-          return;
-        }
-        throw new Error(queryError.message || "Failed to fetch logo");
-      }
-      if (!logoData || !logoData.file_path) {
-        setLogoUrl(null);
-        return;
-      }
-      const logoUrl2 = logoData.file_path;
-      if (validateImage) {
-        try {
-          const response = await fetch(logoUrl2, { method: "HEAD" });
-          if (!response.ok) {
-            log.warn("Logo URL not accessible:", logoUrl2);
-            setLogoUrl(null);
-            return;
-          }
-        } catch (fetchError) {
-          log.warn("Error validating logo URL:", fetchError);
-          setLogoUrl(null);
-          return;
-        }
-      }
-      setLogoUrl(logoUrl2);
-      if (enableCache) {
-        publicDataCache2.set(cacheKey, {
-          data: logoUrl2,
-          timestamp: Date.now(),
-          ttl: cacheTtl
-        });
-      }
-    } catch (err) {
-      log.error("Error fetching logo:", err);
-      const error2 = err instanceof Error ? err : new Error("Unknown error occurred");
-      setError(error2);
-      setLogoUrl(null);
-    } finally {
-      setIsLoading(false);
-    }
-  }, [eventId, organisationId, supabase, cacheTtl, enableCache, validateImage]);
-  useEffect(() => {
-    if (eventId && organisationId) {
-      fetchLogo();
-    } else {
-      setLogoUrl(null);
-      setIsLoading(false);
-      setError(null);
-    }
-  }, [fetchLogo, eventId, organisationId]);
-  const refetch = useCallback(async () => {
-    if (!eventId || !organisationId) return;
-    if (enableCache) {
-      const cacheKey = `public_logo_${eventId}_${organisationId}`;
-      publicDataCache2.delete(cacheKey);
-    }
-    await fetchLogo();
-  }, [fetchLogo, eventId, organisationId, enableCache]);
-  return {
-    logoUrl,
-    fallbackText,
-    isLoading,
-    error,
-    refetch
-  };
-}
-function clearPublicLogoCache() {
-  for (const [key] of publicDataCache2) {
-    if (key.startsWith("public_logo_")) {
-      publicDataCache2.delete(key);
-    }
-  }
-}
-function getPublicLogoCacheStats() {
-  const keys = Array.from(publicDataCache2.keys()).filter((key) => key.startsWith("public_logo_"));
-  return {
-    size: keys.length,
-    keys
-  };
-}
-function validateEventCodeFormat(eventCode) {
-  if (!eventCode || typeof eventCode !== "string") return false;
-  if (eventCode.length < 2 || eventCode.length > 50) return false;
-  if (eventCode.length === 2) {
-    return /^[a-zA-Z0-9]{2}$/.test(eventCode);
-  }
-  const eventCodeRegex = /^[a-zA-Z0-9][a-zA-Z0-9_-]{1,48}[a-zA-Z0-9]$/;
-  const matchesFormat = eventCodeRegex.test(eventCode);
-  if (!matchesFormat) return false;
-  if (eventCode.includes("--") || eventCode.includes("__") || eventCode.includes("-_") || eventCode.includes("_-")) {
-    return false;
-  }
-  return true;
-}
-function usePublicRouteParams(options = {}) {
-  const {
-    fetchEventData = true,
-    eventCodeParam = "eventCode",
-    validateEventCode = true
-  } = options;
-  const params = useParams();
-  useLocation();
-  const [error, setError] = useState(null);
-  const eventCode = useMemo(() => {
-    const code = params[eventCodeParam];
-    if (!code) {
-      return null;
-    }
-    if (validateEventCode && !validateEventCodeFormat(code)) {
-      setError(new Error(`Invalid event code format: ${code}`));
-      return null;
-    }
-    setError(null);
-    return code;
-  }, [params, eventCodeParam, validateEventCode]);
-  const {
-    event,
-    isLoading: eventLoading,
-    error: eventError,
-    refetch: refetchEvent
-  } = usePublicEvent(eventCode || "", {
-    enableCache: true,
-    cacheTtl: 5 * 60 * 1e3
-    // 5 minutes
-  });
-  const isLoading = useMemo(() => {
-    if (!fetchEventData) return false;
-    return eventLoading;
-  }, [fetchEventData, eventLoading]);
-  const finalError = useMemo(() => {
-    if (error) return error;
-    if (!validateEventCode) return null;
-    if (fetchEventData && eventError) return eventError;
-    return null;
-  }, [error, eventError, fetchEventData, validateEventCode]);
-  const eventId = useMemo(() => {
-    if (!fetchEventData || !event) return null;
-    return event.event_id || event.id;
-  }, [fetchEventData, event]);
-  const refetch = useCallback(async () => {
-    if (!fetchEventData) return;
-    await refetchEvent();
-  }, [fetchEventData, refetchEvent]);
-  return {
-    eventCode,
-    eventId,
-    event: fetchEventData ? event : null,
-    isLoading,
-    error: finalError,
-    refetch
-  };
-}
-function usePublicEventCode(eventCodeParam = "eventCode") {
-  const params = useParams();
-  const eventCode = useMemo(() => {
-    const code = params[eventCodeParam];
-    if (!code) {
-      return null;
-    }
-    if (!validateEventCodeFormat(code)) {
-      return null;
-    }
-    return code;
-  }, [params, eventCodeParam]);
-  const error = useMemo(() => {
-    if (!eventCode) {
-      return new Error(`Event code parameter '${eventCodeParam}' not found or invalid`);
-    }
-    return null;
-  }, [eventCode, eventCodeParam]);
-  return {
-    eventCode,
-    error
-  };
-}
-function generatePublicRoutePath(eventCode, pageName = "index") {
-  if (!eventCode || !validateEventCodeFormat(eventCode)) {
-    throw new Error("Invalid event code for route generation");
-  }
-  return `/public/event/${eventCode}/${pageName}`;
-}
-function extractEventCodeFromPath(path) {
-  const match = path.match(/^\/public\/event\/([a-zA-Z0-9_-]{2,50})(?:\/.*)?$/);
-  if (!match) return null;
-  const eventCode = match[1];
-  if (!validateEventCodeFormat(eventCode)) {
-    return null;
-  }
-  return eventCode;
-}
-
-export { StorageUtils, clearPublicEventCache, clearPublicLogoCache, extractEventCodeFromPath, generatePublicRoutePath, getPublicEventCacheStats, getPublicLogoCacheStats, useFormDialog, useOrganisationPermissions, usePublicEvent, usePublicEventCode, usePublicEventLogo, usePublicRouteParams, useZodForm };