ichime-ts-api-client 1.0.0

package/src/http-session.ts

@@ -0,0 +1,99 @@
+import { CookieJar } from "tough-cookie";
+
+export interface RequestOptions extends Omit<RequestInit, "dispatcher"> {
+  timeout?: number;
+}
+
+export class HttpSession {
+  readonly jar: CookieJar;
+  readonly baseUrl: string;
+
+  constructor(baseUrl: string) {
+    this.baseUrl = baseUrl;
+    this.jar = new CookieJar();
+  }
+
+  async request(path: string, options: RequestOptions = {}): Promise<Response> {
+    const { timeout = 10000, ...init } = options;
+    let url = new URL(path, this.baseUrl);
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+    try {
+      // Manually follow redirects to preserve cookies from intermediate responses
+      let redirectCount = 0;
+      const maxRedirects = 10;
+
+      while (redirectCount < maxRedirects) {
+        // Get cookies for this URL
+        const cookieString = await this.jar.getCookieString(url.toString());
+
+        const headers = {
+          Accept: "*/*",
+          "User-Agent":
+            "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36",
+          "Cache-Control": "no-cache",
+          ...(cookieString ? { Cookie: cookieString } : {}),
+          ...init.headers,
+        };
+
+        const response = await fetch(url, {
+          ...init,
+          headers,
+          signal: controller.signal,
+          redirect: "manual", // Don't follow redirects automatically
+        });
+
+        // Store cookies from response BEFORE following redirect
+        const setCookieHeaders = response.headers.getSetCookie();
+        for (const setCookie of setCookieHeaders) {
+          await this.jar.setCookie(setCookie, url.toString());
+        }
+
+        // Check if it's a redirect
+        if (response.status >= 300 && response.status < 400) {
+          const location = response.headers.get("location");
+          if (!location) {
+            return response;
+          }
+
+          // Resolve relative URL against current URL
+          url = new URL(location, url);
+          redirectCount++;
+
+          // For 302/303, switch to GET method
+          if (response.status === 302 || response.status === 303) {
+            init.method = "GET";
+            init.body = undefined;
+          }
+
+          continue;
+        }
+
+        return response;
+      }
+
+      throw new Error("Too many redirects");
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+
+  async getCookie(name: string): Promise<string | undefined> {
+    const cookies = await this.jar.getCookies(this.baseUrl);
+    return cookies.find((c) => c.key === name)?.value;
+  }
+
+  async getCookieString(): Promise<string> {
+    return await this.jar.getCookieString(this.baseUrl);
+  }
+
+  async setCookie(name: string, value: string): Promise<void> {
+    const url = new URL(this.baseUrl);
+    await this.jar.setCookie(
+      `${name}=${value}; Domain=${url.hostname}; Path=/`,
+      this.baseUrl,
+    );
+  }
+}

package/src/index.ts

@@ -0,0 +1,53 @@
+// Core
+
+// API Client
+export {
+  ApiClient,
+  type ListEpisodesOptions,
+  type ListSeriesOptions,
+} from "./api/api-client.js";
+export { isEmptyDate, parseApiDate } from "./api/date-decoder.js";
+export { ApiClientError, ApiError } from "./api/errors.js";
+// API Types
+export type {
+  Episode,
+  EpisodeFull,
+  Series,
+  SeriesFull,
+  SeriesFullDescription,
+  SeriesFullGenre,
+  SeriesType,
+  Titles,
+  Translation,
+  TranslationEmbed,
+  TranslationEmbedStream,
+  TranslationFull,
+} from "./api/types/index.js";
+export { HttpSession, type RequestOptions } from "./http-session.js";
+export { WebClientError, WebClientTypeNormalizationError } from "./web/errors.js";
+export { extractIdentifiersFromUrl, parseDurationString, parseWebDate } from "./web/helpers.js";
+// Web Types
+export type {
+  AnimeListCategory,
+  AnimeListEditableEntry,
+  AnimeListEntry,
+  AnimeListEntryStatus,
+  EditAnimeListResult,
+  MomentDetails,
+  MomentEmbed,
+  MomentPreview,
+  MomentSorting,
+  NewPersonalEpisode,
+  NewRecentEpisode,
+  Profile,
+  VideoSource,
+} from "./web/types/index.js";
+export {
+  AnimeListCategoryNumericId,
+  AnimeListCategoryWebPath,
+  AnimeListEntryStatusNumericId,
+  animeListCategoryFromNumericId,
+  animeListEntryStatusFromNumericId,
+} from "./web/types/index.js";
+// Web Client
+export { WebClient } from "./web/web-client.js";

package/src/web/errors.ts

@@ -0,0 +1,43 @@
+export class WebClientError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "WebClientError";
+  }
+
+  static couldNotConvertResponseToHttpResponse(): WebClientError {
+    return new WebClientError("Could not convert response to HTTP response");
+  }
+
+  static couldNotConvertResponseDataToString(): WebClientError {
+    return new WebClientError("Could not convert response data to string");
+  }
+
+  static badStatusCode(statusCode: number): WebClientError {
+    return new WebClientError(`Bad status code: ${statusCode}`);
+  }
+
+  static authenticationRequired(): WebClientError {
+    return new WebClientError("Authentication required");
+  }
+
+  static couldNotParseHtml(): WebClientError {
+    return new WebClientError("Could not parse HTML");
+  }
+
+  static unknownError(error: Error): WebClientError {
+    const err = new WebClientError(`Unknown error: ${error.message}`);
+    err.cause = error;
+    return err;
+  }
+}
+
+export class WebClientTypeNormalizationError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "WebClientTypeNormalizationError";
+  }
+
+  static failedCreatingDTOFromHTMLElement(message: string): WebClientTypeNormalizationError {
+    return new WebClientTypeNormalizationError(message);
+  }
+}

