itube-specs 0.0.712 → 0.0.713

package/package.json

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

package/runtime/utils/cleaners/clean-category-card.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect } from 'vitest';
+import { cleanCategoryCard } from './clean-category-card';
+
+describe('cleanCategoryCard', () => {
+  it('полные данные', () => {
+    const raw = {
+      name: 'teen',
+      title: 'Teen',
+      videosCount: 100,
+      video_thumb_urls: {
+        webp: { '320x180': 'https://img.com/small.webp' },
+      },
+      guid: 'abc-123',
+      description: 'Test desc',
+      icon: 'icon.svg',
+    };
+    const result = cleanCategoryCard(raw as any);
+    expect(result).toEqual({
+      name: 'teen',
+      title: 'Teen',
+      videosCount: 100,
+      thumbUrls: { webp: { '320x180': 'https://img.com/small.webp' } },
+      guid: 'abc-123',
+      description: 'Test desc',
+      icon: 'icon.svg',
+    });
+  });
+
+  it('пустые данные → дефолты', () => {
+    const result = cleanCategoryCard({} as any);
+    expect(result.name).toBe('');
+    expect(result.title).toBe('');
+    expect(result.videosCount).toBe(0);
+    expect(result.thumbUrls).toBeUndefined();
+    expect(result.guid).toBe('');
+    expect(result.description).toBe('');
+    expect(result.icon).toBe('');
+  });
+
+  it('thumbUrls без нужного размера', () => {
+    const raw = { video_thumb_urls: { webp: {} } };
+    const result = cleanCategoryCard(raw as any);
+    expect(result.thumbUrls).toEqual({ webp: { '320x180': '' } });
+  });
+});

package/runtime/utils/cleaners/clean-category-info.test.ts

@@ -0,0 +1,42 @@
+import { describe, it, expect } from 'vitest';
+import { cleanCategoryInfo } from './clean-category-info';
+
+describe('cleanCategoryInfo', () => {
+  it('полные данные', () => {
+    const raw = {
+      guid: 'abc',
+      title: 'Teen',
+      videosCount: 50,
+      description: 'desc',
+      fullDescription: 'full desc',
+      related: [{ title: 'MILF', name: 'milf' }],
+      meta_description: 'meta desc',
+      meta_title: 'meta title',
+      header: 'h1 header',
+    };
+    const result = cleanCategoryInfo(raw as any);
+    expect(result.guid).toBe('abc');
+    expect(result.title).toBe('Teen');
+    expect(result.videosCount).toBe(50);
+    expect(result.fullDescription).toBe('full desc');
+    expect(result.metaDescription).toBe('meta desc');
+    expect(result.metaTitle).toBe('meta title');
+    expect(result.header).toBe('h1 header');
+    expect(result.related).toEqual([
+      { title: 'MILF', value: 'milf', prefix: 'categories' },
+    ]);
+  });
+
+  it('пустые данные → дефолты', () => {
+    const result = cleanCategoryInfo({} as any);
+    expect(result.guid).toBe('');
+    expect(result.title).toBe('');
+    expect(result.videosCount).toBe(0);
+    expect(result.description).toBe('');
+    expect(result.fullDescription).toBe('');
+    expect(result.related).toEqual([]);
+    expect(result.metaDescription).toBe('');
+    expect(result.metaTitle).toBe('');
+    expect(result.header).toBe('');
+  });
+});

