itube-specs 0.0.795 → 0.0.796

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

@@ -5,48 +5,48 @@ import { useRoute } from 'vue-router';
 import type { IModelCard, PaginatedResponse } from '../../types';
 
 export const useFetchModelsByLetter = async (
-    apiMethod: (...args: any[]) => Promise<PaginatedResponse<IModelCard>>
+  apiMethod: (...args: any[]) => Promise<PaginatedResponse<IModelCard>>
 ) => {
-    const route = useRoute();
-    const mobile = !!useState<boolean>('isMobile').value;
-    const perPage = mobile ? 12 : 48;
-    const slug = useSlug();
-    const lang = useLang() as Language;
-    const key = AsyncData.ModelsByFirstLetter;
-    const stateKey = computed(() => `data-${key}-${slug.value}-${JSON.stringify(route.query)}-${lang}`);
+  const route = useRoute();
+  const mobile = !!useState<boolean>('isMobile').value;
+  const perPage = mobile ? 12 : 48;
+  const slug = useSlug();
+  const lang = useLang() as Language;
+  const key = AsyncData.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_'))
-        .map(([key, value]) => ({
-            name: key.replace(/^filter_/, ''),
-            value: Array.isArray(value) ? value[0] : (value as string),
-        })));
+  const filters = computed(() => Object.entries(route.query)
+    .filter(([key]) => key.startsWith('filter_'))
+    .map(([key, value]) => ({
+      name: key.replace(/^filter_/, ''),
+      value: Array.isArray(value) ? value[0] : (value as string),
+    })));
 
-    const { data, status, refresh } = await useAsyncData<PaginatedResponse<IModelCard>>(
-        stateKey.value,
-        () => useApiFetcher<PaginatedResponse<IModelCard>>(
-            stateKey.value,
-            apiMethod,
-            lang,
-            {
-                page: Number(route.query.page) || 1,
-                'per-page': perPage,
-            },
-            getSelectedQuery(route, sortModels) || 'rank',
-            unref(filters),
-            unref(slug),
-        )(),
-        {
-            watch: [
-                () => {
-                    if (route.query) {
-                        const currentQuery = route.query;
-                        return JSON.stringify(currentQuery);
-                    }
-                },
-            ],
-        }
-    );
+  const { data, status, refresh } = await useAsyncData<PaginatedResponse<IModelCard>>(
+    stateKey.value,
+    () => useApiFetcher<PaginatedResponse<IModelCard>>(
+      stateKey.value,
+      apiMethod,
+      lang,
+      {
+        page: Number(route.query.page) || 1,
+        'per-page': perPage,
+      },
+      getSelectedQuery(route, sortModels) || 'rank',
+      unref(filters),
+      unref(slug),
+    )(),
+    {
+      watch: [
+        () => {
+          if (route.query) {
+            const currentQuery = route.query;
+            return JSON.stringify(currentQuery);
+          }
+        },
+      ],
+    }
+  );
 
-    return { data, status, refresh };
+  return { data, status, refresh };
 };

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

@@ -4,39 +4,39 @@ import type { IModelCard, PaginatedResponse } from '../../types';
 import { useRoute } from 'vue-router';
 
 export const useFetchModelsByPhrases = async (
-    apiMethod: (...args: any[]) => Promise<PaginatedResponse<IModelCard>>
+  apiMethod: (...args: any[]) => Promise<PaginatedResponse<IModelCard>>
 ) => {
-    const route = useRoute();
-    const mobile = !!useState<boolean>('isMobile').value;
-    const perPage = mobile ? 12 : 48;
-    const lang = useLang() as Language;
-    const slug = useSlug();
-    const key = AsyncData.ModelsByPhrases;
-    const stateKey = computed(() => `data-${key}-${slug.value}-${JSON.stringify(route.query)}-${lang}`);
+  const route = useRoute();
+  const mobile = !!useState<boolean>('isMobile').value;
+  const perPage = mobile ? 12 : 48;
+  const lang = useLang() as Language;
+  const slug = useSlug();
+  const key = AsyncData.ModelsByPhrases;
+  const stateKey = computed(() => `data-${key}-${slug.value}-${JSON.stringify(route.query)}-${lang}`);
 
-    const { data, status, error } = await useAsyncData<PaginatedResponse<IModelCard>>(
-        stateKey.value,
-        () => useApiFetcher<PaginatedResponse<IModelCard>>(
-            stateKey.value,
-            apiMethod,
-            {
-                page: Number(route.query['page']) || 1,
-                'per-page': perPage,
-            },
-            lang,
-            slug.value,
-        )(),
-        {
-            watch: [
-                () => {
-                    if (route.query) {
-                        const currentQuery = route.query;
-                        return JSON.stringify(currentQuery);
-                    }
-                },
-            ],
-        }
-    );
+  const { data, status, error } = await useAsyncData<PaginatedResponse<IModelCard>>(
+    stateKey.value,
+    () => useApiFetcher<PaginatedResponse<IModelCard>>(
+      stateKey.value,
+      apiMethod,
+      {
+        page: Number(route.query['page']) || 1,
+        'per-page': perPage,
+      },
+      lang,
+      slug.value,
+    )(),
+    {
+      watch: [
+        () => {
+          if (route.query) {
+            const currentQuery = route.query;
+            return JSON.stringify(currentQuery);
+          }
+        },
+      ],
+    }
+  );
 
-    return { data, status, error };
+  return { data, status, error };
 };

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

