itube-specs 0.0.779 → 0.0.781

package/utils/category-letter-groups/__tests__/group-by-first-letter.test.ts

@@ -0,0 +1,42 @@
+import { describe, it, expect } from 'vitest';
+import { groupByFirstLetter } from '../group-by-first-letter';
+
+describe('groupByFirstLetter', () => {
+  it('группирует по первой букве в верхнем регистре', () => {
+    const result = groupByFirstLetter([
+      { title: 'apple' },
+      { title: 'Avocado' },
+      { title: 'banana' },
+    ]);
+    expect(result['A']).toHaveLength(2);
+    expect(result['B']).toHaveLength(1);
+  });
+
+  it('нелатинские и нелитерные символы попадают в #', () => {
+    const result = groupByFirstLetter([
+      { title: '123' },
+      { title: 'Яблоко' },
+      { title: 'Apple' },
+    ]);
+    expect(result['#']).toHaveLength(2);
+    expect(result['A']).toHaveLength(1);
+  });
+
+  it('# сортируется в конец', () => {
+    const result = groupByFirstLetter([
+      { title: 'zebra' },
+      { title: '1one' },
+      { title: 'apple' },
+    ]);
+    expect(Object.keys(result)).toEqual(['A', 'Z', '#']);
+  });
+
+  it('кастомное поле группировки', () => {
+    const result = groupByFirstLetter([{ name: 'Bob' }, { name: 'Alice' }], 'name');
+    expect(Object.keys(result)).toEqual(['A', 'B']);
+  });
+
+  it('пустой массив → {}', () => {
+    expect(groupByFirstLetter([])).toEqual({});
+  });
+});

package/utils/category-letter-groups/group-by-first-letter.ts

@@ -0,0 +1,25 @@
+/**
+ * Группирует объекты по первой латинской букве указанного поля; нелатинские и нелитерные
+ * символы (цифры, кириллица) попадают под ключ `#`. Группы отсортированы по алфавиту, `#` в конце.
+ * @param items - массив объектов
+ * @param field - поле для группировки (по умолчанию `title`)
+ */
+export function groupByFirstLetter<T extends Record<string, any>>(
+  items: T[],
+  field = 'title',
+): Record<string, T[]> {
+  const groups: Record<string, T[]> = {};
+  for (const item of items) {
+    const firstChar = String(item[field] ?? '')[0]?.toUpperCase() ?? '#';
+    const key = /[A-Z]/.test(firstChar) ? firstChar : '#';
+    if (!groups[key]) groups[key] = [];
+    groups[key].push(item);
+  }
+  return Object.fromEntries(
+    Object.entries(groups).sort(([a], [b]) => {
+      if (a === '#') return 1;
+      if (b === '#') return -1;
+      return a.localeCompare(b);
+    }),
+  );
+}

package/utils/filter-main/__tests__/build-filter-query.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect } from 'vitest';
+import { buildFilterQuery } from '../build-filter-query';
+
+describe('buildFilterQuery', () => {
+  it('строит строку категорий из filterValue', () => {
+    const result = buildFilterQuery({
+      currentQuery: {},
+      filterValue: { age: '18', body: 'slim' },
+      durationValue: '',
+      addedValue: '',
+    });
+    expect(result.categories).toBe('age_18,body_slim');
+  });
+
+  it('добавляет duration и added когда заданы', () => {
+    const result = buildFilterQuery({
+      currentQuery: {},
+      filterValue: {},
+      durationValue: '10',
+      addedValue: 'week',
+    });
+    expect(result.duration).toBe('10');
+    expect(result.added).toBe('week');
+  });
+
+  it('categories = undefined когда фильтров нет', () => {
+    const result = buildFilterQuery({
+      currentQuery: {},
+      filterValue: {},
+      durationValue: '',
+      addedValue: '',
+    });
+    expect(result.categories).toBeUndefined();
+  });
+
+  it('сохраняет sort и сбрасывает page', () => {
+    const result = buildFilterQuery({
+      currentQuery: { sort: 'new', page: '3' },
+      filterValue: { age: '18' },
+      durationValue: '',
+      addedValue: '',
+    });
+    expect(result.sort).toBe('new');
+    expect(result.page).toBeUndefined();
+  });
+
+  it('отбрасывает пустые значения filterValue', () => {
+    const result = buildFilterQuery({
+      currentQuery: {},
+      filterValue: { age: '18', body: '' },
+      durationValue: '',
+      addedValue: '',
+    });
+    expect(result.categories).toBe('age_18');
+  });
+});

