itube-specs 0.0.257 → 0.0.258

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

@@ -0,0 +1,35 @@
+import { EAsyncData } from '../runtime';
+import type { IMultiSuggest } from '../types';
+import { ELanguage } from '../runtime';
+import { useRoute } from 'vue-router';
+
+export function useFetchMultiSuggest(
+    apiMethod: (...args: any[]) => Promise<IMultiSuggest | null>,
+    phrasesLimit: number,
+    modelsLimit: number,
+    categoriesLimit: number,
+    watchRoute = false
+) {
+    const route = useRoute();
+    const searchValue = useState<string>('searchValue', () => '');
+    const { locale } = useI18n();
+    const lang = locale.value as ELanguage;
+
+    const { data, status } = useAsyncData<IMultiSuggest | null>(
+        watchRoute ? EAsyncData.MultiSuggestRouteSearch : EAsyncData.MultiSuggestSearch,
+        () => useApiFetcher<IMultiSuggest | null>(
+            EAsyncData.Channels,
+            apiMethod,
+            lang,
+            watchRoute ? useSlug().value : searchValue.value,
+            phrasesLimit,
+            modelsLimit,
+            categoriesLimit
+        )(),
+        {
+            watch: [() => watchRoute ? String(route.params?.slug) : searchValue.value],
+        }
+    );
+
+    return { data, status };
+}

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

@@ -0,0 +1,18 @@
+import { useRoute } from 'vue-router';
+import { EAsyncData } from '../runtime';
+import type { IPlaylistInfoType } from '../types';
+
+export const useFetchPlaylistsById = async (apiMethod: (...args: any[]) => Promise<IPlaylistInfoType>) => {
+    const route = useRoute();
+
+    const { data, status, error, refresh } = await useAsyncData<IPlaylistInfoType>(
+        EAsyncData.PlaylistById,
+        () => useApiFetcher<IPlaylistInfoType>(
+            EAsyncData.PlaylistById,
+            apiMethod,
+            String(route.params['id'])
+        )(),
+    );
+
+    return { data, status, error, refresh };
+};

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

@@ -0,0 +1,36 @@
+import { useRoute } from 'vue-router';
+import { EAsyncData, ELanguage, getSelectedQuery } from '../runtime';
+import { sortPlaylists } from '../lib';
+import type { IPlaylistCard, PaginatedResponse } from '../types';
+
+export const useFetchPlaylistsByNiche = async (apiMethod: (...args: any[]) => Promise<PaginatedResponse<IPlaylistCard>>) => {
+    const route = useRoute();
+    const { locale } = useI18n();
+    const lang = locale.value as ELanguage;
+
+    const { data, status, error } = await useAsyncData<PaginatedResponse<IPlaylistCard>>(
+        EAsyncData.GetPlaylistsByNiche,
+        () => useApiFetcher<PaginatedResponse<IPlaylistCard>>(
+            EAsyncData.PlaylistById,
+            apiMethod,
+            {
+                page: Number(route.query[ 'page' ]) || 1,
+                'per-page': 48,
+            },
+            getSelectedQuery(route, sortPlaylists) || '-views',
+            lang,
+        )(),
+        {
+            watch: [
+                () => {
+                    if (route.query) {
+                        const currentQuery = route.query;
+                        return JSON.stringify(currentQuery);
+                    }
+                },
+            ],
+        }
+    );
+
+    return { data, status, error };
+};

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

@@ -0,0 +1,17 @@
+import { EAsyncData } from '../runtime';
+import { ELanguage } from '../runtime';
+
+export const useFetchRelatedSearch = (apiMethod: (...args: any[]) => Promise<Array<string>>) => {
+    const lang = useI18n().locale.value as ELanguage;
+
+    const { data, status, error } = useAsyncData<Array<string>>(
+        EAsyncData.RelatedSearch,
+        () => useApiFetcher<Array<string>>(
+            EAsyncData.RelatedSearch,
+            apiMethod,
+            lang,
+        )(),
+    );
+
+    return { data, status, error };
+};

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

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

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

