Run prettier

lib/analytics.ts

@@ -1,62 +1,62 @@
-import type { NextRequest, NextFetchEvent } from "next/server";
-import type { NextApiRequest } from "next";
+import type { NextRequest, NextFetchEvent } from 'next/server'
+import type { NextApiRequest } from 'next'
 
 export const initAnalytics = ({
   request,
-  event,
+  event
 }: {
-  request: NextRequest | NextApiRequest | Request;
-  event?: NextFetchEvent;
+  request: NextRequest | NextApiRequest | Request
+  event?: NextFetchEvent
 }) => {
-  const endpoint = process.env.VERCEL_URL;
+  const endpoint = process.env.VERCEL_URL
 
   return {
     track: async (eventName: string, data?: any) => {
       try {
-        if (!endpoint && process.env.NODE_ENV === "development") {
+        if (!endpoint && process.env.NODE_ENV === 'development') {
           console.log(
             `[Vercel Web Analytics] Track "${eventName}"` +
-              (data ? ` with data ${JSON.stringify(data || {})}` : "")
-          );
-          return;
+              (data ? ` with data ${JSON.stringify(data || {})}` : '')
+          )
+          return
         }
 
-        const headers: { [key: string]: string } = {};
+        const headers: { [key: string]: string } = {}
         Object.entries(request.headers).map(([key, value]) => {
-          headers[key] = value;
-        });
+          headers[key] = value
+        })
 
         const body = {
           o: headers.referer,
           ts: new Date().getTime(),
-          r: "",
+          r: '',
           en: eventName,
-          ed: data,
-        };
+          ed: data
+        }
 
         const promise = fetch(
           `https://${process.env.VERCEL_URL}/_vercel/insights/event`,
           {
             headers: {
-              "content-type": "application/json",
-              "user-agent": headers["user-agent"] as string,
-              "x-forwarded-for": headers["x-forwarded-for"] as string,
-              "x-va-server": "1",
+              'content-type': 'application/json',
+              'user-agent': headers['user-agent'] as string,
+              'x-forwarded-for': headers['x-forwarded-for'] as string,
+              'x-va-server': '1'
             },
             body: JSON.stringify(body),
-            method: "POST",
+            method: 'POST'
           }
-        );
+        )
 
         if (event) {
-          event.waitUntil(promise);
+          event.waitUntil(promise)
         }
         {
-          await promise;
+          await promise
         }
       } catch (err) {
-        console.error(err);
+        console.error(err)
       }
-    },
-  };
-};
+    }
+  }
+}

lib/fonts.ts

@@ -1,21 +1,21 @@
 import {
   JetBrains_Mono as FontMono,
   IBM_Plex_Sans as FontMessage,
-  Inter as FontSans,
-} from "next/font/google";
+  Inter as FontSans
+} from 'next/font/google'
 
 export const fontSans = FontSans({
-  subsets: ["latin"],
-  variable: "--font-sans",
-});
+  subsets: ['latin'],
+  variable: '--font-sans'
+})
 
 export const fontMessage = FontMessage({
-  subsets: ["latin"],
-  weight: ["400", "500", "600"],
-  variable: "--font-message",
-});
+  subsets: ['latin'],
+  weight: ['400', '500', '600'],
+  variable: '--font-message'
+})
 
 export const fontMono = FontMono({
-  subsets: ["latin"],
-  variable: "--font-mono",
-});
+  subsets: ['latin'],
+  variable: '--font-mono'
+})

lib/hooks/use-command-enter-submit.tsx

@@ -1,19 +1,19 @@
-import type { RefObject } from "react";
-import { useRef } from "react";
+import type { RefObject } from 'react'
+import { useRef } from 'react'
 
 export function useCmdEnterSubmit(): {
-  formRef: RefObject<HTMLFormElement>;
-  onKeyDown: (event: React.KeyboardEvent<HTMLTextAreaElement>) => void;
+  formRef: RefObject<HTMLFormElement>
+  onKeyDown: (event: React.KeyboardEvent<HTMLTextAreaElement>) => void
 } {
-  const formRef = useRef<HTMLFormElement>(null);
+  const formRef = useRef<HTMLFormElement>(null)
 
   const handleKeyDown = (
     event: React.KeyboardEvent<HTMLTextAreaElement>
   ): void => {
-    if (event.key === "Enter") {
-      formRef.current?.requestSubmit();
+    if (event.key === 'Enter') {
+      formRef.current?.requestSubmit()
     }
-  };
+  }
 
-  return { formRef, onKeyDown: handleKeyDown };
+  return { formRef, onKeyDown: handleKeyDown }
 }