package/runtime/utils/cleaners/clean-channel-card.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect } from 'vitest';
+import { cleanChannelCard } from './clean-channel-card';
+
+describe('cleanChannelCard', () => {
+  it('полные данные', () => {
+    const raw = {
+      guid: 'ch-1',
+      name: 'Channel',
+      url: '/channel/1',
+      videos_count: 200,
+      is_network: true,
+      updated: 1700000000,
+      avatar_url: 'https://img.com/avatar.jpg',
+      video_thumb_urls: {
+        webp: {
+          '320x180': 'https://img.com/s.webp',
+          '480x270': 'https://img.com/m.webp',
+        },
+      },
+      description: 'Channel desc',
+    };
+    const result = cleanChannelCard(raw as any);
+    expect(result.guid).toBe('ch-1');
+    expect(result.name).toBe('Channel');
+    expect(result.videosCount).toBe(200);
+    expect(result.isNetwork).toBe(true);
+    expect(result.avatarUrl).toBe('https://img.com/avatar.jpg');
+    expect(result.thumbUrls).toEqual({
+      webp: {
+        '320x180': 'https://img.com/s.webp',
+        '480x270': 'https://img.com/m.webp',
+      },
+    });
+  });
+
+  it('пустые данные → дефолты', () => {
+    const result = cleanChannelCard({} as any);
+    expect(result.guid).toBe('');
+    expect(result.name).toBe('');
+    expect(result.videosCount).toBe(0);
+    expect(result.isNetwork).toBe(false);
+    expect(result.thumbUrls).toBeUndefined();
+  });
+});

package/runtime/utils/cleaners/clean-channel-info.test.ts

@@ -0,0 +1,41 @@
+import { describe, it, expect } from 'vitest';
+import { cleanChannelInfo } from './clean-channel-info';
+
+describe('cleanChannelInfo', () => {
+  it('полные данные', () => {
+    const raw = {
+      guid: 'ch-1',
+      name: 'Channel Name',
+      url: '/channel/1',
+      description: 'desc',
+      videos_count: 100,
+      is_network: false,
+      updated: 1700000000,
+      avatar_url: 'https://img.com/avatar.jpg',
+      video_thumb_urls: { webp: { '320x180': 'https://img.com/s.webp' } },
+      tags: ['tag1', 'tag2'],
+    };
+    const result = cleanChannelInfo(raw as any);
+    expect(result.title).toBe('Channel Name');
+    expect(result.img).toBe('https://img.com/avatar.jpg');
+    expect(result.tags).toEqual(['tag1', 'tag2']);
+  });
+
+  it('без avatar_url → берёт thumb', () => {
+    const raw = {
+      avatar_url: '',
+      video_thumb_urls: { webp: { '320x180': 'https://img.com/thumb.webp' } },
+    };
+    const result = cleanChannelInfo(raw as any);
+    expect(result.img).toBe('https://img.com/thumb.webp');
+  });
+
+  it('пустые данные с пустым webp → дефолты', () => {
+    const raw = { video_thumb_urls: { webp: {} } };
+    const result = cleanChannelInfo(raw as any);
+    expect(result.guid).toBe('');
+    expect(result.title).toBe('');
+    expect(result.videosCount).toBe(0);
+    expect(result.tags).toEqual([]);
+  });
+});

package/runtime/utils/cleaners/clean-mini-category-card.test.ts

@@ -0,0 +1,31 @@
+import { describe, it, expect } from 'vitest';
+import { cleanMiniCategoryCard } from './clean-mini-category-card';
+
+describe('cleanMiniCategoryCard', () => {
+  it('полные данные', () => {
+    const raw = {
+      name: 'teen',
+      title: 'Teen',
+      is_top: true,
+      videosCount: 50,
+      icon: 'icon.svg',
+    };
+    const result = cleanMiniCategoryCard(raw as any);
+    expect(result).toEqual({
+      name: 'teen',
+      title: 'Teen',
+      isTop: true,
+      videosCount: 50,
+      icon: 'icon.svg',
+    });
+  });
+
+  it('пустые данные → дефолты', () => {
+    const result = cleanMiniCategoryCard({} as any);
+    expect(result.name).toBe('');
+    expect(result.title).toBe('');
+    expect(result.isTop).toBe(false);
+    expect(result.videosCount).toBe(0);
+    expect(result.icon).toBeUndefined();
+  });
+});

