itube-specs 0.0.195

package/runtime/utils/cleaners/clean-playlist-data.ts

@@ -0,0 +1,15 @@
+import type { IRawPlaylistData, IPlaylistData } from '../../../types';
+
+export const cleanPlaylistData = (card: IRawPlaylistData): IPlaylistData => ({
+  updated: card.updated,
+  id: card.id,
+  name: card.name,
+  username: card.username,
+  playlistType: card.playlist_type,
+  videosCount: card.videos_count,
+  firstVideoId: card.first_video_id,
+  searchTags: card.search_tags,
+  views: card.views,
+  likes: card.likes,
+  dislikes: card.dislikes,
+})

package/runtime/utils/cleaners/clean-playlist-video.ts

@@ -0,0 +1,12 @@
+import type { IRawPlaylistVideo, IVideoCard } from '../../../types';
+
+export const cleanPlaylistVideo = (card: IRawPlaylistVideo): IVideoCard => ({
+  guid: card.guid,
+  duration: card.duration,
+  title: card.name,
+  id: card.videoId,
+  thumbUrl: card.thumb,
+  playlistId: card.playlistId,
+  md5: card.videoMd5,
+  thumbNum: card.thumbNum,
+})

package/runtime/utils/cleaners/clean-profile-data.ts

@@ -0,0 +1,11 @@
+import type { IRawProfileData, IProfileData } from '../../../types';
+
+export const cleanProfileData = (data: IRawProfileData): IProfileData => ({
+  username: data.username,
+  email: data.email,
+  avatar: data.avatar,
+  country: data.country,
+  city: data.city,
+  birthday: data.birthday,
+  gender: data.gender,
+})

package/runtime/utils/cleaners/clean-user-playlists-card.ts

@@ -0,0 +1,11 @@
+import type { IRawPlaylistsUser, IPlaylistCard } from '../../../types';
+
+export const cleanUserPlaylistCard = (card: IRawPlaylistsUser): IPlaylistCard => ({
+  created: card.created,
+  id: card.id,
+  name: card.name,
+  username: card.username,
+  playlistType: card.playlistType,
+  thumbUrls: card.thumbs.slice(0, 4),
+  videosCount: card.videoCount,
+})

package/runtime/utils/cleaners/clean-video-card.ts

@@ -0,0 +1,19 @@
+import type { IRawVideoCard, IVideoCard } from '../../../types';
+
+export const cleanVideoCard = (card: IRawVideoCard): IVideoCard => ({
+  guid: card.guid,
+  quality: card.quality,
+  duration: card.duration,
+  title: card.title,
+  views: card.views,
+  id: card.id,
+  tags: card.tags,
+  isNew: card.is_new,
+  channelAvatar: card.channel?.avatar_url,
+  channelName: card.channel?.name,
+  url: card.url,
+  previewUrl: card.preview_url,
+  thumbUrl: card.thumb_urls?.webp['480x270'],
+  md5: card.md5,
+  thumbNum: card.thumb_number,
+})

package/runtime/utils/cleaners/clean-video-data.ts

@@ -0,0 +1,27 @@
+import type { IRawVideoData, IVideoData } from '../../../types';
+
+export const cleanVideoData = (data: IRawVideoData): IVideoData => ({
+    guid: data.guid || '',
+    md5: data.md5 || '',
+    quality: data.quality || '',
+    duration: data.duration || 0,
+    title: data.title || '',
+    views: data.views || 0,
+    likes: data.likes || 0,
+    id: data.id || '',
+    tags: data.tags || '',
+    models: data.models || '',
+    categories: data.categories || '',
+    actions: data.actions || null,
+    channelName: data.channel?.name || '',
+    channelAvatar: data.channel?.avatar || '',
+    url: data.url || '',
+    previewUrl: data.preview_url || '',
+    thumbUrl: data.thumb_urls?.webp['480x270'] || '',
+    vttUrl: data.vtt_url || '',
+    vttSpriteUrl: data.vtt_sprite_url || '',
+    created: data.created || 0,
+    videoUrl: data.video_url || '',
+    isDeleted: data.is_deleted,
+    thumbNum: data.thumb_number,
+})

