itube-specs 0.0.289 → 0.0.291

package/composables/use-api-fetcher.ts

@@ -1,25 +1,28 @@
 export function useApiFetcher<T>(
-  key: string,
-  apiMethod: (...args: any[]) => Promise<T>,
-  ...apiArgs: any[]
+    key: string | null,
+    apiMethod: (...args: any[]) => Promise<T>,
+    ...apiArgs: any[]
 ) {
-  return async function fetchData() {
-    const state = useState<T | null>(key, () => null);
+    return async function fetchData() {
+        const hasKey = key?.trim();
+        const state = hasKey ? useState<T | null>(key!, () => null) : null;
 
-    if (state.value !== null) {
-      return state.value;
-    }
+        if (state && state.value !== null && state.value !== undefined) {
+            return state.value;
+        }
 
-    try {
-      const result = await apiMethod(...apiArgs);
-      state.value = result;
-      return result;
-    } catch (err) {
-      throw createError({
-        statusCode: 500,
-        statusMessage: `Error fetching ${key}`,
-        message: err instanceof Error ? err.message : 'An unknown error occurred',
-      });
-    }
-  };
+        try {
+            const result = await apiMethod(...apiArgs);
+
+            if (state) state.value = result;
+
+            return result;
+        } catch (err) {
+            throw createError({
+                statusCode: 500,
+                statusMessage: `Error fetching ${key}`,
+                message: err instanceof Error ? err.message : 'An unknown error occurred',
+            });
+        }
+    };
 }

package/composables/use-fetch-categories-by-letter.ts

