itube-specs 0.0.710 → 0.0.712

package/package.json

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

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

@@ -0,0 +1,38 @@
+import { describe, it, expect } from 'vitest';
+import { convertDateToTimestamp } from './convert-date-to-timestamp';
+
+const c = convertDateToTimestamp();
+
+describe('convertDateToTimestamp', () => {
+  describe('toUnix', () => {
+    it('валидная дата', () => {
+      expect(c.toUnix('2025-01-01')).toBe(Date.UTC(2025, 0, 1) / 1000);
+    });
+
+    it('начало эпохи', () => {
+      expect(c.toUnix('1970-01-01')).toBe(0);
+    });
+
+    it('невалидная дата → null', () => {
+      expect(c.toUnix('invalid')).toBe(null);
+    });
+  });
+
+  describe('fromUnix', () => {
+    it('timestamp → дата', () => {
+      expect(c.fromUnix(0)).toBe('1970-01-01');
+    });
+
+    it('конкретная дата', () => {
+      const ts = Date.UTC(2024, 2, 5) / 1000;
+      expect(c.fromUnix(ts)).toBe('2024-03-05');
+    });
+  });
+
+  describe('roundtrip', () => {
+    it('toUnix → fromUnix', () => {
+      const date = '2024-03-05';
+      expect(c.fromUnix(c.toUnix(date)!)).toBe(date);
+    });
+  });
+});

package/runtime/utils/converters/convert-snake-keys-to-camel.test.ts

@@ -0,0 +1,29 @@
+import { describe, it, expect } from 'vitest';
+import { convertSnakeKeysToCamel } from './convert-snake-keys-to-camel';
+
+describe('convertSnakeKeysToCamel', () => {
+  it('простой объект', () => {
+    expect(convertSnakeKeysToCamel({ user_name: 'John', is_active: true }))
+      .toEqual({ userName: 'John', isActive: true });
+  });
+
+  it('вложенный объект', () => {
+    expect(convertSnakeKeysToCamel({ user_info: { first_name: 'John' } }))
+      .toEqual({ userInfo: { firstName: 'John' } });
+  });
+
+  it('массив объектов', () => {
+    expect(convertSnakeKeysToCamel([{ video_id: 1 }, { video_id: 2 }]))
+      .toEqual([{ videoId: 1 }, { videoId: 2 }]);
+  });
+
+  it('примитив возвращается как есть', () => {
+    expect(convertSnakeKeysToCamel('hello')).toBe('hello');
+    expect(convertSnakeKeysToCamel(42)).toBe(42);
+    expect(convertSnakeKeysToCamel(null)).toBe(null);
+  });
+
+  it('ключ без подчёркиваний', () => {
+    expect(convertSnakeKeysToCamel({ name: 'John' })).toEqual({ name: 'John' });
+  });
+});

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

@@ -0,0 +1,78 @@
+import { describe, it, expect } from 'vitest';
+import { convertString } from './convert-string';
+
+const s = convertString();
+
+describe('convertString', () => {
+  describe('toSlug', () => {
+    it('пробелы → дефисы', () => {
+      expect(s.toSlug('Big Tits')).toBe('big-tits');
+    });
+
+    it('дефисы → подчёркивания', () => {
+      expect(s.toSlug('A-B')).toBe('a_b');
+    });
+
+    it('подчёркивания → тильда', () => {
+      expect(s.toSlug('a_b')).toBe('a~b');
+    });
+  });
+
+  describe('fromSlug', () => {
+    it('дефисы → пробелы', () => {
+      expect(s.fromSlug('big-tits')).toBe('big tits');
+    });
+
+    it('подчёркивания → дефисы', () => {
+      expect(s.fromSlug('a_b')).toBe('a-b');
+    });
+
+    it('тильда → подчёркивание', () => {
+      expect(s.fromSlug('a~b')).toBe('a_b');
+    });
+  });
+
+  describe('toSnakeCase', () => {
+    it('camelCase', () => {
+      expect(s.toSnakeCase('bigTits')).toBe('big_tits');
+    });
+
+    it('пробелы', () => {
+      expect(s.toSnakeCase('big tits')).toBe('big_tits');
+    });
+
+    it('дефисы', () => {
+      expect(s.toSnakeCase('big-tits')).toBe('big_tits');
+    });
+  });
+
+  describe('toKebabCase', () => {
+    it('camelCase', () => {
+      expect(s.toKebabCase('bigTits')).toBe('big-tits');
+    });
+
+    it('подчёркивания', () => {
+      expect(s.toKebabCase('big_tits')).toBe('big-tits');
+    });
+
+    it('пробелы', () => {
+      expect(s.toKebabCase('big tits')).toBe('big-tits');
+    });
+  });
+
+  describe('toCapitalize', () => {
+    it('одно слово', () => {
+      expect(s.toCapitalize('teen')).toBe('Teen');
+    });
+
+    it('несколько слов', () => {
+      expect(s.toCapitalize('big tits')).toBe('Big Tits');
+    });
+  });
+
+  describe('roundtrip', () => {
+    it('toSlug → fromSlug', () => {
+      expect(s.fromSlug(s.toSlug('Big Tits'))).toBe('big tits');
+    });
+  });
+});

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

