feat: format with prettier

apps/web/components/Contexts/AI/AIChatBotContext.tsx

@@ -1,76 +1,74 @@
-'use client';
-import { AIMessage } from '@components/Objects/Activities/AI/AIActivityAsk';
+'use client'
+import { AIMessage } from '@components/Objects/Activities/AI/AIActivityAsk'
 import React, { createContext, useContext, useReducer } from 'react'
-export const AIChatBotContext = createContext(null) as any;
-export const AIChatBotDispatchContext = createContext(null) as any;
+export const AIChatBotContext = createContext(null) as any
+export const AIChatBotDispatchContext = createContext(null) as any
 
 export type AIChatBotStateTypes = {
-    messages: AIMessage[],
-    isModalOpen: boolean,
-    aichat_uuid: string,
-    isWaitingForResponse: boolean,
-    chatInputValue: string
-    error: AIError
+  messages: AIMessage[]
+  isModalOpen: boolean
+  aichat_uuid: string
+  isWaitingForResponse: boolean
+  chatInputValue: string
+  error: AIError
 }
 
 type AIError = {
-    isError: boolean
-    status: number
-    error_message: string
+  isError: boolean
+  status: number
+  error_message: string
 }
 
 function AIChatBotProvider({ children }: { children: React.ReactNode }) {
-    const [aiChatBotState, dispatchAIChatBot] = useReducer(aiChatBotReducer,
-        {
-            messages: [] as AIMessage[],
-            isModalOpen: false,
-            aichat_uuid: null,
-            isWaitingForResponse: false,
-            chatInputValue: '',
-            error: { isError: false, status: 0, error_message: ' ' } as AIError
-        }
-    );
-    return (
-        <AIChatBotContext.Provider value={aiChatBotState}>
-            <AIChatBotDispatchContext.Provider value={dispatchAIChatBot}>
-                {children}
-            </AIChatBotDispatchContext.Provider>
-        </AIChatBotContext.Provider>
-    )
+  const [aiChatBotState, dispatchAIChatBot] = useReducer(aiChatBotReducer, {
+    messages: [] as AIMessage[],
+    isModalOpen: false,
+    aichat_uuid: null,
+    isWaitingForResponse: false,
+    chatInputValue: '',
+    error: { isError: false, status: 0, error_message: ' ' } as AIError,
+  })
+  return (
+    <AIChatBotContext.Provider value={aiChatBotState}>
+      <AIChatBotDispatchContext.Provider value={dispatchAIChatBot}>
+        {children}
+      </AIChatBotDispatchContext.Provider>
+    </AIChatBotContext.Provider>
+  )
 }
 
 export default AIChatBotProvider
 
 export function useAIChatBot() {
-    return useContext(AIChatBotContext);
+  return useContext(AIChatBotContext)
 }
 
 export function useAIChatBotDispatch() {
-    return useContext(AIChatBotDispatchContext);
+  return useContext(AIChatBotDispatchContext)
 }
 
 function aiChatBotReducer(state: any, action: any) {
-    switch (action.type) {
-        case 'setMessages':
-            return { ...state, messages: action.payload };
-        case 'addMessage':
-            return { ...state, messages: [...state.messages, action.payload] };
-        case 'setIsModalOpen':
-            return { ...state, isModalOpen: true };
-        case 'setIsModalClose':
-            return { ...state, isModalOpen: false };
-        case 'setAichat_uuid':
-            return { ...state, aichat_uuid: action.payload };
-        case 'setIsWaitingForResponse':
-            return { ...state, isWaitingForResponse: true };
-        case 'setIsNoLongerWaitingForResponse':
-            return { ...state, isWaitingForResponse: false };
-        case 'setChatInputValue':
-            return { ...state, chatInputValue: action.payload };
-        case 'setError':
-            return { ...state, error: action.payload };
+  switch (action.type) {
+    case 'setMessages':
+      return { ...state, messages: action.payload }
+    case 'addMessage':
+      return { ...state, messages: [...state.messages, action.payload] }
+    case 'setIsModalOpen':
+      return { ...state, isModalOpen: true }
+    case 'setIsModalClose':
+      return { ...state, isModalOpen: false }
+    case 'setAichat_uuid':
+      return { ...state, aichat_uuid: action.payload }
+    case 'setIsWaitingForResponse':
+      return { ...state, isWaitingForResponse: true }
+    case 'setIsNoLongerWaitingForResponse':
+      return { ...state, isWaitingForResponse: false }
+    case 'setChatInputValue':
+      return { ...state, chatInputValue: action.payload }
+    case 'setError':
+      return { ...state, error: action.payload }
 
-        default:
-            throw new Error(`Unhandled action type: ${action.type}`)
-    }
-}
+    default:
+      throw new Error(`Unhandled action type: ${action.type}`)
+  }
+}