lib/hooks/use-copy-to-cliipboard.tsx

@@ -1,14 +1,14 @@
-'use client';
-import { useState } from 'react';
+'use client'
+import { useState } from 'react'
 
 export interface useCopyToClipboardProps {
-  timeout?: number;
+  timeout?: number
 }
 
 export function useCopyToClipboard({
-  timeout = 2000,
+  timeout = 2000
 }: useCopyToClipboardProps) {
-  const [isCopied, setIsCopied] = useState<Boolean>(false);
+  const [isCopied, setIsCopied] = useState<Boolean>(false)
 
   const copyToClipboard = (value: string) => {
     if (
@@ -16,17 +16,17 @@ export function useCopyToClipboard({
       !navigator.clipboard ||
       !navigator.clipboard.writeText
     ) {
-      return;
+      return
     }
 
     navigator.clipboard.writeText(value).then(() => {
-      setIsCopied(true);
+      setIsCopied(true)
 
       setTimeout(() => {
-        setIsCopied(false);
-      }, timeout);
-    });
-  };
+        setIsCopied(false)
+      }, timeout)
+    })
+  }
 
-  return { isCopied, copyToClipboard };
+  return { isCopied, copyToClipboard }
 }

lib/hooks/use-follow-scroll.ts

@@ -1,43 +1,43 @@
-import { useEffect, useRef } from "react";
+import { useEffect, useRef } from 'react'
 
 const scrollToEnd = () => {
   window.scrollTo({
     top: document.body.scrollHeight,
-    left: 0,
-  });
-};
+    left: 0
+  })
+}
 
 export function useFollowScroll(shouldFollow: boolean) {
-  const shouldFollowRef = useRef(shouldFollow);
-  const scrollRef = useRef(false);
-  const triggeredBySelfRef = useRef(false);
+  const shouldFollowRef = useRef(shouldFollow)
+  const scrollRef = useRef(false)
+  const triggeredBySelfRef = useRef(false)
 
   useEffect(() => {
     const handleScroll = () => {
       if (triggeredBySelfRef.current) {
-        triggeredBySelfRef.current = false;
-        return;
+        triggeredBySelfRef.current = false
+        return
       }
-      scrollRef.current = true;
-    };
-    window.addEventListener("scroll", handleScroll);
-    return () => window.removeEventListener("scroll", handleScroll);
-  }, []);
+      scrollRef.current = true
+    }
+    window.addEventListener('scroll', handleScroll)
+    return () => window.removeEventListener('scroll', handleScroll)
+  }, [])
 
   useEffect(() => {
     if (!scrollRef.current && shouldFollowRef.current) {
       setTimeout(() => {
-        triggeredBySelfRef.current = true;
-        scrollToEnd();
-      });
+        triggeredBySelfRef.current = true
+        scrollToEnd()
+      })
     }
-  });
+  })
 
   useEffect(() => {
-    shouldFollowRef.current = shouldFollow;
+    shouldFollowRef.current = shouldFollow
     if (!shouldFollow) {
       // Reset scrollRef
-      scrollRef.current = false;
+      scrollRef.current = false
     }
-  }, [shouldFollow]);
+  }, [shouldFollow])
 }

lib/hooks/use-local-storage.ts

@@ -1,26 +1,26 @@
-import { useEffect, useState } from "react";
+import { useEffect, useState } from 'react'
 
 const useLocalStorage = <T>(
   key: string,
   initialValue: T
 ): [T, (value: T) => void] => {
-  const [storedValue, setStoredValue] = useState(initialValue);
+  const [storedValue, setStoredValue] = useState(initialValue)
 
   useEffect(() => {
     // Retrieve from localStorage
-    const item = window.localStorage.getItem(key);
+    const item = window.localStorage.getItem(key)
     if (item) {
-      setStoredValue(JSON.parse(item));
+      setStoredValue(JSON.parse(item))
     }
-  }, [key]);
+  }, [key])
 
   const setValue = (value: T) => {
     // Save state
-    setStoredValue(value);
+    setStoredValue(value)
     // Save to localStorage
-    window.localStorage.setItem(key, JSON.stringify(value));
-  };
-  return [storedValue, setValue];
-};
+    window.localStorage.setItem(key, JSON.stringify(value))
+  }
+  return [storedValue, setValue]
+}
 