package/utils/filter-main/__tests__/get-active-filter-values.test.ts

@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'vitest';
+import { getActiveFilterValues } from '../get-active-filter-values';
+
+describe('getActiveFilterValues', () => {
+  it('собирает категории, duration и added в плоский список', () => {
+    const result = getActiveFilterValues({ categories: 'age_18,body_slim', duration: '10', added: 'week' });
+    expect(result).toEqual(['age_18', 'body_slim', '10', 'week']);
+  });
+
+  it('поддерживает массив категорий', () => {
+    expect(getActiveFilterValues({ categories: ['age_18', 'body_slim'] }))
+        .toEqual(['age_18', 'body_slim']);
+  });
+
+  it('игнорирует пустые duration/added', () => {
+    expect(getActiveFilterValues({ duration: '', added: '' })).toEqual([]);
+  });
+
+  it('пустой query → []', () => {
+    expect(getActiveFilterValues({})).toEqual([]);
+  });
+});

package/utils/filter-main/__tests__/parse-category-filter-values.test.ts

@@ -0,0 +1,20 @@
+import { describe, it, expect } from 'vitest';
+import { parseCategoryFilterValues } from '../parse-category-filter-values';
+
+describe('parseCategoryFilterValues', () => {
+  it('разбирает key_value в объект', () => {
+    expect(parseCategoryFilterValues(['age_18', 'body_slim'])).toEqual({ age: '18', body: 'slim' });
+  });
+
+  it('склеивает значение с подчёркиваниями обратно', () => {
+    expect(parseCategoryFilterValues(['orientation_bi_curious'])).toEqual({ orientation: 'bi_curious' });
+  });
+
+  it('пропускает сегменты без значения', () => {
+    expect(parseCategoryFilterValues(['age_18', 'broken'])).toEqual({ age: '18' });
+  });
+
+  it('пустой список → {}', () => {
+    expect(parseCategoryFilterValues([])).toEqual({});
+  });
+});

package/utils/filter-main/build-filter-query.ts

@@ -0,0 +1,42 @@
+type QueryParam = string | (string | null)[] | null | undefined;
+type QueryRecord = Record<string, QueryParam>;
+
+/**
+ * Собирает query для применения фильтра: непустые значения `filterValue` склеивает в строку
+ * категорий `key_value,...`, добавляет duration/added, сохраняет sort и сбрасывает page.
+ * @param params.currentQuery - текущий query роута
+ * @param params.filterValue - выбранные категории (ключ → значение)
+ * @param params.durationValue - выбранная длительность
+ * @param params.addedValue - выбранный период добавления
+ */
+export function buildFilterQuery(params: {
+  currentQuery: QueryRecord;
+  filterValue: Record<string, string>;
+  durationValue: string;
+  addedValue: string;
+}): QueryRecord {
+  const { currentQuery, filterValue, durationValue, addedValue } = params;
+
+  const oldQuery = { ...currentQuery };
+  delete oldQuery['page'];
+
+  const mainFiltersValue = {
+    ...(durationValue ? { duration: durationValue } : {}),
+    ...(addedValue ? { added: addedValue } : {}),
+  };
+
+  const preserved = {
+    ...mainFiltersValue,
+    ...(oldQuery.sort ? { sort: oldQuery.sort } : {}),
+    ...(oldQuery.page ? { page: oldQuery.page } : {}),
+  };
+
+  const categories = Object.entries(filterValue)
+      .filter(([, value]) => typeof value === 'string' && value.length > 0)
+      .map(([key, value]) => `${key}_${value}`);
+
+  return {
+    ...preserved,
+    categories: categories.length ? categories.join(',') : undefined,
+  };
+}

package/utils/filter-main/get-active-filter-values.ts

