@jmruthers/pace-core 0.6.10 → 0.6.11

package/dist/{usePublicRouteParams-G3Ks53mk.d.ts → usePublicRouteParams-BgV6VhMi.d.ts}

@@ -1,10 +1,73 @@
+import { h as Event, u as OrganisationRole, v as OrganisationPermission, S as SuperAdminContext } from './event-BfCox3N2.js';
 import * as react_hook_form from 'react-hook-form';
 import { DefaultValues } from 'react-hook-form';
 import { z } from 'zod';
-import { l as OrganisationRole, m as OrganisationPermission, S as SuperAdminContext, E as Event } from './event-WTAQuGcq.js';
 import { SupabaseClient } from '@supabase/supabase-js';
-import { D as Database } from './database.generated-DT8JTZiP.js';
-import { F as FileCategory, a as FileReference } from './file-reference-BavO2eQj.js';
+import { D as Database } from './database.generated-qkdoiVrJ.js';
+import { F as FileCategory, a as FileReference } from './file-reference-DU1hcawx.js';
+
+/**
+ * @file Event Hook
+ * @package @jmruthers/pace-core
+ * @module Hooks
+ * @since 0.1.0
+ *
+ * Convenience hook for accessing event context.
+ * This hook provides a simple interface for working with events.
+ *
+ * Note: This is a convenience wrapper around the EventService.
+ * For better performance, consider using useEventService directly.
+ */
+
+/**
+ * Optional event context hook that never throws.
+ * Use when a component must work with or without EventServiceProvider (e.g. PaceAppLayout).
+ *
+ * @returns `{ selectedEvent: Event | null }` — when provider is absent, `selectedEvent` is always null.
+ * @example
+ * const { selectedEvent } = useOptionalEvents();
+ * // selectedEvent is null when outside EventServiceProvider; otherwise the current selected event.
+ */
+declare function useOptionalEvents(): {
+    selectedEvent: Event | null;
+};
+interface EventContextType {
+    events: Event[];
+    selectedEvent: Event | null;
+    isLoading: boolean;
+    error: Error | null;
+    setSelectedEvent: (event: Event | null) => void;
+    refreshEvents: () => Promise<void>;
+    clearEventSelection: () => Promise<void>;
+}
+/**
+ * Hook to access event context
+ *
+ * @returns Event context with events, selected event, and helper methods
+ * @throws {Error} If used outside EventServiceProvider
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { events, selectedEvent, setSelectedEvent } = useEvents();
+ *
+ *   return (
+ *     <nav>
+ *       <ul>
+ *         {events.map(event => (
+ *           <li key={event.id}>
+ *             <button onClick={() => setSelectedEvent(event)}>
+ *               {event.event_name}
+ *             </button>
+ *           </li>
+ *         ))}
+ *       </ul>
+ *     </nav>
+ *   );
+ * }
+ * ```
+ */
+declare function useEvents(): EventContextType;
 
 interface UseZodFormProps<T extends z.ZodTypeAny> {
     schema: T;
@@ -393,6 +456,12 @@ interface StorageUploadResult {
     metadata?: StorageFileMetadata;
     error?: string;
 }
+/** Success payload for uploadFile when using ApiResult. */
+interface StorageUploadSuccess {
+    path: string;
+    publicUrl?: string;
+    metadata?: StorageFileMetadata;
+}
 interface StorageUrlOptions {
     /** The app name from rbac_apps */
     appName: string;
@@ -874,4 +943,4 @@ declare function generatePublicRoutePath(eventCode: string, pageName?: string):
  */
 declare function extractEventCodeFromPath(path: string): string | null;
 
-export { type UsePublicEventReturn as A, type UsePublicEventOptions as B, type UsePublicFileDisplayReturn as C, type UsePublicFileDisplayOptions as D, type UsePublicEventLogoReturn as E, type UsePublicEventLogoOptions as F, type UsePublicRouteParamsReturn as G, type FileSizeLimits as H, type StorageConfig as I, type StorageFileMetadata as J, type StorageUrlOptions as K, type OrganisationSecurityHook as O, type StorageUploadOptions as S, type UseOrganisationPermissionsReturn as U, type StorageUploadResult as a, type StorageListOptions as b, type StorageListResult as c, type StorageFileInfo as d, useOrganisationPermissions as e, useOrganisationSecurity as f, useZodForm as g, useFormDialog as h, type UseFormDialogOptions as i, type UseFormDialogReturn as j, useAppConfig as k, type UseAppConfigReturn as l, usePublicEvent as m, clearPublicEventCache as n, getPublicEventCacheStats as o, usePublicFileDisplay as p, clearPublicFileDisplayCache as q, getPublicFileDisplayCacheStats as r, usePublicEventLogo as s, clearPublicLogoCache as t, useEventTheme as u, getPublicLogoCacheStats as v, usePublicRouteParams as w, usePublicEventCode as x, generatePublicRoutePath as y, extractEventCodeFromPath as z };
+export { generatePublicRoutePath as A, extractEventCodeFromPath as B, type UsePublicEventReturn as C, type UsePublicEventOptions as D, type EventContextType as E, type UsePublicFileDisplayReturn as F, type UsePublicFileDisplayOptions as G, type UsePublicEventLogoReturn as H, type UsePublicEventLogoOptions as I, type UsePublicRouteParamsReturn as J, type FileSizeLimits as K, type StorageConfig as L, type StorageFileMetadata as M, type StorageUploadSuccess as N, type OrganisationSecurityHook as O, type StorageUrlOptions as P, type StorageUploadOptions as S, type UseOrganisationPermissionsReturn as U, type StorageUploadResult as a, type StorageListOptions as b, type StorageListResult as c, type StorageFileInfo as d, useOptionalEvents as e, useEventTheme as f, useOrganisationPermissions as g, useOrganisationSecurity as h, useZodForm as i, useFormDialog as j, type UseFormDialogOptions as k, type UseFormDialogReturn as l, useAppConfig as m, type UseAppConfigReturn as n, usePublicEvent as o, clearPublicEventCache as p, getPublicEventCacheStats as q, usePublicFileDisplay as r, clearPublicFileDisplayCache as s, getPublicFileDisplayCacheStats as t, useEvents as u, usePublicEventLogo as v, clearPublicLogoCache as w, getPublicLogoCacheStats as x, usePublicRouteParams as y, usePublicEventCode as z };

package/dist/utils.d.ts

@@ -1,7 +1,8 @@
-import { S as SanitizationOptions } from './timezone-K-ptz3HO.js';
-export { U as DateTimeFormatOptions, q as LogLevel, L as Logger, r as LoggerConfig, O as SecureDataAccess, V as calculatePasswordStrength, g as cn, l as createBaseClient, o as createLogger, N as dateSchema, e as emailSchema, A as formatCompactNumber, x as formatCurrency, t as formatDate, Q as formatDateOnlyForDisplay, w as formatDateTime, P as formatDateTimeForDisplay, T as formatDateTimeForMap, R as formatDateTimeForTable, B as formatFileSize, C as formatInTimeZone, y as formatNumber, z as formatPercent, v as formatTime, E as formatTimeInTimeZone, H as fromZonedTime, i as getAppConfig, k as getCurrentAppId, J as getTimeZoneDifference, D as getTimezoneAbbreviation, F as getUserTimeZone, m as logger, n as nameSchema, b as passwordSchema, p as phoneSchema, M as renderSafeHtml, I as roundToNearestMinutes, c as sanitizeFormData, d as sanitizeHtml, s as sanitizeUserInput, h as setAppConfig, G as toZonedTime, a as urlSchema, u as useSessionTracking, K as validateHtml } from './timezone-K-ptz3HO.js';
+import { S as SanitizationOptions } from './timezone-BTWWXKVY.js';
+export { U as DateTimeFormatOptions, q as LogLevel, L as Logger, r as LoggerConfig, O as SecureDataAccess, V as calculatePasswordStrength, g as cn, l as createBaseClient, o as createLogger, N as dateSchema, e as emailSchema, A as formatCompactNumber, x as formatCurrency, t as formatDate, Q as formatDateOnlyForDisplay, w as formatDateTime, P as formatDateTimeForDisplay, T as formatDateTimeForMap, R as formatDateTimeForTable, B as formatFileSize, C as formatInTimeZone, y as formatNumber, z as formatPercent, v as formatTime, E as formatTimeInTimeZone, H as fromZonedTime, i as getAppConfig, k as getCurrentAppId, J as getTimeZoneDifference, D as getTimezoneAbbreviation, F as getUserTimeZone, m as logger, n as nameSchema, b as passwordSchema, p as phoneSchema, M as renderSafeHtml, I as roundToNearestMinutes, c as sanitizeFormData, d as sanitizeHtml, s as sanitizeUserInput, h as setAppConfig, G as toZonedTime, a as urlSchema, u as useSessionTracking, K as validateHtml } from './timezone-BTWWXKVY.js';
 import { SupabaseClient } from '@supabase/supabase-js';
-import { D as Database } from './database.generated-DT8JTZiP.js';
+import { D as Database } from './database.generated-qkdoiVrJ.js';
+import { A as ApiResult } from './api-result-USV1Czr-.js';
 export { g as changePasswordSchema, t as combineSchemas, i as contactFormSchema, l as loginSchema, f as passwordResetSchema, q as pickSchema, r as registrationSchema, c as secureLoginSchema, s as securePasswordSchema, h as userProfileSchema } from './validation-g5n0hDkh.js';
 import { z } from 'zod';
 export { u as useComponentPerformance } from './useComponentPerformance-DE9l5RkL.js';
@@ -113,24 +114,24 @@ declare function getCurrentAppNameWithFallback(fallback?: string): string;
  *
  * @param supabase - Supabase client instance
  * @param appName - The app name to resolve
- * @returns Promise resolving to the app ID or null if not found
+ * @returns Promise resolving to ApiResult with app ID or null if not found
  */
-declare function getAppId(supabase: SupabaseClient<Database>, appName: string): Promise<string | null>;
+declare function getAppId(supabase: SupabaseClient<Database>, appName: string): Promise<ApiResult<string | null>>;
 /**
  * Resolves multiple app names to their corresponding app IDs
  *
  * @param supabase - Supabase client instance
  * @param appNames - Array of app names to resolve
- * @returns Promise resolving to a map of app names to app IDs
+ * @returns Promise resolving to ApiResult with map of app names to app IDs
  */
-declare function getAppIds(supabase: SupabaseClient<Database>, appNames: string[]): Promise<Record<string, string | null>>;
+declare function getAppIds(supabase: SupabaseClient<Database>, appNames: string[]): Promise<ApiResult<Record<string, string | null>>>;
 /**
  * Cached app ID resolver with TTL
  */
 declare class CachedAppIdResolver {
     private cache;
     private ttl;
-    getAppId(supabase: SupabaseClient<Database>, appName: string): Promise<string | null>;
+    getAppId(supabase: SupabaseClient<Database>, appName: string): Promise<ApiResult<string | null>>;
     clearCache(): void;
     clearCacheForApp(appName: string): void;
 }
@@ -244,6 +245,7 @@ declare const usernameSchema: z.ZodPipeline<z.ZodEffects<z.ZodString, string, st
  * @file CSRF Protection Implementation
  * @description Session-based CSRF token management with security enhancements
  */
+
 interface CSRFTokenData {
     token: string;
     sessionId: string;
@@ -257,15 +259,15 @@ declare class CSRFManager {
     /**
      * Generate a new CSRF token for the current session
      */
-    generateToken(sessionId: string): Promise<string>;
+    generateToken(sessionId: string): Promise<ApiResult<string>>;
     /**
      * Validate and consume a CSRF token
      */
-    validateToken(token: string, sessionId: string): Promise<boolean>;
+    validateToken(token: string, sessionId: string): Promise<ApiResult<boolean>>;
     /**
-     * Get current valid token for session
+     * Get current valid token for session (finds existing or generates new)
      */
-    getCurrentToken(sessionId: string): Promise<string | null>;
+    getCurrentToken(sessionId: string): Promise<ApiResult<string>>;
     /**
      * Clean up expired and used tokens
      */
@@ -281,12 +283,12 @@ declare class CSRFManager {
     /**
      * Clear all tokens for session
      */
-    clearSession(sessionId: string): Promise<void>;
+    clearSession(sessionId: string): Promise<ApiResult<void>>;
 }
 declare const csrfManager: CSRFManager;
-declare function generateCSRFToken(sessionId: string): Promise<string>;
-declare function validateCSRFToken(token: string, sessionId: string): Promise<boolean>;
-declare function getCSRFToken(sessionId: string): Promise<string | null>;
+declare function generateCSRFToken(sessionId: string): Promise<ApiResult<string>>;
+declare function validateCSRFToken(token: string, sessionId: string): Promise<ApiResult<boolean>>;
+declare function getCSRFToken(sessionId: string): Promise<ApiResult<string>>;
 
 /**
  * @file SQL Injection Protection
@@ -702,23 +704,23 @@ declare function validateDeviceFingerprint(storedFingerprint: DeviceFingerprint,
  *
  * @param supabase - Supabase client instance (unused)
  * @param organisationId - The organisation ID (unused)
- * @returns Promise that resolves immediately
+ * @returns Promise that resolves to ApiResult<void>
  */
-declare function setOrganisationContext(_supabase: SupabaseClient, _organisationId: string): Promise<void>;
+declare function setOrganisationContext(_supabase: SupabaseClient, _organisationId: string): Promise<ApiResult<void>>;
 /**
  * Clear organisation context from the database session
  *
  * @param supabase - Supabase client instance
- * @returns Promise that resolves when context is cleared
+ * @returns Promise that resolves to ApiResult<void>
  */
-declare function clearOrganisationContext(supabase: SupabaseClient): Promise<void>;
+declare function clearOrganisationContext(supabase: SupabaseClient): Promise<ApiResult<void>>;
 /**
  * Get current organisation context from the database session
  *
  * @param supabase - Supabase client instance
- * @returns Promise that resolves to the current organisation ID or null
+ * @returns Promise that resolves to ApiResult<string | null>
  */
-declare function getOrganisationContext(supabase: SupabaseClient): Promise<string | null>;
+declare function getOrganisationContext(supabase: SupabaseClient): Promise<ApiResult<string | null>>;
 /**
  * Check if organisation context functions are available in the database
  *
@@ -726,9 +728,9 @@ declare function getOrganisationContext(supabase: SupabaseClient): Promise<strin
  * Organisation context is now handled via secure client and explicit parameters.
  *
  * @param supabase - Supabase client instance (unused)
- * @returns Promise that resolves to false
+ * @returns Promise that resolves to ApiResult<boolean>
  */
-declare function isOrganisationContextAvailable(_supabase: SupabaseClient): Promise<boolean>;
+declare function isOrganisationContextAvailable(_supabase: SupabaseClient): Promise<ApiResult<boolean>>;
 
 /**
  * @file Location Utilities
@@ -858,31 +860,21 @@ declare function getGoogleMapsUrl(coords?: Coordinates): string;
  * @param query - Search query string
  * @param apiKey - Google Places API key
  * @param options - Optional autocomplete options
- * @returns Promise resolving to array of predictions
+ * @returns Promise resolving to ApiResult with array of predictions
  *
  * @example
  * ```ts
- * const predictions = await fetchPlaceAutocomplete(
+ * const result = await fetchPlaceAutocomplete(
  *   '123 Main St',
  *   'your-api-key',
  *   { components: 'country:au' }
  * );
+ * if (result.ok) console.log(result.data);
  * ```
  */
-declare function fetchPlaceAutocomplete(query: string, apiKey: string, options?: AutocompleteOptions): Promise<GooglePlaceAutocompletePrediction[]>;
-/**
- * Fetch place details from Google Places API
- *
- * @param placeId - Google Place ID
- * @param apiKey - Google Places API key
- * @returns Promise resolving to place details
- *
- * @example
- * ```ts
- * const place = await fetchPlaceDetails('ChIJ...', 'your-api-key');
- * ```
- */
-declare function fetchPlaceDetails(placeId: string, apiKey: string): Promise<{
+declare function fetchPlaceAutocomplete(query: string, apiKey: string, options?: AutocompleteOptions): Promise<ApiResult<GooglePlaceAutocompletePrediction[]>>;
+/** Place details shape from Google Places API */
+type PlaceDetails = {
     place_id: string;
     formatted_address?: string;
     address_components?: Array<{
@@ -896,7 +888,12 @@ declare function fetchPlaceDetails(placeId: string, apiKey: string): Promise<{
             lng: () => number;
         };
     };
-}>;
+};
+/**
+ * Fetch place details from Google Places API.
+ * @returns Promise resolving to ApiResult with place details
+ */
+declare function fetchPlaceDetails(placeId: string, apiKey: string): Promise<ApiResult<PlaceDetails>>;
 /**
  * Parse address components from Google Places API response
  *
@@ -942,15 +939,15 @@ declare function createAddressFromPlaceResult(place: {
  *
  * @param placeId - Google Place ID
  * @param apiKey - Google Places API key
- * @returns Promise resolving to parsed address
+ * @returns Promise resolving to ApiResult with parsed address
  *
  * @example
  * ```ts
- * const address = await getAddressByPlaceId('ChIJ...', 'your-api-key');
- * // Returns: { place_id: 'ChIJ...', full_address: '...', ... }
+ * const result = await getAddressByPlaceId('ChIJ...', 'your-api-key');
+ * if (result.ok) console.log(result.data);
  * ```
  */
-declare function getAddressByPlaceId(placeId: string, apiKey: string): Promise<ParsedAddress | null>;
+declare function getAddressByPlaceId(placeId: string, apiKey: string): Promise<ApiResult<ParsedAddress | null>>;
 
 /**
  * @file Google Maps Script Loader
@@ -961,115 +958,136 @@ declare function getAddressByPlaceId(placeId: string, apiKey: string): Promise<P
  * Utility to dynamically load the Google Maps JavaScript API.
  * This is required because the REST API doesn't support CORS from browsers.
  */
+interface GooglePlacesLocationBiasCircle {
+    center: {
+        latitude: number;
+        longitude: number;
+    };
+    radius: number;
+}
+interface GooglePlacesAutocompleteSuggestionRequest {
+    input: string;
+    includedRegionCodes?: string[];
+    locationBias?: {
+        circle?: GooglePlacesLocationBiasCircle;
+    };
+    includedPrimaryTypes?: string[];
+    languageCode?: string;
+}
+interface GooglePlacesTextMatch {
+    endOffset: number;
+    startOffset: number;
+}
+interface GooglePlacesStructuredFormat {
+    mainText: {
+        text: string;
+    };
+    secondaryText: {
+        text: string;
+    };
+}
+interface GooglePlacesPlacePrediction {
+    placeId: string;
+    text: {
+        text: string;
+        matches: GooglePlacesTextMatch[];
+    };
+    structuredFormat?: GooglePlacesStructuredFormat;
+}
+interface GooglePlacesSuggestion {
+    placePrediction?: GooglePlacesPlacePrediction;
+}
+interface GooglePlacesAutocompleteSuggestion {
+    fetchAutocompleteSuggestions: (request: GooglePlacesAutocompleteSuggestionRequest) => Promise<{
+        suggestions: GooglePlacesSuggestion[];
+    }>;
+}
+interface GooglePlacesAutocompleteServiceRequest {
+    input: string;
+    componentRestrictions?: {
+        country: string | string[];
+    };
+    location?: {
+        lat: () => number;
+        lng: () => number;
+    };
+    radius?: number;
+    types?: string[];
+    language?: string;
+}
+interface GooglePlacesPrediction {
+    description: string;
+    place_id: string;
+    structured_formatting: {
+        main_text: string;
+        secondary_text: string;
+    };
+}
+interface GooglePlacesAutocompleteServiceInstance {
+    getPlacePredictions: (request: GooglePlacesAutocompleteServiceRequest, callback: (predictions: GooglePlacesPrediction[] | null, status: string) => void) => void;
+}
+interface GooglePlacesDetailsRequest {
+    placeId: string;
+    fields?: string[];
+}
+interface GooglePlacesAddressComponent {
+    long_name: string;
+    short_name: string;
+    types: string[];
+}
+interface GooglePlacesGeometry {
+    location?: {
+        lat: () => number;
+        lng: () => number;
+    };
+}
+interface GooglePlacesPlaceDetails {
+    place_id: string;
+    formatted_address?: string;
+    address_components?: GooglePlacesAddressComponent[];
+    geometry?: GooglePlacesGeometry;
+}
+interface GooglePlacesPlacesServiceInstance {
+    getDetails: (request: GooglePlacesDetailsRequest, callback: (place: GooglePlacesPlaceDetails | null, status: string) => void) => void;
+}
+interface GooglePlacesServiceStatus {
+    OK: string;
+    ZERO_RESULTS: string;
+    NOT_FOUND: string;
+    REQUEST_DENIED: string;
+    INVALID_REQUEST: string;
+    OVER_QUERY_LIMIT: string;
+}
+interface GoogleMapsPlaces {
+    AutocompleteSuggestion: GooglePlacesAutocompleteSuggestion;
+    AutocompleteService: new () => GooglePlacesAutocompleteServiceInstance;
+    PlacesService: new (element: HTMLElement) => GooglePlacesPlacesServiceInstance;
+    PlacesServiceStatus: GooglePlacesServiceStatus;
+}
+interface GoogleMapsLatLng {
+    lat: () => number;
+    lng: () => number;
+}
+interface GoogleMapsMaps {
+    places: GoogleMapsPlaces;
+    LatLng: new (lat: number, lng: number) => GoogleMapsLatLng;
+}
+interface GoogleMapsApi {
+    maps: GoogleMapsMaps;
+}
 declare global {
     interface Window {
-        google?: {
-            maps: {
-                places: {
-                    AutocompleteSuggestion: {
-                        fetchAutocompleteSuggestions: (request: {
-                            input: string;
-                            includedRegionCodes?: string[];
-                            locationBias?: {
-                                circle?: {
-                                    center: {
-                                        latitude: number;
-                                        longitude: number;
-                                    };
-                                    radius: number;
-                                };
-                            };
-                            includedPrimaryTypes?: string[];
-                            languageCode?: string;
-                        }) => Promise<{
-                            suggestions: Array<{
-                                placePrediction?: {
-                                    placeId: string;
-                                    text: {
-                                        text: string;
-                                        matches: Array<{
-                                            endOffset: number;
-                                            startOffset: number;
-                                        }>;
-                                    };
-                                    structuredFormat?: {
-                                        mainText: {
-                                            text: string;
-                                        };
-                                        secondaryText: {
-                                            text: string;
-                                        };
-                                    };
-                                };
-                            }>;
-                        }>;
-                    };
-                    AutocompleteService: new () => {
-                        getPlacePredictions: (request: {
-                            input: string;
-                            componentRestrictions?: {
-                                country: string | string[];
-                            };
-                            location?: {
-                                lat: () => number;
-                                lng: () => number;
-                            };
-                            radius?: number;
-                            types?: string[];
-                            language?: string;
-                        }, callback: (predictions: Array<{
-                            description: string;
-                            place_id: string;
-                            structured_formatting: {
-                                main_text: string;
-                                secondary_text: string;
-                            };
-                        }> | null, status: string) => void) => void;
-                    };
-                    PlacesService: new (element: HTMLElement) => {
-                        getDetails: (request: {
-                            placeId: string;
-                            fields?: string[];
-                        }, callback: (place: {
-                            place_id: string;
-                            formatted_address?: string;
-                            address_components?: Array<{
-                                long_name: string;
-                                short_name: string;
-                                types: string[];
-                            }>;
-                            geometry?: {
-                                location?: {
-                                    lat: () => number;
-                                    lng: () => number;
-                                };
-                            };
-                        } | null, status: string) => void) => void;
-                    };
-                    PlacesServiceStatus: {
-                        OK: string;
-                        ZERO_RESULTS: string;
-                        NOT_FOUND: string;
-                        REQUEST_DENIED: string;
-                        INVALID_REQUEST: string;
-                        OVER_QUERY_LIMIT: string;
-                    };
-                };
-                LatLng: new (lat: number, lng: number) => {
-                    lat: () => number;
-                    lng: () => number;
-                };
-            };
-        };
+        google?: GoogleMapsApi;
     }
 }
+
 /**
  * Load Google Maps JavaScript API script
  * @param apiKey - Google Places API key
  * @param libraries - Comma-separated list of libraries to load (default: 'places')
- * @returns Promise that resolves when the script is loaded
+ * @returns Promise that resolves to ApiResult<void>
  */
-declare function loadGoogleMapsScript(apiKey: string, libraries?: string): Promise<void>;
+declare function loadGoogleMapsScript(apiKey: string, libraries?: string): Promise<ApiResult<void>>;
 /**
  * Check if Google Maps is already loaded
  */