package/runtime/utils/cleaners/clean-model-card.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect } from 'vitest';
+import { cleanModelCard } from './clean-model-card';
+
+const makeRaw = (overrides = {}) => ({
+  title: 'Model Name',
+  videos_count: 10,
+  video_thumb_urls: { webp: { '320x180': 'https://img.com/s.webp' } },
+  primary_image_url: 'https://img.com/primary.jpg',
+  guid: 'model-1',
+  parameters: [
+    { name: 'birthplace_country', values: [{ title: 'USA', name: 'usa' }] },
+    { name: 'age', values: [{ title: '25' }] },
+    { name: 'height_cm', values: [{ title: '170' }] },
+    { name: 'weight_kg', values: [{ title: '55' }] },
+  ],
+  ...overrides,
+});
+
+describe('cleanModelCard', () => {
+  it('полные данные', () => {
+    const result = cleanModelCard(makeRaw() as any);
+    expect(result.title).toBe('Model Name');
+    expect(result.videosCount).toBe(10);
+    expect(result.thumbUrl).toBe('https://img.com/s.webp');
+    expect(result.guid).toBe('model-1');
+    expect(result.country).toEqual({ title: 'USA', name: 'usa' });
+  });
+
+  it('параметры: age, height, weight', () => {
+    const result = cleanModelCard(makeRaw() as any);
+    expect(result.parameters).toEqual([
+      { title: 'age', value: '25' },
+      { title: 'height_cm', value: '170' },
+      { title: 'weight_kg', value: '55' },
+    ]);
+  });
+
+  it('без age → параметры без age', () => {
+    const raw = makeRaw({
+      parameters: [
+        { name: 'birthplace_country', values: [{ title: 'USA', name: 'usa' }] },
+        { name: 'height_cm', values: [{ title: '170' }] },
+      ],
+    });
+    const result = cleanModelCard(raw as any);
+    expect(result.parameters).toEqual([
+      { title: 'height_cm', value: '170' },
+    ]);
+  });
+
+  it('пустые параметры', () => {
+    const raw = makeRaw({ parameters: [] });
+    const result = cleanModelCard(raw as any);
+    expect(result.country).toEqual({ title: '', name: '' });
+    expect(result.parameters).toEqual([]);
+  });
+});

package/runtime/utils/cleaners/clean-playlist-card.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect } from 'vitest';
+import { cleanPlaylistCard } from './clean-playlist-card';
+
+describe('cleanPlaylistCard', () => {
+  it('полные данные', () => {
+    const raw = {
+      created: 1700000000,
+      id: 'pl-1',
+      name: 'My Playlist',
+      username: 'user1',
+      playlist_type: 'public',
+      thumbs: [
+        { urls: { webp: { '320x180': 'https://img.com/s1.webp', '480x270': 'https://img.com/m1.webp' } } },
+      ],
+      videos_count: 5,
+      first_video_id: 'v-1',
+      search_tags: 'tag1,tag2',
+      views: 100,
+      likes: 10,
+      dislikes: 2,
+    };
+    const result = cleanPlaylistCard(raw as any);
+    expect(result.id).toBe('pl-1');
+    expect(result.name).toBe('My Playlist');
+    expect(result.playlistType).toBe('public');
+    expect(result.videosCount).toBe(5);
+    expect(result.thumbUrls).toHaveLength(1);
+    expect(result.thumbUrls![0]).toEqual({
+      webp: {
+        '320x180': 'https://img.com/s1.webp',
+        '480x270': 'https://img.com/m1.webp',
+      },
+    });
+  });
+
+  it('пустые данные → дефолты', () => {
+    const result = cleanPlaylistCard({} as any);
+    expect(result.id).toBe('');
+    expect(result.name).toBe('');
+    expect(result.videosCount).toBe(0);
+    expect(result.views).toBe(0);
+    expect(result.likes).toBe(0);
+    expect(result.dislikes).toBe(0);
+  });
+});

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