@@ -0,0 +1,33 @@
+type QueryParam = string | (string | null)[] | null | undefined;
+type QueryRecord = Record<string, QueryParam>;
+
+/**
+ * Собирает плоский список всех активных значений фильтра (категории + `duration` + `added`)
+ * из query — используется для подсчёта количества применённых фильтров.
+ * @param query - query роута
+ */
+export function getActiveFilterValues(query: QueryRecord): string[] {
+  const result: string[] = [];
+
+  const categoriesRaw = query['categories'];
+  if (categoriesRaw) {
+    if (Array.isArray(categoriesRaw)) {
+      categoriesRaw.forEach(item => {
+        if (typeof item === 'string') {
+          result.push(...item.split(',').filter(Boolean));
+        }
+      });
+    } else if (typeof categoriesRaw === 'string') {
+      result.push(...categoriesRaw.split(',').filter(Boolean));
+    }
+  }
+
+  ['duration', 'added'].forEach(key => {
+    const val = query[key];
+    if (typeof val === 'string' && val.length > 0) {
+      result.push(val);
+    }
+  });
+
+  return result;
+}

package/utils/filter-main/parse-category-filter-values.ts

@@ -0,0 +1,15 @@
+/**
+ * Преобразует список категорий вида `key_value` в объект `{ key: value }`.
+ * Сегменты без значения (нет `_`) пропускаются; значение склеивается обратно по `_`.
+ * @param categories - плоский список категорий (см. parseFilterCategories)
+ */
+export function parseCategoryFilterValues(categories: string[]): Record<string, string> {
+  const result: Record<string, string> = {};
+  categories.forEach(str => {
+    const [key, ...rest] = str.split('_');
+    if (key && rest.length > 0) {
+      result[key] = rest.join('_');
+    }
+  });
+  return result;
+}

package/utils/filter-slider/__tests__/build-range-filter-query.test.ts

@@ -0,0 +1,39 @@
+import { describe, it, expect } from 'vitest';
+import { buildRangeFilterQuery } from '../build-range-filter-query';
+
+describe('buildRangeFilterQuery', () => {
+  it('проставляет filter_<name>_from и _to', () => {
+    const result = buildRangeFilterQuery({
+      query: {},
+      name: 'age',
+      from: 20,
+      to: 35,
+      rangeInfo: { min: 18, max: 40 },
+    });
+    expect(result['filter_age_from']).toBe('20');
+    expect(result['filter_age_to']).toBe('35');
+  });
+
+  it('удаляет параметры когда диапазон равен полному (from=min, to=max)', () => {
+    const result = buildRangeFilterQuery({
+      query: { filter_age_from: '18', filter_age_to: '40' },
+      name: 'age',
+      from: 18,
+      to: 40,
+      rangeInfo: { min: 18, max: 40 },
+    });
+    expect(result['filter_age_from']).toBeUndefined();
+    expect(result['filter_age_to']).toBeUndefined();
+  });
+
+  it('сохраняет прочие параметры query', () => {
+    const result = buildRangeFilterQuery({
+      query: { sort: 'new' },
+      name: 'age',
+      from: 20,
+      to: 35,
+      rangeInfo: { min: 18, max: 40 },
+    });
+    expect(result.sort).toBe('new');
+  });
+});

package/utils/filter-slider/__tests__/get-slider-range-info.test.ts

@@ -0,0 +1,28 @@
+import { describe, it, expect } from 'vitest';
+import { getSliderRangeInfo } from '../get-slider-range-info';
+
+describe('getSliderRangeInfo', () => {
+  it('возвращает min/max/step для числовых опций', () => {
+    const result = getSliderRangeInfo([{ name: '18' }, { name: '40' }, { name: '25' }]);
+    expect(result).toEqual({ min: 18, max: 40, step: 1 });
+  });
+
+  it('сортирует значения перед расчётом', () => {
+    const result = getSliderRangeInfo([{ name: '100' }, { name: '5' }]);
+    expect(result?.min).toBe(5);
+    expect(result?.max).toBe(100);
+  });
+
+  it('step = 0 для единственного значения', () => {
+    expect(getSliderRangeInfo([{ name: '18' }])?.step).toBe(0);
+  });
+
+  it('null когда нет числовых опций', () => {
+    expect(getSliderRangeInfo([{ name: 'abc' }, { name: 'xyz' }])).toBeNull();
+  });
+
+  it('отбрасывает нечисловые опции', () => {
+    const result = getSliderRangeInfo([{ name: '18' }, { name: 'abc' }, { name: '40' }]);
+    expect(result).toEqual({ min: 18, max: 40, step: 1 });
+  });
+});