@@ -23,4 +23,4 @@ export const useFetchModelsByTag = async (
     );
 
     return { data, status };
-};
+};

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

@@ -3,31 +3,31 @@ import { AsyncData } from '../../runtime';
 import type { IModelCard, PaginatedResponse } from '../../types';
 
 export const useFetchRelatedModels = async (
-    apiMethod: (...args: any[]) => Promise<PaginatedResponse<IModelCard>>,
-    limit: number,
-    cacheId: string
+  apiMethod: (...args: any[]) => Promise<PaginatedResponse<IModelCard>>,
+  limit: number,
+  cacheId: string
 ) => {
-    const lang = useLang() as Language;
-    const slug = useSlug();
-    const key = AsyncData.TopModelsMore;
-    const stateKey = computed(() => `data-${key}-${slug.value}-${cacheId}-${lang}`);
+  const lang = useLang() as Language;
+  const slug = useSlug();
+  const key = AsyncData.TopModelsMore;
+  const stateKey = computed(() => `data-${key}-${slug.value}-${cacheId}-${lang}`);
 
-    const { data, status, refresh } = await useAsyncData<PaginatedResponse<IModelCard>>(
-        stateKey.value,
-        () => useApiFetcher<PaginatedResponse<IModelCard>>(
-            stateKey.value,
-            apiMethod,
-            slug.value,
-            limit,
-            0,
-            lang,
-            cacheId
-        )(),
-    );
+  const { data, status, refresh } = await useAsyncData<PaginatedResponse<IModelCard>>(
+    stateKey.value,
+    () => useApiFetcher<PaginatedResponse<IModelCard>>(
+      stateKey.value,
+      apiMethod,
+      slug.value,
+      limit,
+      0,
+      lang,
+      cacheId
+    )(),
+  );
 
-    return {
-        data,
-        refresh,
-        status,
-    };
+  return {
+    data,
+    refresh,
+    status,
+  };
 };

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

@@ -5,46 +5,46 @@ import { useRoute } from 'vue-router';
 import type { IModelCard, PaginatedResponse } from '../../types';
 
 export const useFetchModels = async (
-    apiMethod: (...args: any[]) => Promise<PaginatedResponse<IModelCard>>
+  apiMethod: (...args: any[]) => Promise<PaginatedResponse<IModelCard>>
 ) => {
-    const route = useRoute();
-    const mobile = !!useState<boolean>('isMobile').value;
-    const perPage = mobile ? 12 : 48;
-    const lang = useLang() as Language;
-    const key = AsyncData.Models;
-    const stateKey = computed(() => `data-${key}-${JSON.stringify(route.query)}-${lang}`);
+  const route = useRoute();
+  const mobile = !!useState<boolean>('isMobile').value;
+  const perPage = mobile ? 12 : 48;
+  const lang = useLang() as Language;
+  const key = AsyncData.Models;
+  const stateKey = computed(() => `data-${key}-${JSON.stringify(route.query)}-${lang}`);
 
-    const filters = computed(() => Object.entries(route.query)
-        .filter(([key]) => key.startsWith('filter_'))
-        .map(([key, value]) => ({
-            name: key.replace(/^filter_/, ''),
-            value: Array.isArray(value) ? value[0] : (value as string),
-        })));
+  const filters = computed(() => Object.entries(route.query)
+    .filter(([key]) => key.startsWith('filter_'))
+    .map(([key, value]) => ({
+      name: key.replace(/^filter_/, ''),
+      value: Array.isArray(value) ? value[0] : (value as string),
+    })));
 
-    const { data, status, refresh } = await useAsyncData<PaginatedResponse<IModelCard>>(
-        key,
-        () => useApiFetcher<PaginatedResponse<IModelCard>>(
-            stateKey.value,
-            apiMethod,
-            lang,
-            {
-                page: Number(route.query.page) || 1,
-                'per-page': perPage,
-            },
-            getSelectedQuery(route, sortModels) || 'rank',
-            unref(filters)
-        )(),
-        {
-            watch: [
-                () => {
-                    if (route.query) {
-                        const currentQuery = route.query;
-                        return JSON.stringify(currentQuery);
-                    }
-                },
-            ],
-        }
-    );
+  const { data, status, refresh } = await useAsyncData<PaginatedResponse<IModelCard>>(
+    key,
+    () => useApiFetcher<PaginatedResponse<IModelCard>>(
+      stateKey.value,
+      apiMethod,
+      lang,
+      {
+        page: Number(route.query.page) || 1,
+        'per-page': perPage,
+      },
+      getSelectedQuery(route, sortModels) || 'rank',
+      unref(filters)
+    )(),
+    {
+      watch: [
+        () => {
+          if (route.query) {
+            const currentQuery = route.query;
+            return JSON.stringify(currentQuery);
+          }
+        },
+      ],
+    }
+  );
 
-    return { data, status, refresh };
+  return { data, status, refresh };
 };

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

