ichime-ts-api-client 1.0.0

package/README.md

@@ -0,0 +1,105 @@
+# ichime-ts-api-client
+
+TypeScript API client для работы с сайтом [smotret-anime.com](https://smotret-anime.com).
+
+## Установка
+
+```bash
+pnpm add ichime-ts-api-client
+```
+
+## Использование
+
+```typescript
+import { ApiClient } from "ichime-ts-api-client";
+
+const client = new ApiClient();
+
+// Получить список серий
+const series = await client.listSeries({
+  query: "naruto",
+  limit: 10,
+  offset: 0,
+});
+
+console.log(series);
+```
+
+## API
+
+### ApiClient
+
+Основной класс для работы с API.
+
+#### Конструктор
+
+```typescript
+new ApiClient(options?: ApiClientOptions)
+```
+
+**Параметры:**
+- `options.baseURL` - базовый URL API (по умолчанию: `https://smotret-anime.com`)
+- `options.timeout` - таймаут запросов в миллисекундах (по умолчанию: `10000`)
+
+#### Методы
+
+##### `listSeries(options?: ListSeriesOptions): Promise<Series[]>`
+
+Получить список серий.
+
+**Параметры:**
+- `options.query` - поисковый запрос
+- `options.limit` - количество результатов
+- `options.offset` - смещение для пагинации
+- `options.chips` - фильтры в виде объекта ключ-значение
+- `options.myAnimeListId` - ID из MyAnimeList
+
+**Пример:**
+
+```typescript
+const series = await client.listSeries({
+  query: "attack on titan",
+  limit: 20,
+});
+```
+
+## Разработка
+
+### Требования
+
+- Node.js >= 24.0.0
+- pnpm
+
+### Установка зависимостей
+
+```bash
+pnpm install
+```
+
+### Сборка
+
+```bash
+pnpm build
+```
+
+### Тестирование
+
+```bash
+pnpm test
+```
+
+### Линтинг
+
+```bash
+pnpm lint
+```
+
+### Форматирование
+
+```bash
+pnpm format
+```
+
+## Лицензия
+
+MIT

package/biome.json

@@ -0,0 +1,52 @@
+{
+  "$schema": "https://biomejs.dev/schemas/2.3.13/schema.json",
+  "vcs": {
+    "enabled": true,
+    "clientKind": "git",
+    "useIgnoreFile": true
+  },
+  "files": {
+    "ignoreUnknown": false,
+    "includes": ["**", "!**/node_modules", "!**/dist", "!**/.build", "!**/*.swift"]
+  },
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space",
+    "indentWidth": 2,
+    "lineWidth": 100
+  },
+  "assist": {
+    "actions": {
+      "source": {
+        "organizeImports": "on"
+      }
+    }
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true,
+      "complexity": {
+        "noBannedTypes": "error",
+        "noUselessTypeConstraint": "error"
+      },
+      "correctness": {
+        "noUnusedVariables": "error"
+      },
+      "style": {
+        "useConst": "error",
+        "useImportType": "error"
+      },
+      "suspicious": {
+        "noExplicitAny": "warn"
+      }
+    }
+  },
+  "javascript": {
+    "formatter": {
+      "quoteStyle": "double",
+      "semicolons": "always",
+      "trailingCommas": "es5"
+    }
+  }
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "ichime-ts-api-client",
+  "version": "1.0.0",
+  "description": "TypeScript API client for smotret-anime.com",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest",
+    "test:coverage": "vitest --coverage",
+    "lint": "biome check .",
+    "lint:fix": "biome check --write .",
+    "format": "biome format --write .",
+    "typecheck": "tsc --noEmit",
+    "prepublish": "pnpm build"
+  },
+  "keywords": [
+    "anime",
+    "api",
+    "client",
+    "smotret-anime"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.13",
+    "@types/node": "^25.1.0",
+    "@types/tough-cookie": "^4.0.5",
+    "tsdown": "^0.20.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "dependencies": {
+    "cheerio": "^1.2.0",
+    "domhandler": "5.0.3",
+    "dotenv": "^17.2.3",
+    "tough-cookie": "^6.0.0"
+  }
+}