@@ -0,0 +1,42 @@
+import { describe, it, expect } from 'vitest';
+import { cleanPlaylistData } from './clean-playlist-data';
+
+describe('cleanPlaylistData', () => {
+  it('полные данные', () => {
+    const raw = {
+      updated: 1700000000,
+      id: 'pl-1',
+      name: 'Playlist',
+      username: 'user1',
+      playlist_type: 'private',
+      videos_count: 10,
+      first_video_id: 'v-1',
+      search_tags: 'tags',
+      views: 200,
+      likes: 20,
+      dislikes: 3,
+    };
+    const result = cleanPlaylistData(raw as any);
+    expect(result).toEqual({
+      updated: 1700000000,
+      id: 'pl-1',
+      name: 'Playlist',
+      username: 'user1',
+      playlistType: 'private',
+      videosCount: 10,
+      firstVideoId: 'v-1',
+      searchTags: 'tags',
+      views: 200,
+      likes: 20,
+      dislikes: 3,
+    });
+  });
+
+  it('пустые данные → дефолты', () => {
+    const result = cleanPlaylistData({} as any);
+    expect(result.updated).toBe(0);
+    expect(result.id).toBe('');
+    expect(result.videosCount).toBe(0);
+    expect(result.views).toBe(0);
+  });
+});

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

@@ -0,0 +1,39 @@
+import { describe, it, expect } from 'vitest';
+import { cleanPlaylistVideo } from './clean-playlist-video';
+
+describe('cleanPlaylistVideo', () => {
+  it('полные данные', () => {
+    const raw = {
+      guid: 'v-1',
+      duration: 300,
+      title: 'Video Title',
+      id: 'id-1',
+      thumb_urls: {
+        webp: {
+          '320x180': 'https://img.com/s.webp',
+          '480x270': 'https://img.com/m.webp',
+        },
+      },
+      md5: 'abc123',
+    };
+    const result = cleanPlaylistVideo(raw as any);
+    expect(result.guid).toBe('v-1');
+    expect(result.duration).toBe(300);
+    expect(result.title).toBe('Video Title');
+    expect(result.thumbUrls).toEqual({
+      webp: {
+        '320x180': 'https://img.com/s.webp',
+        '480x270': 'https://img.com/m.webp',
+      },
+    });
+  });
+
+  it('пустые данные → дефолты', () => {
+    const result = cleanPlaylistVideo({} as any);
+    expect(result.guid).toBe('');
+    expect(result.duration).toBe(0);
+    expect(result.title).toBe('');
+    expect(result.thumbUrls).toBeUndefined();
+    expect(result.md5).toBe('');
+  });
+});

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

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import { cleanProfileData } from './clean-profile-data';
+
+describe('cleanProfileData', () => {
+  it('полные данные', () => {
+    const raw = {
+      username: 'john',
+      email: 'john@test.com',
+      avatar: 'https://img.com/avatar.jpg',
+      country: 'US',
+      city: 'NYC',
+      birthday: 946684800,
+      gender: 'male',
+      created: 1700000000,
+    };
+    const result = cleanProfileData(raw as any);
+    expect(result).toEqual(raw);
+  });
+
+  it('пустые данные → дефолты', () => {
+    const result = cleanProfileData({} as any);
+    expect(result.username).toBe('');
+    expect(result.email).toBe('');
+    expect(result.avatar).toBe('');
+    expect(result.country).toBe('');
+    expect(result.birthday).toBe(0);
+    expect(result.gender).toBe('');
+    expect(result.created).toBe(0);
+  });
+});

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

@@ -0,0 +1,40 @@
+import { describe, it, expect } from 'vitest';
+import { cleanUserPlaylistCard } from './clean-user-playlists-card';
+
+describe('cleanUserPlaylistCard', () => {
+  it('полные данные', () => {
+    const raw = {
+      created: 1700000000,
+      id: 'pl-1',
+      name: 'My Playlist',
+      username: 'user1',
+      playlistType: 'public',
+      thumbs: [
+        'https://img.com/1.webp',
+        'https://img.com/2.webp',
+        'https://img.com/3.webp',
+        'https://img.com/4.webp',
+        'https://img.com/5.webp',
+      ],
+      videoCount: 10,
+      firstVideoID: 'v-1',
+    };
+    const result = cleanUserPlaylistCard(raw as any);
+    expect(result.id).toBe('pl-1');
+    expect(result.playlistType).toBe('public');
+    expect(result.videosCount).toBe(10);
+    expect(result.firstVideoId).toBe('v-1');
+    expect(result.thumbUrls).toHaveLength(4); // slice(0, 4)
+    expect(result.thumbUrls![0]).toEqual({
+      webp: { '320x180': 'https://img.com/1.webp' },
+    });
+  });
+
+  it('пустые данные → дефолты', () => {
+    const result = cleanUserPlaylistCard({} as any);
+    expect(result.id).toBe('');
+    expect(result.name).toBe('');
+    expect(result.videosCount).toBe(0);
+    expect(result.thumbUrls).toEqual([]);
+  });
+});

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