package/src/web/helpers.ts

@@ -0,0 +1,70 @@
+/**
+ * Извлекает ID сериала и эпизода из URL вида /catalog/{seriesId}-{slug}/{episodeId}-{slug}
+ */
+export function extractIdentifiersFromUrl(url: URL): {
+  seriesId: number | null;
+  episodeId: number | null;
+} {
+  const pathParts = url.pathname.split("/").filter(Boolean);
+
+  if (pathParts.length < 2 || pathParts[0] !== "catalog") {
+    return { seriesId: null, episodeId: null };
+  }
+
+  let seriesId: number | null = null;
+  let episodeId: number | null = null;
+
+  // Извлекаем seriesId из второго сегмента (например, "12345-anime-name")
+  const seriesMatch = pathParts[1]?.match(/(\d+)$/);
+  if (seriesMatch) {
+    seriesId = Number.parseInt(seriesMatch[1], 10);
+  }
+
+  // Извлекаем episodeId из третьего сегмента (например, "67890-episode-1")
+  if (pathParts.length >= 3) {
+    const episodeMatch = pathParts[2]?.match(/(\d+)$/);
+    if (episodeMatch) {
+      episodeId = Number.parseInt(episodeMatch[1], 10);
+    }
+  }
+
+  return { seriesId, episodeId };
+}
+
+/**
+ * Парсит строку длительности формата "mm:ss" или "hh:mm:ss" в секунды.
+ */
+export function parseDurationString(durationString: string): number | null {
+  const parts = durationString.split(":").map((p) => Number.parseInt(p, 10));
+
+  if (parts.some((p) => Number.isNaN(p))) {
+    return null;
+  }
+
+  switch (parts.length) {
+    case 2: // mm:ss
+      return parts[0] * 60 + parts[1];
+    case 3: // hh:mm:ss
+      return parts[0] * 3600 + parts[1] * 60 + parts[2];
+    default:
+      return null;
+  }
+}
+
+/**
+ * Парсит дату в формате "dd.MM.yyyy HH:mm" в московской таймзоне.
+ */
+export function parseWebDate(dateString: string): Date | null {
+  // Формат: "15.01.2024 14:30"
+  const match = dateString.match(/^(\d{2})\.(\d{2})\.(\d{4}) (\d{2}):(\d{2})$/);
+  if (!match) {
+    return null;
+  }
+
+  const [, day, month, year, hours, minutes] = match;
+  // Создаем ISO строку с московским смещением (+03:00)
+  const isoString = `${year}-${month}-${day}T${hours}:${minutes}:00+03:00`;
+  const date = new Date(isoString);
+
+  return Number.isNaN(date.getTime()) ? null : date;
+}

package/src/web/index.ts

@@ -0,0 +1,4 @@
+export { WebClientError, WebClientTypeNormalizationError } from "./errors.js";
+export { extractIdentifiersFromUrl, parseDurationString, parseWebDate } from "./helpers.js";
+export * from "./types/index.js";
+export { WebClient } from "./web-client.js";

package/src/web/types/anime-list-status.ts