package/runtime/utils/compress-image.ts

@@ -0,0 +1,27 @@
+export const compressImage = (blob: Blob, maxSize = 512, quality = 0.8): Promise<Blob> => {
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    img.onload = () => {
+      const canvas = document.createElement('canvas');
+      const scale = maxSize / Math.max(img.width, img.height);
+      canvas.width = img.width * scale;
+      canvas.height = img.height * scale;
+
+      const ctx = canvas.getContext('2d');
+      if (!ctx) return reject(new Error('Canvas context not available'));
+
+      ctx.drawImage(img, 0, 0, canvas.width, canvas.height);
+      canvas.toBlob(
+        (compressedBlob) => {
+          if (compressedBlob) resolve(compressedBlob);
+          else reject(new Error('Compression failed'));
+        },
+        'image/jpeg',
+        quality
+      );
+    };
+
+    img.onerror = reject;
+    img.src = URL.createObjectURL(blob);
+  });
+};

package/runtime/utils/converters/convert-categories-to-chips.ts

@@ -0,0 +1,13 @@
+import type { IRawCategoryCard, IChipsItem } from '../../../types';
+
+/** Конвертирует обьекты категорий в чипсы */
+export function convertCategoriesToChips(
+  items: Array<IRawCategoryCard>,
+  prefix: string
+): Array<IChipsItem> {
+  return items?.map(item => ({
+    title: item.title,
+    value: item.title,
+    prefix: prefix,
+  }));
+}

package/runtime/utils/converters/convert-categories-to-footer.ts

@@ -0,0 +1,11 @@
+import type { IRawCategoryCard, ILinkItem } from '../../../types';
+
+/** Конвертирует обьекты категорий в футер категории */
+export function convertCategoriesToFooter(
+  items: Array<IRawCategoryCard>,
+): Array<ILinkItem> {
+  return items.map(item => ({
+    title: item.title,
+    value: item.title,
+  }));
+}

package/runtime/utils/converters/convert-date-to-timestamp.ts

@@ -0,0 +1,37 @@
+    /**
+     * Преобразует строку вида "дд.мм.гггг" в Unix timestamp (в секундах)
+     */
+export const convertDateToTimestamp = () => {
+    const toUnix = (dateStr: string): number | null => {
+        const [year, month, day] = dateStr.split('-').map(Number);
+        if (!day || !month || !year) {
+            return null;
+        }
+
+        const date = new Date(year, month - 1, day);
+        if (isNaN(date.getTime())) {
+            return null;
+        }
+
+        return Math.floor(date.getTime() / 1000);
+    };
+
+    /**
+     * Преобразует Unix timestamp в строку "yyyy-MM-dd"
+     * (то, что понимает input[type="date"])
+     */
+    const fromUnix = (timestamp: number): string => {
+        const date = new Date(timestamp * 1000);
+
+        const yyyy = date.getFullYear();
+        const mm = String(date.getMonth() + 1).padStart(2, '0'); // месяцы с 0
+        const dd = String(date.getDate()).padStart(2, '0');
+
+        return `${yyyy}-${mm}-${dd}`;
+    };
+
+    return {
+        toUnix,
+        fromUnix,
+    };
+};

package/runtime/utils/converters/convert-model-card-to-chips.ts

@@ -0,0 +1,13 @@
+import type { IRawModelCard, IChipsItem } from '../../../types';
+
+/** Конвертация карточки модели в chips */
+export function convertModelCardToChips(
+  items: Array<IRawModelCard>,
+): Array<IChipsItem> {
+  return items.map(item => ({
+    title: item.title,
+    value: item.title,
+    icon: item.video_thumb_urls?.webp['320x180'],
+    prefix: 'models',
+  }));
+}

package/runtime/utils/converters/convert-string.ts