@@ -0,0 +1,57 @@
+import { describe, it, expect } from 'vitest';
+import { cleanVideoCard } from './clean-video-card';
+
+describe('cleanVideoCard', () => {
+  it('полные данные', () => {
+    const raw = {
+      guid: 'v-1',
+      quality: '1080p',
+      duration: 600,
+      title: 'Video Title',
+      views: 1000,
+      id: 'id-1',
+      tags: 'tag1,tag2',
+      is_new: true,
+      channel: { avatar_url: 'https://img.com/ch.jpg', name: 'Channel' },
+      url: '/video/1',
+      preview_url: 'https://img.com/preview.mp4',
+      thumb_urls: {
+        webp: {
+          '320x180': 'https://img.com/s.webp',
+          '480x270': 'https://img.com/m.webp',
+        },
+      },
+      md5: 'abc',
+      thumb_number: 3,
+      models: [{ title: 'Model A' }, { title: 'Model B' }],
+    };
+    const result = cleanVideoCard(raw as any);
+    expect(result.guid).toBe('v-1');
+    expect(result.quality).toBe('1080p');
+    expect(result.isNew).toBe(true);
+    expect(result.channelName).toBe('Channel');
+    expect(result.channelAvatar).toBe('https://img.com/ch.jpg');
+    expect(result.models).toEqual(['Model A', 'Model B']);
+    expect(result.thumbNum).toBe(3);
+    expect(result.thumbUrls).toEqual({
+      webp: {
+        '320x180': 'https://img.com/s.webp',
+        '480x270': 'https://img.com/m.webp',
+      },
+    });
+  });
+
+  it('пустые данные → дефолты', () => {
+    const result = cleanVideoCard({} as any);
+    expect(result.guid).toBe('');
+    expect(result.quality).toBe('');
+    expect(result.duration).toBe(0);
+    expect(result.views).toBe(0);
+    expect(result.isNew).toBe(false);
+    expect(result.channelAvatar).toBe('');
+    expect(result.channelName).toBe('');
+    expect(result.thumbUrls).toBeUndefined();
+    expect(result.models).toEqual([]);
+    expect(result.thumbNum).toBe(0);
+  });
+});

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

@@ -0,0 +1,57 @@
+import { describe, it, expect } from 'vitest';
+import { cleanVideoData } from './clean-video-data';
+
+describe('cleanVideoData', () => {
+  it('полные данные', () => {
+    const raw = {
+      guid: 'v-1',
+      md5: 'abc',
+      quality: '1080p',
+      duration: 600,
+      title: 'Title',
+      header: 'Header',
+      views: 1000,
+      likes: 100,
+      id: 'id-1',
+      tags: 'tag1',
+      models: 'model1',
+      categories: 'cat1',
+      actions: { liked: true },
+      channel: { name: 'Channel', avatar_url: 'https://img.com/ch.jpg' },
+      url: '/video/1',
+      preview_url: 'https://img.com/preview.mp4',
+      thumb_urls: { webp: { '320x180': 'small' } },
+      vtt_url: '/vtt',
+      vtt_sprite_url: '/sprite',
+      created: 1700000000,
+      video_url: '/stream',
+      is_deleted: false,
+      thumb_number: 5,
+      description: 'desc',
+      dislikes: 3,
+    };
+    const result = cleanVideoData(raw as any);
+    expect(result.guid).toBe('v-1');
+    expect(result.channelName).toBe('Channel');
+    expect(result.thumbUrls).toEqual({ webp: { '320x180': 'small' } });
+    expect(result.vttUrl).toBe('/vtt');
+    expect(result.videoUrl).toBe('/stream');
+    expect(result.isDeleted).toBe(false);
+    expect(result.thumbNum).toBe(5);
+  });
+
+  it('пустые данные → дефолты', () => {
+    const result = cleanVideoData({} as any);
+    expect(result.guid).toBe('');
+    expect(result.duration).toBe(0);
+    expect(result.views).toBe(0);
+    expect(result.likes).toBe(0);
+    expect(result.channelName).toBe('');
+    expect(result.channelAvatar).toBe('');
+    expect(result.thumbUrls).toBeUndefined();
+    expect(result.isDeleted).toBe(false);
+    expect(result.created).toBe(0);
+    expect(result.actions).toBe(null);
+    expect(result.dislikes).toBe(0);
+  });
+});

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