@@ -0,0 +1,24 @@
+import { EAsyncData, ELanguage } from '../runtime';
+import { IModelCard, PaginatedResponse } from 'itube-specs';
+
+export const useFetchTopModels = (apiMethod: (...args: any[]) => Promise<PaginatedResponse<IModelCard>>, limit: number, eName: EAsyncData | string, cacheId: string) => {
+    const { locale } = useI18n();
+
+    const { data, status, refresh } = useAsyncData(
+        String(eName + cacheId),
+        () => useApiFetcher<PaginatedResponse<IModelCard>>(
+            eName as EAsyncData,
+            apiMethod,
+            limit,
+            0,
+            locale.value as ELanguage,
+            cacheId
+        )(),
+    );
+
+    return {
+        data,
+        refresh,
+        status,
+    };
+};

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

@@ -0,0 +1,18 @@
+import { ELanguage, EAsyncData } from '../runtime';
+import type { IChipsItem } from '../types';
+
+export const useFetchTopRandomCategories = (apiMethod: (...args: any[]) => Promise<Array<IChipsItem>>, cacheId: string) => {
+    const { locale } = useI18n();
+
+    const { data: topRandomCategories, refresh, error } = useAsyncData<Array<IChipsItem>>(
+        String(EAsyncData.CategoriesTopRandom + cacheId),
+        () => useApiFetcher<Array<IChipsItem>>(
+            EAsyncData.CategoriesTopRandom,
+            apiMethod,
+            locale.value as ELanguage,
+            cacheId
+        )(),
+    );
+
+    return { topRandomCategories, refresh, error };
+};

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

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

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

@@ -0,0 +1,38 @@
+import { EAsyncData, ELanguage, getSelectedQuery } from '../runtime';
+import type { IVideoCard, PaginatedResponse } from '../types';
+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 { data, status, error } = await useAsyncData<PaginatedResponse<IVideoCard>>(
+    EAsyncData.VideosByChannel,
+    () => useApiFetcher<PaginatedResponse<IVideoCard>>(
+        EAsyncData.VideosByChannel,
+        apiMethod,
+        {
+          page: Number(route.query[ 'page' ]) || 1,
+          'per-page': 48,
+        },
+        useGetVideosFilterRequest(route, selectDurationItems, selectAddedItems),
+        useSlug().value,
+        lang,
+        getSelectedQuery(route, sortItemsDefault) || '-popularity'
+    )(),
+    {
+      watch: [
+        () => {
+          if (route.query) {
+            const currentQuery = route.query;
+            return JSON.stringify(currentQuery);
+          }
+        },
+      ],
+    }
+  );
+
+  return { data, status, error };
+};

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

@@ -0,0 +1,38 @@
+import { EAsyncData, ELanguage, getSelectedQuery } from '../runtime';
+import type { IVideoCard, PaginatedResponse } from '../types';
+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 { data, status, error } = await useAsyncData<PaginatedResponse<IVideoCard>>(
+    EAsyncData.ModelsVideos,
+    () => useApiFetcher<PaginatedResponse<IVideoCard>>(
+        EAsyncData.ModelsVideos,
+        apiMethod,
+        {
+          page: Number(route.query['page']) || 1,
+          'per-page': 48,
+        },
+        useGetVideosFilterRequest(route, selectDurationItems, selectAddedItems),
+        useSlug().value,
+        lang,
+        getSelectedQuery(route, sortItemsDefault) || '-popularity'
+    )(),
+    {
+      watch: [
+        () => {
+          if (route.query) {
+            const currentQuery = route.query;
+            return JSON.stringify(currentQuery);
+          }
+        },
+      ],
+    }
+  );
+
+  return { data, status, error };
+};

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