package/utils/filter-slider/build-range-filter-query.ts

@@ -0,0 +1,32 @@
+type QueryParam = string | (string | null)[] | null;
+type QueryRecord = Record<string, QueryParam>;
+
+/**
+ * Строит query для range-фильтра, проставляя `filter_<name>_from` / `_to`. Если выбранный
+ * диапазon совпадает с полным (`from === min && to === max`) — параметры убираются из query.
+ * @param params.query - текущий query
+ * @param params.name - имя фильтра
+ * @param params.from - нижняя граница выбора
+ * @param params.to - верхняя граница выбора
+ * @param params.rangeInfo - полный диапазон фильтра (min/max)
+ */
+export function buildRangeFilterQuery(params: {
+  query: QueryRecord;
+  name: string;
+  from: string | number;
+  to: string | number;
+  rangeInfo: { min: number; max: number };
+}): QueryRecord {
+  const { query: currentQuery, name, from, to, rangeInfo } = params;
+  const query = { ...currentQuery };
+
+  query[`filter_${name}_from`] = String(from);
+  query[`filter_${name}_to`] = String(to);
+
+  if (from === rangeInfo.min && to === rangeInfo.max) {
+    delete query[`filter_${name}_from`];
+    delete query[`filter_${name}_to`];
+  }
+
+  return query;
+}

package/utils/filter-slider/get-slider-range-info.ts

@@ -0,0 +1,28 @@
+export interface RangeInfo {
+  min: number;
+  step: number;
+  max: number;
+}
+
+/**
+ * Вычисляет границы и шаг диапазона слайдера из числовых значений `name` опций
+ * (мин, макс по отсортированным числам; шаг 1 при наличии >1 значения, иначе 0).
+ * Возвращает null, если числовых опций нет.
+ * @param options - опции фильтра (поле `name` ожидается числовым)
+ */
+export function getSliderRangeInfo(options: { name: string }[]): RangeInfo | null {
+  const numericValues = options
+      .map(opt => Number(opt.name))
+      .filter(v => !isNaN(v))
+      .sort((a, b) => a - b);
+
+  if (numericValues.length === 0) {
+    return null;
+  }
+
+  const min = numericValues[0] || 0;
+  const max = numericValues[numericValues.length - 1] || 100;
+  const step = numericValues.length > 1 ? 1 : 0;
+
+  return { min, step, max };
+}

package/utils/get-sorted-filter-groups.ts

@@ -0,0 +1,13 @@
+/**
+ * Возвращает уникальные группы фильтров (по `group.title`), отсортированные по `group.order`.
+ * @param filters - список фильтров, у каждого поле `group`
+ */
+export function getSortedFilterGroups<G extends { title: string; order: number }>(
+  filters: { group: G }[],
+): G[] {
+  const uniqueTitles = [...new Set(filters.map(item => item.group.title))];
+  return uniqueTitles
+      .map(title => filters.find(filter => filter.group.title === title)?.group)
+      .filter((group): group is G => Boolean(group))
+      .sort((a, b) => a.order - b.order);
+}

package/utils/info-main/__tests__/group-parameters-by-group.test.ts