@@ -0,0 +1,26 @@
+import { describe, it, expect } from 'vitest';
+import { convertCategoriesToChips } from './convert-categories-to-chips';
+
+describe('convertCategoriesToChips', () => {
+  it('конвертирует массив категорий в чипсы', () => {
+    const items = [
+      { title: 'Teen', name: 'teen' },
+      { title: 'MILF', name: 'milf' },
+    ];
+    const result = convertCategoriesToChips(items as any, 'categories');
+    expect(result).toEqual([
+      { title: 'Teen', value: 'teen', prefix: 'categories' },
+      { title: 'MILF', value: 'milf', prefix: 'categories' },
+    ]);
+  });
+
+  it('пустой массив', () => {
+    expect(convertCategoriesToChips([], 'categories')).toEqual([]);
+  });
+
+  it('использует переданный prefix', () => {
+    const items = [{ title: 'A', name: 'a' }];
+    const result = convertCategoriesToChips(items as any, 'models');
+    expect(result[0].prefix).toBe('models');
+  });
+});

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

@@ -0,0 +1,20 @@
+import { describe, it, expect } from 'vitest';
+import { convertCategoriesToFooter } from './convert-categories-to-footer';
+
+describe('convertCategoriesToFooter', () => {
+  it('конвертирует категории в футер', () => {
+    const items = [
+      { title: 'Teen', name: 'teen' },
+      { title: 'MILF', name: 'milf' },
+    ];
+    const result = convertCategoriesToFooter(items as any);
+    expect(result).toEqual([
+      { title: 'Teen', name: 'teen' },
+      { title: 'MILF', name: 'milf' },
+    ]);
+  });
+
+  it('пустой массив', () => {
+    expect(convertCategoriesToFooter([])).toEqual([]);
+  });
+});

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

@@ -0,0 +1,20 @@
+import { describe, it, expect } from 'vitest';
+import { convertModelCardToChips } from './convert-model-card-to-chips';
+
+describe('convertModelCardToChips', () => {
+  it('конвертирует карточки моделей в чипсы', () => {
+    const items = [
+      { title: 'Model A', video_thumb_urls: { webp: { '320x180': 'https://img.com/a.webp' } } },
+      { title: 'Model B', video_thumb_urls: { webp: { '320x180': 'https://img.com/b.webp' } } },
+    ];
+    const result = convertModelCardToChips(items as any);
+    expect(result).toEqual([
+      { title: 'Model A', value: 'Model A', icon: 'https://img.com/a.webp', prefix: 'models' },
+      { title: 'Model B', value: 'Model B', icon: 'https://img.com/b.webp', prefix: 'models' },
+    ]);
+  });
+
+  it('пустой массив', () => {
+    expect(convertModelCardToChips([])).toEqual([]);
+  });
+});

package/runtime/utils/converters/convert-query-categories.test.ts

@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'vitest';
+import { convertQueryCategories } from './convert-query-categories';
+
+describe('convertQueryCategories', () => {
+  it('конвертирует query категории', () => {
+    const route = { query: { categories: 'cat_teen,cat_milf' } };
+    const result = convertQueryCategories(route as any);
+    expect(result).toBe('Teen, Milf');
+  });
+
+  it('ограничивает до 3 категорий', () => {
+    const route = { query: { categories: 'cat_a,cat_b,cat_c,cat_d' } };
+    const result = convertQueryCategories(route as any);
+    expect(result).toBe('A, B, C');
+  });
+
+  it('одна категория', () => {
+    const route = { query: { categories: 'cat_teen' } };
+    const result = convertQueryCategories(route as any);
+    expect(result).toBe('Teen');
+  });
+});