-export default useLocalStorage;
+export default useLocalStorage

lib/hooks/use-scroll.ts

@@ -1,16 +1,16 @@
-import { useCallback, useEffect, useState } from "react";
+import { useCallback, useEffect, useState } from 'react'
 
 export default function useScroll(threshold: number) {
-  const [scrolled, setScrolled] = useState(false);
+  const [scrolled, setScrolled] = useState(false)
 
   const onScroll = useCallback(() => {
-    setScrolled(window.pageYOffset > threshold);
-  }, [threshold]);
+    setScrolled(window.pageYOffset > threshold)
+  }, [threshold])
 
   useEffect(() => {
-    window.addEventListener("scroll", onScroll);
-    return () => window.removeEventListener("scroll", onScroll);
-  }, [onScroll]);
+    window.addEventListener('scroll', onScroll)
+    return () => window.removeEventListener('scroll', onScroll)
+  }, [onScroll])
 
-  return scrolled;
+  return scrolled
 }

lib/hooks/use-window-size.ts

@@ -1,14 +1,14 @@
-"use client";
-import { useEffect, useState } from "react";
+'use client'
+import { useEffect, useState } from 'react'
 
 export default function useWindowSize() {
   const [windowSize, setWindowSize] = useState<{
-    width: number | undefined;
-    height: number | undefined;
+    width: number | undefined
+    height: number | undefined
   }>({
     width: undefined,
-    height: undefined,
-  });
+    height: undefined
+  })
 
   useEffect(() => {
     // Handler to call on window resize
@@ -16,24 +16,23 @@ export default function useWindowSize() {
       // Set window width/height to state
       setWindowSize({
         width: window.innerWidth,
-        height: window.innerHeight,
-      });
+        height: window.innerHeight
+      })
     }
 
     // Add event listener
-    window.addEventListener("resize", handleResize);
+    window.addEventListener('resize', handleResize)
 
     // Call handler right away so state gets updated with initial window size
-    handleResize();
+    handleResize()
 
     // Remove event listener on cleanup
-    return () => window.removeEventListener("resize", handleResize);
-  }, []); // Empty array ensures that effect is only run on mount
+    return () => window.removeEventListener('resize', handleResize)
+  }, []) // Empty array ensures that effect is only run on mount
 
   return {
     windowSize,
-    isMobile: typeof windowSize?.width === "number" && windowSize?.width < 768,
-    isDesktop:
-      typeof windowSize?.width === "number" && windowSize?.width >= 768,
-  };
+    isMobile: typeof windowSize?.width === 'number' && windowSize?.width < 768,
+    isDesktop: typeof windowSize?.width === 'number' && windowSize?.width >= 768
+  }
 }

lib/types.ts

@@ -1,9 +1,9 @@
-import { type Message } from "ai-connector";
+import { type Message } from 'ai-connector'
 
 export interface Chat extends Record<string, any> {
-  id: string;
-  title: string;
-  createdAt: Date;
-  userId: string;
-  messages: Message[];
+  id: string
+  title: string
+  createdAt: Date
+  userId: string
+  messages: Message[]
 }

lib/utils.ts

@@ -1,34 +1,34 @@
-import { clsx, type ClassValue } from "clsx";
-import { customAlphabet } from "nanoid";
-import { twMerge } from "tailwind-merge";
+import { clsx, type ClassValue } from 'clsx'
+import { customAlphabet } from 'nanoid'
+import { twMerge } from 'tailwind-merge'
 
 export function cn(...inputs: ClassValue[]) {
-  return twMerge(clsx(inputs));
+  return twMerge(clsx(inputs))
 }
 
 export const nanoid = customAlphabet(
-  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
   7
-); // 7-character random string
+) // 7-character random string
 
 export async function fetcher<JSON = any>(
   input: RequestInfo,
   init?: RequestInit
 ): Promise<JSON> {
-  const res = await fetch(input, init);
+  const res = await fetch(input, init)
 
   if (!res.ok) {
-    const json = await res.json();
+    const json = await res.json()
     if (json.error) {
       const error = new Error(json.error) as Error & {
-        status: number;
-      };
-      error.status = res.status;
-      throw error;
+        status: number
+      }
+      error.status = res.status
+      throw error
     } else {
-      throw new Error("An unexpected error occurred");
+      throw new Error('An unexpected error occurred')
     }
   }
 
-  return res.json();
+  return res.json()
 }