@@ -0,0 +1,33 @@
+import { describe, it, expect } from 'vitest';
+import { groupObjectsByFirstLetter } from './group-objects-by-first-letter';
+
+describe('groupObjectsByFirstLetter', () => {
+  const items = [
+    { name: 'Alice' },
+    { name: 'Anna' },
+    { name: 'Bob' },
+    { name: '123test' },
+  ];
+
+  it('группирует по первой букве', () => {
+    const result = groupObjectsByFirstLetter(items, 'name');
+    expect(result['A']).toHaveLength(2);
+    expect(result['B']).toHaveLength(1);
+  });
+
+  it('цифры попадают в POST', () => {
+    const result = groupObjectsByFirstLetter(items, 'name');
+    expect(result['POST']).toHaveLength(1);
+    expect(result['POST'][0]).toEqual({ name: '123test' });
+  });
+
+  it('кастомный nonLetterKey', () => {
+    const result = groupObjectsByFirstLetter(items, 'name', 'OTHER');
+    expect(result['OTHER']).toHaveLength(1);
+  });
+
+  it('пустой массив', () => {
+    const result = groupObjectsByFirstLetter([], 'name');
+    expect(result).toEqual({});
+  });
+});

package/runtime/utils/format-date.test.ts

@@ -0,0 +1,18 @@
+import { describe, it, expect } from 'vitest';
+import { formatDate } from './format-date';
+
+describe('formatDate', () => {
+  it('обычная дата', () => {
+    // 2025-01-15 00:00:00 UTC
+    expect(formatDate(1736899200)).toBe('15.01.2025');
+  });
+
+  it('начало эпохи', () => {
+    expect(formatDate(0)).toBe('01.01.1970');
+  });
+
+  it('с padding нулей', () => {
+    // 2024-03-05 UTC
+    expect(formatDate(1709596800)).toBe('05.03.2024');
+  });
+});

package/runtime/utils/format-number.test.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect } from 'vitest';
+import { formatNumber } from './format-number';
+
+describe('formatNumber', () => {
+  it('тысячи', () => {
+    expect(formatNumber(10400)).toBe('10.4K');
+  });
+
+  it('миллионы', () => {
+    expect(formatNumber(1500000)).toBe('1.5M');
+  });
+
+  it('маленькое число без сокращения', () => {
+    expect(formatNumber(999)).toBe('999');
+  });
+
+  it('ноль', () => {
+    expect(formatNumber(0)).toBe('0');
+  });
+
+  it('ровно тысяча', () => {
+    expect(formatNumber(1000)).toBe('1K');
+  });
+});

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

@@ -0,0 +1,24 @@
+import { describe, it, expect } from 'vitest';
+import { formatTime } from './format-time';
+
+describe('formatTime', () => {
+  it('только секунды', () => {
+    expect(formatTime(5)).toBe('00:05');
+  });
+
+  it('минуты и секунды', () => {
+    expect(formatTime(65)).toBe('01:05');
+  });
+
+  it('часы, минуты, секунды', () => {
+    expect(formatTime(3661)).toBe('01:01:01');
+  });
+
+  it('ноль', () => {
+    expect(formatTime(0)).toBe('00:00');
+  });
+
+  it('ровно час', () => {
+    expect(formatTime(3600)).toBe('01:00:00');
+  });
+});