package/runtime/utils/converters/convert-string-array-to-chips.test.ts

@@ -0,0 +1,21 @@
+import { describe, it, expect } from 'vitest';
+import { convertStringArrayToChips } from './convert-string-array-to-chips';
+
+describe('convertStringArrayToChips', () => {
+  it('конвертирует массив строк в чипсы', () => {
+    const result = convertStringArrayToChips(['teen', 'milf'], 'tags', '/videos');
+    expect(result).toEqual([
+      { title: 'teen', value: 'teen', prefix: 'tags', resetPath: '/videos' },
+      { title: 'milf', value: 'milf', prefix: 'tags', resetPath: '/videos' },
+    ]);
+  });
+
+  it('# → post', () => {
+    const result = convertStringArrayToChips(['#', 'teen'], 'tags', '/');
+    expect(result[0]).toEqual({ title: 'post', value: 'post', prefix: 'tags', resetPath: '/' });
+  });
+
+  it('пустой массив', () => {
+    expect(convertStringArrayToChips([], 'tags', '/')).toEqual([]);
+  });
+});

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

@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest';
+import { groupCategoriesByFirstLetter } from './group-categories-by-first-letter';
+
+const items = [
+  { title: 'Amateur', name: 'amateur', videosCount: 10, guid: '1', icon: '', is_top: false },
+  { title: 'Anal', name: 'anal', videosCount: 5, guid: '2', icon: '', is_top: true },
+  { title: 'Big Tits', name: 'big-tits', videosCount: 20, guid: '3', icon: '', is_top: false },
+  { title: '69', name: '69', videosCount: 8, guid: '4', icon: '', is_top: false },
+];
+
+describe('groupCategoriesByFirstLetter', () => {
+  it('группирует по первой букве title', () => {
+    const result = groupCategoriesByFirstLetter(items as any, 'title', 'en');
+    expect(Object.keys(result)).toContain('A');
+    expect(Object.keys(result)).toContain('B');
+    expect(result['A']).toHaveLength(2);
+    expect(result['B']).toHaveLength(1);
+  });
+
+  it('цифры попадают в POST', () => {
+    const result = groupCategoriesByFirstLetter(items as any, 'title', 'en');
+    expect(result['POST']).toHaveLength(1);
+    expect(result['POST'][0].name).toBe('69');
+  });
+
+  it('кастомный nonLetterKey', () => {
+    const result = groupCategoriesByFirstLetter(items as any, 'title', 'en', 'OTHER');
+    expect(result['OTHER']).toHaveLength(1);
+  });
+
+  it('POST ключ идёт последним', () => {
+    const result = groupCategoriesByFirstLetter(items as any, 'title', 'en');
+    const keys = Object.keys(result);
+    expect(keys[keys.length - 1]).toBe('POST');
+  });
+
+  it('пустой массив', () => {
+    const result = groupCategoriesByFirstLetter([], 'title', 'en');
+    expect(result).toEqual({});
+  });
+
+  it('не массив → пустой результат', () => {
+    const result = groupCategoriesByFirstLetter(null as any, 'title', 'en');
+    expect(result).toEqual({});
+  });
+});

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