@@ -0,0 +1,42 @@
+import { describe, it, expect } from 'vitest';
+import { groupParametersByGroup } from '../group-parameters-by-group';
+
+function param(name: string, groupName: string, order: number, isFilter = false) {
+  return {
+    name,
+    title: name.toUpperCase(),
+    values: [],
+    kind: 'select' as const,
+    is_filter: isFilter,
+    icon: '',
+    group: { name: groupName, title: `${groupName}-title`, order },
+  };
+}
+
+describe('groupParametersByGroup', () => {
+  it('группирует по group.name и сортирует группы по order', () => {
+    const result = groupParametersByGroup([
+      param('a', 'second', 2),
+      param('b', 'first', 1),
+    ]);
+    expect(result.map(g => g.title)).toEqual(['first-title', 'second-title']);
+  });
+
+  it('собирает несколько параметров одной группы в items', () => {
+    const result = groupParametersByGroup([
+      param('a', 'g', 1),
+      param('b', 'g', 1),
+    ]);
+    expect(result).toHaveLength(1);
+    expect(result[0].items.map(i => i.name)).toEqual(['a', 'b']);
+  });
+
+  it('переименовывает is_filter → isFilter', () => {
+    const result = groupParametersByGroup([param('a', 'g', 1, true)]);
+    expect(result[0].items[0].isFilter).toBe(true);
+  });
+
+  it('пустой список → []', () => {
+    expect(groupParametersByGroup([])).toEqual([]);
+  });
+});

package/utils/info-main/group-parameters-by-group.ts

@@ -0,0 +1,37 @@
+import type { IGroupedParameter } from '../../types';
+
+interface RawParameter {
+  name: string;
+  title: string;
+  values: { name: string; title: string }[];
+  kind: 'range' | 'select' | 'chips' | 'radio';
+  is_filter: boolean;
+  icon: string;
+  group: { name: string; title: string; order: number };
+}
+
+/**
+ * Группирует параметры карточки по `group.name` в объекты с заголовком/порядком группы
+ * и списком items (с переименованием `is_filter` → `isFilter`); группы сортируются по `order`.
+ * @param parameters - плоский список параметров
+ */
+export function groupParametersByGroup(parameters: RawParameter[]): IGroupedParameter[] {
+  const groups = new Map<string, IGroupedParameter>();
+
+  for (const param of parameters) {
+    const groupName = param.group.name;
+    if (!groups.has(groupName)) {
+      groups.set(groupName, { title: param.group.title, order: param.group.order, items: [] });
+    }
+    groups.get(groupName)!.items.push({
+      name: param.name,
+      title: param.title,
+      values: param.values,
+      kind: param.kind,
+      isFilter: param.is_filter,
+      icon: param.icon,
+    });
+  }
+
+  return [...groups.values()].sort((a, b) => a.order - b.order);
+}

package/utils/iso-code-map.ts

@@ -0,0 +1,2 @@
+/** Маппинг ISO-кодов страны на код локали (для стран, где они различаются) */
+export const isoCodeMap: Record<string, string> = { cn: 'zh', kr: 'ko', ae: 'ar', ar: 'ar1' };

package/utils/parse-filter-categories.ts

@@ -0,0 +1,14 @@
+type QueryParam = string | (string | null)[] | null | undefined;
+type QueryRecord = Record<string, QueryParam>;
+
+/**
+ * Разбирает query-параметр `categories` (строку через запятую или массив строк)
+ * в плоский список значений вида `key_value`, отбрасывая пустые сегменты.
+ * @param query - query роута
+ */
+export function parseFilterCategories(query: QueryRecord): string[] {
+  const raw = query.categories;
+  if (!raw) return [];
+  if (typeof raw === 'string') return raw.split(',').filter(Boolean);
+  return (raw as string[]).flatMap(c => (c || '').split(',')).filter(Boolean);
+}

package/utils/player-channel/__tests__/get-name-initials.test.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect } from 'vitest';
+import { getNameInitials } from '../get-name-initials';
+
+describe('getNameInitials', () => {
+  it('берёт первые буквы первых двух слов', () => {
+    expect(getNameInitials('John Doe')).toBe('JD');
+  });
+
+  it('игнорирует слова после второго', () => {
+    expect(getNameInitials('John Michael Doe')).toBe('JM');
+  });
+
+  it('одно слово → одна буква', () => {
+    expect(getNameInitials('madonna')).toBe('M');
+  });
+
+  it('схлопывает множественные пробелы', () => {
+    expect(getNameInitials('John   Doe')).toBe('JD');
+  });
+
+  it('пустая строка → пустая строка', () => {
+    expect(getNameInitials('')).toBe('');
+  });
+});

package/utils/player-channel/get-name-initials.ts