apps/web/components/Contexts/AI/AIEditorContext.tsx

@@ -1,92 +1,93 @@
-'use client';
-import { AIMessage } from '@components/Objects/Activities/AI/AIActivityAsk';
+'use client'
+import { AIMessage } from '@components/Objects/Activities/AI/AIActivityAsk'
 import React, { createContext, useContext, useReducer } from 'react'
-export const AIEditorContext = createContext(null) as any;
-export const AIEditorDispatchContext = createContext(null) as any;
+export const AIEditorContext = createContext(null) as any
+export const AIEditorDispatchContext = createContext(null) as any
 
 export type AIEditorStateTypes = {
-
-    messages: AIMessage[],
-    isModalOpen: boolean,
-    isFeedbackModalOpen: boolean,
-    aichat_uuid: string,
-    isWaitingForResponse: boolean,
-    chatInputValue: string,
-    selectedTool: 'Writer' | 'ContinueWriting' | 'MakeLonger' | 'GenerateQuiz' | 'Translate'
-    isUserInputEnabled: boolean
-    error: AIError
+  messages: AIMessage[]
+  isModalOpen: boolean
+  isFeedbackModalOpen: boolean
+  aichat_uuid: string
+  isWaitingForResponse: boolean
+  chatInputValue: string
+  selectedTool:
+    | 'Writer'
+    | 'ContinueWriting'
+    | 'MakeLonger'
+    | 'GenerateQuiz'
+    | 'Translate'
+  isUserInputEnabled: boolean
+  error: AIError
 }
 
 type AIError = {
-    isError: boolean
-    status: number
-    error_message: string
+  isError: boolean
+  status: number
+  error_message: string
 }
 
 function AIEditorProvider({ children }: { children: React.ReactNode }) {
-    const [aIEditorState, dispatchAIEditor] = useReducer(aIEditorReducer,
-        {
-            messages: [] as AIMessage[],
-            isModalOpen: false,
-            isFeedbackModalOpen: false,
-            aichat_uuid: null,
-            isWaitingForResponse: false,
-            chatInputValue: '',
-            selectedTool: 'Writer',
-            isUserInputEnabled: true,
-            error: { isError: false, status: 0, error_message: ' ' } as AIError
-        }
-    );
-    return (
-        <AIEditorContext.Provider value={aIEditorState}>
-            <AIEditorDispatchContext.Provider value={dispatchAIEditor}>
-                {children}
-            </AIEditorDispatchContext.Provider>
-        </AIEditorContext.Provider>
-    )
+  const [aIEditorState, dispatchAIEditor] = useReducer(aIEditorReducer, {
+    messages: [] as AIMessage[],
+    isModalOpen: false,
+    isFeedbackModalOpen: false,
+    aichat_uuid: null,
+    isWaitingForResponse: false,
+    chatInputValue: '',
+    selectedTool: 'Writer',
+    isUserInputEnabled: true,
+    error: { isError: false, status: 0, error_message: ' ' } as AIError,
+  })
+  return (
+    <AIEditorContext.Provider value={aIEditorState}>
+      <AIEditorDispatchContext.Provider value={dispatchAIEditor}>
+        {children}
+      </AIEditorDispatchContext.Provider>
+    </AIEditorContext.Provider>
+  )
 }
 
 export default AIEditorProvider
 
 export function useAIEditor() {
-    return useContext(AIEditorContext);
+  return useContext(AIEditorContext)
 }
 
 export function useAIEditorDispatch() {
-    return useContext(AIEditorDispatchContext);
+  return useContext(AIEditorDispatchContext)
 }
 
 function aIEditorReducer(state: any, action: any) {
-    switch (action.type) {
-        case 'setMessages':
-            return { ...state, messages: action.payload };
-        case 'addMessage':
-            return { ...state, messages: [...state.messages, action.payload] };
-        case 'setIsModalOpen':
-            return { ...state, isModalOpen: true };
-        case 'setIsModalClose':
-            return { ...state, isModalOpen: false };
-        case 'setAichat_uuid':
-            return { ...state, aichat_uuid: action.payload };
-        case 'setIsWaitingForResponse':
-            return { ...state, isWaitingForResponse: true };
-        case 'setIsNoLongerWaitingForResponse':
-            return { ...state, isWaitingForResponse: false };
-        case 'setChatInputValue':
-            return { ...state, chatInputValue: action.payload };
-        case 'setSelectedTool':
-            return { ...state, selectedTool: action.payload };
-        case 'setIsFeedbackModalOpen':
-            return { ...state, isFeedbackModalOpen: true };
-        case 'setIsFeedbackModalClose':
-            return { ...state, isFeedbackModalOpen: false };
-        case 'setIsUserInputEnabled':
-            return { ...state, isUserInputEnabled: action.payload };
-        case 'setError':
-            return { ...state, error: action.payload };
+  switch (action.type) {
+    case 'setMessages':
+      return { ...state, messages: action.payload }
+    case 'addMessage':
+      return { ...state, messages: [...state.messages, action.payload] }
+    case 'setIsModalOpen':
+      return { ...state, isModalOpen: true }
+    case 'setIsModalClose':
+      return { ...state, isModalOpen: false }
+    case 'setAichat_uuid':
+      return { ...state, aichat_uuid: action.payload }
+    case 'setIsWaitingForResponse':
+      return { ...state, isWaitingForResponse: true }
+    case 'setIsNoLongerWaitingForResponse':
+      return { ...state, isWaitingForResponse: false }
+    case 'setChatInputValue':
+      return { ...state, chatInputValue: action.payload }
+    case 'setSelectedTool':
+      return { ...state, selectedTool: action.payload }
+    case 'setIsFeedbackModalOpen':
+      return { ...state, isFeedbackModalOpen: true }
+    case 'setIsFeedbackModalClose':
+      return { ...state, isFeedbackModalOpen: false }
+    case 'setIsUserInputEnabled':
+      return { ...state, isUserInputEnabled: action.payload }
+    case 'setError':
+      return { ...state, error: action.payload }
 
-
-        default:
-            throw new Error(`Unhandled action type: ${action.type}`)
-    }
-}
+    default:
+      throw new Error(`Unhandled action type: ${action.type}`)
+  }
+}