@@ -4,13 +4,15 @@ import type { ICategoryCard } from '../types';
 export const useFetchCategoriesByLetter = (
     apiMethod: (...args: any[]) => Promise<Array<ICategoryCard>>
 ) => {
+    const key = EAsyncData.Categories;
     const lang = useI18n().locale.value as ELanguage;
     const slug = useSlug();
+    const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
 
     const { data, status, error } = useAsyncData<Array<ICategoryCard>>(
-        EAsyncData.Categories,
+        key,
         () => useApiFetcher<Array<ICategoryCard>>(
-            EAsyncData.Categories,
+            stateKey.value,
             apiMethod,
             lang,
             slug.value,

package/composables/use-fetch-categories-by-name.ts

@@ -4,13 +4,15 @@ import type { ICardInfo } from '../types';
 export const useFetchCategoriesByName = async (
   apiMethod: (...args: any[]) => Promise<ICardInfo>
 ) => {
+    const key = EAsyncData.CategoriesByName;
     const lang = useI18n().locale.value as ELanguage;
     const slug = useSlug();
+    const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
 
     const { data, status, error } = await useAsyncData<ICardInfo>(
-        EAsyncData.CategoriesByName,
+        key,
         () => useApiFetcher<ICardInfo>(
-            EAsyncData.CategoriesByName,
+            stateKey.value,
             apiMethod,
             lang,
             slug.value,

package/composables/use-fetch-categories-by-phrase.ts

@@ -4,13 +4,15 @@ import type { IChipsItem } from '../types';
 export const useFetchCategoriesByPhrase = async (
     apiMethod: (...args: any[]) => Promise<Array<IChipsItem>>
 ) => {
+    const key = EAsyncData.CategoriesByPhrase;
     const lang = useI18n().locale.value as ELanguage;
     const slug = useSlug();
+    const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
 
     const { data, status, error } = await useAsyncData<Array<IChipsItem>>(
-        EAsyncData.CategoriesByPhrase,
+        key,
         () => useApiFetcher<Array<IChipsItem>>(
-            EAsyncData.CategoriesByPhrase,
+            stateKey.value,
             apiMethod,
             lang,
             slug.value,

package/composables/use-fetch-categories-group-by-letter.ts

@@ -4,13 +4,15 @@ import type { ICategoryCard } from '../types';
 export const useFetchCategoriesGroupByLetter = (
     apiMethod: (...args: any[]) => Promise<Record<string, Array<ICategoryCard>>>
 ) => {
+    const key = EAsyncData.GroupsCategoriesByLetter;
     const { locale } = useI18n();
     const lang = locale.value as ELanguage;
+    const stateKey = computed(() => `data-${key}-${lang}`);
 
     const { data, error, refresh, status } = useAsyncData<Record<string, Array<ICategoryCard>>>(
-        EAsyncData.GroupsCategoriesByLetter,
+        key,
         () => useApiFetcher<Record<string, Array<ICategoryCard>>>(
-            EAsyncData.GroupsCategoriesByLetter,
+            stateKey.value,
             apiMethod,
             lang,
         )(),

package/composables/use-fetch-categories-related.ts

@@ -4,14 +4,15 @@ import type { IRelatedPhrases } from '../types';
 export const useFetchCategoriesRelated = (
   apiMethod: (...args: any[]) => Promise<IRelatedPhrases>
 ) => {
-
   const lang = useI18n().locale.value as ELanguage;
   const slug = useSlug();
+  const key = EAsyncData.CategoriesRelated;
+  const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
 
   const { data, status, error } = useAsyncData<IRelatedPhrases>(
-    EAsyncData.CategoriesRelated,
+    key,
     () => useApiFetcher<IRelatedPhrases>(
-        EAsyncData.CategoriesRelated,
+        stateKey.value,
         apiMethod,
         lang,
         slug.value,

package/composables/use-fetch-channels-by-name.ts

@@ -6,11 +6,13 @@ export const useFetchChannelsByName = (
 ) => {
     const lang = useI18n().locale.value as ELanguage;
     const slug = useSlug();
+    const key = EAsyncData.ChannelByName;
+    const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
 
     const { data, status, error } = useAsyncData<ICardInfo>(
-        EAsyncData.ChannelByName,
+        key,
         () => useApiFetcher<ICardInfo>(
-            EAsyncData.ChannelByName,
+            stateKey.value,
             apiMethod,
             lang,
             slug.value,

package/composables/use-fetch-channels-by-network-name.ts

@@ -8,11 +8,13 @@ export const useFetchChannelsByNetworkName = (
   const lang = useI18n().locale.value as ELanguage;
     const route = useRoute();
     const slug = useSlug();
+    const key = EAsyncData.ChannelsByNetworkName;
+    const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
 
     const { data, status, error } = useAsyncData<PaginatedResponse<IChannelCard>>(
-        EAsyncData.ChannelsByNetworkName,
+        key,
         () => useApiFetcher<PaginatedResponse<IChannelCard>>(
-            EAsyncData.ChannelsByNetworkName,
+            stateKey.value,
             apiMethod,
             lang,
             {

package/composables/use-fetch-channels.ts

@@ -8,11 +8,13 @@ export const useFetchChannels = async (
 ) => {
     const route = useRoute();
     const lang = useI18n().locale.value as ELanguage;
+    const key = EAsyncData.Channels;
+    const stateKey = computed(() => `data-${key}-${JSON.stringify(route.query)}-${lang}`);
 
     const { data, status, error } = await useAsyncData<PaginatedResponse<IChannelCard>>(
-        EAsyncData.Channels,
+        key,
         () => useApiFetcher<PaginatedResponse<IChannelCard>>(
-            EAsyncData.Channels,
+            stateKey.value,
             apiMethod,
             lang,
             {

package/composables/use-fetch-dictionaries-countries.ts

@@ -5,11 +5,13 @@ export const useFetchDictionariesCountries = (
     apiMethod: (...args: any[]) => Promise<ICountries>
 ) => {
     const lang = useI18n().locale.value as ELanguage;
+    const key = EAsyncData.Countries;
+    const stateKey = computed(() => `data-${key}-${lang}`);
 
     const { data, status, error } = useAsyncData<ICountries>(
-        EAsyncData.Countries,
+        key,
         () => useApiFetcher<ICountries>(
-            EAsyncData.Countries,
+            stateKey.value,
             apiMethod,
             lang,
         )(),

package/composables/use-fetch-dictionaries-genders.ts

@@ -5,11 +5,13 @@ export const useFetchDictionariesGenders = (
     apiMethod: (...args: any[]) => Promise<IGenders>
 ) => {
     const lang = useI18n().locale.value as ELanguage;
+    const key = EAsyncData.Genders;
+    const stateKey = computed(() => `data-${key}-${lang}`);
 
     const { data, status, error } = useAsyncData<IGenders>(
-        EAsyncData.Genders,
+        key,
         () => useApiFetcher<IGenders>(
-            EAsyncData.Genders,
+            stateKey.value,
             apiMethod,
             lang,
         )(),

package/composables/use-fetch-footer-categories.ts

@@ -6,11 +6,13 @@ export const useFetchFooterCategories = (
 ) => {
     const { locale } = useI18n();
     const lang = locale.value as ELanguage;
+    const key = EAsyncData.CategoriesTopRandomFooter;
+    const stateKey = computed(() => `data-${key}-${lang}`);
 
     const { data, status, error } = useAsyncData<IChipsItem[]>(
-        EAsyncData.CategoriesTopRandomFooter,
+        key,
         () => useApiFetcher<IChipsItem[]>(
-            EAsyncData.CategoriesTopRandomFooter,
+            stateKey.value,
             apiMethod,
             lang,
         )(),

package/composables/use-fetch-groups-categories.ts

@@ -6,11 +6,13 @@ export const useFetchGroupsCategories = async (
 ) => {
     const { locale } = useI18n();
     const lang = locale.value as ELanguage;
+    const key = EAsyncData.GroupsCategoriesFilter;
+    const stateKey = computed(() => `data-${key}-${lang}`);
 
     const { data, pending: status, error } = await useAsyncData<IGroupCategories[]>(
-        EAsyncData.GroupsCategoriesFilter,
+        key,
         () => useApiFetcher<IGroupCategories[]>(
-            EAsyncData.Categories,
+            stateKey.value,
             apiMethod,
             lang,
         )(),

package/composables/use-fetch-model-by-name.ts

@@ -4,18 +4,20 @@ import type { ICardInfo } from '../types';
 export const useFetchModelByName = async (
     apiMethod: (...args: any[]) => Promise<ICardInfo>
 ) => {
-  const lang = useI18n().locale.value as ELanguage;
-  const slug = useSlug();
+    const lang = useI18n().locale.value as ELanguage;
+    const slug = useSlug();
+    const key = EAsyncData.GroupsCategoriesFilter;
+    const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
 
-  const { data, status, error } = await useAsyncData<ICardInfo>(
-    EAsyncData.ModelsByName,
-    () => useApiFetcher<ICardInfo>(
-        EAsyncData.ModelsByName,
-        apiMethod,
-        lang,
-        slug.value,
-    )()
-  );
+    const { data, status, error } = await useAsyncData<ICardInfo>(
+        key,
+        () => useApiFetcher<ICardInfo>(
+            stateKey.value,
+            apiMethod,
+            lang,
+            slug.value,
+        )()
+    );
 
-  return { data, status, error };
+    return { data, status, error };
 };

package/composables/use-fetch-models-by-letter.ts

@@ -7,7 +7,10 @@ export const useFetchModelsByLetter = async (
     apiMethod: (...args: any[]) => Promise<PaginatedResponse<IModelCard>>
 ) => {
     const route = useRoute();
+    const slug = useSlug();
     const lang = useI18n().locale.value as ELanguage;
+    const key = EAsyncData.ModelsByFirstLetter;
+    const stateKey = computed(() => `data-${key}-${slug.value}-${JSON.stringify(route.query)}-${lang}`);
 
     const filters = computed(() => Object.entries(route.query)
         .filter(([key]) => key.startsWith('filter_'))
@@ -16,12 +19,10 @@ export const useFetchModelsByLetter = async (
             value: Array.isArray(value) ? value[ 0 ] : (value as string),
         })));
 
-    const slug = useSlug();
-
     const { data, status, refresh } = await useAsyncData<PaginatedResponse<IModelCard>>(
-        () => `${EAsyncData.Models}-${route.params.slug || ''}`,
+        stateKey.value,
         () => useApiFetcher<PaginatedResponse<IModelCard>>(
-            EAsyncData.Models,
+            stateKey.value,
             apiMethod,
             lang,
             {

package/composables/use-fetch-models-by-phrases.ts

@@ -9,11 +9,13 @@ export const useFetchModelsByPhrases = async (
     const { locale } = useI18n();
     const lang = locale.value as ELanguage;
     const slug = useSlug();
+    const key = EAsyncData.ModelsByPhrases;
+    const stateKey = computed(() => `data-${key}-${slug.value}-${JSON.stringify(route.query)}-${lang}`);
 
     const { data, status, error } = await useAsyncData<PaginatedResponse<IModelCard>>(
-        EAsyncData.ModelsByPhrases,
+        key,
         () => useApiFetcher<PaginatedResponse<IModelCard>>(
-            EAsyncData.ModelsByPhrases,
+            stateKey.value,
             apiMethod,
             {
                 'per-page': 48,

package/composables/use-fetch-models-related.ts

@@ -7,17 +7,20 @@ export const useFetchRelatedModels = (
     cacheId: string
 ) => {
     const { locale } = useI18n();
+    const lang = locale.value as ELanguage;
     const slug = useSlug();
+    const key = EAsyncData.TopModelsMore;
+    const stateKey = computed(() => `data-${key}-${slug.value}-${cacheId}-${lang}`);
 
     const { data, status, refresh } = useAsyncData<PaginatedResponse<IModelCard>>(
-        `${EAsyncData.TopModelsMore} ${cacheId}`,
+        stateKey.value,
         () => useApiFetcher<PaginatedResponse<IModelCard>>(
-            EAsyncData.TopModelsMore,
+            stateKey.value,
             apiMethod,
             slug.value,
             limit,
             0,
-            locale.value as ELanguage,
+            lang,
             cacheId
         )(),
     );

package/composables/use-fetch-models.ts

@@ -8,6 +8,8 @@ export const useFetchModels = async (
 ) => {
     const route = useRoute();
     const lang = useI18n().locale.value as ELanguage;
+    const key = EAsyncData.Models;
+    const stateKey = computed(() => `data-${key}-${JSON.stringify(route.query)}-${lang}`);
 
     const filters = computed(() => Object.entries(route.query)
         .filter(([key]) => key.startsWith('filter_'))
@@ -17,9 +19,9 @@ export const useFetchModels = async (
         })));
 
     const { data, status, refresh } = await useAsyncData<PaginatedResponse<IModelCard>>(
-        EAsyncData.Models,
+        key,
         () => useApiFetcher<PaginatedResponse<IModelCard>>(
-            EAsyncData.Models,
+            stateKey.value,
             apiMethod,
             lang,
             {

package/composables/use-fetch-multi-suggest.ts

@@ -15,11 +15,13 @@ export function useFetchMultiSuggest(
     const { locale } = useI18n();
     const lang = locale.value as ELanguage;
     const slug = useSlug();
+    const key = watchRoute ? EAsyncData.MultiSuggestRouteSearch : EAsyncData.MultiSuggestSearch;
+    const stateKey = computed(() => `data-${key}-${watchRoute ? slug.value : searchValue.value}-${lang}`);
 
     const { data, status } = useAsyncData<IMultiSuggest | null>(
-        watchRoute ? EAsyncData.MultiSuggestRouteSearch : EAsyncData.MultiSuggestSearch,
+        key,
         () => useApiFetcher<IMultiSuggest | null>(
-            EAsyncData.Channels,
+            stateKey.value,
             apiMethod,
             lang,
             watchRoute ? slug.value : searchValue.value,

package/composables/use-fetch-playlists-by-id.ts

@@ -4,13 +4,16 @@ import type { IPlaylistInfoType } from '../types';
 
 export const useFetchPlaylistsById = async (apiMethod: (...args: any[]) => Promise<IPlaylistInfoType>) => {
     const route = useRoute();
+    const id = computed(() => String(route.params['id']));
+    const key = EAsyncData.PlaylistById;
+    const stateKey = computed(() => `data-${key}-${id.value}-${JSON.stringify(route.query)}`);
 
     const { data, status, error, refresh } = await useAsyncData<IPlaylistInfoType>(
-        EAsyncData.PlaylistById,
+        key,
         () => useApiFetcher<IPlaylistInfoType>(
-            EAsyncData.PlaylistById,
+            stateKey.value,
             apiMethod,
-            String(route.params['id'])
+            id.value
         )(),
     );
 

package/composables/use-fetch-videos-by-categories.ts

@@ -14,7 +14,7 @@ export const useFetchVideosByCategories = async (
     const { data, status, error } = await useAsyncData<PaginatedResponse<IVideoCard>>(
         EAsyncData.VideosByCategory,
         () => useApiFetcher<PaginatedResponse<IVideoCard>>(
-            EAsyncData.VideosByCategory,
+            null,
             apiMethod,
             lang,
             {

package/composables/use-fetch-videos.ts

@@ -10,10 +10,11 @@ export const useFetchVideos = async (
     const perPage = 48;
     const lang = useI18n().locale.value as ELanguage;
     const filters = computed(() => useGetVideosFilterRequest(route, selectDurationItems, selectAddedItems));
-    const stateKey = computed(() => `data-${EAsyncData.Videos}-${JSON.stringify(route.query)}`);
+    const key = EAsyncData.Videos;
+    const stateKey = computed(() => `data-${key}-${JSON.stringify(route.query)}-${lang}`);
 
     const { data, status, error } = await useAsyncData<PaginatedResponse<IVideoCard>>(
-        EAsyncData.Videos,
+        key,
         () => useApiFetcher<PaginatedResponse<IVideoCard>>(
             stateKey.value,
             apiMethod,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "itube-specs",
   "type": "module",
-  "version": "0.0.289",
+  "version": "0.0.291",
   "main": "./nuxt.config.ts",
   "types": "./types/index.d.ts",
   "scripts": {