package/runtime/utils/get-duration.test.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect } from 'vitest';
+import { getDuration } from './get-duration';
+
+describe('getDuration', () => {
+  it('только секунды', () => {
+    expect(getDuration(45)).toBe('00:45');
+  });
+
+  it('минуты и секунды', () => {
+    expect(getDuration(125)).toBe('02:05');
+  });
+
+  it('с часами', () => {
+    expect(getDuration(3661)).toBe('01:01:01');
+  });
+
+  it('ноль', () => {
+    expect(getDuration(0)).toBe('00:00');
+  });
+
+  it('ровно час', () => {
+    expect(getDuration(3600)).toBe('01:00:00');
+  });
+});

package/runtime/utils/get-month.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import { getMonth } from './get-month';
+
+const t = (key: string) => key;
+
+describe('getMonth', () => {
+  it('январь = 0', () => {
+    expect(getMonth(t, 0)).toBe('january');
+  });
+
+  it('декабрь = 11', () => {
+    expect(getMonth(t, 11)).toBe('december');
+  });
+
+  it('июнь = 5', () => {
+    expect(getMonth(t, 5)).toBe('june');
+  });
+
+  it('undefined → декабрь (дефолт)', () => {
+    expect(getMonth(t)).toBe('december');
+  });
+
+  it('отрицательное число → декабрь', () => {
+    expect(getMonth(t, -1)).toBe('december');
+  });
+
+  it('число >= 12 → декабрь', () => {
+    expect(getMonth(t, 12)).toBe('december');
+  });
+});

package/runtime/utils/normalize-url.test.ts

@@ -0,0 +1,59 @@
+import { describe, it, expect } from 'vitest';
+import { normalizeUrl } from './normalize-url';
+
+describe('normalizeUrl', () => {
+  it('удаляет page=1', () => {
+    const result = normalizeUrl({ path: '/videos', query: { page: '1' } });
+    expect(result.query.page).toBeUndefined();
+  });
+
+  it('сохраняет page=2', () => {
+    const result = normalizeUrl({ path: '/videos', query: { page: '2' } });
+    expect(result.query.page).toBe('2');
+  });
+
+  it('удаляет sort=trending', () => {
+    const result = normalizeUrl({ path: '/videos', query: { sort: 'trending' } });
+    expect(result.query.sort).toBeUndefined();
+  });
+
+  it('сохраняет sort=popular', () => {
+    const result = normalizeUrl({ path: '/videos', query: { sort: 'popular' } });
+    expect(result.query.sort).toBe('popular');
+  });
+
+  it('удаляет пустые значения', () => {
+    const result = normalizeUrl({ path: '/', query: { a: '', b: null as any, c: 'ok' } });
+    expect(result.query).toEqual({ c: 'ok' });
+  });
+
+  it('lowercase путь', () => {
+    const result = normalizeUrl({ path: '/Videos/BIG', query: {} });
+    expect(result.path).toBe('/videos/big');
+  });
+
+  it('lowercase query', () => {
+    const result = normalizeUrl({ path: '/', query: { Sort: 'Popular' } });
+    expect(result.query).toEqual({ sort: 'popular' });
+  });
+
+  it('%20 и пробелы → дефисы', () => {
+    const result = normalizeUrl({ path: '/big%20tits videos', query: {} });
+    expect(result.path).toBe('/big-tits-videos');
+  });
+
+  it('убирает двойные дефисы', () => {
+    const result = normalizeUrl({ path: '/big--tits', query: {} });
+    expect(result.path).toBe('/big-tits');
+  });
+
+  it('убирает trailing slash', () => {
+    const result = normalizeUrl({ path: '/videos/', query: {} });
+    expect(result.path).toBe('/videos');
+  });
+
+  it('не убирает /', () => {
+    const result = normalizeUrl({ path: '/', query: {} });
+    expect(result.path).toBe('/');
+  });
+});

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