@@ -0,0 +1,56 @@
+import type { IChipsItem } from '../../../types';
+
+export const convertString = () => {
+    const toSlug = (input: string): string => {
+        return input
+            .toLowerCase()
+            .replace(/-/g, '\u0000')
+            .replace(/\s+/g, '-')
+            .replace(/\u0000/g, '_');
+    };
+
+    const fromSlug = (slug: string): string => {
+        return slug
+            .replace(/_/g, '\u0000')
+            .replace(/-/g, ' ')
+            .replace(/\u0000/g, '-');
+    };
+
+    const toSnakeCase = (slug: string): string => {
+        return slug
+            .replace(/([a-z])([A-Z])/g, '$1_$2')
+            .replace(/\s+/g, '_')
+            .replace(/-/g, '_')
+            .toLowerCase();
+    };
+
+    const toKebabCase = (str: string): string => {
+        return str
+            .replace(/([a-z])([A-Z])/g, '$1-$2')
+            .replace(/\s+/g, '-')
+            .replace(/_/g, '-')
+            .replace(/-+/g, '-')
+            .toLowerCase();
+    };
+
+    const toChips = (string: string, prefix: string): IChipsItem => {
+        return {
+            title: string,
+            value: string,
+            prefix: prefix,
+        }
+    }
+
+    const toCapitalize = (string: string): string => {
+        return string.split(' ').map(i => i.charAt(0).toUpperCase() + i.slice(1)).join(' ');
+    }
+
+    return {
+        toChips,
+        toSlug,
+        toSnakeCase,
+        fromSlug,
+        toKebabCase,
+        toCapitalize,
+    };
+};

package/runtime/utils/converters/group-categories-by-first-letter.ts

@@ -0,0 +1,24 @@
+import type { IRawCategoryCard, ICategoryCard } from '../../../types';
+
+/** Метод для группировки мини категорий по первой букве свойства */
+export function groupCategoriesByFirstLetter(
+  items: Array<IRawCategoryCard>,
+  prop: string,
+  nonLetterKey = 'POST',
+): Record<string, Array<ICategoryCard>> {
+  return items.reduce((acc, item) => {
+    const firstLetter = (item[prop as keyof IRawCategoryCard] as string).charAt(0).toUpperCase();
+    const key = /[A-Za-z]/.test(firstLetter) ? firstLetter : nonLetterKey;
+    if (!acc[key]) {
+      acc[key] = [];
+    }
+    acc[key].push({
+      isTop: item.is_top,
+      title: item.title,
+      name: item.name,
+      videosCount: item.videosCount,
+      guid: item.guid
+    });
+    return acc;
+  }, {} as Record<string, Array<ICategoryCard>>);
+}

package/runtime/utils/converters/group-objects-by-first-letter.ts

@@ -0,0 +1,16 @@
+/** Метод для группировки категорий по первой букве свойства */
+export function groupObjectsByFirstLetter<T>(
+  items: Array<T>,
+  prop: string,
+  nonLetterKey = 'POST',
+): Record<string, Array<T>> {
+  return items.reduce((acc, item) => {
+    const firstLetter = (item[prop as keyof T] as string).charAt(0).toUpperCase();
+    const key = /[A-Za-z]/.test(firstLetter) ? firstLetter : nonLetterKey;
+    if (!acc[key]) {
+      acc[key] = [];
+    }
+    acc[key].push(item);
+    return acc;
+  }, {} as Record<string, Array<T>>);
+}

package/runtime/utils/format-date.ts

@@ -0,0 +1,12 @@
+export function formatDate(seconds: number): string {
+  const date = new Date(1000 * seconds);
+
+  const day = date.getDate();
+  const month = date.getMonth() + 1;
+  const year = date.getFullYear();
+
+  const formattedDay = String(day).padStart(2, '0');
+  const formattedMonth = String(month).padStart(2, '0');
+
+  return `${formattedDay}.${formattedMonth}.${year}`;
+}

package/runtime/utils/format-number.ts