@@ -0,0 +1,38 @@
+import { EAsyncData, ELanguage, getSelectedQuery } from '../runtime';
+import { selectAddedItems, selectDurationItems, sortItemsDefault } from '../lib';
+import { useRoute } from 'vue-router';
+import type { IVideoCard, PaginatedResponse } from '../types';
+
+export const useFetchVideosByTag = async (apiMethod: (...args: any[]) => Promise<PaginatedResponse<IVideoCard>>) => {
+    const route = useRoute();
+    const { locale } = useI18n();
+    const lang = locale.value as ELanguage;
+
+    const { data, status, error } = await useAsyncData<PaginatedResponse<IVideoCard>>(
+        EAsyncData.VideosByTag,
+        () => useApiFetcher<PaginatedResponse<IVideoCard>>(
+            EAsyncData.VideosByTag,
+            apiMethod,
+            {
+                page: Number(route.query[ 'page' ]) || 1,
+                'per-page': 48,
+            },
+            useGetVideosFilterRequest(route, selectDurationItems, selectAddedItems),
+            useSlug().value,
+            lang,
+            getSelectedQuery(route, sortItemsDefault) || '-popularity'
+        )(),
+        {
+            watch: [
+                () => {
+                    if (route.query) {
+                        const currentQuery = route.query;
+                        return JSON.stringify(currentQuery);
+                    }
+                },
+            ],
+        }
+    );
+
+    return { data, status, error };
+};

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

@@ -0,0 +1,35 @@
+import { EAsyncData, ELanguage } from '../runtime';
+import type { IVideoCard, PaginatedResponse } from '../types';
+import { useRoute } from 'vue-router';
+
+export const useFetchVideosSearchByNiche = async (apiMethod: (...args: any[]) => Promise<PaginatedResponse<IVideoCard>>) => {
+    const { locale } = useI18n();
+    const lang = locale.value as ELanguage;
+    const route = useRoute();
+
+    const { data, status, error } = await useAsyncData<PaginatedResponse<IVideoCard>>(
+        EAsyncData.VideosBySearch,
+        () => useApiFetcher<PaginatedResponse<IVideoCard>>(
+            EAsyncData.VideosBySearch,
+            apiMethod,
+            {
+                page: Number(route.query[ 'page' ]) || 1,
+                'per-page': 48,
+            },
+            lang,
+            useSlug().value,
+        )(),
+        {
+            watch: [
+                () => {
+                    if (route.query) {
+                        const currentQuery = route.query;
+                        return JSON.stringify(currentQuery);
+                    }
+                },
+            ],
+        }
+    );
+
+    return { data, status, error };
+};

package/composables/use-user.ts

@@ -6,7 +6,7 @@ import type {
   IPasswordForm,
   IRegistrateForm,
   IChangeEmail
-} from 'itube-specs/types';
+} from '../types';
 
 function omit<T extends object, K extends keyof T>(obj: T, keys: K[]): Omit<T, K> {
   const result = {} as Omit<T, K>;

package/lib/scheme/select-added-items.ts

@@ -1,4 +1,4 @@
-import type { ISelectItem } from 'itube-specs/types';
+import type { ISelectItem } from '../types';
 
 export const selectAddedItems: Array<ISelectItem> = [
     {

package/lib/scheme/select-duration-items.ts

@@ -1,4 +1,4 @@
-import type { ISelectItem } from 'itube-specs/types';
+import type { ISelectItem } from '../types';
 
 export const selectDurationItems: Array<ISelectItem> = [
     {

package/lib/scheme/sort-channels.ts

@@ -1,4 +1,4 @@
-import { IChipsItem } from 'itube-specs/types';
+import { IChipsItem } from '../types';
 
 export const sortChannels: Array<IChipsItem> =  [
   {

package/lib/scheme/sort-items-default.ts

@@ -1,4 +1,4 @@
-import { IChipsItem } from 'itube-specs/types';
+import { IChipsItem } from '../types';
 
 export const sortItemsDefault: Array<IChipsItem> = [
   {

package/lib/scheme/sort-models.ts

@@ -1,4 +1,4 @@
-import type { IChipsItem } from 'itube-specs/types';
+import type { IChipsItem } from '../types';
 
 export const sortModels: Array<IChipsItem> =  [
   {

package/lib/scheme/sort-playlists.ts

@@ -1,4 +1,4 @@
-import type { IChipsItem } from 'itube-specs/types';
+import type { IChipsItem } from '../types';
 
 export const sortPlaylists: Array<IChipsItem> =  [
   {

package/package.json

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