itube-specs 0.0.291 → 0.0.292

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

@@ -7,11 +7,13 @@ export const useFetchPlaylistsByNiche = async (apiMethod: (...args: any[]) => Pr
     const route = useRoute();
     const { locale } = useI18n();
     const lang = locale.value as ELanguage;
+    const key = EAsyncData.GetPlaylistsByNiche;
+    const stateKey = computed(() => `data-${key}-${JSON.stringify(route.query)}-${lang}`);
 
     const { data, status, error } = await useAsyncData<PaginatedResponse<IPlaylistCard>>(
-        EAsyncData.GetPlaylistsByNiche,
+        key,
         () => useApiFetcher<PaginatedResponse<IPlaylistCard>>(
-            EAsyncData.PlaylistById,
+            stateKey.value,
             apiMethod,
             {
                 page: Number(route.query[ 'page' ]) || 1,

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

@@ -9,11 +9,13 @@ export const useFetchPlaylistsGetVideosById = (
     const PER_PAGE = 48;
     const route = useRoute();
     const id = computed(() => String(route.params[ 'id' ]));
+    const key = EAsyncData.GetPlaylistsVideo;
+    const stateKey = computed(() => `data-${key}-${JSON.stringify(route.query)}-${id.value}`);
 
     const { data, status, error } = useAsyncData<PaginatedResponse<IVideoCard>>(
-        EAsyncData.GetPlaylistsVideo,
+        key,
         () => useApiFetcher<PaginatedResponse<IVideoCard>>(
-            EAsyncData.GetPlaylistsVideo,
+            stateKey.value,
             apiMethod,
             id.value,
             isListPage ? {

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

@@ -3,11 +3,13 @@ import { ELanguage } from '../runtime';
 
 export const useFetchRelatedSearch = (apiMethod: (...args: any[]) => Promise<Array<string>>) => {
     const lang = useI18n().locale.value as ELanguage;
+    const key = EAsyncData.RelatedSearch;
+    const stateKey = computed(() => `data-${key}-${lang}`);
 
     const { data, status, error } = useAsyncData<Array<string>>(
-        EAsyncData.RelatedSearch,
+        key,
         () => useApiFetcher<Array<string>>(
-            EAsyncData.RelatedSearch,
+            stateKey.value,
             apiMethod,
             lang,
         )(),

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

@@ -10,6 +10,8 @@ export const useFetchRelatedVideos = async (
     const route = useRoute();
     const PER_PAGE = 14;
     const slug = useSlug();
+    const key = EAsyncData.RelatedVideos;
+    const stateKey = computed(() => `data-${key}-${slug.value}-${JSON.stringify(route.query)}-${lang}`);
 
     // const routeName = route.name;
     // const paths = ['playlists-id-slug', 'videos-slug'];
@@ -19,9 +21,9 @@ export const useFetchRelatedVideos = async (
     // }
 
     const { data, status, error } = await useAsyncData<PaginatedResponse<IVideoCard>>(
-        EAsyncData.RelatedVideos,
+        key,
         () => useApiFetcher<PaginatedResponse<IVideoCard>>(
-            EAsyncData.RelatedVideos,
+            stateKey.value,
             apiMethod,
             {
                 page: Number(route.query[ 'page' ]) || 1,

package/composables/use-fetch-top-chips-models.ts

@@ -3,15 +3,18 @@ import type { IModelTag } from '../types';
 
 export const useFetchTopChipsModels = (apiMethod: (...args: any[]) => Promise<IModelTag[]>, cacheId: string) => {
     const { locale } = useI18n();
+    const lang = locale.value as ELanguage;
+    const key = EAsyncData.TopChipsModels;
+    const stateKey = computed(() => `data-${key}-${cacheId}-${lang}`);
 
     const { data: topChipsModels, refresh, status } = useAsyncData<IModelTag[]>(
-        String(EAsyncData.TopChipsModels + cacheId),
+        stateKey.value,
         () => useApiFetcher<IModelTag[]>(
-            EAsyncData.TopChipsModels,
+            stateKey.value,
             apiMethod,
             20,
             0,
-            locale.value as ELanguage,
+            lang,
             cacheId,
         )(),
     );

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

@@ -4,11 +4,13 @@ import type { IModelCard, PaginatedResponse } from '../types';
 export const useFetchTopModels = (apiMethod: (...args: any[]) => Promise<PaginatedResponse<IModelCard>>, limit: number, eName: EAsyncData | string, cacheId: string) => {
     const { locale } = useI18n();
     const lang = locale.value as ELanguage;
+    const key = eName;
+    const stateKey = computed(() => `data-${key}-${cacheId}-${lang}`);
 
     const { data, status, refresh } = useAsyncData(
-        String(eName + cacheId),
+        stateKey.value,
         () => useApiFetcher<PaginatedResponse<IModelCard>>(
-            eName as EAsyncData,
+            stateKey.value,
             apiMethod,
             limit,
             0,

package/composables/use-fetch-top-random-categories.ts

@@ -4,11 +4,13 @@ import type { IChipsItem } from '../types';
 export const useFetchTopRandomCategories = (apiMethod: (...args: any[]) => Promise<Array<IChipsItem>>, cacheId: string) => {
     const { locale } = useI18n();
     const lang = locale.value as ELanguage;
+    const key = EAsyncData.CategoriesTopRandom;
+    const stateKey = computed(() => `data-${key}-${cacheId}-${lang}`);
 
     const { data: topRandomCategories, refresh, error } = useAsyncData<Array<IChipsItem>>(
-        String(EAsyncData.CategoriesTopRandom + cacheId),
+        stateKey.value,
         () => useApiFetcher<Array<IChipsItem>>(
-            EAsyncData.CategoriesTopRandom,
+            stateKey.value,
             apiMethod,
             lang,
             cacheId

package/composables/use-fetch-top-random-full.ts

@@ -6,11 +6,13 @@ export const useFetchTopRandomFull = async (
 ) => {
     const { locale } = useI18n();
     const lang = locale.value as ELanguage;
+    const key = EAsyncData.CategoriesTopRandomFull;
+    const stateKey = computed(() => `data-${key}-${lang}`);
 
     const { data, status, error } = await useAsyncData<Array<ICategoryCard>>(
         EAsyncData.CategoriesTopRandomFull,
         () => useApiFetcher<Array<ICategoryCard>>(
-            EAsyncData.CategoriesTopRandomFull,
+            stateKey.value,
             apiMethod,
             lang,
         )(),

package/composables/use-fetch-video-referer-phrases.ts

@@ -1,41 +1,42 @@
-import { useRoute } from 'vue-router';
 import { EAsyncData, ELanguage } from '../runtime';
 
 export const useFetchVideoRefererPhrases = (
     apiMethod: (...args: any[]) => Promise<string[]>) => {
-  const { locale } = useI18n();
-  const lang = locale.value as ELanguage;
+    const { locale } = useI18n();
+    const lang = locale.value as ELanguage;
     const slug = useSlug();
+    const key = EAsyncData.RefererPhrases;
+    const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
 
-  const { data, status, error } = useAsyncData<string[]>(
-    EAsyncData.RefererPhrases,
-    () => useApiFetcher<string[]>(
-        EAsyncData.RefererPhrases,
-        apiMethod,
-        lang,
-        slug.value,
-        undefined
-    )(),
-  );
+    const { data, status, error } = useAsyncData<string[]>(
+        key,
+        () => useApiFetcher<string[]>(
+            stateKey.value,
+            apiMethod,
+            lang,
+            slug.value,
+            undefined
+        )(),
+    );
 
-  // async function fetchData() {
-  //   try {
-  //     const { $features } = useNuxtApp();
-  //     const slug = convertString().fromSlug(String(route.params['slug'])) || '';
-  //
-  //     if ($features.FetchByUrlEnabled) {
-  //       return await VideosApiService.refererPhrasesByUrl(lang, slug, undefined);
-  //     } else {
-  //       return await VideosApiService.refererPhrasesById(lang, slug, undefined);
-  //     }
-  //   } catch (err) {
-  //     throw createError({
-  //       statusCode: 500,
-  //       statusMessage: 'Error fetching video data',
-  //       message: err instanceof Error ? err.message : 'An unknown error occurred',
-  //     });
-  //   }
-  // }
+    // async function fetchData() {
+    //   try {
+    //     const { $features } = useNuxtApp();
+    //     const slug = convertString().fromSlug(String(route.params['slug'])) || '';
+    //
+    //     if ($features.FetchByUrlEnabled) {
+    //       return await VideosApiService.refererPhrasesByUrl(lang, slug, undefined);
+    //     } else {
+    //       return await VideosApiService.refererPhrasesById(lang, slug, undefined);
+    //     }
+    //   } catch (err) {
+    //     throw createError({
+    //       statusCode: 500,
+    //       statusMessage: 'Error fetching video data',
+    //       message: err instanceof Error ? err.message : 'An unknown error occurred',
+    //     });
+    //   }
+    // }
 
-  return { data, status, error };
+    return { data, status, error };
 };

package/composables/use-fetch-video.ts

@@ -8,6 +8,8 @@ export const useFetchVideo = async (
   const { locale } = useI18n();
   const lang = locale.value as ELanguage;
   const slug = useSlug();
+  const key = EAsyncData.Video;
+  const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
   let headers = {} as HeadersInit & { 'User-Agent': string };
 
   /* Проверка - если сср, то прокидываем беку заголовки пользователя, чтобы не сработал антихотлинк */
@@ -19,9 +21,9 @@ export const useFetchVideo = async (
   }
 
   const { data, status, error } = await useAsyncData<IVideoData>(
-    EAsyncData.Video,
+    key,
     () => useApiFetcher<IVideoData>(
-        EAsyncData.Video,
+        stateKey.value,
         apiMethod,
         lang,
         slug.value,

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

@@ -9,12 +9,14 @@ export const useFetchVideosByCategories = async (
     const route = useRoute();
     const lang = useI18n().locale.value as ELanguage;
     const slug = useSlug();
+    const key = EAsyncData.VideosByCategory;
+    const stateKey = computed(() => `data-${key}-${slug.value}-${JSON.stringify(route.query)}-${lang}`);
     const filters = computed(() => useGetVideosFilterRequest(route, selectDurationItems, selectAddedItems));
 
     const { data, status, error } = await useAsyncData<PaginatedResponse<IVideoCard>>(
-        EAsyncData.VideosByCategory,
+        key,
         () => useApiFetcher<PaginatedResponse<IVideoCard>>(
-            null,
+            stateKey.value,
             apiMethod,
             lang,
             {

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

@@ -4,37 +4,39 @@ import { selectAddedItems, selectDurationItems, sortItemsDefault } from '../lib'
 import { useRoute } from 'vue-router';
 
 export const useFetchVideosByChannel = async (apiMethod: (...args: any[]) => Promise<PaginatedResponse<IVideoCard>>) => {
-  const route = useRoute();
-  const { locale } = useI18n();
-  const lang = locale.value as ELanguage;
+    const route = useRoute();
+    const { locale } = useI18n();
+    const lang = locale.value as ELanguage;
     const slug = useSlug();
     const filters = computed(() => useGetVideosFilterRequest(route, selectDurationItems, selectAddedItems));
+    const key = EAsyncData.VideosByChannel;
+    const stateKey = computed(() => `data-${key}-${slug.value}-${JSON.stringify(route.query)}-${lang}`);
 
-  const { data, status, error } = await useAsyncData<PaginatedResponse<IVideoCard>>(
-    EAsyncData.VideosByChannel,
-    () => useApiFetcher<PaginatedResponse<IVideoCard>>(
-        EAsyncData.VideosByChannel,
-        apiMethod,
+    const { data, status, error } = await useAsyncData<PaginatedResponse<IVideoCard>>(
+        key,
+        () => useApiFetcher<PaginatedResponse<IVideoCard>>(
+            stateKey.value,
+            apiMethod,
+            {
+                page: Number(route.query[ 'page' ]) || 1,
+                'per-page': 48,
+            },
+            filters.value,
+            slug.value,
+            lang,
+            getSelectedQuery(route, sortItemsDefault) || '-popularity'
+        )(),
         {
-          page: Number(route.query[ 'page' ]) || 1,
-          'per-page': 48,
-        },
-        filters.value,
-        slug.value,
-        lang,
-        getSelectedQuery(route, sortItemsDefault) || '-popularity'
-    )(),
-    {
-      watch: [
-        () => {
-          if (route.query) {
-            const currentQuery = route.query;
-            return JSON.stringify(currentQuery);
-          }
-        },
-      ],
-    }
-  );
+            watch: [
+                () => {
+                    if (route.query) {
+                        const currentQuery = route.query;
+                        return JSON.stringify(currentQuery);
+                    }
+                },
+            ],
+        }
+    );
 
-  return { data, status, error };
+    return { data, status, error };
 };

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

@@ -4,37 +4,39 @@ import { selectAddedItems, selectDurationItems, sortItemsDefault } from '../lib'
 import { useRoute } from 'vue-router';
 
 export const useFetchVideosByModel = async (apiMethod: (...args: any[]) => Promise<PaginatedResponse<IVideoCard>>) => {
-  const route = useRoute();
-  const { locale } = useI18n();
-  const lang = locale.value as ELanguage;
+    const route = useRoute();
+    const { locale } = useI18n();
+    const lang = locale.value as ELanguage;
     const slug = useSlug();
     const filters = computed(() => useGetVideosFilterRequest(route, selectDurationItems, selectAddedItems));
+    const key = EAsyncData.ModelsVideos;
+    const stateKey = computed(() => `data-${key}-${slug.value}-${JSON.stringify(route.query)}-${lang}`);
 
-  const { data, status, error } = await useAsyncData<PaginatedResponse<IVideoCard>>(
-    EAsyncData.ModelsVideos,
-    () => useApiFetcher<PaginatedResponse<IVideoCard>>(
-        EAsyncData.ModelsVideos,
-        apiMethod,
+    const { data, status, error } = await useAsyncData<PaginatedResponse<IVideoCard>>(
+        key,
+        () => useApiFetcher<PaginatedResponse<IVideoCard>>(
+            stateKey.value,
+            apiMethod,
+            {
+                page: Number(route.query[ 'page' ]) || 1,
+                'per-page': 48,
+            },
+            filters.value,
+            slug.value,
+            lang,
+            getSelectedQuery(route, sortItemsDefault) || '-popularity'
+        )(),
         {
-          page: Number(route.query['page']) || 1,
-          'per-page': 48,
-        },
-        filters.value,
-        slug.value,
-        lang,
-        getSelectedQuery(route, sortItemsDefault) || '-popularity'
-    )(),
-    {
-      watch: [
-        () => {
-          if (route.query) {
-            const currentQuery = route.query;
-            return JSON.stringify(currentQuery);
-          }
-        },
-      ],
-    }
-  );
+            watch: [
+                () => {
+                    if (route.query) {
+                        const currentQuery = route.query;
+                        return JSON.stringify(currentQuery);
+                    }
+                },
+            ],
+        }
+    );
 
-  return { data, status, error };
+    return { data, status, error };
 };

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

@@ -9,11 +9,13 @@ export const useFetchVideosByTag = async (apiMethod: (...args: any[]) => Promise
     const lang = locale.value as ELanguage;
     const slug = useSlug();
     const filters = computed(() => useGetVideosFilterRequest(route, selectDurationItems, selectAddedItems));
+    const key = EAsyncData.VideosByTag;
+    const stateKey = computed(() => `data-${key}-${slug.value}-${JSON.stringify(route.query)}-${lang}`);
 
     const { data, status, error } = await useAsyncData<PaginatedResponse<IVideoCard>>(
-        EAsyncData.VideosByTag,
+        key,
         () => useApiFetcher<PaginatedResponse<IVideoCard>>(
-            EAsyncData.VideosByTag,
+            stateKey.value,
             apiMethod,
             {
                 page: Number(route.query[ 'page' ]) || 1,

package/composables/use-fetch-videos-search-by-niche.ts

@@ -7,11 +7,13 @@ export const useFetchVideosSearchByNiche = async (apiMethod: (...args: any[]) =>
     const lang = locale.value as ELanguage;
     const route = useRoute();
     const slug = useSlug();
+    const key = EAsyncData.VideosBySearch;
+    const stateKey = computed(() => `data-${key}-${slug.value}-${JSON.stringify(route.query)}-${lang}`);
 
     const { data, status, error } = await useAsyncData<PaginatedResponse<IVideoCard>>(
-        EAsyncData.VideosBySearch,
+        key,
         () => useApiFetcher<PaginatedResponse<IVideoCard>>(
-            EAsyncData.VideosBySearch,
+            stateKey.value,
             apiMethod,
             {
                 page: Number(route.query[ 'page' ]) || 1,

package/package.json

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