@@ -0,0 +1,36 @@
+import { describe, it, expect } from 'vitest';
+import { parseApiError } from './parse-api-error';
+
+describe('parseApiError', () => {
+  it('error.message', () => {
+    expect(parseApiError({ message: 'Not found' })).toBe('Not found');
+  });
+
+  it('response._data как объект', () => {
+    const error = { response: { _data: { error: 'Bad request' } } };
+    expect(parseApiError(error)).toBe('Bad request');
+  });
+
+  it('response._data как JSON строка', () => {
+    const error = { response: { _data: '{"error":"Forbidden"}' } };
+    expect(parseApiError(error)).toBe('Forbidden');
+  });
+
+  it('вложенный data.error', () => {
+    const error = { response: { _data: { data: { error: 'Validation failed' } } } };
+    expect(parseApiError(error)).toBe('Validation failed');
+  });
+
+  it('массив ошибок — первый элемент', () => {
+    const error = { response: { _data: { error: ['Field required', 'Too short'] } } };
+    expect(parseApiError(error)).toBe('Field required');
+  });
+
+  it('fallback при null', () => {
+    expect(parseApiError(null)).toBe('Unknown error occurred.');
+  });
+
+  it('fallback при пустом объекте', () => {
+    expect(parseApiError({})).toBe('Unknown error occurred.');
+  });
+});

package/runtime/utils/validate-email.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect } from 'vitest';
+import { validateEmail } from './validate-email';
+
+describe('validateEmail', () => {
+  it('валидный email', () => {
+    expect(validateEmail('user@example.com')).toBe(true);
+  });
+
+  it('с точкой в имени', () => {
+    expect(validateEmail('first.last@example.com')).toBe(true);
+  });
+
+  it('с поддоменом', () => {
+    expect(validateEmail('user@mail.example.com')).toBe(true);
+  });
+
+  it('без @', () => {
+    expect(validateEmail('userexample.com')).toBe(false);
+  });
+
+  it('без домена', () => {
+    expect(validateEmail('user@')).toBe(false);
+  });
+
+  it('пустая строка', () => {
+    expect(validateEmail('')).toBe(false);
+  });
+
+  it('пробелы', () => {
+    expect(validateEmail('user @example.com')).toBe(false);
+  });
+});

package/runtime/utils/validate-password.test.ts

@@ -0,0 +1,20 @@
+import { describe, it, expect } from 'vitest';
+import { validatePassword } from './validate-password';
+
+describe('validatePassword', () => {
+  it('длина > 4 — валиден', () => {
+    expect(validatePassword('12345')).toBe(true);
+  });
+
+  it('длина 4 — невалиден', () => {
+    expect(validatePassword('1234')).toBe(false);
+  });
+
+  it('длина 1 — невалиден', () => {
+    expect(validatePassword('a')).toBe(false);
+  });
+
+  it('длинный пароль', () => {
+    expect(validatePassword('super_secure_password_123')).toBe(true);
+  });
+});

package/runtime/utils/validate-phone.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect } from 'vitest';
+import { validatePhone } from './validate-phone';
+
+describe('validatePhone', () => {
+  it('международный формат', () => {
+    expect(validatePhone('+79001234567')).toBe(true);
+  });
+
+  it('с дефисами', () => {
+    expect(validatePhone('8-900-123-45-67')).toBe(true);
+  });
+
+  it('с пробелами', () => {
+    expect(validatePhone('+7 900 123 4567')).toBe(true);
+  });
+
+  it('со скобками', () => {
+    expect(validatePhone('+7(900)1234567')).toBe(true);
+  });
+
+  it('слишком короткий', () => {
+    expect(validatePhone('12345')).toBe(false);
+  });
+
+  it('пустая строка', () => {
+    expect(validatePhone('')).toBe(false);
+  });
+
+  it('буквы', () => {
+    expect(validatePhone('phone123')).toBe(false);
+  });
+});

package/runtime/utils/validate-username.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect } from 'vitest';
+import { validateUsername } from './validate-username';
+
+describe('validateUsername', () => {
+  it('латиница', () => {
+    expect(validateUsername('john')).toBe(true);
+  });
+
+  it('с цифрами', () => {
+    expect(validateUsername('user123')).toBe(true);
+  });
+
+  it('с подчёркиванием и дефисом', () => {
+    expect(validateUsername('my_user-name')).toBe(true);
+  });
+
+  it('1 символ — невалиден', () => {
+    expect(validateUsername('a')).toBe(false);
+  });
+
+  it('21 символ — невалиден', () => {
+    expect(validateUsername('a'.repeat(21))).toBe(false);
+  });
+
+  it('20 символов — валиден', () => {
+    expect(validateUsername('a'.repeat(20))).toBe(true);
+  });
+
+  it('пустая строка', () => {
+    expect(validateUsername('')).toBe(false);
+  });
+
+  it('спецсимволы', () => {
+    expect(validateUsername('user@name')).toBe(false);
+  });
+});