@@ -0,0 +1,32 @@
+import { describe, it, expect } from 'vitest';
+import { getMultipleQuery } from './get-multiple-query';
+
+describe('getMultipleQuery', () => {
+  const route = { query: { duration: '10-30' } };
+  const items = [
+    { value: '0-10', key: 'duration', query: [0, 10] },
+    { value: '10-30', key: 'duration', query: [10, 30] },
+    { value: '30+', key: 'duration', query: 30 },
+  ];
+
+  it('массив query → min и max', () => {
+    const result = getMultipleQuery(route as any, items as any, 'min', 'max');
+    expect(result).toEqual({ min: 10, max: 30 });
+  });
+
+  it('последний элемент → только min', () => {
+    const r = { query: { duration: '30+' } };
+    const result = getMultipleQuery(r as any, items as any, 'min', 'max');
+    expect(result).toEqual({ min: 30 });
+  });
+
+  it('не массив и не последний → только max', () => {
+    const r = { query: { duration: '0-10' } };
+    const shortItems = [
+      { value: '0-10', key: 'duration', query: 'ten' },
+      { value: '30+', key: 'duration', query: 30 },
+    ];
+    const result = getMultipleQuery(r as any, shortItems as any, 'min', 'max');
+    expect(result).toEqual({ max: 'ten' });
+  });
+});

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

@@ -0,0 +1,24 @@
+import { describe, it, expect } from 'vitest';
+import { getSelectedQuery } from './get-selected-query';
+
+describe('getSelectedQuery', () => {
+  it('находит query по значению из route', () => {
+    const route = { query: { sort: 'popular' } };
+    const items = [
+      { value: 'popular', key: 'sort', query: 'popular-query' },
+      { value: 'newest', key: 'sort', query: 'newest-query' },
+    ];
+    expect(getSelectedQuery(route as any, items as any)).toBe('popular-query');
+  });
+
+  it('не найдено → undefined', () => {
+    const route = { query: { sort: 'unknown' } };
+    const items = [{ value: 'popular', key: 'sort', query: 'q' }];
+    expect(getSelectedQuery(route as any, items as any)).toBeUndefined();
+  });
+
+  it('пустой items → undefined', () => {
+    const route = { query: { sort: 'popular' } };
+    expect(getSelectedQuery(route as any, [])).toBeUndefined();
+  });
+});

package/runtime/utils/is-mobile-device.test.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect } from 'vitest';
+import { isMobileDevice } from './is-mobile-device';
+
+describe('isMobileDevice', () => {
+  it('Android', () => {
+    expect(isMobileDevice('Mozilla/5.0 (Linux; Android 10)')).toBe(true);
+  });
+
+  it('iPhone', () => {
+    expect(isMobileDevice('Mozilla/5.0 (iPhone; CPU iPhone OS 14_0)')).toBe(true);
+  });
+
+  it('iPad', () => {
+    expect(isMobileDevice('Mozilla/5.0 (iPad; CPU OS 14_0)')).toBe(true);
+  });
+
+  it('desktop → false', () => {
+    expect(isMobileDevice('Mozilla/5.0 (Windows NT 10.0; Win64; x64)')).toBe(false);
+  });
+
+  it('пустая строка → false', () => {
+    expect(isMobileDevice('')).toBe(false);
+  });
+});

package/runtime/utils/video-data-add-model-icon.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect } from 'vitest';
+import { videoDataAddModelIcon } from './video-data-add-model-icon';
+
+describe('videoDataAddModelIcon', () => {
+  it('добавляет icon к matching модели', () => {
+    const videoData = {
+      models: [
+        { guid: 'm-1', title: 'Model A' },
+        { guid: 'm-2', title: 'Model B' },
+      ],
+    };
+    const modelsData = [
+      { guid: 'm-1', primary_image_url: 'https://img.com/a.jpg' },
+    ];
+    const result = videoDataAddModelIcon(videoData as any, modelsData as any);
+    expect(result.models[0].icon).toBe('https://img.com/a.jpg');
+    expect(result.models[1].icon).toBeUndefined();
+  });
+
+  it('не мутирует исходный объект', () => {
+    const videoData = { models: [{ guid: 'm-1', title: 'A' }] };
+    const modelsData = [{ guid: 'm-1', primary_image_url: 'url' }];
+    const result = videoDataAddModelIcon(videoData as any, modelsData as any);
+    expect(result).not.toBe(videoData);
+  });
+
+  it('пустой массив моделей', () => {
+    const videoData = { models: [{ guid: 'm-1', title: 'A' }] };
+    const result = videoDataAddModelIcon(videoData as any, []);
+    expect(result.models[0].icon).toBeUndefined();
+  });
+});