itube-specs 0.0.795 → 0.0.797

package/components/ui/input.vue

@@ -236,6 +236,7 @@ const normalizedValue = computed(() => {
   transition: var(--transition) transform;
   resize: none;
   font: inherit;
+  font-size: 16px;
   border: 1px solid transparent;
 
   &:focus {
@@ -245,6 +246,7 @@ const normalizedValue = computed(() => {
   @include from-br(sm) {
     padding-block: 8px;
     padding-inline: 16px;
+    font-size: 14px;
   }
 }
 

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

@@ -3,22 +3,22 @@ import { AsyncData } from '../../runtime';
 import type { ICategoryCard } from '../../types';
 
 export const useFetchCategoriesByLetter = async (
-    apiMethod: (...args: any[]) => Promise<Array<ICategoryCard>>
+  apiMethod: (...args: any[]) => Promise<Array<ICategoryCard>>
 ) => {
-    const key = AsyncData.CategoriesByLetter;
-    const lang = useLang() as Language;
-    const slug = useSlug();
-    const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
+  const key = AsyncData.CategoriesByLetter;
+  const lang = useLang() as Language;
+  const slug = useSlug();
+  const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
 
-    const { data, status, error } = await useAsyncData<Array<ICategoryCard>>(
-        stateKey.value,
-        () => useApiFetcher<Array<ICategoryCard>>(
-            stateKey.value,
-            apiMethod,
-            lang,
-            slug.value,
-        )()
-    );
+  const { data, status, error } = await useAsyncData<Array<ICategoryCard>>(
+    stateKey.value,
+    () => useApiFetcher<Array<ICategoryCard>>(
+      stateKey.value,
+      apiMethod,
+      lang,
+      slug.value,
+    )()
+  );
 
-    return { data, status, error };
+  return { data, status, error };
 };

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

@@ -3,25 +3,25 @@ import { AsyncData } from '../../runtime';
 import type { IChipsItem } from '../../types';
 
 export const useFetchCategoriesByPhrase = async (
-    apiMethod: (...args: any[]) => Promise<Array<IChipsItem>>
+  apiMethod: (...args: any[]) => Promise<Array<IChipsItem>>
 ) => {
-    const key = AsyncData.CategoriesByPhrase;
-    const lang = useLang() as Language;
-    const slug = useSlug();
-    const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
+  const key = AsyncData.CategoriesByPhrase;
+  const lang = useLang() as Language;
+  const slug = useSlug();
+  const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
 
-    const { data, status, error } = await useAsyncData<Array<IChipsItem>>(
-        stateKey.value,
-        () => useApiFetcher<Array<IChipsItem>>(
-            stateKey.value,
-            apiMethod,
-            lang,
-            slug.value,
-            1,
-            1,
-            100
-        )()
-    );
+  const { data, status, error } = await useAsyncData<Array<IChipsItem>>(
+    stateKey.value,
+    () => useApiFetcher<Array<IChipsItem>>(
+      stateKey.value,
+      apiMethod,
+      lang,
+      slug.value,
+      1,
+      1,
+      100
+    )()
+  );
 
-    return { data, status, error };
+  return { data, status, error };
 };

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

@@ -2,20 +2,20 @@ import type { AsyncData, Language } from '../../runtime';
 import type { ICategoryCard, IChipsItem } from '../../types';
 
 export const useFetchCategoriesGroupByLetter = async (
-    key: AsyncData,
-    apiMethod: (...args: any[]) => Promise<Record<string, Array<ICategoryCard>>> | Promise<IChipsItem[]>
+  key: AsyncData,
+  apiMethod: (...args: any[]) => Promise<Record<string, Array<ICategoryCard>>> | Promise<IChipsItem[]>
 ) => {
-    const lang = useLang() as Language;
-    const stateKey = computed(() => `data-${key}-${lang}`);
+  const lang = useLang() as Language;
+  const stateKey = computed(() => `data-${key}-${lang}`);
 
-    const { data, error, refresh, status } = await useAsyncData<Record<string, Array<ICategoryCard>> | IChipsItem[]>(
-        key,
-        () => useApiFetcher<Record<string, Array<ICategoryCard>> | IChipsItem[]>(
-            stateKey.value,
-            apiMethod,
-            lang,
-        )(),
-    );
+  const { data, error, refresh, status } = await useAsyncData<Record<string, Array<ICategoryCard>> | IChipsItem[]>(
+    key,
+    () => useApiFetcher<Record<string, Array<ICategoryCard>> | IChipsItem[]>(
+      stateKey.value,
+      apiMethod,
+      lang,
+    )(),
+  );
 
-    return { data, error, refresh, status };
+  return { data, error, refresh, status };
 };

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

@@ -3,25 +3,25 @@ import { AsyncData } from '../../runtime';
 import type { IChannelCard, PaginatedResponse } from '../../types';
 
 export const useFetchChannelsByModel = async (
-    apiMethod: (...args: any[]) => Promise<PaginatedResponse<IChannelCard>>
+  apiMethod: (...args: any[]) => Promise<PaginatedResponse<IChannelCard>>
 ) => {
-    const lang = useLang() as Language;
-    const slug = useSlug();
-    const key = AsyncData.ChannelsByModel;
-    const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
+  const lang = useLang() as Language;
+  const slug = useSlug();
+  const key = AsyncData.ChannelsByModel;
+  const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
 
-    const { data, status, error } = await useAsyncData<PaginatedResponse<IChannelCard>>(
-        stateKey.value,
-        () => useApiFetcher<PaginatedResponse<IChannelCard>>(
-            stateKey.value,
-            apiMethod,
-            lang,
-            {
-                page: 1,
-            },
-            slug.value,
-        )(),
-    );
+  const { data, status, error } = await useAsyncData<PaginatedResponse<IChannelCard>>(
+    stateKey.value,
+    () => useApiFetcher<PaginatedResponse<IChannelCard>>(
+      stateKey.value,
+      apiMethod,
+      lang,
+      {
+        page: 1,
+      },
+      slug.value,
+    )(),
+  );
 
-    return { data, status, error };
+  return { data, status, error };
 };

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

@@ -3,22 +3,22 @@ import { AsyncData } from '../../runtime';
 import type { ICardInfo } from '../../types';
 
 export const useFetchChannelsByName = async (
-    apiMethod: (...args: any[]) => Promise<ICardInfo>
+  apiMethod: (...args: any[]) => Promise<ICardInfo>
 ) => {
-    const lang = useLang() as Language;
-    const slug = useSlug('channel');
-    const key = AsyncData.ChannelByName;
-    const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
+  const lang = useLang() as Language;
+  const slug = useSlug('channel');
+  const key = AsyncData.ChannelByName;
+  const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
 
-    const { data, status, error } = await useAsyncData<ICardInfo>(
-        stateKey.value,
-        () => useApiFetcher<ICardInfo>(
-            stateKey.value,
-            apiMethod,
-            lang,
-            slug.value,
-        )()
-    );
+  const { data, status, error } = await useAsyncData<ICardInfo>(
+    stateKey.value,
+    () => useApiFetcher<ICardInfo>(
+      stateKey.value,
+      apiMethod,
+      lang,
+      slug.value,
+    )()
+  );
 
-    return { data, status, error };
+  return { data, status, error };
 };

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

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

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

@@ -5,38 +5,38 @@ import { sortChannels } from '../../lib';
 import type { IChannelCard, PaginatedResponse } from '../../types';
 
 export const useFetchChannels = async (
-    apiMethod: (...args: any[]) => Promise<PaginatedResponse<IChannelCard>>
+  apiMethod: (...args: any[]) => Promise<PaginatedResponse<IChannelCard>>
 ) => {
-    const route = useRoute();
-    const mobile = !!useState<boolean>('isMobile').value;
-    const perPage = mobile ? 12 : 48;
-    const lang = useLang() as Language;
-    const key = AsyncData.Channels;
-    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.Channels;
+  const stateKey = computed(() => `data-${key}-${JSON.stringify(route.query)}-${lang}`);
 
-    const { data, status, error } = await useAsyncData<PaginatedResponse<IChannelCard>>(
-        key,
-        () => useApiFetcher<PaginatedResponse<IChannelCard>>(
-            stateKey.value,
-            apiMethod,
-            lang,
-            {
-                page: Number(route.query['page']) || 1,
-                'per-page': perPage,
-            },
-            getSelectedQuery(route, sortChannels) || '-popularity',
-        )(),
-        {
-            watch: [
-                () => {
-                    if (route.query) {
-                        const currentQuery = route.query;
-                        return JSON.stringify(currentQuery);
-                    }
-                },
-            ],
-        }
-    );
+  const { data, status, error } = await useAsyncData<PaginatedResponse<IChannelCard>>(
+    key,
+    () => useApiFetcher<PaginatedResponse<IChannelCard>>(
+      stateKey.value,
+      apiMethod,
+      lang,
+      {
+        page: Number(route.query['page']) || 1,
+        'per-page': perPage,
+      },
+      getSelectedQuery(route, sortChannels) || '-popularity',
+    )(),
+    {
+      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-dictionaries-countries.ts

@@ -3,20 +3,20 @@ import type { Language } from '../../runtime';
 import { AsyncData } from '../../runtime';
 
 export const useFetchDictionariesCountries = async (
-    apiMethod: (...args: any[]) => Promise<ICountries>
+  apiMethod: (...args: any[]) => Promise<ICountries>
 ) => {
-    const lang = useLang() as Language;
-    const key = AsyncData.Countries;
-    const stateKey = computed(() => `data-${key}-${lang}`);
+  const lang = useLang() as Language;
+  const key = AsyncData.Countries;
+  const stateKey = computed(() => `data-${key}-${lang}`);
 
-    const { data, status, error } = await useAsyncData<ICountries>(
-        key,
-        () => useApiFetcher<ICountries>(
-            stateKey.value,
-            apiMethod,
-            lang,
-        )(),
-    );
+  const { data, status, error } = await useAsyncData<ICountries>(
+    key,
+    () => useApiFetcher<ICountries>(
+      stateKey.value,
+      apiMethod,
+      lang,
+    )(),
+  );
 
-    return { countriesData: data, status, error };
+  return { countriesData: data, status, error };
 };

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

@@ -3,20 +3,20 @@ import type { Language } from '../../runtime';
 import { AsyncData } from '../../runtime';
 
 export const useFetchDictionariesGenders = async (
-    apiMethod: (...args: any[]) => Promise<IGenders>
+  apiMethod: (...args: any[]) => Promise<IGenders>
 ) => {
-    const lang = useLang() as Language;
-    const key = AsyncData.Genders;
-    const stateKey = computed(() => `data-${key}-${lang}`);
+  const lang = useLang() as Language;
+  const key = AsyncData.Genders;
+  const stateKey = computed(() => `data-${key}-${lang}`);
 
-    const { data, status, error } = await useAsyncData<IGenders>(
-        key,
-        () => useApiFetcher<IGenders>(
-            stateKey.value,
-            apiMethod,
-            lang,
-        )(),
-    );
+  const { data, status, error } = await useAsyncData<IGenders>(
+    key,
+    () => useApiFetcher<IGenders>(
+      stateKey.value,
+      apiMethod,
+      lang,
+    )(),
+  );
 
-    return { gendersData: data, status, error };
+  return { gendersData: data, status, error };
 };

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

@@ -2,23 +2,23 @@ import type { Language } from '../../runtime';
 import type { IGroupCategories } from '../../types';
 
 export const useFetchGroupsCategoriesLazy = (
-    apiMethod: (...args: any[]) => Promise<IGroupCategories[]>
+  apiMethod: (...args: any[]) => Promise<IGroupCategories[]>
 ) => {
-    const data = useState<IGroupCategories[] | null>('lazy-groups-categories', () => null);
-    const isLoading = useState<boolean>('lazy-groups-categories-loading', () => false);
-    const lang = useLang() as Language;
+  const data = useState<IGroupCategories[] | null>('lazy-groups-categories', () => null);
+  const isLoading = useState<boolean>('lazy-groups-categories-loading', () => false);
+  const lang = useLang() as Language;
 
-    async function load() {
-        if (data.value?.length || isLoading.value) return;
-        isLoading.value = true;
-        try {
-            data.value = await apiMethod(lang);
-        } catch (err) {
-            console.error('Failed to load groups categories:', err);
-        } finally {
-            isLoading.value = false;
-        }
+  async function load() {
+    if (data.value?.length || isLoading.value) return;
+    isLoading.value = true;
+    try {
+      data.value = await apiMethod(lang);
+    } catch (err) {
+      console.error('Failed to load groups categories:', err);
+    } finally {
+      isLoading.value = false;
     }
+  }
 
-    return { data, isLoading, load };
+  return { data, isLoading, load };
 };

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

@@ -3,20 +3,20 @@ import { AsyncData } from '../../runtime';
 import type { IGroupCategories } from '../../types';
 
 export const useFetchGroupsCategories = async (
-    apiMethod: (...args: any[]) => Promise<IGroupCategories[]>
+  apiMethod: (...args: any[]) => Promise<IGroupCategories[]>
 ) => {
-    const lang = useLang() as Language;
-    const key = AsyncData.GroupsCategoriesFilter;
-    const stateKey = computed(() => `data-${key}-${lang}`);
+  const lang = useLang() as Language;
+  const key = AsyncData.GroupsCategoriesFilter;
+  const stateKey = computed(() => `data-${key}-${lang}`);
 
-    const { data, pending: status, error } = await useAsyncData<IGroupCategories[]>(
-        key,
-        () => useApiFetcher<IGroupCategories[]>(
-            stateKey.value,
-            apiMethod,
-            lang,
-        )(),
-    );
+  const { data, pending: status, error } = await useAsyncData<IGroupCategories[]>(
+    key,
+    () => useApiFetcher<IGroupCategories[]>(
+      stateKey.value,
+      apiMethod,
+      lang,
+    )(),
+  );
 
-    return { data, status, error };
+  return { data, status, error };
 };

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

@@ -3,22 +3,22 @@ import { AsyncData } from '../../runtime';
 import type { ICardInfo } from '../../types';
 
 export const useFetchModelByName = async (
-    apiMethod: (...args: any[]) => Promise<ICardInfo>
+  apiMethod: (...args: any[]) => Promise<ICardInfo>
 ) => {
-    const lang = useLang() as Language;
-    const slug = useSlug();
-    const key = AsyncData.ModelsByName;
-    const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
+  const lang = useLang() as Language;
+  const slug = useSlug();
+  const key = AsyncData.ModelsByName;
+  const stateKey = computed(() => `data-${key}-${slug.value}-${lang}`);
 
-    const { data, status, error } = await useAsyncData<ICardInfo>(
-        stateKey.value,
-        () => useApiFetcher<ICardInfo>(
-            stateKey.value,
-            apiMethod,
-            lang,
-            slug.value,
-        )()
-    );
+  const { data, status, error } = await useAsyncData<ICardInfo>(
+    stateKey.value,
+    () => useApiFetcher<ICardInfo>(
+      stateKey.value,
+      apiMethod,
+      lang,
+      slug.value,
+    )()
+  );
 
-    return { data, status, error };
+  return { data, status, error };
 };

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

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

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

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