@jmruthers/pace-core 0.5.92 → 0.5.94

package/dist/{chunk-M52CQP5W.js → chunk-MKMKUCPF.js}

@@ -1,17 +1,21 @@
 import {
   init_useOrganisations,
   useOrganisations
-} from "./chunk-OXFOS62D.js";
+} from "./chunk-MVNOAHOP.js";
 import {
   init_UnifiedAuthProvider
-} from "./chunk-AYC2P377.js";
+} from "./chunk-ORACUZ7H.js";
 import {
   OrganisationServiceContext,
   OrganisationServiceProvider,
   init_OrganisationServiceProvider,
   useOrganisationService,
   useUnifiedAuth
-} from "./chunk-AAM57AEU.js";
+} from "./chunk-5RYPBJYL.js";
+import {
+  init_organisationContext,
+  setOrganisationContext
+} from "./chunk-BDZUMRBD.js";
 import {
   __esm,
   __export
@@ -646,8 +650,746 @@ async function archiveFile(supabase, path, options) {
   }
 }
 
+// src/hooks/public/usePublicFileDisplay.ts
+import { useState, useEffect, useCallback } from "react";
+var publicFileCache = /* @__PURE__ */ new Map();
+function usePublicFileDisplay(table_name, record_id, organisation_id, category, options) {
+  const {
+    cacheTtl = 30 * 60 * 1e3,
+    // 30 minutes
+    enableCache = true,
+    supabase
+  } = options;
+  const [fileUrl, setFileUrl] = useState(null);
+  const [fileReference, setFileReference] = useState(null);
+  const [fileReferences, setFileReferences] = useState([]);
+  const [fileUrls, setFileUrls] = useState(/* @__PURE__ */ new Map());
+  const [fileCount, setFileCount] = useState(0);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const fetchFiles = useCallback(async () => {
+    if (!table_name || !record_id || !organisation_id || !supabase) {
+      setFileUrl(null);
+      setFileReference(null);
+      setFileReferences([]);
+      setFileUrls(/* @__PURE__ */ new Map());
+      setFileCount(0);
+      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(organisation_id)) {
+      console.warn("[usePublicFileDisplay] Invalid organisationId format (not a valid UUID):", organisation_id);
+    }
+    const cacheKey = `public_file_${table_name}_${record_id}_${organisation_id}_${category || "all"}`;
+    if (enableCache) {
+      const cached = publicFileCache.get(cacheKey);
+      if (cached && Date.now() - cached.timestamp < cached.ttl) {
+        const cachedData = cached.data;
+        setFileUrl(cachedData.fileUrl || null);
+        setFileReference(cachedData.fileReference || null);
+        setFileReferences(cachedData.fileReferences || []);
+        setFileUrls(cachedData.fileUrls || /* @__PURE__ */ new Map());
+        setFileCount(cachedData.fileCount || 0);
+        setIsLoading(false);
+        setError(null);
+        return;
+      }
+    }
+    try {
+      setIsLoading(true);
+      setError(null);
+      let files = [];
+      if (category) {
+        const { data, error: rpcError } = await supabase.rpc("data_file_reference_by_category_list", {
+          p_table_name: table_name,
+          p_record_id: record_id,
+          p_category: category,
+          p_organisation_id: organisation_id
+        });
+        if (rpcError) {
+          throw new Error(rpcError.message || "Failed to fetch file reference");
+        }
+        files = data || [];
+      } else {
+        const { data: fileIds, error: rpcError } = await supabase.rpc("data_file_reference_list", {
+          p_table_name: table_name,
+          p_record_id: record_id,
+          p_organisation_id: organisation_id
+        });
+        if (rpcError) {
+          throw new Error(rpcError.message || "Failed to fetch file references");
+        }
+        if (!fileIds || fileIds.length === 0) {
+          files = [];
+        } else {
+          const ids = fileIds.map((item) => item.id);
+          const { data: fullData, error: fetchError } = await supabase.from("file_references").select("*").in("id", ids).eq("is_public", true);
+          if (fetchError) {
+            throw new Error(fetchError.message || "Failed to fetch file references");
+          }
+          files = fullData || [];
+        }
+      }
+      const publicFiles = files.filter((f) => f.is_public === true);
+      if (publicFiles.length === 0) {
+        setFileUrl(null);
+        setFileReference(null);
+        setFileReferences([]);
+        setFileUrls(/* @__PURE__ */ new Map());
+        setFileCount(0);
+        if (enableCache) {
+          publicFileCache.set(cacheKey, {
+            data: { fileUrl: null, fileReference: null, fileReferences: [], fileUrls: /* @__PURE__ */ new Map(), fileCount: 0 },
+            timestamp: Date.now(),
+            ttl: cacheTtl
+          });
+        }
+        return;
+      }
+      const fileRefs = publicFiles.map((f) => ({
+        id: f.id,
+        table_name: f.table_name,
+        record_id: f.record_id,
+        file_path: f.file_path,
+        file_metadata: f.file_metadata || {},
+        organisation_id: f.organisation_id,
+        app_id: f.app_id,
+        is_public: f.is_public ?? true,
+        created_at: f.created_at,
+        updated_at: f.updated_at
+      }));
+      setFileReferences(fileRefs);
+      setFileCount(fileRefs.length);
+      if (category && fileRefs.length > 0) {
+        const firstFile = fileRefs[0];
+        setFileReference(firstFile);
+        const url = getPublicUrl(supabase, firstFile.file_path, true);
+        setFileUrl(url);
+      } else {
+        const urlMap = /* @__PURE__ */ new Map();
+        for (const fileRef of fileRefs) {
+          const url = getPublicUrl(supabase, fileRef.file_path, true);
+          if (url) {
+            urlMap.set(fileRef.id, url);
+          }
+        }
+        setFileUrls(urlMap);
+        setFileReference(null);
+        setFileUrl(null);
+      }
+      if (enableCache) {
+        publicFileCache.set(cacheKey, {
+          data: {
+            fileUrl: category ? fileRefs.length > 0 ? getPublicUrl(supabase, fileRefs[0].file_path, true) : null : null,
+            fileReference: category && fileRefs.length > 0 ? fileRefs[0] : null,
+            fileReferences: fileRefs,
+            fileUrls: category ? /* @__PURE__ */ new Map() : (() => {
+              const urlMap = /* @__PURE__ */ new Map();
+              for (const fileRef of fileRefs) {
+                const url = getPublicUrl(supabase, fileRef.file_path, true);
+                if (url) {
+                  urlMap.set(fileRef.id, url);
+                }
+              }
+              return urlMap;
+            })(),
+            fileCount: fileRefs.length
+          },
+          timestamp: Date.now(),
+          ttl: cacheTtl
+        });
+      }
+    } catch (err) {
+      console.error("[usePublicFileDisplay] Error fetching files:", err);
+      const error2 = err instanceof Error ? err : new Error("Unknown error occurred");
+      setError(error2);
+      setFileUrl(null);
+      setFileReference(null);
+      setFileReferences([]);
+      setFileUrls(/* @__PURE__ */ new Map());
+      setFileCount(0);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [table_name, record_id, organisation_id, category, supabase, cacheTtl, enableCache]);
+  useEffect(() => {
+    if (table_name && record_id && organisation_id) {
+      fetchFiles();
+    } else {
+      setFileUrl(null);
+      setFileReference(null);
+      setFileReferences([]);
+      setFileUrls(/* @__PURE__ */ new Map());
+      setFileCount(0);
+      setIsLoading(false);
+      setError(null);
+    }
+  }, [fetchFiles, table_name, record_id, organisation_id]);
+  const refetch = useCallback(async () => {
+    if (!table_name || !record_id || !organisation_id) return;
+    if (enableCache) {
+      const cacheKey = `public_file_${table_name}_${record_id}_${organisation_id}_${category || "all"}`;
+      publicFileCache.delete(cacheKey);
+    }
+    await fetchFiles();
+  }, [fetchFiles, table_name, record_id, organisation_id, category, enableCache]);
+  return {
+    fileUrl,
+    fileReference,
+    fileReferences,
+    fileUrls,
+    fileCount,
+    isLoading,
+    error,
+    refetch
+  };
+}
+function clearPublicFileDisplayCache() {
+  for (const [key] of publicFileCache) {
+    if (key.startsWith("public_file_")) {
+      publicFileCache.delete(key);
+    }
+  }
+}
+function getPublicFileDisplayCacheStats() {
+  const keys = Array.from(publicFileCache.keys()).filter((key) => key.startsWith("public_file_"));
+  return {
+    size: keys.length,
+    keys
+  };
+}
+
+// src/hooks/useFileDisplay.ts
+import { useState as useState2, useEffect as useEffect2, useCallback as useCallback2 } from "react";
+
+// src/utils/file-reference.ts
+init_organisationContext();
+var FileReferenceServiceImpl = class {
+  constructor(supabase) {
+    this.supabase = supabase;
+  }
+  async createFileReference(options, file) {
+    try {
+      if (!options.organisation_id) {
+        throw new Error("organisation_id is required for file upload");
+      }
+      if (!options.table_name) {
+        throw new Error("table_name is required for file upload");
+      }
+      if (!options.record_id) {
+        throw new Error("record_id is required for file upload");
+      }
+      const uploadResult = await uploadFile(this.supabase, file, {
+        appName: "file-reference",
+        orgId: options.organisation_id,
+        isPublic: options.is_public || false,
+        customPath: options.category
+        // Use category as the custom path
+      });
+      if (!uploadResult.success) {
+        throw new Error(`Failed to upload file: ${uploadResult.error}`);
+      }
+      if (!uploadResult.path) {
+        throw new Error("File upload did not return a path");
+      }
+      const filePath = uploadResult.path;
+      const metadata = await extractFileMetadata(file, {
+        appName: "file-reference",
+        orgId: options.organisation_id,
+        isPublic: options.is_public || false
+      }, "system");
+      await setOrganisationContext(this.supabase, options.organisation_id);
+      const { data, error } = await this.supabase.rpc("data_file_reference_create", {
+        p_table_name: options.table_name,
+        p_record_id: options.record_id,
+        p_file_path: filePath,
+        p_organisation_id: options.organisation_id,
+        p_app_id: options.app_id,
+        p_file_metadata: {
+          fileName: file.name,
+          fileType: file.type,
+          fileSize: file.size,
+          category: options.category,
+          ...metadata,
+          ...options.custom_metadata
+        },
+        p_is_public: options.is_public || false
+      });
+      if (error) {
+        await deleteFile(this.supabase, filePath, options.is_public || false);
+        throw new Error(`Failed to create file reference: ${error.message}`);
+      }
+      const { data: fileRef, error: fetchError } = await this.supabase.from("file_references").select("*").eq("id", data).single();
+      if (fetchError || !fileRef) {
+        throw new Error(`Failed to fetch created file reference: ${fetchError?.message}`);
+      }
+      return fileRef;
+    } catch (error) {
+      console.error("Error creating file reference:", error);
+      throw error;
+    }
+  }
+  async getFileReference(table_name, record_id, organisation_id) {
+    try {
+      const { data, error } = await this.supabase.from("file_references").select("*").eq("table_name", table_name).eq("record_id", record_id).eq("organisation_id", organisation_id).single();
+      if (error) {
+        if (error.code === "PGRST116") {
+          return null;
+        }
+        throw new Error(`Failed to get file reference: ${error.message}`);
+      }
+      return data;
+    } catch (error) {
+      console.error("Error getting file reference:", error);
+      throw error;
+    }
+  }
+  async getFileUrl(table_name, record_id, organisation_id) {
+    try {
+      const fileRef = await this.getFileReference(table_name, record_id, organisation_id);
+      if (!fileRef) {
+        return null;
+      }
+      if (fileRef.is_public) {
+        const { data: pathData } = await this.supabase.rpc("data_file_reference_url_get", {
+          p_table_name: table_name,
+          p_record_id: record_id,
+          p_organisation_id: organisation_id
+        });
+        if (!pathData) {
+          return null;
+        }
+        return getPublicUrl(this.supabase, pathData, true);
+      } else {
+        return await this.getSignedUrl(table_name, record_id, organisation_id);
+      }
+    } catch (error) {
+      console.error("Error getting file URL:", error);
+      throw error;
+    }
+  }
+  async getSignedUrl(table_name, record_id, organisation_id, expires_in = 3600) {
+    try {
+      const { data: filePath, error } = await this.supabase.rpc("data_file_reference_signed_url_get", {
+        p_table_name: table_name,
+        p_record_id: record_id,
+        p_organisation_id: organisation_id,
+        p_expires_in: expires_in
+      });
+      if (error) {
+        throw new Error(`Failed to get signed URL: ${error.message}`);
+      }
+      if (!filePath) {
+        return null;
+      }
+      const signedUrlResult = await getSignedUrl(this.supabase, filePath, {
+        appName: "file-reference",
+        orgId: organisation_id,
+        expiresIn: expires_in
+      });
+      return signedUrlResult?.url || null;
+    } catch (error) {
+      console.error("Error getting signed URL:", error);
+      throw error;
+    }
+  }
+  async updateFileReference(id, updates) {
+    try {
+      const { data, error } = await this.supabase.from("file_references").update(updates).eq("id", id).select().single();
+      if (error) {
+        throw new Error(`Failed to update file reference: ${error.message}`);
+      }
+      return data;
+    } catch (error) {
+      console.error("Error updating file reference:", error);
+      throw error;
+    }
+  }
+  async deleteFileReference(table_name, record_id, organisation_id, delete_file = false) {
+    try {
+      const fileRef = await this.getFileReference(table_name, record_id, organisation_id);
+      const { error } = await this.supabase.rpc("data_file_reference_delete", {
+        p_table_name: table_name,
+        p_record_id: record_id,
+        p_organisation_id: organisation_id,
+        p_delete_file: delete_file
+      });
+      if (error) {
+        throw new Error(`Failed to delete file reference: ${error.message}`);
+      }
+      if (delete_file && fileRef) {
+        await deleteFile(this.supabase, fileRef.file_path, fileRef.is_public || false);
+      }
+      return true;
+    } catch (error) {
+      console.error("Error deleting file reference:", error);
+      throw error;
+    }
+  }
+  async listFileReferences(table_name, record_id, organisation_id) {
+    try {
+      const { data, error } = await this.supabase.rpc("data_file_reference_list", {
+        p_table_name: table_name,
+        p_record_id: record_id,
+        p_organisation_id: organisation_id
+      });
+      if (error) {
+        throw new Error(`Failed to list file references: ${error.message}`);
+      }
+      if (!data || data.length === 0) {
+        return [];
+      }
+      const ids = data.map((item) => item.id);
+      const { data: fullData, error: fetchError } = await this.supabase.from("file_references").select("*").in("id", ids);
+      if (fetchError) {
+        throw new Error(`Failed to fetch file references: ${fetchError.message}`);
+      }
+      return fullData || [];
+    } catch (error) {
+      console.error("Error listing file references:", error);
+      throw error;
+    }
+  }
+  async getFileCount(table_name, record_id, organisation_id) {
+    try {
+      const { data, error } = await this.supabase.rpc("data_file_reference_count_get", {
+        p_table_name: table_name,
+        p_record_id: record_id,
+        p_organisation_id: organisation_id
+      });
+      if (error) {
+        throw new Error(`Failed to get file count: ${error.message}`);
+      }
+      return data || 0;
+    } catch (error) {
+      console.error("Error getting file count:", error);
+      throw error;
+    }
+  }
+  async getFileReferenceById(id, organisation_id) {
+    try {
+      const { data, error } = await this.supabase.rpc("data_file_reference_get", {
+        p_file_reference_id: id,
+        p_organisation_id: organisation_id
+      });
+      if (error) {
+        throw new Error(`Failed to get file reference by ID: ${error.message}`);
+      }
+      if (!data || data.length === 0) {
+        return null;
+      }
+      return data[0];
+    } catch (error) {
+      console.error("Error getting file reference by ID:", error);
+      throw error;
+    }
+  }
+  async getFilesByCategory(table_name, record_id, category, organisation_id) {
+    try {
+      const { data, error } = await this.supabase.rpc("data_file_reference_by_category_list", {
+        p_table_name: table_name,
+        p_record_id: record_id,
+        p_category: category,
+        p_organisation_id: organisation_id
+      });
+      if (error) {
+        throw new Error(`Failed to get files by category: ${error.message}`);
+      }
+      if (!data || data.length === 0) {
+        return [];
+      }
+      const ids = data.map((item) => item.id);
+      const { data: fullData, error: fetchError } = await this.supabase.from("file_references").select("*").in("id", ids);
+      if (fetchError) {
+        throw new Error(`Failed to fetch file references: ${fetchError.message}`);
+      }
+      return fullData || [];
+    } catch (error) {
+      console.error("Error getting files by category:", error);
+      throw error;
+    }
+  }
+  async uploadMultipleFiles(options, files) {
+    const success = [];
+    const failed = [];
+    const results = [];
+    for (const file of files) {
+      try {
+        const fileReference = await this.createFileReference(options, file);
+        success.push(fileReference);
+        results.push({
+          file,
+          result: {
+            file_reference: fileReference,
+            file_url: fileReference.is_public ? getPublicUrl(this.supabase, fileReference.file_path, true) : ""
+          }
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        failed.push({ file, error: message });
+        results.push({ file, result: null, error: message });
+      }
+    }
+    return {
+      success,
+      failed,
+      total: results.length,
+      successful: success.length,
+      results
+    };
+  }
+};
+function createFileReferenceService(supabase) {
+  return new FileReferenceServiceImpl(supabase);
+}
+async function uploadFileWithReference(supabase, options, file) {
+  const service = createFileReferenceService(supabase);
+  const fileReference = await service.createFileReference(options, file);
+  const fileUrl = options.is_public ? getPublicUrl(supabase, fileReference.file_path, true) : await getSignedUrl(supabase, fileReference.file_path, {
+    appName: "file-reference",
+    orgId: options.organisation_id,
+    expiresIn: 3600
+  });
+  const urlString = typeof fileUrl === "string" ? fileUrl : fileUrl?.url || "";
+  return {
+    file_reference: fileReference,
+    file_url: urlString,
+    signed_url: options.is_public ? void 0 : urlString || void 0
+  };
+}
+
+// src/hooks/useFileDisplay.ts
+var authenticatedFileCache = /* @__PURE__ */ new Map();
+var MAX_CACHE_SIZE = 100;
+function cleanupCache() {
+  const now = Date.now();
+  const entries = Array.from(authenticatedFileCache.entries());
+  const expiredKeys = [];
+  entries.forEach(([key, value]) => {
+    if (now - value.timestamp >= value.ttl) {
+      expiredKeys.push(key);
+    }
+  });
+  expiredKeys.forEach((key) => authenticatedFileCache.delete(key));
+  if (authenticatedFileCache.size > MAX_CACHE_SIZE) {
+    const sorted = entries.filter(([key]) => !expiredKeys.includes(key)).sort((a, b) => a[1].timestamp - b[1].timestamp);
+    const toRemove = sorted.slice(0, authenticatedFileCache.size - MAX_CACHE_SIZE);
+    toRemove.forEach(([key]) => authenticatedFileCache.delete(key));
+  }
+}
+function useFileDisplay(table_name, record_id, organisation_id, category, options) {
+  const {
+    cacheTtl = 30 * 60 * 1e3,
+    // 30 minutes
+    enableCache = true,
+    supabase
+  } = options;
+  const [fileUrl, setFileUrl] = useState2(null);
+  const [fileReference, setFileReference] = useState2(null);
+  const [fileReferences, setFileReferences] = useState2([]);
+  const [fileUrls, setFileUrls] = useState2(/* @__PURE__ */ new Map());
+  const [fileCount, setFileCount] = useState2(0);
+  const [isLoading, setIsLoading] = useState2(false);
+  const [error, setError] = useState2(null);
+  const fetchFiles = useCallback2(async () => {
+    if (!table_name || !record_id || !organisation_id || !supabase) {
+      setFileUrl(null);
+      setFileReference(null);
+      setFileReferences([]);
+      setFileUrls(/* @__PURE__ */ new Map());
+      setFileCount(0);
+      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(organisation_id)) {
+      console.warn("[useFileDisplay] Invalid organisationId format (not a valid UUID):", organisation_id);
+    }
+    const cacheKey = `file_${table_name}_${record_id}_${organisation_id}_${category || "all"}`;
+    if (enableCache) {
+      const cached = authenticatedFileCache.get(cacheKey);
+      if (cached && Date.now() - cached.timestamp < cached.ttl) {
+        const cachedData = cached.data;
+        setFileUrl(cachedData.fileUrl || null);
+        setFileReference(cachedData.fileReference || null);
+        setFileReferences(cachedData.fileReferences || []);
+        setFileUrls(cachedData.fileUrls || /* @__PURE__ */ new Map());
+        setFileCount(cachedData.fileCount || 0);
+        setIsLoading(false);
+        setError(null);
+        return;
+      }
+    }
+    try {
+      setIsLoading(true);
+      setError(null);
+      const service = createFileReferenceService(supabase);
+      let files = [];
+      if (category) {
+        files = await service.getFilesByCategory(
+          table_name,
+          record_id,
+          category,
+          organisation_id
+        );
+      } else {
+        files = await service.listFileReferences(
+          table_name,
+          record_id,
+          organisation_id
+        );
+      }
+      if (files.length === 0) {
+        setFileUrl(null);
+        setFileReference(null);
+        setFileReferences([]);
+        setFileUrls(/* @__PURE__ */ new Map());
+        setFileCount(0);
+        if (enableCache) {
+          authenticatedFileCache.set(cacheKey, {
+            data: { fileUrl: null, fileReference: null, fileReferences: [], fileUrls: /* @__PURE__ */ new Map(), fileCount: 0 },
+            timestamp: Date.now(),
+            ttl: cacheTtl
+          });
+          cleanupCache();
+        }
+        return;
+      }
+      setFileReferences(files);
+      setFileCount(files.length);
+      if (category && files.length > 0) {
+        const firstFile = files[0];
+        setFileReference(firstFile);
+        let url = null;
+        if (firstFile.is_public) {
+          url = getPublicUrl(supabase, firstFile.file_path, true);
+        } else {
+          const signedUrlResult = await getSignedUrl(supabase, firstFile.file_path, {
+            appName: "pace-core",
+            orgId: organisation_id,
+            expiresIn: 3600
+          });
+          url = signedUrlResult?.url || null;
+        }
+        setFileUrl(url);
+      } else {
+        const urlMap = /* @__PURE__ */ new Map();
+        for (const fileRef of files) {
+          let url = null;
+          if (fileRef.is_public) {
+            url = getPublicUrl(supabase, fileRef.file_path, true);
+          } else {
+            const signedUrlResult = await getSignedUrl(supabase, fileRef.file_path, {
+              appName: "pace-core",
+              orgId: organisation_id,
+              expiresIn: 3600
+            });
+            url = signedUrlResult?.url || null;
+          }
+          if (url) {
+            urlMap.set(fileRef.id, url);
+          }
+        }
+        setFileUrls(urlMap);
+        setFileReference(null);
+        setFileUrl(null);
+      }
+      if (enableCache) {
+        let cacheData = {
+          fileReference: category && files.length > 0 ? files[0] : null,
+          fileReferences: files,
+          fileUrls: /* @__PURE__ */ new Map(),
+          fileCount: files.length
+        };
+        if (category && files.length > 0) {
+          const firstFile = files[0];
+          let url = null;
+          if (firstFile.is_public) {
+            url = getPublicUrl(supabase, firstFile.file_path, true);
+          }
+          cacheData.fileUrl = url;
+        } else {
+          const urlMap = /* @__PURE__ */ new Map();
+          for (const fileRef of files) {
+            if (fileRef.is_public) {
+              const url = getPublicUrl(supabase, fileRef.file_path, true);
+              if (url) {
+                urlMap.set(fileRef.id, url);
+              }
+            }
+          }
+          cacheData.fileUrls = urlMap;
+        }
+        authenticatedFileCache.set(cacheKey, {
+          data: cacheData,
+          timestamp: Date.now(),
+          ttl: cacheTtl
+        });
+        cleanupCache();
+      }
+    } catch (err) {
+      console.error("[useFileDisplay] Error fetching files:", err);
+      const error2 = err instanceof Error ? err : new Error("Unknown error occurred");
+      setError(error2);
+      setFileUrl(null);
+      setFileReference(null);
+      setFileReferences([]);
+      setFileUrls(/* @__PURE__ */ new Map());
+      setFileCount(0);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [table_name, record_id, organisation_id, category, supabase, cacheTtl, enableCache]);
+  useEffect2(() => {
+    if (table_name && record_id && organisation_id && supabase) {
+      fetchFiles();
+    } else {
+      setFileUrl(null);
+      setFileReference(null);
+      setFileReferences([]);
+      setFileUrls(/* @__PURE__ */ new Map());
+      setFileCount(0);
+      setIsLoading(false);
+      setError(null);
+    }
+  }, [fetchFiles, table_name, record_id, organisation_id, supabase]);
+  const refetch = useCallback2(async () => {
+    if (!table_name || !record_id || !organisation_id || !supabase) return;
+    if (enableCache) {
+      const cacheKey = `file_${table_name}_${record_id}_${organisation_id}_${category || "all"}`;
+      authenticatedFileCache.delete(cacheKey);
+    }
+    await fetchFiles();
+  }, [fetchFiles, table_name, record_id, organisation_id, category, supabase, enableCache]);
+  return {
+    fileUrl,
+    fileReference,
+    fileReferences,
+    fileUrls,
+    fileCount,
+    isLoading,
+    error,
+    refetch
+  };
+}
+function clearFileDisplayCache() {
+  for (const [key] of authenticatedFileCache) {
+    if (key.startsWith("file_")) {
+      authenticatedFileCache.delete(key);
+    }
+  }
+}
+function getFileDisplayCacheStats() {
+  const keys = Array.from(authenticatedFileCache.keys()).filter((key) => key.startsWith("file_"));
+  return {
+    size: keys.length,
+    keys
+  };
+}
+
 // src/hooks/public/usePublicEventLogo.ts
-import { useState, useEffect, useCallback, useMemo as useMemo3 } from "react";
+import { useState as useState3, useEffect as useEffect3, useCallback as useCallback3, useMemo as useMemo4 } from "react";
 var publicDataCache = /* @__PURE__ */ new Map();
 function defaultGenerateFallbackText(eventName) {
   if (!eventName) return "EV";
@@ -662,13 +1404,13 @@ function usePublicEventLogo(eventId, eventName, organisationId, options) {
     generateFallbackText = defaultGenerateFallbackText,
     supabase
   } = options;
-  const [logoUrl, setLogoUrl] = useState(null);
-  const [isLoading, setIsLoading] = useState(false);
-  const [error, setError] = useState(null);
-  const fallbackText = useMemo3(() => {
+  const [logoUrl, setLogoUrl] = useState3(null);
+  const [isLoading, setIsLoading] = useState3(false);
+  const [error, setError] = useState3(null);
+  const fallbackText = useMemo4(() => {
     return eventName ? generateFallbackText(eventName) : "EV";
   }, [eventName, generateFallbackText]);
-  const fetchLogo = useCallback(async () => {
+  const fetchLogo = useCallback3(async () => {
     if (!eventId || !organisationId || !supabase) {
       setLogoUrl(null);
       setIsLoading(false);
@@ -738,7 +1480,7 @@ function usePublicEventLogo(eventId, eventName, organisationId, options) {
       setIsLoading(false);
     }
   }, [eventId, organisationId, supabase, cacheTtl, enableCache, validateImage]);
-  useEffect(() => {
+  useEffect3(() => {
     if (eventId && organisationId) {
       fetchLogo();
     } else {
@@ -747,7 +1489,7 @@ function usePublicEventLogo(eventId, eventName, organisationId, options) {
       setError(null);
     }
   }, [fetchLogo, eventId, organisationId]);
-  const refetch = useCallback(async () => {
+  const refetch = useCallback3(async () => {
     if (!eventId || !organisationId) return;
     if (enableCache) {
       const cacheKey = `public_logo_${eventId}_${organisationId}`;
@@ -806,8 +1548,16 @@ export {
   listFiles,
   downloadFile,
   archiveFile,
+  createFileReferenceService,
+  uploadFileWithReference,
+  usePublicFileDisplay,
+  clearPublicFileDisplayCache,
+  getPublicFileDisplayCacheStats,
+  useFileDisplay,
+  clearFileDisplayCache,
+  getFileDisplayCacheStats,
   usePublicEventLogo,
   clearPublicLogoCache,
   getPublicLogoCacheStats
 };
-//# sourceMappingURL=chunk-M52CQP5W.js.map
+//# sourceMappingURL=chunk-MKMKUCPF.js.map