@jmruthers/pace-core 0.2.4

package/src/hooks/useStorage.ts

@@ -0,0 +1,274 @@
+/**
+ * React hook for storage operations
+ */
+
+import { useState, useCallback } from 'react';
+import { SupabaseClient } from '@supabase/supabase-js';
+import { 
+  StorageUploadOptions, 
+  StorageUploadResult, 
+  StorageFileInfo,
+  StorageListOptions,
+  StorageListResult,
+  uploadFile,
+  getPublicUrl,
+  getSignedUrl,
+  deleteFile,
+  listFiles,
+  archiveFile
+} from '../utils/storage';
+
+export interface UseStorageOptions {
+  supabase: SupabaseClient;
+  appName: string;
+  orgId: string;
+}
+
+export interface UseStorageReturn {
+  // Upload
+  uploadFile: (file: File, options?: Partial<StorageUploadOptions>) => Promise<StorageUploadResult>;
+  isUploading: boolean;
+  uploadError: string | null;
+  
+  // URLs
+  getPublicUrl: (path: string) => string;
+  getSignedUrl: (path: string, expiresIn?: number) => Promise<string | null>;
+  getFileUrl: (path: string) => string; // Alias for getPublicUrl
+  
+  // File management
+  deleteFile: (path: string) => Promise<{ success: boolean; error?: string }>;
+  archiveFile: (path: string) => Promise<{ success: boolean; error?: string }>;
+  
+  // Listing
+  listFiles: (options?: Partial<StorageListOptions>) => Promise<StorageListResult>;
+  isListing: boolean;
+  listError: string | null;
+  isLoading: boolean; // Alias for isListing
+  error: string | null; // Alias for listError
+  
+  // State
+  files: StorageFileInfo[];
+  refreshFiles: () => Promise<void>;
+}
+
+/**
+ * Hook for storage operations with app and organisation context
+ */
+export function useStorage({ supabase, appName, orgId }: UseStorageOptions): UseStorageReturn {
+  const [isUploading, setIsUploading] = useState(false);
+  const [uploadError, setUploadError] = useState<string | null>(null);
+  const [isListing, setIsListing] = useState(false);
+  const [listError, setListError] = useState<string | null>(null);
+  const [files, setFiles] = useState<StorageFileInfo[]>([]);
+
+  // Upload file
+  const handleUploadFile = useCallback(async (
+    file: File, 
+    options: Partial<StorageUploadOptions> = {}
+  ): Promise<StorageUploadResult> => {
+    setIsUploading(true);
+    setUploadError(null);
+
+    try {
+      const uploadOptions: StorageUploadOptions = {
+        appName,
+        orgId,
+        isPublic: false,
+        ...options
+      };
+
+      const result = await uploadFile(supabase, file, uploadOptions);
+      
+      if (result.success) {
+        // Refresh file list
+        await refreshFiles();
+      } else {
+        setUploadError(result.error || 'Upload failed');
+      }
+
+      return result;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Upload failed';
+      setUploadError(errorMessage);
+      return {
+        success: false,
+        error: errorMessage
+      };
+    } finally {
+      setIsUploading(false);
+    }
+  }, [supabase, appName, orgId]);
+
+  // Get public URL
+  const handleGetPublicUrl = useCallback((path: string): string => {
+    return getPublicUrl(supabase, path);
+  }, [supabase]);
+
+  // Get signed URL
+  const handleGetSignedUrl = useCallback(async (
+    path: string, 
+    expiresIn?: number
+  ): Promise<string | null> => {
+    try {
+      const result = await getSignedUrl(supabase, path, {
+        appName,
+        orgId,
+        expiresIn
+      });
+      return result?.url || null;
+    } catch (error) {
+      console.error('Failed to get signed URL:', error);
+      return null;
+    }
+  }, [supabase, appName, orgId]);
+
+  // Delete file
+  const handleDeleteFile = useCallback(async (path: string) => {
+    try {
+      const result = await deleteFile(supabase, path);
+      if (result.success) {
+        await refreshFiles();
+      }
+      return result;
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Delete failed'
+      };
+    }
+  }, [supabase]);
+
+  // Archive file
+  const handleArchiveFile = useCallback(async (path: string) => {
+    try {
+      const result = await archiveFile(supabase, path, { appName, orgId });
+      if (result.success) {
+        await refreshFiles();
+      }
+      return result;
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Archive failed'
+      };
+    }
+  }, [supabase, appName, orgId]);
+
+  // List files
+  const handleListFiles = useCallback(async (
+    options: Partial<StorageListOptions> = {}
+  ): Promise<StorageListResult> => {
+    setIsListing(true);
+    setListError(null);
+
+    try {
+      const listOptions: StorageListOptions = {
+        appName,
+        orgId,
+        ...options
+      };
+
+      const result = await listFiles(supabase, listOptions);
+      setFiles(result.files);
+      return result;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'List failed';
+      setListError(errorMessage);
+      return { files: [], totalCount: 0, hasMore: false };
+    } finally {
+      setIsListing(false);
+    }
+  }, [supabase, appName, orgId]);
+
+  // Refresh files
+  const refreshFiles = useCallback(async () => {
+    await handleListFiles();
+  }, [handleListFiles]);
+
+  return {
+    // Upload
+    uploadFile: handleUploadFile,
+    isUploading,
+    uploadError,
+    
+    // URLs
+    getPublicUrl: handleGetPublicUrl,
+    getSignedUrl: handleGetSignedUrl,
+    getFileUrl: handleGetPublicUrl, // Alias for getPublicUrl
+    
+    // File management
+    deleteFile: handleDeleteFile,
+    archiveFile: handleArchiveFile,
+    
+    // Listing
+    listFiles: handleListFiles,
+    isListing,
+    listError,
+    isLoading: isListing, // Alias for isListing
+    error: listError, // Alias for listError
+    
+    // State
+    files,
+    refreshFiles
+  };
+}
+
+/**
+ * Hook for file upload with progress tracking
+ */
+export function useFileUpload({ supabase, appName, orgId }: UseStorageOptions) {
+  const [uploadProgress, setUploadProgress] = useState(0);
+  const [isUploading, setIsUploading] = useState(false);
+  const [uploadError, setUploadError] = useState<string | null>(null);
+
+  const uploadWithProgress = useCallback(async (
+    file: File,
+    options: Partial<StorageUploadOptions> = {}
+  ): Promise<StorageUploadResult> => {
+    setIsUploading(true);
+    setUploadProgress(0);
+    setUploadError(null);
+
+    try {
+      // Simulate progress (Supabase doesn't provide real progress)
+      const progressInterval = setInterval(() => {
+        setUploadProgress(prev => Math.min(prev + 10, 90));
+      }, 100);
+
+      const uploadOptions: StorageUploadOptions = {
+        appName,
+        orgId,
+        isPublic: false,
+        ...options
+      };
+
+      const result = await uploadFile(supabase, file, uploadOptions);
+      
+      clearInterval(progressInterval);
+      setUploadProgress(100);
+
+      if (!result.success) {
+        setUploadError(result.error || 'Upload failed');
+      }
+
+      return result;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Upload failed';
+      setUploadError(errorMessage);
+      return {
+        success: false,
+        error: errorMessage
+      };
+    } finally {
+      setIsUploading(false);
+      setTimeout(() => setUploadProgress(0), 1000);
+    }
+  }, [supabase, appName, orgId]);
+
+  return {
+    uploadWithProgress,
+    uploadProgress,
+    isUploading,
+    uploadError
+  };
+}