@@ -4,34 +4,34 @@ import type { IMultiSuggest } from '../../types';
 import { useRoute } from 'vue-router';
 
 export async function useFetchMultiSuggest(
-    apiMethod: (...args: any[]) => Promise<IMultiSuggest | null>,
-    phrasesLimit: number,
-    modelsLimit: number,
-    categoriesLimit: number,
-    watchRoute = false
+  apiMethod: (...args: any[]) => Promise<IMultiSuggest | null>,
+  phrasesLimit: number,
+  modelsLimit: number,
+  categoriesLimit: number,
+  watchRoute = false
 ) {
-    const route = useRoute();
-    const searchValue = useState<string>('searchValue', () => '');
-    const lang = useLang() as Language;
-    const slug = useSlug();
-    const key = watchRoute ? AsyncData.MultiSuggestRouteSearch : AsyncData.MultiSuggestSearch;
-    const stateKey = computed(() => `data-${key}-${watchRoute ? slug.value : searchValue.value}-${lang}`);
+  const route = useRoute();
+  const searchValue = useState<string>('searchValue', () => '');
+  const lang = useLang() as Language;
+  const slug = useSlug();
+  const key = watchRoute ? AsyncData.MultiSuggestRouteSearch : AsyncData.MultiSuggestSearch;
+  const stateKey = computed(() => `data-${key}-${watchRoute ? slug.value : searchValue.value}-${lang}`);
 
-    const { data, status } = await useAsyncData<IMultiSuggest | null>(
-        key,
-        () => useApiFetcher<IMultiSuggest | null>(
-            stateKey.value,
-            apiMethod,
-            lang,
-            watchRoute ? slug.value : searchValue.value,
-            phrasesLimit,
-            modelsLimit,
-            categoriesLimit
-        )(),
-        {
-            watch: [() => watchRoute ? String(route.params?.slug) : searchValue.value],
-        }
-    );
+  const { data, status } = await useAsyncData<IMultiSuggest | null>(
+    key,
+    () => useApiFetcher<IMultiSuggest | null>(
+      stateKey.value,
+      apiMethod,
+      lang,
+      watchRoute ? slug.value : searchValue.value,
+      phrasesLimit,
+      modelsLimit,
+      categoriesLimit
+    )(),
+    {
+      watch: [() => watchRoute ? String(route.params?.slug) : searchValue.value],
+    }
+  );
 
-    return { data, status };
+  return { data, status };
 }

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