@@ -0,0 +1,12 @@
+/**
+ * Форматирует число в короткий формат 10400 => 10.4K
+ * @param {number} number - число
+ */
+
+export function formatNumber (number: number) {
+  return number.toLocaleString('en-US', {
+    maximumFractionDigits: 2,
+    notation: 'compact',
+    compactDisplay: 'short'
+  });
+};

package/runtime/utils/format-time-ago.ts

@@ -0,0 +1,21 @@
+export function formatTimeAgo(date: number, t) {
+  const pastDate = new Date(date * 1000);
+  const now = new Date();
+
+  const diffInMs = Number(now) - Number(pastDate);
+  const diffInDays = Math.floor(diffInMs / (1000 * 60 * 60 * 24));
+
+  if (diffInDays === 0) {
+    return t('today');
+  } else if (diffInDays === 1) {
+    return t('day_ago');
+  } else if (diffInDays < 30) {
+    return `${diffInDays} ${t('days_ago')}`;
+  } else if (diffInDays < 365) {
+    const diffInMonths = Math.floor(diffInDays / 30);
+    return `${diffInMonths} ${t('month')}${diffInMonths > 1 ? 's' : ''} ${t('ago')}`;
+  } else {
+    const diffInYears = Math.floor(diffInDays / 365);
+    return `${diffInYears} ${t('year')}${diffInYears > 1 ? 's' : ''} ${t('ago')}`;
+  }
+}

package/runtime/utils/get-duration.ts

@@ -0,0 +1,17 @@
+/**
+ * Возвращает продолжительность по переданным секундам в формате hh:mm:ss
+ * @param {seconds} number - число секунды
+ */
+export function getDuration (seconds: number) {
+  const date = new Date(0);
+  date.setSeconds(seconds);
+  const setZero = (number: number) => number < 10 ? `0${number}` : number;
+
+  const setHours = () => {
+    if (date.getUTCHours() > 0) {
+      return `${setZero(date.getUTCHours())}:`;
+    }
+    return '';
+  };
+  return `${setHours()}${setZero(date.getUTCMinutes())}:${setZero(date.getUTCSeconds())}`;
+};

package/runtime/utils/get-month.ts

@@ -0,0 +1,22 @@
+/**
+ * возвращает название месяца по цифре
+  */
+export function getMonth(t: (key: string) => string, number?: number) {
+  const months = [
+    'january',
+    'february',
+    'march',
+    'april',
+    'may',
+    'june',
+    'july',
+    'august',
+    'september',
+    'october',
+    'november',
+    'december'
+  ];
+  const index = typeof number === 'number' && number >= 0 && number < 12 ? number : 11;
+  const key = months[index];
+  return t(key) || key;
+}

package/runtime/utils/get-multiple-query.ts

@@ -0,0 +1,26 @@
+import type { RouteLocationNormalizedLoaded } from 'vue-router';
+import type { IChipsItem, ISelectItem } from '../../types';
+import { getSelectedQuery } from '../utils/get-selected-query';
+
+export function getMultipleQuery (
+  route: RouteLocationNormalizedLoaded,
+  items: ISelectItem[] | IChipsItem[],
+  minKey: string,
+  maxKey: string,
+) {
+  const query = getSelectedQuery(route, items);
+  if (Array.isArray(query)) {
+    return {
+      [minKey]: query[0],
+      [maxKey]: query[1],
+    };
+  } else if (query === items[items.length - 1]?.query) {
+    return {
+      [minKey]: query,
+    };
+  } else {
+    return {
+      [maxKey]: query,
+    };
+  }
+}

package/runtime/utils/get-selected-query.ts

@@ -0,0 +1,6 @@
+import type { RouteLocation } from 'vue-router';
+import type { IChipsItem, ISelectItem } from '../../types';
+
+export function getSelectedQuery(route: RouteLocation, items: IChipsItem[] | ISelectItem[]) {
+  return items.find(item => item.value === route.query[item.key || ''])?.query;
+}

package/runtime/utils/is-mobile.ts