apps/web/components/Contexts/CourseContext.tsx

@@ -1,63 +1,70 @@
-'use client';
-import PageLoading from '@components/Objects/Loaders/PageLoading';
-import { getAPIUrl } from '@services/config/config';
-import { swrFetcher } from '@services/utils/ts/requests';
+'use client'
+import PageLoading from '@components/Objects/Loaders/PageLoading'
+import { getAPIUrl } from '@services/config/config'
+import { swrFetcher } from '@services/utils/ts/requests'
 import React, { createContext, useContext, useEffect, useReducer } from 'react'
-import useSWR from 'swr';
+import useSWR from 'swr'
 
-export const CourseContext = createContext(null) as any;
-export const CourseDispatchContext = createContext(null) as any;
+export const CourseContext = createContext(null) as any
+export const CourseDispatchContext = createContext(null) as any
 
-export function CourseProvider({ children, courseuuid }: { children: React.ReactNode, courseuuid: string }) {
-    const { data: courseStructureData } = useSWR(`${getAPIUrl()}courses/${courseuuid}/meta`, swrFetcher);
-    const [courseStructure, dispatchCourseStructure] = useReducer(courseReducer,
-        {
-            courseStructure: courseStructureData ? courseStructureData : {},
-            courseOrder: {},
-            isSaved: true
-        }
-    );
+export function CourseProvider({
+  children,
+  courseuuid,
+}: {
+  children: React.ReactNode
+  courseuuid: string
+}) {
+  const { data: courseStructureData } = useSWR(
+    `${getAPIUrl()}courses/${courseuuid}/meta`,
+    swrFetcher
+  )
+  const [courseStructure, dispatchCourseStructure] = useReducer(courseReducer, {
+    courseStructure: courseStructureData ? courseStructureData : {},
+    courseOrder: {},
+    isSaved: true,
+  })
 
+  // When courseStructureData is loaded, update the state
+  useEffect(() => {
+    if (courseStructureData) {
+      dispatchCourseStructure({
+        type: 'setCourseStructure',
+        payload: courseStructureData,
+      })
+    }
+  }, [courseStructureData])
 
-    // When courseStructureData is loaded, update the state
-    useEffect(() => {
-        if (courseStructureData) {
-            dispatchCourseStructure({ type: 'setCourseStructure', payload: courseStructureData });
-        }
-    }, [courseStructureData]);
+  if (!courseStructureData) return <PageLoading></PageLoading>
 
-
-    if (!courseStructureData) return <PageLoading></PageLoading>
-
-
-    return (
-        <CourseContext.Provider value={courseStructure}>
-            <CourseDispatchContext.Provider value={dispatchCourseStructure}>
-                {children}
-            </CourseDispatchContext.Provider>
-        </CourseContext.Provider>
-    )
+  return (
+    <CourseContext.Provider value={courseStructure}>
+      <CourseDispatchContext.Provider value={dispatchCourseStructure}>
+        {children}
+      </CourseDispatchContext.Provider>
+    </CourseContext.Provider>
+  )
 }
 
 export function useCourse() {
-    return useContext(CourseContext);
+  return useContext(CourseContext)
 }
 
 export function useCourseDispatch() {
-    return useContext(CourseDispatchContext);
+  return useContext(CourseDispatchContext)
 }
 
 function courseReducer(state: any, action: any) {
-    switch (action.type) {
-        case 'setCourseStructure':
-            return { ...state, courseStructure: action.payload };
-        case 'setCourseOrder':
-            return { ...state, courseOrder: action.payload };
-        case 'setIsSaved':
-            return { ...state, isSaved: true };
-        case 'setIsNotSaved':
-            return { ...state, isSaved: false };
-        default:
-            throw new Error(`Unhandled action type: ${action.type}`);
-    }
-}
+  switch (action.type) {
+    case 'setCourseStructure':
+      return { ...state, courseStructure: action.payload }
+    case 'setCourseOrder':
+      return { ...state, courseOrder: action.payload }
+    case 'setIsSaved':
+      return { ...state, isSaved: true }
+    case 'setIsNotSaved':
+      return { ...state, isSaved: false }
+    default:
+      throw new Error(`Unhandled action type: ${action.type}`)
+  }
+}