@@ -3,21 +3,21 @@ import { AsyncData, type Language } from '../../runtime';
 import type { IPlaylistData } from '../../types';
 
 export const useFetchPlaylistsById = async (apiMethod: (...args: any[]) => Promise<IPlaylistData>) => {
-    const route = useRoute();
-    const id = computed(() => String(route.params['playlistId']));
-    const key = AsyncData.PlaylistById;
-    const stateKey = computed(() => `data-${key}-${id.value}`);
-    const lang = useLang() as Language;
+  const route = useRoute();
+  const id = computed(() => String(route.params['playlistId']));
+  const key = AsyncData.PlaylistById;
+  const stateKey = computed(() => `data-${key}-${id.value}`);
+  const lang = useLang() as Language;
 
-    const { data, status, error, refresh } = await useAsyncData<IPlaylistData>(
-        stateKey.value,
-        () => useApiFetcher<IPlaylistData>(
-            stateKey.value,
-            apiMethod,
-            id.value,
-            lang
-        )(),
-    );
+  const { data, status, error, refresh } = await useAsyncData<IPlaylistData>(
+    stateKey.value,
+    () => useApiFetcher<IPlaylistData>(
+      stateKey.value,
+      apiMethod,
+      id.value,
+      lang
+    )(),
+  );
 
-    return { data, status, error, refresh };
+  return { data, status, error, refresh };
 };

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

@@ -5,36 +5,36 @@ import { sortPlaylists } from '../../lib';
 import type { IPlaylistCard, PaginatedResponse } from '../../types';
 
 export const useFetchPlaylistsByNiche = async (apiMethod: (...args: any[]) => Promise<PaginatedResponse<IPlaylistCard>>) => {
-    const route = useRoute();
-    const mobile = !!useState<boolean>('isMobile').value;
-    const perPage = mobile ? 12 : 48;
-    const lang = useLang() as Language;
-    const key = AsyncData.GetPlaylistsByNiche;
-    const stateKey = computed(() => `data-${key}-${JSON.stringify(route.query)}-${lang}`);
+  const route = useRoute();
+  const mobile = !!useState<boolean>('isMobile').value;
+  const perPage = mobile ? 12 : 48;
+  const lang = useLang() as Language;
+  const key = AsyncData.GetPlaylistsByNiche;
+  const stateKey = computed(() => `data-${key}-${JSON.stringify(route.query)}-${lang}`);
 
-    const { data, status, error } = await useAsyncData<PaginatedResponse<IPlaylistCard>>(
-        key,
-        () => useApiFetcher<PaginatedResponse<IPlaylistCard>>(
-            stateKey.value,
-            apiMethod,
-            {
-                page: Number(route.query['page']) || 1,
-                'per-page': perPage,
-            },
-            getSelectedQuery(route, sortPlaylists) || '-views',
-            lang,
-        )(),
-        {
-            watch: [
-                () => {
-                    if (route.query) {
-                        const currentQuery = route.query;
-                        return JSON.stringify(currentQuery);
-                    }
-                },
-            ],
-        }
-    );
+  const { data, status, error } = await useAsyncData<PaginatedResponse<IPlaylistCard>>(
+    key,
+    () => useApiFetcher<PaginatedResponse<IPlaylistCard>>(
+      stateKey.value,
+      apiMethod,
+      {
+        page: Number(route.query['page']) || 1,
+        'per-page': perPage,
+      },
+      getSelectedQuery(route, sortPlaylists) || '-views',
+      lang,
+    )(),
+    {
+      watch: [
+        () => {
+          if (route.query) {
+            const currentQuery = route.query;
+            return JSON.stringify(currentQuery);
+          }
+        },
+      ],
+    }
+  );
 
-    return { data, status, error };
+  return { data, status, error };
 };

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

@@ -3,36 +3,36 @@ import type { IVideoCard, PaginatedResponse } from '../../types';
 import { useRoute } from 'vue-router';
 
 export const useFetchPlaylistsGetVideosById = async (
-    apiMethod: (...args: any[]) => Promise<PaginatedResponse<IVideoCard>>,
-    isListPage?: boolean
+  apiMethod: (...args: any[]) => Promise<PaginatedResponse<IVideoCard>>,
+  isListPage?: boolean
 ) => {
-    const mobile = !!useState<boolean>('isMobile').value;
-    const perPage = mobile ? 12 : 48;
-    const route = useRoute();
-    const id = computed(() => String(route.params['playlistId']));
-    const key = AsyncData.GetPlaylistsVideo;
-    const stateKey = computed(() => `data-${key}-${id.value}`);
-    const lang = useLang() as Language;
+  const mobile = !!useState<boolean>('isMobile').value;
+  const perPage = mobile ? 12 : 48;
+  const route = useRoute();
+  const id = computed(() => String(route.params['playlistId']));
+  const key = AsyncData.GetPlaylistsVideo;
+  const stateKey = computed(() => `data-${key}-${id.value}`);
+  const lang = useLang() as Language;
 
-    const { data, status, error } = await useAsyncData<PaginatedResponse<IVideoCard>>(
-        stateKey.value,
-        () => useApiFetcherNoCache<PaginatedResponse<IVideoCard>>(
-            stateKey.value,
-            apiMethod,
-            id.value,
-            isListPage ? {
-                page: Number(route.query['page']) || 1,
-                ['per-page']: perPage,
-            } : {
-                page: 1,
-            },
-            lang,
-        )(),
-    );
+  const { data, status, error } = await useAsyncData<PaginatedResponse<IVideoCard>>(
+    stateKey.value,
+    () => useApiFetcherNoCache<PaginatedResponse<IVideoCard>>(
+      stateKey.value,
+      apiMethod,
+      id.value,
+      isListPage ? {
+        page: Number(route.query['page']) || 1,
+        ['per-page']: perPage,
+      } : {
+        page: 1,
+      },
+      lang,
+    )(),
+  );
 
-    return {
-        error,
-        status,
-        data,
-    };
+  return {
+    error,
+    status,
+    data,
+  };
 };

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

