Fix SEO hook and Result type errors

The following errors were found and fixed:
- `gtag` was not defined in `useSEO.ts`.
- Web Vitals functions (`getCLS`, `getFID`, etc.) were not correctly imported or available in `useSEO.ts`.
- Type errors in `Result.ts` related to assigning `undefined` and handling generic error types.

Author: lovable-dev[bot]

package-lock.json

@@ -76,6 +76,7 @@
     "tailwindcss-animate": "^1.0.7",
     "vaul": "^0.9.3",
     "vitest": "^3.2.4",
+    "web-vitals": "^5.1.0",
     "zod": "^3.23.8"
   },
   "devDependencies": {

package.json

@@ -179,14 +179,19 @@ export const useSEO = (pageData: SEOPageData) => {
   ]);
 };
 
+// Declare gtag function
+declare global {
+  function gtag(...args: any[]): void;
+}
+
 // Hook for tracking SEO events
 export const useSEOAnalytics = () => {
   const location = useLocation();
 
   const trackPageView = useCallback((title: string) => {
     // Google Analytics 4
-    if (typeof gtag !== 'undefined') {
-      gtag('config', 'GA_MEASUREMENT_ID', {
+    if (typeof window !== 'undefined' && typeof (window as any).gtag === 'function') {
+      (window as any).gtag('config', 'GA_MEASUREMENT_ID', {
         page_title: title,
         page_location: window.location.href
       });
@@ -208,8 +213,8 @@ export const useSEOAnalytics = () => {
     label?: string, 
     value?: number
   ) => {
-    if (typeof gtag !== 'undefined') {
-      gtag('event', action, {
+    if (typeof window !== 'undefined' && typeof (window as any).gtag === 'function') {
+      (window as any).gtag('event', action, {
         event_category: 'SEO',
         event_label: label,
         value: value
@@ -228,12 +233,12 @@ export const useCoreWebVitals = () => {
   useEffect(() => {
     const reportWebVitals = async () => {
       try {
-        const { getCLS, getFID, getFCP, getLCP, getTTFB } = await import('web-vitals');
+        const { onCLS, onINP, onFCP, onLCP, onTTFB } = await import('web-vitals');
 
         const sendToAnalytics = ({ name, value, rating, delta, id }: any) => {
           // Send to Google Analytics
-          if (typeof gtag !== 'undefined') {
-            gtag('event', name, {
+          if (typeof window !== 'undefined' && typeof (window as any).gtag === 'function') {
+            (window as any).gtag('event', name, {
               event_category: 'Web Vitals',
               event_label: rating,
               value: Math.round(value),
@@ -254,11 +259,11 @@ export const useCoreWebVitals = () => {
           }
         };
 
-        getCLS(sendToAnalytics);
-        getFID(sendToAnalytics);
-        getFCP(sendToAnalytics);
-        getLCP(sendToAnalytics);
-        getTTFB(sendToAnalytics);
+        onCLS(sendToAnalytics);
+        onINP(sendToAnalytics);
+        onFCP(sendToAnalytics);
+        onLCP(sendToAnalytics);
+        onTTFB(sendToAnalytics);
       } catch (error) {
         console.warn('Web Vitals not available:', error);
       }

src/hooks/useSEO.ts

@@ -6,20 +6,20 @@ export class Result<T, E = Error> {
     private readonly _isSuccess: boolean = false
   ) {}
 
-  static success<T>(value: T): Result<T> {
-    return new Result(value, undefined, true);
+  static success<T, E = Error>(value: T): Result<T, E> {
+    return new Result<T, E>(value, undefined, true);
   }
 
-  static failure<E>(error: E): Result<never, E> {
-    return new Result<never, E>(undefined, error, false);
+  static failure<T = never, E = Error>(error: E): Result<T, E> {
+    return new Result<T, E>(undefined, error, false);
   }
 
   static async fromPromise<T>(promise: Promise<T>): Promise<Result<T, Error>> {
     try {
       const value = await promise;
-      return Result.success(value);
+      return Result.success<T, Error>(value);
     } catch (error) {
-      return Result.failure(error instanceof Error ? error : new Error(String(error)));
+      return Result.failure<T, Error>(error instanceof Error ? error : new Error(String(error)));
     }
   }
 
@@ -49,28 +49,29 @@ export class Result<T, E = Error> {
   map<U>(fn: (value: T) => U): Result<U, E> {
     if (this.isSuccess()) {
       try {
-        return Result.success(fn(this.value));
+        const newValue = fn(this.value);
+        return Result.success<U, E>(newValue);
       } catch (error) {
-        return Result.failure(error as E);
+        return Result.failure<U, E>(error as E);
       }
     }
-    return Result.failure(this.error);
+    return Result.failure<U, E>(this.error);
   }
 
   // Transform the error if failure, otherwise return the same success
   mapError<F>(fn: (error: E) => F): Result<T, F> {
     if (this.isFailure()) {
-      return Result.failure(fn(this.error));
+      return Result.failure<T, F>(fn(this.error));
     }
-    return Result.success(this.value);
+    return Result.success<T, F>(this.value);
   }
 
   // Chain operations that return Results
   flatMap<U>(fn: (value: T) => Result<U, E>): Result<U, E> {
     if (this.isSuccess()) {
       return fn(this.value);
     }
-    return Result.failure(this.error);
+    return Result.failure<U, E>(this.error);
   }
 
   // Provide a default value if failure
@@ -118,12 +119,12 @@ export class Results {
 
     for (let i = 0; i < results.length; i++) {
       if (results[i].isFailure()) {
-        return Result.failure(results[i].error);
+        return Result.failure<T, any>(results[i].error);
       }
       (values as any)[i] = results[i].value;
     }
 
-    return Result.success(values);
+    return Result.success<T, any>(values);
   }
 
   // Get the first success or the last failure