package/src/api/api-client.ts

@@ -0,0 +1,173 @@
+import type { HttpSession } from "../http-session.js";
+import { transformDatesInResponse } from "./date-decoder.js";
+import { ApiClientError, ApiError } from "./errors.js";
+import type {
+  Episode,
+  EpisodeFull,
+  Series,
+  SeriesFull,
+  TranslationEmbed,
+  TranslationFull,
+} from "./types/index.js";
+
+interface ApiSuccessfulResponse<T> {
+  data: T;
+}
+
+interface ApiErrorResponse {
+  error: {
+    code: number;
+    message: string;
+  };
+}
+
+export interface ListSeriesOptions {
+  query?: string;
+  limit?: number;
+  offset?: number;
+  chips?: Record<string, string>;
+  myAnimeListId?: number;
+}
+
+export interface ListEpisodesOptions {
+  seriesId?: number;
+  limit?: number;
+  offset?: number;
+}
+
+export class ApiClient {
+  constructor(private readonly session: HttpSession) {}
+
+  async sendRequest<T>(endpoint: string, queryItems: Record<string, string> = {}): Promise<T> {
+    const url = new URL(`/api${endpoint}`, this.session.baseUrl);
+
+    // Сортируем параметры по имени (как в Swift)
+    const sortedParams = Object.entries(queryItems).sort(([a], [b]) => a.localeCompare(b));
+    for (const [key, value] of sortedParams) {
+      url.searchParams.set(key, value);
+    }
+
+    let response: Response;
+    try {
+      response = await this.session.request(url.pathname + url.search, {
+        method: "GET",
+        headers: {
+          Accept: "application/json",
+        },
+      });
+    } catch (error) {
+      throw ApiClientError.requestFailed(error instanceof Error ? error : undefined);
+    }
+
+    let data: unknown;
+    try {
+      data = await response.json();
+    } catch (error) {
+      throw ApiClientError.canNotDecodeResponseJson(error instanceof Error ? error : undefined);
+    }
+
+    // Проверяем на ошибку API
+    if (this.isApiErrorResponse(data)) {
+      const apiError = data.error;
+
+      if (apiError.code === 403) {
+        throw ApiClientError.apiError(ApiError.authenticationRequired());
+      }
+
+      if (apiError.code === 404) {
+        throw ApiClientError.apiError(ApiError.notFound());
+      }
+
+      throw ApiClientError.apiError(ApiError.other(apiError.code, apiError.message));
+    }
+
+    // Успешный ответ
+    if (this.isApiSuccessfulResponse<T>(data)) {
+      return transformDatesInResponse<T>(data.data);
+    }
+
+    throw ApiClientError.canNotDecodeResponseJson();
+  }
+
+  private isApiErrorResponse(data: unknown): data is ApiErrorResponse {
+    return (
+      typeof data === "object" &&
+      data !== null &&
+      "error" in data &&
+      typeof (data as ApiErrorResponse).error === "object" &&
+      (data as ApiErrorResponse).error !== null &&
+      "code" in (data as ApiErrorResponse).error &&
+      "message" in (data as ApiErrorResponse).error
+    );
+  }
+
+  private isApiSuccessfulResponse<T>(data: unknown): data is ApiSuccessfulResponse<T> {
+    return typeof data === "object" && data !== null && "data" in data;
+  }
+
+  // === API Requests ===
+
+  async getSeries(seriesId: number): Promise<SeriesFull> {
+    return this.sendRequest<SeriesFull>(`/series/${seriesId}`);
+  }
+
+  async getEpisode(episodeId: number): Promise<EpisodeFull> {
+    return this.sendRequest<EpisodeFull>(`/episodes/${episodeId}`);
+  }
+
+  async listSeries(options: ListSeriesOptions = {}): Promise<Series[]> {
+    const queryItems: Record<string, string> = {};
+
+    if (options.chips) {
+      const chipsValue = Object.entries(options.chips)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([key, value]) => `${key}=${value}`)
+        .join(";");
+      queryItems.chips = chipsValue;
+    }
+
+    if (options.query !== undefined) {
+      queryItems.query = options.query;
+    }
+
+    if (options.limit !== undefined) {
+      queryItems.limit = String(options.limit);
+    }
+
+    if (options.offset !== undefined) {
+      queryItems.offset = String(options.offset);
+    }
+
+    if (options.myAnimeListId !== undefined) {
+      queryItems.myAnimeListId = String(options.myAnimeListId);
+    }
+
+    return this.sendRequest<Series[]>("/series", queryItems);
+  }
+
+  async listEpisodes(options: ListEpisodesOptions = {}): Promise<Episode[]> {
+    const queryItems: Record<string, string> = {};
+
+    if (options.seriesId !== undefined) {
+      queryItems.seriesId = String(options.seriesId);
+    }
+
+    if (options.limit !== undefined) {
+      queryItems.limit = String(options.limit);
+    }
+
+    if (options.offset !== undefined) {
+      queryItems.offset = String(options.offset);
+    }
+
+    return this.sendRequest<Episode[]>("/episodes", queryItems);
+  }
+
+  async getTranslation(translationId: number): Promise<TranslationFull> {
+    return this.sendRequest<TranslationFull>(`/translations/${translationId}`);
+  }
+
+  async getTranslationEmbed(translationId: number): Promise<TranslationEmbed> {
+    return this.sendRequest<TranslationEmbed>(`/translations/embed/${translationId}`);
+  }
+}