@@ -0,0 +1,11 @@
+/**
+ * Возвращает инициалы из имени: берёт первые буквы первых двух слов в верхнем регистре.
+ * @param name - имя (слова разделяются пробелами)
+ */
+export function getNameInitials(name: string): string {
+  return name
+      .split(/\s+/)
+      .slice(0, 2)
+      .map(word => word.charAt(0).toUpperCase())
+      .join('');
+}

package/utils/player-like/__tests__/apply-reaction.test.ts

@@ -0,0 +1,28 @@
+import { describe, it, expect } from 'vitest';
+import { applyReaction } from '../apply-reaction';
+
+describe('applyReaction', () => {
+  it('like: +1 лайк, -1 дизлайк', () => {
+    expect(applyReaction('like', 10, 5)).toEqual({ likes: 11, dislikes: 4 });
+  });
+
+  it('like: дизлайк не уходит ниже нуля', () => {
+    expect(applyReaction('like', 10, 0)).toEqual({ likes: 11, dislikes: 0 });
+  });
+
+  it('like: лайк не растёт выше 1000', () => {
+    expect(applyReaction('like', 1000, 5)).toEqual({ likes: 1000, dislikes: 4 });
+  });
+
+  it('dislike: +1 дизлайк, -1 лайк', () => {
+    expect(applyReaction('dislike', 10, 5)).toEqual({ likes: 9, dislikes: 6 });
+  });
+
+  it('dislike: лайк не уходит ниже нуля', () => {
+    expect(applyReaction('dislike', 0, 5)).toEqual({ likes: 0, dislikes: 6 });
+  });
+
+  it('dislike: дизлайк не растёт выше 1000', () => {
+    expect(applyReaction('dislike', 10, 1000)).toEqual({ likes: 9, dislikes: 1000 });
+  });
+});

package/utils/player-like/__tests__/get-reaction-percents.test.ts

@@ -0,0 +1,16 @@
+import { describe, it, expect } from 'vitest';
+import { getReactionPercents } from '../get-reaction-percents';
+
+describe('getReactionPercents', () => {
+  it('0/0 → 0% и 0% (без деления на ноль)', () => {
+    expect(getReactionPercents(0, 0)).toEqual({ likePercent: 0, dislikePercent: 0 });
+  });
+
+  it('равные значения → 50/50', () => {
+    expect(getReactionPercents(5, 5)).toEqual({ likePercent: 50, dislikePercent: 50 });
+  });
+
+  it('только лайки → 100/0', () => {
+    expect(getReactionPercents(8, 0)).toEqual({ likePercent: 100, dislikePercent: 0 });
+  });
+});

package/utils/player-like/apply-reaction.ts

@@ -0,0 +1,23 @@
+/**
+ * Пересчитывает счётчики при новой реакции: выбранному типу +1 (но не выше 1000),
+ * противоположному -1 (но не ниже 0).
+ * @param type - выбранная реакция
+ * @param likes - текущее число лайков
+ * @param dislikes - текущее число дизлайков
+ */
+export function applyReaction(
+  type: 'like' | 'dislike',
+  likes: number,
+  dislikes: number,
+): { likes: number; dislikes: number } {
+  if (type === 'like') {
+    return {
+      likes: likes < 1000 ? likes + 1 : likes,
+      dislikes: dislikes > 0 ? dislikes - 1 : dislikes,
+    };
+  }
+  return {
+    likes: likes > 0 ? likes - 1 : likes,
+    dislikes: dislikes < 1000 ? dislikes + 1 : dislikes,
+  };
+}

package/utils/player-like/get-reaction-percents.ts

@@ -0,0 +1,19 @@
+/**
+ * Считает доли лайков и дизлайков в процентах от их суммы; при нулевой сумме
+ * делитель = 1, чтобы избежать деления на ноль (обе доли тогда 0%).
+ * @param likes - число лайков
+ * @param dislikes - число дизлайков
+ */
+export function getReactionPercents(
+  likes: number,
+  dislikes: number,
+): { likePercent: number; dislikePercent: number } {
+  const likesCount = likes || 0;
+  const dislikesCount = dislikes || 0;
+  const total = likesCount + dislikesCount || 1;
+
+  return {
+    likePercent: (likesCount / total) * 100,
+    dislikePercent: (dislikesCount / total) * 100,
+  };
+}