@@ -2,17 +2,17 @@ import type { Language  } from '../../runtime';
 import { AsyncData  } from '../../runtime';
 
 export const useFetchRelatedSearch = async (apiMethod: (...args: any[]) => Promise<Array<string>>) => {
-    const lang = useLang() as Language;
-    const key = AsyncData.RelatedSearch;
+  const lang = useLang() as Language;
+  const key = AsyncData.RelatedSearch;
 
-    const { data, status, error } = await useAsyncData<Array<string>>(
-        key,
-        () => useApiFetcher<Array<string>>(
-            null,
-            apiMethod,
-            lang,
-        )(),
-    );
+  const { data, status, error } = await useAsyncData<Array<string>>(
+    key,
+    () => useApiFetcher<Array<string>>(
+      null,
+      apiMethod,
+      lang,
+    )(),
+  );
 
-    return { data, status, error };
+  return { data, status, error };
 };

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

@@ -4,36 +4,36 @@ import { AsyncData } from '../../runtime';
 import type { IVideoCard, PaginatedResponse } from '../../types';
 
 export const useFetchRelatedVideos = async (
-    apiMethod: (...args: any[]) => Promise<PaginatedResponse<IVideoCard>>
+  apiMethod: (...args: any[]) => Promise<PaginatedResponse<IVideoCard>>
 ) => {
-    const lang = useLang() as Language;
-    const route = useRoute();
-    const mobile = !!useState<boolean>('isMobile').value;
-    const perPage = mobile ? 6 : 14;
-    const slug = useSlug();
-    const key = AsyncData.RelatedVideos;
-    const stateKey = computed(() => `data-${key}-${slug.value}-${JSON.stringify(route.query)}-${lang}`);
+  const lang = useLang() as Language;
+  const route = useRoute();
+  const mobile = !!useState<boolean>('isMobile').value;
+  const perPage = mobile ? 6 : 14;
+  const slug = useSlug();
+  const key = AsyncData.RelatedVideos;
+  const stateKey = computed(() => `data-${key}-${slug.value}-${JSON.stringify(route.query)}-${lang}`);
 
-    const { data, status, error } = await useAsyncData<PaginatedResponse<IVideoCard>>(
-        stateKey.value,
-        () => {
-            if (!slug.value) return Promise.resolve(null as unknown as PaginatedResponse<IVideoCard>);
+  const { data, status, error } = await useAsyncData<PaginatedResponse<IVideoCard>>(
+    stateKey.value,
+    () => {
+      if (!slug.value) return Promise.resolve(null as unknown as PaginatedResponse<IVideoCard>);
 
-            return useApiFetcher<PaginatedResponse<IVideoCard>>(
-                stateKey.value,
-                apiMethod,
-                {
-                    page: Number(route.query['page']) || 1,
-                    'per-page': perPage,
-                },
-                lang,
-                slug.value
-            )();
-        },
+      return useApiFetcher<PaginatedResponse<IVideoCard>>(
+        stateKey.value,
+        apiMethod,
         {
-            watch: [() => route.query.page],
-        }
-    );
+          page: Number(route.query['page']) || 1,
+          'per-page': perPage,
+        },
+        lang,
+        slug.value
+      )();
+    },
+    {
+      watch: [() => route.query.page],
+    }
+  );
 
-    return { data, status, error };
+  return { data, status, error };
 };