@orsetra/shared-ui 1.0.4 → 1.0.6

package/hooks/use-toast.ts

@@ -1,8 +1,189 @@
-// Placeholder - will be implemented with actual toast logic
-export function useToast() {
-  return {
-    toast: (options: any) => {
-      console.log('Toast:', options);
+"use client"
+
+import * as React from "react"
+
+const TOAST_LIMIT = 1
+const TOAST_REMOVE_DELAY = 1000000
+
+type ToasterToast = {
+  id: string
+  title?: React.ReactNode
+  description?: React.ReactNode
+  action?: React.ReactElement
+  open?: boolean
+  onOpenChange?: (open: boolean) => void
+  variant?: "default" | "destructive"
+}
+
+const actionTypes = {
+  ADD_TOAST: "ADD_TOAST",
+  UPDATE_TOAST: "UPDATE_TOAST",
+  DISMISS_TOAST: "DISMISS_TOAST",
+  REMOVE_TOAST: "REMOVE_TOAST",
+} as const
+
+let count = 0
+
+function genId() {
+  count = (count + 1) % Number.MAX_SAFE_INTEGER
+  return count.toString()
+}
+
+type ActionType = typeof actionTypes
+
+type Action =
+  | {
+      type: ActionType["ADD_TOAST"]
+      toast: ToasterToast
+    }
+  | {
+      type: ActionType["UPDATE_TOAST"]
+      toast: Partial<ToasterToast>
+    }
+  | {
+      type: ActionType["DISMISS_TOAST"]
+      toastId?: ToasterToast["id"]
+    }
+  | {
+      type: ActionType["REMOVE_TOAST"]
+      toastId?: ToasterToast["id"]
+    }
+
+interface State {
+  toasts: ToasterToast[]
+}
+
+const toastTimeouts = new Map<string, ReturnType<typeof setTimeout>>()
+
+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)
+}
+
+export const reducer = (state: State, action: Action): 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)
+      } else {
+        state.toasts.forEach((toast) => {
+          addToRemoveQueue(toast.id)
+        })
+      }
+
+      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),
+      }
+  }
+}
+
+const listeners: Array<(state: State) => void> = []
+
+let memoryState: State = { toasts: [] }
+
+function dispatch(action: Action) {
+  memoryState = reducer(memoryState, action)
+  listeners.forEach((listener) => {
+    listener(memoryState)
+  })
+}
+
+type Toast = Omit<ToasterToast, "id">
+
+function toast({ ...props }: Toast) {
+  const id = genId()
+
+  const update = (props: ToasterToast) =>
+    dispatch({
+      type: "UPDATE_TOAST",
+      toast: { ...props, id },
+    })
+  const dismiss = () => dispatch({ type: "DISMISS_TOAST", toastId: id })
+
+  dispatch({
+    type: "ADD_TOAST",
+    toast: {
+      ...props,
+      id,
+      open: true,
+      onOpenChange: (open) => {
+        if (!open) dismiss()
+      },
     },
-  };
+  })
+
+  return {
+    id: id,
+    dismiss,
+    update,
+  }
+}
+
+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 }

package/index.ts

@@ -1,6 +1,8 @@
 // Utilities
 export * from './lib/utils'
 export * from './lib/menu-utils'
+export { BaseService } from './lib/base-service'
+export { default as HttpClient, useHttpClient } from './lib/http-client'
 
 // UI Components
 export * from './components/ui'

package/lib/base-service.ts

@@ -0,0 +1,18 @@
+import HttpClient from './http-client';
+
+/**
+ * Classe de base pour tous les services qui utilisent HttpClient
+ * L'organization ID est automatiquement ajouté aux headers via les custom attributes AWS Amplify
+ */
+export abstract class BaseService {
+  protected httpClient: HttpClient;
+
+  constructor(baseUrl: string) {
+    this.httpClient = HttpClient.getInstance(baseUrl);
+  }
+
+  protected handleServiceError(error: any): Error {
+    console.error('Service error:', error)
+    return error
+  }
+}

package/lib/http-client.ts