@@ -0,0 +1,70 @@
+export type AnimeListEntryStatus =
+  | "watching"
+  | "completed"
+  | "onHold"
+  | "dropped"
+  | "planned"
+  | "notInList";
+
+export const AnimeListEntryStatusNumericId: Record<AnimeListEntryStatus, number> = {
+  planned: 0,
+  watching: 1,
+  completed: 2,
+  onHold: 3,
+  dropped: 4,
+  notInList: 99,
+};
+
+export function animeListEntryStatusFromNumericId(id: number): AnimeListEntryStatus | null {
+  switch (id) {
+    case 0:
+      return "planned";
+    case 1:
+      return "watching";
+    case 2:
+      return "completed";
+    case 3:
+      return "onHold";
+    case 4:
+      return "dropped";
+    case 99:
+      return "notInList";
+    default:
+      return null;
+  }
+}
+
+export type AnimeListCategory = "watching" | "completed" | "onHold" | "dropped" | "planned";
+
+export const AnimeListCategoryWebPath: Record<AnimeListCategory, string> = {
+  watching: "watching",
+  completed: "completed",
+  onHold: "onhold",
+  dropped: "dropped",
+  planned: "planned",
+};
+
+export const AnimeListCategoryNumericId: Record<AnimeListCategory, number> = {
+  planned: 0,
+  watching: 1,
+  completed: 2,
+  onHold: 3,
+  dropped: 4,
+};
+
+export function animeListCategoryFromNumericId(id: number): AnimeListCategory | null {
+  switch (id) {
+    case 0:
+      return "planned";
+    case 1:
+      return "watching";
+    case 2:
+      return "completed";
+    case 3:
+      return "onHold";
+    case 4:
+      return "dropped";
+    default:
+      return null;
+  }
+}

package/src/web/types/anime-list.ts

@@ -0,0 +1,23 @@
+import type { AnimeListEntryStatus } from "./anime-list-status.js";
+
+export interface AnimeListEntry {
+  seriesId: number;
+  seriesTitleFull: string;
+  episodesWatched: number;
+  episodesTotal: number | null;
+  score: number | null;
+}
+
+export interface AnimeListEditableEntry {
+  episodesWatched: number;
+  status: AnimeListEntryStatus;
+  score: number | null;
+  commentary: string | null;
+}
+
+export interface EditAnimeListResult {
+  id: number;
+  status: string;
+  score: string;
+  episodes: string;
+}

package/src/web/types/index.ts

@@ -0,0 +1,21 @@
+export type { AnimeListEditableEntry, AnimeListEntry, EditAnimeListResult } from "./anime-list.js";
+export type {
+  AnimeListCategory,
+  AnimeListEntryStatus,
+} from "./anime-list-status.js";
+export {
+  AnimeListCategoryNumericId,
+  AnimeListCategoryWebPath,
+  AnimeListEntryStatusNumericId,
+  animeListCategoryFromNumericId,
+  animeListEntryStatusFromNumericId,
+} from "./anime-list-status.js";
+export type {
+  MomentDetails,
+  MomentEmbed,
+  MomentPreview,
+  MomentSorting,
+  VideoSource,
+} from "./moment.js";
+export type { NewPersonalEpisode, NewRecentEpisode } from "./personal-episode.js";
+export type { Profile } from "./profile.js";

package/src/web/types/moment.ts

@@ -0,0 +1,25 @@
+export interface MomentPreview {
+  momentId: number;
+  coverUrl: string;
+  momentTitle: string;
+  sourceDescription: string;
+  /** Duration in seconds */
+  durationSeconds: number;
+}
+
+export interface MomentDetails {
+  seriesId: number;
+  seriesTitle: string;
+  episodeId: number;
+}
+
+export interface VideoSource {
+  height: number;
+  urls: string[];
+}
+
+export interface MomentEmbed {
+  videoUrl: string;
+}
+
+export type MomentSorting = "new" | "old" | "popular";

package/src/web/types/personal-episode.ts

@@ -0,0 +1,19 @@
+export interface NewPersonalEpisode {
+  seriesId: number;
+  seriesPosterUrl: string;
+  seriesTitleRu: string;
+  seriesTitleRomaji: string;
+  episodeId: number;
+  episodeNumberLabel: string;
+  episodeUpdateType: string;
+}
+
+export interface NewRecentEpisode {
+  seriesId: number;
+  seriesPosterUrl: string;
+  seriesTitleRu: string;
+  seriesTitleRomaji: string;
+  episodeId: number;
+  episodeNumberLabel: string;
+  episodeUploadedAt: Date;
+}

package/src/web/types/profile.ts

@@ -0,0 +1,5 @@
+export interface Profile {
+  id: number;
+  name: string;
+  avatarUrl: string;
+}