@@ -0,0 +1,15 @@
+import { useBreakpoints } from '@vueuse/core';
+import type { CssBreakpoints } from '../../types';
+
+export const isMobile = (projectBreakpoints: Record<CssBreakpoints, number>) => {
+    const breakpoints = useBreakpoints(
+        {
+            xs: projectBreakpoints.xs,
+            sm: projectBreakpoints.sm,
+            md: projectBreakpoints.md,
+            lg: projectBreakpoints.lg,
+            xl: projectBreakpoints.xl,
+        }
+    );
+    return breakpoints.smaller('sm');
+};

package/runtime/utils/normalize-url.ts

@@ -0,0 +1,43 @@
+export function normalizeUrl(to: { path: string; query: Record<string, any> }) {
+  let path = to.path
+  let query = { ...to.query }
+
+  // 1) Удаляем page=1
+  if (query.page === '1') {
+    const { page, ...rest } = query
+    query = rest
+  }
+
+    // 2) Удаляем sort=trending
+  if (query.sort === 'trending') {
+    const { sort, ...rest } = query
+    query = rest
+  }
+
+  // Приводим query к нижнему регистру (ключи и строковые значения)
+  const loweredQuery: Record<string, any> = {}
+  for (const [key, value] of Object.entries(query)) {
+    const lowerKey = key.toLowerCase()
+    loweredQuery[lowerKey] = typeof value === 'string' ? value.toLowerCase() : value
+  }
+  query = loweredQuery
+
+  // 2) Приводим путь к нижнему регистру
+  path = path.toLowerCase()
+
+  // 3) Заменяем пробелы и %20 на дефисы
+  path = path
+    .replace(/%20/gi, '-')  // encoded
+    .replace(/ /g, '-')      // raw
+    .replace(/\+/g, '-')     // some browsers encode spaces as +
+
+  // 4) Убираем двойные дефисы
+  path = path.replace(/--+/g, '-')
+
+  // 5) Убираем хвостовой /
+  if (path.length > 1) {
+    path = path.replace(/\/+$/, '')
+  }
+
+  return { path, query }
+}

package/runtime/utils/on-backdrop-click.ts

@@ -0,0 +1,5 @@
+export function onBackdropClick(target: HTMLDialogElement, callback: () => void) {
+  if (target?.nodeName === 'DIALOG') {
+    callback();
+  }
+}

package/runtime/utils/scroll-lock.ts

@@ -0,0 +1,28 @@
+let scrollY = 0;
+
+const lockScroll = () => {
+  if (typeof window === 'undefined') return;
+
+  scrollY = window.scrollY;
+  document.body.style.position = 'fixed';
+  document.body.style.top = `-${scrollY}px`;
+  document.body.style.left = '0';
+  document.body.style.right = '0';
+  document.body.style.overflow = 'hidden';
+};
+
+const unlockScroll = () => {
+  if (typeof window === 'undefined') return;
+
+  document.body.style.position = '';
+  document.body.style.top = '';
+  document.body.style.left = '';
+  document.body.style.right = '';
+  document.body.style.overflow = '';
+  window.scrollTo(0, scrollY);
+};
+
+export const scrollLock = () => ({
+  lockScroll,
+  unlockScroll,
+});

package/runtime/utils/server/abort-controller.ts

@@ -0,0 +1,14 @@
+export class AbortControllerUtil {
+  private static abortController: AbortController | undefined;
+
+  static createAbortController(): AbortController {
+    this.abortController = new AbortController();
+    return this.abortController;
+  }
+
+  static getSignalAbortController(): AbortSignal | undefined {
+    const signal = this.abortController?.signal;
+    this.abortController = undefined;
+    return signal;
+  }
+}

package/runtime/utils/server/api-helper.ts