apps/web/components/Contexts/Editor/EditorContext.tsx

@@ -1,32 +1,30 @@
-'use client';
+'use client'
 import React, { useState } from 'react'
 
-
-export const EditorProviderContext = React.createContext(null) as any;
+export const EditorProviderContext = React.createContext(null) as any
 
 type EditorProviderProps = {
-    children: React.ReactNode
-    options: EditorProviderState
+  children: React.ReactNode
+  options: EditorProviderState
 }
 
 type EditorProviderState = {
-    isEditable: boolean
+  isEditable: boolean
 }
 
 function EditorOptionsProvider({ children, options }: EditorProviderProps) {
-    const [editorOptions, setEditorOptions] = useState<EditorProviderState>(options);
+  const [editorOptions, setEditorOptions] =
+    useState<EditorProviderState>(options)
 
-    return (
-        <EditorProviderContext.Provider value={editorOptions}>
-            {children}
-        </EditorProviderContext.Provider>
-    )
+  return (
+    <EditorProviderContext.Provider value={editorOptions}>
+      {children}
+    </EditorProviderContext.Provider>
+  )
 }
 
 export default EditorOptionsProvider
 
 export function useEditorProvider() {
-    return React.useContext(EditorProviderContext);
+  return React.useContext(EditorProviderContext)
 }
-
-

apps/web/components/Contexts/OrgContext.tsx

@@ -1,25 +1,25 @@
-'use client';
-import { getAPIUrl } from '@services/config/config';
-import { swrFetcher } from '@services/utils/ts/requests';
+'use client'
+import { getAPIUrl } from '@services/config/config'
+import { swrFetcher } from '@services/utils/ts/requests'
 import React, { useContext, useEffect } from 'react'
-import useSWR from 'swr';
-import { createContext } from 'react';
+import useSWR from 'swr'
+import { createContext } from 'react'
 