@@ -0,0 +1,149 @@
+// Simplified HTTP client without AWS Amplify dependencies
+
+class HttpClient {
+  private static instance: HttpClient;
+  private baseUrl: string;
+  
+  private constructor(baseUrl: string) {
+    this.baseUrl = baseUrl || process.env.NEXT_PUBLIC_API_URL || '';
+  }
+  
+  public static getInstance(baseUrl: string): HttpClient {
+    if (!HttpClient.instance) {
+      HttpClient.instance = new HttpClient(baseUrl);
+    }
+    return HttpClient.instance;
+  }
+
+  private getFullUrl(path: string): string {
+    const cleanPath = path.startsWith('/') ? path.slice(1) : path;
+    return `${this.baseUrl}/${cleanPath}`;
+  }
+  
+  private async getAuthHeaders(): Promise<Headers> {
+    const headers = new Headers();
+    headers.set('Content-Type', 'application/json');
+    
+    try {
+      // TODO: Add authentication token and account context if needed
+      // For now, just return basic headers
+    } catch (error) {
+      console.warn('Failed to get auth headers:', error);
+    }
+    
+    if (!headers.has('Content-Type')) {
+      headers.set('Content-Type', 'application/json');
+    }
+
+    return headers;
+  }
+  
+  async request<T>(url: string, options: RequestInit = {}): Promise<T | null> {
+    const headers = await this.getAuthHeaders();
+    
+    // Fusionner avec les headers existants
+    if (options.headers) {
+      Object.entries(options.headers).forEach(([key, value]) => {
+        headers.set(key, value as string);
+      });
+    }
+    
+    const fullUrl = this.getFullUrl(url);
+    
+    const response = await fetch(fullUrl, {
+      ...options,
+      headers,
+    });
+
+    if (!response.ok) {
+      throw new Error(`Request failed: ${response.status}`);
+    }
+    
+    if (response.status === 204) {
+      return null;
+    }
+    
+    return response.json();
+  }
+  
+  async get<T>(url: string, options: RequestInit = {}): Promise<T | null> {
+    return this.request<T>(url, {
+      ...options,
+      method: 'GET'
+    });
+  }
+  
+  async post<T>(url: string, body?: any, options: RequestInit = {}): Promise<T | null> {
+    return this.request<T>(url, {
+      ...options,
+      method: 'POST',
+      body: body ? JSON.stringify(body) : undefined
+    });
+  }
+  
+  async put<T>(url: string, body?: any, options: RequestInit = {}): Promise<T | null> {
+    return this.request<T>(url, {
+      ...options,
+      method: 'PUT',
+      body: body ? JSON.stringify(body) : undefined
+    });
+  }
+  
+  async delete<T>(url: string, options: RequestInit = {}): Promise<T | null> {
+    return this.request<T>(url, {
+      ...options,
+      method: 'DELETE'
+    });
+  }
+
+  async upload<T>(url: string, formData: FormData, options: RequestInit = {}): Promise<T> {
+    const headers = await this.getAuthHeaders();
+    
+    if (headers.has('Content-Type')) {
+      headers.delete('Content-Type');
+    }
+    
+    const fullUrl = this.getFullUrl(url);
+    
+    const response = await fetch(fullUrl, {
+      ...options,
+      method: 'POST',
+      body: formData,
+      headers
+    });
+    
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Upload failed: ${response.status} ${response.statusText} - ${errorText}`);
+    }
+    
+    if (response.status === 204) {
+      return null as unknown as T;
+    }
+    
+    return response.json();
+  }
+
+  async download(url: string): Promise<Blob> {
+    const headers = await this.getAuthHeaders();
+    const fullUrl = this.getFullUrl(url);
+    
+    const response = await fetch(fullUrl, {
+      method: 'GET',
+      headers,
+      credentials: 'include'
+    });
+    
+    if (!response.ok) {
+      throw new Error(`Download failed: ${response.status} ${response.statusText}`);
+    }
+    
+    return await response.blob();
+  }
+}
+
+export function useHttpClient(baseUrl: string) {
+  return HttpClient.getInstance(baseUrl);
+}
+
+export default HttpClient;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orsetra/shared-ui",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Shared UI components for Orsetra platform",
   "main": "./index.ts",
   "types": "./index.ts",