@@ -0,0 +1,41 @@
+import type { NitroFetchOptions } from "nitropack/types";
+import { AbortControllerUtil } from '../server/abort-controller';
+
+/** Хелпер для работы с API */
+export class ApiHelper {
+    /** Метод для получения данных */
+    static async fetch<T>(
+        path: string,
+        fetchOptions: NitroFetchOptions<string>,
+        runtimeConfig?: any,
+    ): Promise<T> {
+        // TODO поменяется апи ендпойнт, после переделать
+        // const apiDomain = useRuntimeConfig()?.public?.apiDomain;
+        const signal = AbortControllerUtil.getSignalAbortController();
+
+        const _fetchOptions = {
+            ...fetchOptions,
+            headers: {
+                ...(fetchOptions.headers || {}),
+                'x-domain': runtimeConfig.public.xDomain,
+            },
+            body: fetchOptions.body !== undefined
+                ? fetchOptions.body : undefined,
+        };
+
+        try {
+            const res = await $fetch(`/bff${path}`, { retry: 0, ..._fetchOptions, signal, });
+
+            if (typeof res === 'string') {
+                return JSON.parse(res).data;
+            } else {
+                return res as T;
+            }
+        } catch (error) {
+            if (signal?.aborted) {
+                throw AbortControllerUtil.createAbortController();
+            }
+            throw error;
+        }
+    }
+}

package/runtime/utils/server/get-url-with-proxied-params.ts

@@ -0,0 +1,6 @@
+export function getUrlWithProxiedParams(url: string, event) {
+    const _url = new URL(url);
+    _url.search = new URLSearchParams(getQuery(event));
+
+    return _url.toString();
+}

package/runtime/utils/server/parse-api-error.ts

@@ -0,0 +1,14 @@
+export function parseApiError(error: any): string {
+  let errorMessage = 'Unknown error occurred.';
+
+  try {
+    const raw = error?.response?._data;
+    const parsed = typeof raw === 'string' ? JSON.parse(raw) : raw;
+
+    errorMessage = parsed?.error || error?.message || errorMessage;
+  } catch (parseError) {
+    console.warn('Failed to parse error._data', parseError);
+  }
+
+  return errorMessage;
+}

package/runtime/utils/server/server-api-helper.ts

@@ -0,0 +1,28 @@
+import { H3Event } from "h3";
+
+/** Класс для работы с серверным API (бекенд) */
+export class ServerApiHelper {
+  /* Класс для запроса данных на бекенде */
+  public static async fetch<T>(url: string, event: H3Event, requestOptions: RequestInit): Promise<T> {
+    try {
+      const response = await fetch(url, {
+        headers: getHeaders(event),
+        ...requestOptions,
+      });
+      return (await response.json())?.data as T;
+    } catch (error) {
+      throw new Error(`Cannot fetch: ${error.data}`);
+    }
+  }
+  // TODO проверить а надо ли, если ничего не сломается оставить только один метод
+  public static async fetchNitro<T>(url: string, event: H3Event, requestOptions: RequestInit): Promise<T> {
+    try {
+      return JSON.parse(String(await $fetch(url, {
+        headers: getHeaders(event),
+        ...requestOptions,
+      })));
+    } catch (error) {
+      throw new Error(`Cannot fetch: ${error.data}`);
+    }
+  };
+}

package/runtime/utils/validate-email.ts

@@ -0,0 +1,4 @@
+export function validateEmail(value: string) {
+    const re = /^[\w&*+-]+(?:\.[\w&*+-]+)*@(?:[\da-z-]+\.)+[a-z]{2,}$/gi;
+    return value?.length !== 0 && re.test(String(value).toLowerCase());
+};

package/runtime/utils/validate-password.ts

@@ -0,0 +1,3 @@
+export function validatePassword(value: string) {
+  return value.length > 4;
+};

package/runtime/utils/validate-phone.ts

@@ -0,0 +1,4 @@
+export function validatePhone (value: string) {
+  const re = /^\+?[0-9\s\-().]{7,20}$/;
+  return value?.length !== 0 && re.test(String(value).trim());
+};

package/runtime/utils/validate-username.ts

@@ -0,0 +1,4 @@
+export function validateUsername (value: string) {
+  const re = /^[a-zA-Z0-9_-]{2,20}$/;
+  return value.length !== 0 && re.test(String(value).toLowerCase());
+};