-export const OrgContext = createContext({}) as any;
+export const OrgContext = createContext({}) as any
 
-export function OrgProvider({ children, orgslug }: { children: React.ReactNode, orgslug: string }) {
-    const { data: org } = useSWR(`${getAPIUrl()}orgs/slug/${orgslug}`, swrFetcher);
-    useEffect(() => {
+export function OrgProvider({
+  children,
+  orgslug,
+}: {
+  children: React.ReactNode
+  orgslug: string
+}) {
+  const { data: org } = useSWR(`${getAPIUrl()}orgs/slug/${orgslug}`, swrFetcher)
+  useEffect(() => {}, [org])
 
-    }, [org]);
-
-    return (
-        <OrgContext.Provider value={org}>
-            {children}
-        </OrgContext.Provider>
-    )
+  return <OrgContext.Provider value={org}>{children}</OrgContext.Provider>
 }
 
 export function useOrg() {
-    return useContext(OrgContext);
+  return useContext(OrgContext)
 }

apps/web/components/Contexts/SessionContext.tsx

@@ -1,59 +1,77 @@
-'use client';
-import { getNewAccessTokenUsingRefreshToken, getUserSession } from '@services/auth/auth';
+'use client'
+import {
+  getNewAccessTokenUsingRefreshToken,
+  getUserSession,
+} from '@services/auth/auth'
 import React, { useContext, createContext, useEffect } from 'react'
 
-export const SessionContext = createContext({}) as any;
+export const SessionContext = createContext({}) as any
 
 type Session = {
-    access_token: string;
-    user: any;
-    roles: any;
-    isLoading: boolean;
-    isAuthenticated: boolean;
+  access_token: string
+  user: any
+  roles: any
+  isLoading: boolean
+  isAuthenticated: boolean
 }
 
 function SessionProvider({ children }: { children: React.ReactNode }) {
-    const [session, setSession] = React.useState<Session>({ access_token: "", user: {}, roles: {}, isLoading: true, isAuthenticated: false });
+  const [session, setSession] = React.useState<Session>({
+    access_token: '',
+    user: {},
+    roles: {},
+    isLoading: true,
+    isAuthenticated: false,
+  })
 
-    async function getNewAccessTokenUsingRefreshTokenUI() {
-        let data = await getNewAccessTokenUsingRefreshToken();
-        return data.access_token;
+  async function getNewAccessTokenUsingRefreshTokenUI() {
+    let data = await getNewAccessTokenUsingRefreshToken()
+    return data.access_token
+  }
+
+  async function checkSession() {
+    // Get new access token using refresh token
+    const access_token = await getNewAccessTokenUsingRefreshTokenUI()
+
+    if (access_token) {
+      // Get user session info
+      const user_session = await getUserSession(access_token)
+
+      // Set session
+      setSession({
+        access_token: access_token,
+        user: user_session.user,
+        roles: user_session.roles,
+        isLoading: false,
+        isAuthenticated: true,
+      })
     }
 
-    async function checkSession() {
-        // Get new access token using refresh token
-        const access_token = await getNewAccessTokenUsingRefreshTokenUI();
-
-        if (access_token) {
-            // Get user session info
-            const user_session = await getUserSession(access_token);
-
-            // Set session
-            setSession({ access_token: access_token, user: user_session.user, roles: user_session.roles, isLoading: false, isAuthenticated: true });
-        }
-
-        if (!access_token) {
-            setSession({ access_token: "", user: {}, roles: {}, isLoading: false, isAuthenticated: false });
-        }
+    if (!access_token) {
+      setSession({
+        access_token: '',
+        user: {},
+        roles: {},
+        isLoading: false,
+        isAuthenticated: false,
+      })
     }
+  }
 
+  useEffect(() => {
+    // Check session
+    checkSession()
+  }, [])
 
-
-    useEffect(() => {
-        // Check session
-        checkSession();
-
-    }, [])
-
-    return (
-        <SessionContext.Provider value={session}>
-            {children}
-        </SessionContext.Provider>
-    )
+  return (
+    <SessionContext.Provider value={session}>
+      {children}
+    </SessionContext.Provider>
+  )
 }
 
 export function useSession() {
-    return useContext(SessionContext);
+  return useContext(SessionContext)
 }
 
-export default SessionProvider
+export default SessionProvider