package/src/api/date-decoder.ts

@@ -0,0 +1,57 @@
+/**
+ * Парсит даты в формате API Anime365: "yyyy-MM-dd HH:mm:ss" в московской таймзоне.
+ */
+export function parseApiDate(dateString: string): Date {
+  // API возвращает даты в формате "2024-01-15 14:30:00" в московской таймзоне (UTC+3)
+  const [datePart, timePart] = dateString.split(" ");
+  if (!datePart || !timePart) {
+    throw new Error(`Invalid date format: ${dateString}`);
+  }
+
+  // Добавляем смещение московской таймзоны (+03:00)
+  const isoString = `${datePart}T${timePart}+03:00`;
+  const date = new Date(isoString);
+
+  if (Number.isNaN(date.getTime())) {
+    throw new Error(`Invalid date: ${dateString}`);
+  }
+
+  return date;
+}
+
+/**
+ * Проверяет, является ли дата "пустой" датой-заглушкой API (2000-01-01 00:00:00).
+ */
+export function isEmptyDate(date: Date): boolean {
+  // API возвращает "2000-01-01 00:00:00" MSK как пустую дату
+  // В UTC это будет 1999-12-31 21:00:00
+  return date.getTime() === new Date("1999-12-31T21:00:00.000Z").getTime();
+}
+
+/**
+ * Рекурсивно преобразует строки дат в объекты Date в JSON-ответе.
+ * Ищет поля, заканчивающиеся на "DateTime".
+ */
+export function transformDatesInResponse<T>(obj: unknown): T {
+  if (obj === null || obj === undefined) {
+    return obj as T;
+  }
+
+  if (Array.isArray(obj)) {
+    return obj.map((item) => transformDatesInResponse(item)) as T;
+  }
+
+  if (typeof obj === "object") {
+    const result: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(obj)) {
+      if (key.endsWith("DateTime") && typeof value === "string") {
+        result[key] = parseApiDate(value);
+      } else {
+        result[key] = transformDatesInResponse(value);
+      }
+    }
+    return result as T;
+  }
+
+  return obj as T;
+}

package/src/api/errors.ts