package/src/hooks/useToast.ts

@@ -0,0 +1,242 @@
+
+/**
+ * @file Toast hook for managing toast notifications
+ * @package @jmruthers/pace-core
+ * @module Hooks
+ * @since 0.1.0
+ */
+
+import * as React from "react"
+
+/** Maximum number of toasts to show at once */
+const TOAST_LIMIT = 5
+/** Delay before removing a dismissed toast */
+const TOAST_REMOVE_DELAY = 1000
+
+export interface ToastProps {
+  title?: React.ReactNode;
+  description?: React.ReactNode;
+  variant?: 'default' | 'destructive' | 'success';
+  duration?: number;
+  onClose?: () => void;
+  action?: React.ReactElement;
+}
+
+/**
+ * Extended toast props with additional properties
+ * @interface ToasterToast
+ */
+type ToasterToast = ToastProps & {
+  /** Unique identifier for the toast */
+  id: string
+  /** Optional title content */
+  title?: React.ReactNode
+  /** Optional description content */
+  description?: React.ReactNode
+  /** Optional action button */
+  action?: React.ReactElement
+  /** Open state */
+  open?: boolean
+  /** Open change handler */
+  onOpenChange?: (open: boolean) => void
+  /** Dismiss function */
+  dismiss?: () => void
+}
+
+/**
+ * State interface for toast management
+ */
+interface State {
+  /** Array of active toasts */
+  toasts: ToasterToast[]
+}
+
+/** Map of toast IDs to their removal timeouts */
+const toastTimeouts = new Map<string, ReturnType<typeof setTimeout>>()
+
+/** Current toast state */
+let memoryState: State = {
+  toasts: [],
+}
+
+/** List of state change listeners */
+const listeners: Array<(state: State) => void> = []
+
+/**
+ * Reset the toast state and clear all timeouts
+ */
+export function reset() {
+  memoryState = { toasts: [] }
+  toastTimeouts.forEach((timeout) => clearTimeout(timeout))
+  toastTimeouts.clear()
+}
+
+/**
+ * Dispatch a state change
+ * @param action - Action to dispatch
+ */
+function dispatch(action: {
+  type: "ADD_TOAST" | "UPDATE_TOAST" | "DISMISS_TOAST" | "REMOVE_TOAST"
+  toast?: ToasterToast
+  toastId?: string
+}) {
+  memoryState = reducer(memoryState, action)
+  listeners.forEach((listener) => {
+    listener(memoryState)
+  })
+}
+
+/**
+ * Generate a unique ID for a toast
+ * @returns Unique ID string
+ */
+function genId() {
+  return Math.random().toString(36).substring(2, 9)
+}
+
+/**
+ * Add a toast to the removal queue
+ * @param toastId - ID of the toast to remove
+ */
+const addToRemoveQueue = (toastId: string) => {
+  if (toastTimeouts.has(toastId)) {
+    return
+  }
+
+  const timeout = setTimeout(() => {
+    toastTimeouts.delete(toastId)
+    dispatch({
+      type: "REMOVE_TOAST",
+      toastId: toastId,
+    })
+  }, TOAST_REMOVE_DELAY)
+
+  toastTimeouts.set(toastId, timeout)
+}
+
+/**
+ * State reducer for toast management
+ * @param state - Current state
+ * @param action - Action to process
+ * @returns New state
+ */
+function reducer(state: State, action: {
+  type: "ADD_TOAST" | "UPDATE_TOAST" | "DISMISS_TOAST" | "REMOVE_TOAST"
+  toast?: ToasterToast
+  toastId?: string
+}): State {
+  switch (action.type) {
+    case "ADD_TOAST":
+      return {
+        ...state,
+        toasts: [action.toast!, ...state.toasts].slice(0, TOAST_LIMIT),
+      }
+
+    case "UPDATE_TOAST":
+      return {
+        ...state,
+        toasts: state.toasts.map((t) =>
+          t.id === action.toast?.id ? { ...t, ...action.toast } : t
+        ),
+      }
+
+    case "DISMISS_TOAST": {
+      const { toastId } = action
+
+      if (toastId) {
+        addToRemoveQueue(toastId)
+      }
+
+      return {
+        ...state,
+        toasts: state.toasts.map((t) =>
+          t.id === toastId || toastId === undefined
+            ? {
+                ...t,
+                open: false,
+              }
+            : t
+        ),
+      }
+    }
+
+    case "REMOVE_TOAST":
+      if (action.toastId === undefined) {
+        return {
+          ...state,
+          toasts: [],
+        }
+      }
+      return {
+        ...state,
+        toasts: state.toasts.filter((t) => t.id !== action.toastId),
+      }
+  }
+}
+
+/**
+ * Toast configuration without ID
+ */
+type Toast = Omit<ToasterToast, "id">
+
+/**
+ * Creates a new toast notification
+ * @param props - Toast configuration
+ * @returns Object with toast ID and control methods
+ */
+function toast({ ...props }: Toast) {
+  const id = genId()
+
+  const update = (props: Partial<Omit<ToasterToast, "id">>) =>
+    dispatch({
+      type: "UPDATE_TOAST",
+      toast: { ...props, id },
+    })
+  const dismiss = () => dispatch({ type: "DISMISS_TOAST", toastId: id })
+
+  dispatch({
+    type: "ADD_TOAST",
+    toast: {
+      ...props,
+      id,
+      open: true,
+      dismiss,
+      onOpenChange: (open) => {
+        if (!open) dismiss()
+      },
+    },
+  })
+
+  return {
+    id: id,
+    dismiss,
+    update,
+  }
+}
+
+/**
+ * Hook for managing toast notifications
+ * @returns Object with toast state and control methods
+ */
+function useToast() {
+  const [state, setState] = React.useState<State>(memoryState)
+
+  React.useEffect(() => {
+    listeners.push(setState)
+    return () => {
+      const index = listeners.indexOf(setState)
+      if (index > -1) {
+        listeners.splice(index, 1)
+      }
+    }
+  }, [state])
+
+  return {
+    ...state,
+    toast,
+    dismiss: (toastId?: string) => dispatch({ type: "DISMISS_TOAST", toastId }),
+  }
+}
+
+export { useToast, toast }
+export type { ToasterToast }

package/src/hooks/useZodForm.ts

@@ -0,0 +1,28 @@
+
+/**
+ * Zod Form Hook
+ * 
+ * Enhanced form hook with Zod validation
+ */
+
+import { useForm } from 'react-hook-form';
+import { zodResolver } from '@hookform/resolvers/zod';
+import { z } from 'zod';
+
+interface UseZodFormProps<T extends z.ZodTypeAny> {
+  schema: T;
+  defaultValues?: Partial<z.infer<T>>;
+  mode?: 'onSubmit' | 'onBlur' | 'onChange' | 'onTouched' | 'all';
+}
+
+export function useZodForm<T extends z.ZodTypeAny>({
+  schema,
+  defaultValues,
+  mode = 'onSubmit'
+}: UseZodFormProps<T>) {
+  return useForm<z.infer<T>>({
+    resolver: zodResolver(schema),
+    defaultValues: defaultValues as any,
+    mode
+  });
+}