@c-rex/contexts 0.1.5 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@c-rex/contexts",
-    "version": "0.1.5",
+    "version": "0.1.7",
     "type": "module",
     "files": [
         "src"

package/src/config-provider.tsx

@@ -7,32 +7,34 @@ import { getConfigs } from '@c-rex/utils/next-cookies'
 import React, { createContext, useContext, useEffect, useState } from 'react'
 
 type AppConfigContextType = {
-    configs: ConfigInterface
-    availableLanguagesAndCountries: LanguageAndCountries[]
-    loading: boolean
     error: Error | null
     uiLang: string | null
+    configs: ConfigInterface
+    loading: boolean
+    packageID: string | null
     contentLang: string | null
+    articleLang: string | null
     availableVersions: SidebarAvailableVersionsInterface[] | null
-    packageID: string | null
+    availableLanguagesAndCountries: LanguageAndCountries[]
     setUiLang: (lang: string | null) => void
     setContentLang: (lang: string | null) => void
     setAvailableVersions: (versions: SidebarAvailableVersionsInterface[] | null) => void
-    setLoading: (loading: boolean) => void,
-    setPackageID: (lang: string | null) => void
+    setPackageID: (id: string | null) => void
+    setArticleLang: (lang: string | null) => void
 }
 
 const AppConfigContext = createContext<AppConfigContextType | undefined>(undefined)
 
 export const AppConfigProvider = ({ children }: { children: React.ReactNode }) => {
+    const [error, setError] = useState<Error | null>(null)
+    const [uiLang, setUiLang] = useState<string | null>(null)
     const [configs, setConfigs] = useState<ConfigInterface | null>(null)
-    const [availableLanguagesAndCountries, setAvailableLanguagesAndCountries] = useState<LanguageAndCountries[] | null>(null)
-    const [availableVersions, setAvailableVersions] = useState<SidebarAvailableVersionsInterface[] | null>(null)
     const [loading, setLoading] = useState(true)
-    const [uiLang, setUiLang] = useState<string | null>(null)
     const [packageID, setPackageID] = useState<string | null>(null)
+    const [articleLang, setArticleLang] = useState<string | null>(null)
     const [contentLang, setContentLang] = useState<string | null>(null)
-    const [error, setError] = useState<Error | null>(null)
+    const [availableVersions, setAvailableVersions] = useState<SidebarAvailableVersionsInterface[] | null>(null)
+    const [availableLanguagesAndCountries, setAvailableLanguagesAndCountries] = useState<LanguageAndCountries[] | null>(null)
 
     const manageUILanguage = async (configs: ConfigInterface): Promise<void> => {
         let locale = getFromCookieString(document.cookie, UI_LANG_KEY)
@@ -43,7 +45,7 @@ export const AppConfigProvider = ({ children }: { children: React.ReactNode }) =
                 ? browserLang
                 : configs.languageSwitcher.default;
 
-            setCookie(UI_LANG_KEY, locale);
+            await setCookie(UI_LANG_KEY, locale);
         }
         setUiLang(locale)
     }
@@ -58,7 +60,7 @@ export const AppConfigProvider = ({ children }: { children: React.ReactNode }) =
                 ? browserLang
                 : configs.languageSwitcher.default;
 
-            setCookie(CONTENT_LANG_KEY, locale);
+            await setCookie(CONTENT_LANG_KEY, locale);
         }
 
         setContentLang(locale)
@@ -96,11 +98,19 @@ export const AppConfigProvider = ({ children }: { children: React.ReactNode }) =
 
                 await manageToken()
 
-                const configsResult = await getConfigs()
-                const langs = await call<LanguageAndCountries[]>("LanguageService.getLanguagesAndCountries")
+                const [configsResult, langs] = await Promise.all([
+                    getConfigs(),
+                    call<LanguageAndCountries[]>("LanguageService.getLanguagesAndCountries")
+                ])
 
-                await manageUILanguage(configsResult)
-                await manageContentLanguage(configsResult, langs)
+                if (!configsResult) {
+                    throw new Error("Config cookie not available");
+                }
+
+                await Promise.all([
+                    manageUILanguage(configsResult),
+                    manageContentLanguage(configsResult, langs)
+                ])
 
                 setAvailableLanguagesAndCountries(langs)
                 setConfigs(configsResult)
@@ -132,12 +142,13 @@ export const AppConfigProvider = ({ children }: { children: React.ReactNode }) =
                 error,
                 uiLang,
                 contentLang,
+                availableVersions,
+                packageID,
+                articleLang,
+                setArticleLang,
                 setUiLang,
                 setContentLang,
-                availableVersions,
                 setAvailableVersions,
-                setLoading,
-                packageID,
                 setPackageID
             }}
         >

package/src/search.tsx

@@ -1,52 +1,29 @@
-import { createContext, useContext, ReactNode, useState } from "react";
+"use client"
+
+import { createContext, useContext, ReactNode, useState, useEffect, use } from "react";
+import { Loading } from "@c-rex/components/loading";
 
 type SearchContextProps = {
-    selectedLanguage: string[];
-    availableLanguages: string[];
-    selectLanguage: (language: string) => void;
-    getSelectedLanguages: () => string[];
-    setLanguages: (languages: string[]) => void;
+    loading: boolean;
+    setLoading: (loading: boolean) => void;
 }
 
 const SearchContext = createContext<SearchContextProps | undefined>(undefined);
 
 export const SearchProvider = ({ children }: { children: ReactNode }) => {
-    const [selectedLanguage, setSelectedLanguage] = useState<string[]>([]);
-    const [availableLanguages, setAvailableLanguages] = useState<string[]>([]);
-
-    const selectLanguage = (language: string) => {
-        if (selectedLanguage.includes(language)) {
-            setSelectedLanguage(selectedLanguage.filter(l => l !== language));
-        } else {
-            setSelectedLanguage([...selectedLanguage, language]);
-        }
-    };
-    const getSelectedLanguages = () => {
-        return selectedLanguage;
-    }
-    const setLanguages = (languages: string[]) => {
-        setAvailableLanguages(languages);
-    }
+    const [loading, setLoading] = useState<boolean>(true)
 
     return (
-        <SearchContext.Provider value={{
-            selectedLanguage,
-            availableLanguages,
-            selectLanguage,
-            getSelectedLanguages,
-            setLanguages
-        }}>
-            <>
-                {children}
-            </>
+        <SearchContext.Provider value={{ setLoading, loading }}>
+            {loading && <Loading opacity />}
+
+            {children}
         </SearchContext.Provider>
     );
 };
 
 export const useSearchContext = () => {
     const context = useContext(SearchContext);
-    if (!context) {
-        throw new Error("useSearchContext must be used within a SearchProvider");
-    }
+    if (!context) throw new Error("useSearchContext must be used within a SearchProvider");
     return context;
 };