@@ -0,0 +1,43 @@
+export class ApiError extends Error {
+  constructor(
+    public readonly code: number,
+    message: string
+  ) {
+    super(message);
+    this.name = "ApiError";
+  }
+
+  static authenticationRequired(): ApiError {
+    return new ApiError(403, "Authentication required");
+  }
+
+  static notFound(): ApiError {
+    return new ApiError(404, "Not found");
+  }
+
+  static other(code: number, message: string): ApiError {
+    return new ApiError(code, message);
+  }
+}
+
+export class ApiClientError extends Error {
+  constructor(
+    message: string,
+    public readonly cause?: ApiError | Error
+  ) {
+    super(message);
+    this.name = "ApiClientError";
+  }
+
+  static canNotDecodeResponseJson(error?: Error): ApiClientError {
+    return new ApiClientError("Cannot decode response JSON", error);
+  }
+
+  static apiError(error: ApiError): ApiClientError {
+    return new ApiClientError(`API error: ${error.message}`, error);
+  }
+
+  static requestFailed(error?: Error): ApiClientError {
+    return new ApiClientError("Request failed", error);
+  }
+}

package/src/api/index.ts

@@ -0,0 +1,4 @@
+export { ApiClient, type ListEpisodesOptions, type ListSeriesOptions } from "./api-client.js";
+export { isEmptyDate, parseApiDate } from "./date-decoder.js";
+export { ApiClientError, ApiError } from "./errors.js";
+export * from "./types/index.js";

package/src/api/types/episode.ts

@@ -0,0 +1,16 @@
+import type { Translation } from "./translation.js";
+
+export interface Episode {
+  id: number;
+  episodeFull: string;
+  episodeInt: string;
+  episodeType: string;
+  firstUploadedDateTime: Date;
+  isActive: number;
+  isFirstUploaded: number;
+}
+
+export interface EpisodeFull extends Episode {
+  seriesId: number;
+  translations: Translation[];
+}

package/src/api/types/index.ts

@@ -0,0 +1,15 @@
+export type { Episode, EpisodeFull } from "./episode.js";
+export type {
+  Series,
+  SeriesFull,
+  SeriesFullDescription,
+  SeriesFullGenre,
+  Titles,
+} from "./series.js";
+export type { SeriesType } from "./series-type.js";
+export type {
+  Translation,
+  TranslationEmbed,
+  TranslationEmbedStream,
+  TranslationFull,
+} from "./translation.js";

package/src/api/types/series-type.ts

@@ -0,0 +1,10 @@
+export type SeriesType =
+  | "tv"
+  | "tv_special"
+  | "movie"
+  | "ova"
+  | "music"
+  | "ona"
+  | "special"
+  | "pv"
+  | "cm";

package/src/api/types/series.ts

@@ -0,0 +1,44 @@
+import type { Episode } from "./episode.js";
+import type { SeriesType } from "./series-type.js";
+
+export interface Titles {
+  ru: string | null;
+  romaji: string | null;
+}
+
+export interface Series {
+  id: number;
+  title: string;
+  titles: Titles;
+  posterUrl: string | null;
+  myAnimeListScore: string;
+  season: string;
+  type: SeriesType | null;
+  year: number | null;
+}
+
+export interface SeriesFullGenre {
+  id: number;
+  title: string;
+}
+
+export interface SeriesFullDescription {
+  source: string;
+  value: string;
+}
+
+export interface SeriesFull {
+  id: number;
+  title: string;
+  posterUrl: string | null;
+  myAnimeListScore: string;
+  myAnimeListId: number;
+  isAiring: number;
+  numberOfEpisodes: number;
+  season: string;
+  type: SeriesType | null;
+  titles: Titles;
+  genres: SeriesFullGenre[] | null;
+  descriptions: SeriesFullDescription[] | null;
+  episodes: Episode[] | null;
+}

package/src/api/types/translation.ts

@@ -0,0 +1,30 @@
+import type { Episode } from "./episode.js";
+import type { Series } from "./series.js";
+
+export interface Translation {
+  id: number;
+  activeDateTime: Date;
+  addedDateTime: Date;
+  isActive: number;
+  qualityType: string;
+  typeKind: string;
+  typeLang: string;
+  authorsSummary: string;
+  height: number;
+}
+
+export interface TranslationFull {
+  episode: Episode;
+  series: Series;
+}
+
+export interface TranslationEmbedStream {
+  height: number;
+  urls: string[];
+}
+
+export interface TranslationEmbed {
+  stream: TranslationEmbedStream[];
+  subtitlesUrl: string | null;
+  subtitlesVttUrl: string | null;
+}