feat: new token saving

.vscode/settings.json

@@ -9,5 +9,8 @@
     // "**/node_modules": true,
     "**/.angular": true
   },
-  "editor.formatOnSave": true
-}
+  "editor.formatOnSave": true,
+  "cSpell.words": [
+    "Manhwa"
+  ]
+}

apps/NwaifuAnime/src/app/app.component.html

@@ -6,6 +6,9 @@
     <h1>Update not available</h1>
   }
 }
-<app-header (searchEvent)="onSearch($event)"></app-header>
+<app-header></app-header>
 <div class="h-10"></div>
-<router-outlet></router-outlet>
+<main>
+  <router-outlet></router-outlet>
+</main>
+<app-notification></app-notification>

apps/NwaifuAnime/src/app/app.component.less

@@ -0,0 +1,4 @@
+main {
+  overflow-y: auto;
+  height: calc(100vh - 3rem);
+}

apps/NwaifuAnime/src/app/app.component.ts

@@ -2,10 +2,11 @@ import { Component } from "@angular/core";
 import { RouterModule } from "@angular/router";
 import { AppService } from "./app.service";
 import { HeaderComponent } from "./components/header/header.component";
+import { NotificationComponent } from "./components/notification/notification.component";
 
 @Component({
   standalone: true,
-  imports: [RouterModule, HeaderComponent],
+  imports: [RouterModule, HeaderComponent, NotificationComponent, NotificationComponent],
   selector: "app-root",
   templateUrl: "./app.component.html",
   styleUrl: "./app.component.less",
@@ -26,8 +27,4 @@ export class AppComponent {
   get serviceWorkerEnabled() {
     return this.sw.serviceWorkerEnabled;
   }
-
-  onSearch(text: string) {
-    console.log(text);
-  }
 }

apps/NwaifuAnime/src/app/app.config.ts

@@ -1,11 +1,17 @@
-import { ApplicationConfig, provideZoneChangeDetection, isDevMode } from "@angular/core";
+import { provideHttpClient, withFetch } from "@angular/common/http";
+import { ApplicationConfig, isDevMode, provideZoneChangeDetection } from "@angular/core";
 import { provideRouter } from "@angular/router";
+import { provideServiceWorker } from "@angular/service-worker";
 import { appRoutes } from "./app.routes";
-import { provideServiceWorker } from '@angular/service-worker';
 
 export const appConfig: ApplicationConfig = {
-  providers: [provideZoneChangeDetection({ eventCoalescing: true }), provideRouter(appRoutes), provideServiceWorker('ngsw-worker.js', {
-            enabled: !isDevMode(),
-            registrationStrategy: 'registerWhenStable:30000'
-          })],
+  providers: [
+    provideZoneChangeDetection({ eventCoalescing: true }),
+    provideRouter(appRoutes),
+    provideServiceWorker("ngsw-worker.js", {
+      enabled: !isDevMode(),
+      registrationStrategy: "registerWhenStable:30000",
+    }),
+    provideHttpClient(withFetch()),
+  ],
 };

apps/NwaifuAnime/src/app/app.routes.ts

@@ -1,9 +1,18 @@
 import { Route } from "@angular/router";
+import { AuthComponent } from "./components/auth/auth.component";
+import { DetailComponent } from "./components/detail/detail.component";
 import { HomeComponent } from "./components/home/home.component";
+import { ReaderComponent } from "./components/reader/reader.component";
 
 export const appRoutes: Route[] = [
   {
     path: "",
     component: HomeComponent,
   },
+  { path: "detail", component: DetailComponent },
+  { path: "reader", component: ReaderComponent },
+  {
+    path: "auth",
+    component: AuthComponent,
+  },
 ];

apps/NwaifuAnime/src/app/components/auth/auth.component.html

@@ -0,0 +1,46 @@
+<div class="flex flex-col m-6">
+  <div class="mangalib-auth">
+    <h2>Авторизация в MangaLib</h2>
+    <ol class="list-decimal flex flex-col gap-4">
+      <li>
+        <p class="font-bold">Авторизация через токен</p>
+        <div class="flex flex-row gap-4">
+          <input
+            type="text"
+            placeholder="Token"
+            class="outline-none border-md border px-2"
+            #libSocialToken
+          />
+          <button
+            type="button"
+            (click)="setLibSocialToken()"
+            class="hover:bg-slate-600 bg-slate-400 p-3 rounded-md text-white"
+          >
+            Сохранить
+          </button>
+        </div>
+      </li>
+      <li>
+        Вход через скрипт TamperMonkey. Если нет кнопки, значит вы не установили скрипт
+        <a
+          href="https://test-front.mangalib.me"
+          class="hover:bg-slate-600 bg-slate-400 p-3 rounded-md text-white tamperMonkey"
+        >
+          Вход
+        </a>
+      </li>
+      <li>
+        <div class="flex flex-row gap-3">
+          <button
+            type="button"
+            (click)="checkToken()"
+            class="hover:bg-slate-600 bg-slate-400 p-3 rounded-md text-white"
+          >
+            Проверить токен
+          </button>
+          <h3 class="self-center">{{ isRuLibAuth ? "Авторизован" : "Не авторизован" }}</h3>
+        </div>
+      </li>
+    </ol>
+  </div>
+</div>

apps/NwaifuAnime/src/app/components/auth/auth.component.ts

@@ -0,0 +1,86 @@
+import { CommonModule } from "@angular/common";
+import { AfterViewInit, Component, ElementRef, OnDestroy, ViewChild } from "@angular/core";
+import { ActivatedRoute, Router, RouterLink } from "@angular/router";
+import { Subject, takeUntil } from "rxjs";
+import { NotificationService } from "../../services/notification/notification.service";
+import { RulibAuthService } from "../../services/parsers/rulib/rulib.auth.service";
+import { EAuthTokenService } from "./enum";
+
+@Component({
+  selector: "app-auth",
+  templateUrl: "./auth.component.html",
+  styleUrls: ["./auth.component.less"],
+  standalone: true,
+  imports: [CommonModule, RouterLink],
+})
+export class AuthComponent implements AfterViewInit, OnDestroy {
+  private destroy$ = new Subject<void>();
+  @ViewChild("libSocialToken") libSocialToken: ElementRef<HTMLInputElement> | null = null;
+  isRuLibAuth = false;
+  constructor(
+    private route: ActivatedRoute,
+    private router: Router,
+    private rulibAuthService: RulibAuthService,
+    private notificationService: NotificationService,
+  ) {}
+
+  private setToken(service: EAuthTokenService, token: string) {
+    switch (service) {
+      case EAuthTokenService.RULIB:
+        this.rulibAuthService
+          .setToken(token)
+          .pipe(takeUntil(this.destroy$))
+          .subscribe((data) => {
+            if (data) {
+              this.router.navigate(["/"]);
+              this.notificationService.info("Успешная авторизация в RuLib!", "Вход");
+            } else {
+              this.router.navigate(["/", "auth"]);
+              this.notificationService.error(
+                "Не удалось авторизоваться в RuLib! Попробуйте ещё раз.",
+                "Вход",
+                4000,
+              );
+            }
+          });
+        break;
+      default:
+        this.router.navigate(["/", "auth"]);
+        this.notificationService.error("Неизвестный сервис авторизации!", "Вход");
+        return;
+    }
+  }
+
+  setLibSocialToken() {
+    if (this.libSocialToken) {
+      const token = this.libSocialToken.nativeElement.value;
+      this.setToken(EAuthTokenService.RULIB, token);
+    }
+  }
+
+  checkToken() {
+    this.rulibAuthService
+      .checkToken(this.rulibAuthService.getToken())
+      .pipe(takeUntil(this.destroy$))
+      .subscribe((data) => {
+        this.isRuLibAuth = data;
+      });
+  }
+
+  ngAfterViewInit(): void {
+    this.route.queryParams.pipe(takeUntil(this.destroy$)).subscribe((params) => {
+      const { token, service } = params;
+      if (token && service) {
+        this.setToken(service as EAuthTokenService, token);
+      }
+    });
+    if (this.libSocialToken) {
+      this.libSocialToken.nativeElement.value = this.rulibAuthService.getToken();
+    }
+    this.checkToken();
+  }
+  ngOnDestroy(): void {
+    this.destroy$.next();
+    this.destroy$.complete();
+  }
+}

apps/NwaifuAnime/src/app/components/auth/enum.ts

@@ -0,0 +1,3 @@
+export enum EAuthTokenService {
+  RULIB = "rulib",
+}

apps/NwaifuAnime/src/app/components/detail/detail.component.html

@@ -0,0 +1,44 @@
+<div class="flex flex-col items-center">
+  @if (needAuth) {
+    <h1>Необходима авторизация</h1>
+    <a routerLink="/auth" class="text-center bg-slate-600 text-white p-3 rounded-md mb-4">Войти</a>
+  }
+  @if (detail_item) {
+    <h1>{{ detail_item.name }}</h1>
+    <h2>{{ detail_item.rus_name }}</h2>
+    <img [src]="detail_item.cover.default" [alt]="detail_item.slug" />
+
+    @if (!needAuth) {
+      <details class="w-full">
+        <summary class="text-center sticky top-0 bg-white z-10 py-2">
+          <h3>Главы</h3>
+        </summary>
+        <div class="flex flex-col items-center pb-16">
+          @for (chapter of chapters.data; track $index) {
+            <a
+              routerLink="/reader"
+              [queryParams]="{
+                url: detail_item.slug_url,
+                chapter: chapter.number,
+                volume: chapter.volume,
+              }"
+              [title]="chapter.name"
+              class="p-3 text-white bg-slate-600 w-[300px] mt-3 rounded-lg"
+            >
+              <h3>
+                <strong>{{ chapter.number }}.</strong> {{ chapter.name || "Нет названия" }}
+              </h3>
+            </a>
+          }
+        </div>
+      </details>
+      <a
+        routerLink="/reader"
+        class="p-3 text-white bg-slate-600 w-[300px] mt-5 rounded-lg text-center"
+        [queryParams]="{ url: detail_item.slug_url, volume: 1, chapter: 1 }"
+      >
+        Читать
+      </a>
+    }
+  }
+</div>

apps/NwaifuAnime/src/app/components/detail/detail.component.ts

@@ -0,0 +1,70 @@
+import { CommonModule } from "@angular/common";
+import { AfterViewInit, Component, OnDestroy } from "@angular/core";
+import { ActivatedRoute, Router, RouterLink } from "@angular/router";
+import { Subject, takeUntil } from "rxjs";
+import { IRulibChaptersResult } from "../../services/parsers/rulib/rulib.chapters.dto";
+import { Data } from "../../services/parsers/rulib/rulib.detail.dto";
+import { SearchService } from "../../services/search.service";
+
+@Component({
+  selector: "app-detail",
+  templateUrl: "./detail.component.html",
+  styleUrls: ["./detail.component.less"],
+  standalone: true,
+  imports: [CommonModule, RouterLink],
+})
+export class DetailComponent implements AfterViewInit, OnDestroy {
+  detail_item: Data | null = null;
+  chapters: IRulibChaptersResult = { data: [] };
+  needAuth: boolean = false;
+  private destroy$ = new Subject<void>();
+  constructor(
+    private route: ActivatedRoute,
+    private searchService: SearchService,
+    private router: Router,
+  ) {}
+
+  private getDetails(url: string) {
+    this.searchService
+      .getDetails(url)
+      .pipe(takeUntil(this.destroy$))
+      .subscribe({
+        next: (data) => {
+          this.detail_item = data.data;
+        },
+        error: (error) => {
+          console.log(error);
+        },
+      });
+    this.searchService
+      .getChapters(url)
+      .pipe(takeUntil(this.destroy$))
+      .subscribe({
+        next: (data) => {
+          this.chapters = data;
+          if (data.data.length === 0) {
+            this.needAuth = true;
+          }
+        },
+        error: (error) => {
+          console.log(error);
+        },
+      });
+  }
+
+  ngAfterViewInit(): void {
+    this.route.queryParams.pipe(takeUntil(this.destroy$)).subscribe((params) => {
+      const url = params["url"];
+      if (url) {
+        this.getDetails(url);
+      } else {
+        this.router.navigate(["/"]);
+      }
+    });
+  }
+
+  ngOnDestroy(): void {
+    this.destroy$.next();
+    this.destroy$.complete();
+  }
+}

apps/NwaifuAnime/src/app/components/header/header.component.html

@@ -1,8 +1,8 @@
 <div
-  class="header fixed flex justify-between w-full p-2 bg-gray-700 md:h-8 h-auto items-center md:flex-row flex-col md:gap-0 gap-3"
+  class="header fixed flex justify-between w-full p-2 bg-gray-700 md:h-8 items-center md:flex-row flex-col md:gap-0 gap-3 text-xl md:text-base"
 >
   <div class="flex justify-between flex-row w-full align-middle">
-    <h1 class="text-white">NwaifuAnime</h1>
+    <a href="/"><h1 class="text-white" title="Main page">NwaifuAnime</h1></a>
     <!-- Search bar on small screens -->
     <button type="button" class="md:hidden" (click)="changeMenu()">
       <i [class]="menuBtnClass"></i>
@@ -15,8 +15,13 @@
       type="search"
       #searchInput
       class="outline-none ps-1 text-sm leading-6 w-full border-0 bg-transparent border-r border-gray-700"
+      (keydown.enter)="search()"
     />
-    <button class="align-middle w-[100px] text-center" type="submit" (click)="search()">
+    <button
+      class="align-middle w-[100px] text-center border-0 flex flex-col items-center justify-center"
+      type="submit"
+      (click)="search()"
+    >
       <span class="text-sm text-black h-full">Поиск</span>
     </button>
   </div>

apps/NwaifuAnime/src/app/components/header/header.component.ts

@@ -1,5 +1,7 @@
 import { CommonModule } from "@angular/common";
-import { Component, ElementRef, EventEmitter, Output, ViewChild } from "@angular/core";
+import { AfterViewInit, Component, ElementRef, OnDestroy, ViewChild } from "@angular/core";
+import { ActivatedRoute, NavigationEnd, Router } from "@angular/router";
+import { Subject, filter, takeUntil } from "rxjs";
 
 @Component({
   selector: "app-header",
@@ -8,10 +10,24 @@ import { Component, ElementRef, EventEmitter, Output, ViewChild } from "@angular
   standalone: true,
   imports: [CommonModule],
 })
-export class HeaderComponent {
-  @Output() searchEvent: EventEmitter<string> = new EventEmitter();
+export class HeaderComponent implements AfterViewInit, OnDestroy {
   @ViewChild("searchInput") searchInput: ElementRef<HTMLInputElement> | null = null;
   menuOpened = false;
+  private destroy$ = new Subject<void>();
+  constructor(
+    private router: Router,
+    private route: ActivatedRoute,
+  ) {
+    this.router.events
+      .pipe(filter((event) => event instanceof NavigationEnd))
+      .pipe(takeUntil(this.destroy$))
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      .subscribe((val: any) => {
+        if (val.url.startsWith("/detail") || val.url.startsWith("/reader")) {
+          this.menuOpened = false;
+        }
+      });
+  }
   changeMenu() {
     this.menuOpened = !this.menuOpened;
   }
@@ -21,13 +37,27 @@ export class HeaderComponent {
   }
 
   get searchBarClass(): string {
-    return `search-bar bg-slate-300 md:w-[50%] w-full md:m-0 ms-2 me-2 max-h-6 md:flex justify-start flex-row items-center rounded-md ${this.menuOpened ? "flex" : "hidden"}`;
+    return `search-bar bg-slate-300 md:w-[50%] w-full md:m-0 ms-2 me-2 md:h-6 h-10 md:flex justify-start flex-row items-center rounded-md ${this.menuOpened ? "flex" : "hidden"}`;
   }
 
   search() {
     if (this.searchInput) {
       const text = this.searchInput.nativeElement.value;
-      this.searchEvent.emit(text);
+      this.router.navigateByUrl(`/?search=${text}`);
     }
   }
+
+  ngAfterViewInit(): void {
+    this.route.queryParams.pipe(takeUntil(this.destroy$)).subscribe((params) => {
+      const search = params["search"];
+      if (search && this.searchInput) {
+        this.searchInput.nativeElement.value = search;
+      }
+    });
+  }
+
+  ngOnDestroy(): void {
+    this.destroy$.next();
+    this.destroy$.complete();
+  }
 }

apps/NwaifuAnime/src/app/components/home/home.component.html

@@ -1 +1,16 @@
 <h1>It's home component</h1>
+<div class="flex flex-col items-center w-full px-3">
+  @for (item of items; track $index) {
+    <a
+      routerLink="/detail"
+      [queryParams]="{ url: item.slug_url }"
+      title="{{ item.name }}"
+      class="mb-6 max-w-[700px] w-full"
+    >
+      <div class="card flex flex-col items-center border-black border-2 rounded-md p-4 w-full">
+        <h1>{{ item.rus_name }}</h1>
+        <img [src]="item.cover.thumbnail" [alt]="item.slug" class="w-[200px] h-auto aspect-auto" />
+      </div>
+    </a>
+  }
+</div>

apps/NwaifuAnime/src/app/components/home/home.component.ts

@@ -1,11 +1,43 @@
 import { CommonModule } from "@angular/common";
-import { Component } from "@angular/core";
+import { AfterViewInit, Component, Input, OnDestroy } from "@angular/core";
+import { ActivatedRoute, RouterLink } from "@angular/router";
+import { Subject, takeUntil } from "rxjs";
+import { Datum } from "../../services/parsers/rulib/rulib.search.dto";
+import { SearchService } from "../../services/search.service";
 
 @Component({
   standalone: true,
   selector: "app-home",
   templateUrl: "./home.component.html",
   styleUrls: ["./home.component.less"],
-  imports: [CommonModule],
+  imports: [CommonModule, RouterLink],
 })
-export class HomeComponent {}
+export class HomeComponent implements OnDestroy, AfterViewInit {
+  @Input() items: Datum[] = [];
+
+  private destroy$ = new Subject<void>();
+
+  constructor(
+    private searchService: SearchService,
+    private route: ActivatedRoute,
+  ) {}
+
+  ngOnDestroy(): void {
+    this.destroy$.next();
+    this.destroy$.complete();
+  }
+
+  ngAfterViewInit(): void {
+    this.route.queryParams.subscribe((params) => {
+      const search = params["search"];
+      if (search) {
+        this.searchService
+          .search(search)
+          .pipe(takeUntil(this.destroy$))
+          .subscribe((data) => {
+            this.items = data.data;
+          });
+      }
+    });
+  }
+}

apps/NwaifuAnime/src/app/components/notification/notification.component.html

@@ -0,0 +1,12 @@
+<div
+  class="notification-container fixed md:right-0 bottom-0 max-w-[100%] min-w-[100%] min-h-[8rem] h-[8rem] md:min-w-[20rem] px-3 pb-4"
+  [hidden]="!show_notification"
+>
+  <div [class]="'notification rounded-md bg-white border-2 ' + borderColor + ' h-full'">
+    <div [class]="'head flex flex-row justify-between px-2 py-2 h-5 border-b-2 ' + borderColor">
+      <h3 class="self-center">{{ notification.name }}</h3>
+      <button class="self-center" (click)="closeNotification()" type="button">X</button>
+    </div>
+    <div class="notification-text mx-3 my-1">{{ notification.message }}</div>
+  </div>
+</div>

apps/NwaifuAnime/src/app/components/notification/notification.component.ts

@@ -0,0 +1,53 @@
+import { CommonModule } from "@angular/common";
+import { AfterViewInit, Component, OnDestroy } from "@angular/core";
+import { Subject, takeUntil } from "rxjs";
+import { INotification } from "../../services/notification/notification.dto";
+import { NotificationService } from "../../services/notification/notification.service";
+
+@Component({
+  standalone: true,
+  selector: "app-notification",
+  templateUrl: "./notification.component.html",
+  styleUrls: ["./notification.component.less"],
+  imports: [CommonModule],
+})
+export class NotificationComponent implements AfterViewInit, OnDestroy {
+  show_notification = false;
+  isError = false;
+  private closeNotificationTimer: ReturnType<typeof setTimeout> | null = null;
+  notification: INotification = { isError: false, message: "", name: "", time: 0 };
+
+  private destroy$ = new Subject<void>();
+
+  constructor(private notificationService: NotificationService) {}
+
+  ngAfterViewInit(): void {
+    this.notificationService.notification$
+      .asObservable()
+      .pipe(takeUntil(this.destroy$))
+      .subscribe((data) => {
+        if (!data) return;
+        this.notification = data;
+        this.show_notification = true;
+        if (this.closeNotificationTimer) {
+          clearTimeout(this.closeNotificationTimer);
+        }
+        this.closeNotificationTimer = setTimeout(() => {
+          this.show_notification = false;
+        }, data.time);
+      });
+  }
+
+  ngOnDestroy(): void {
+    this.destroy$.next();
+    this.destroy$.complete();
+  }
+
+  closeNotification() {
+    this.show_notification = false;
+  }
+
+  get borderColor(): string {
+    return this.notification.isError ? "border-red-600" : "border-green-600";
+  }
+}

apps/NwaifuAnime/src/app/components/reader/reader.component.html

@@ -0,0 +1,39 @@
+<div
+  class="flex flex-row items-center justify-between me-4 max-w-[900px] relative -translate-x-[50%] left-[50%]"
+>
+  <a
+    [routerLink]="['/', 'detail']"
+    [queryParams]="{ url: url }"
+    class="bg-slate-600 text-white rounded-lg p-3 m-4"
+  >
+    Назад к тайтлу
+  </a>
+  <h3>{{ currentChapterInfo?.number }}. {{ currentChapterInfo?.name || "Нет названия" }}</h3>
+</div>
+<div class="flex flex-col items-center">
+  @if (pages.length > 0 && currentPage) {
+    <div [class]="imageContainerClass">
+      @if (!isManhwa) {
+        <app-scale-image [imageSrc]="currentPage.imageUrl"></app-scale-image>
+      } @else {
+        @for (page of manhwaPages; track page.id) {
+          <app-scale-image
+            [imageSrc]="page.imageUrl"
+            [host]="host"
+            (view)="loadPage(page.index)"
+            [hostScrollable]="isHostScrollable()"
+          ></app-scale-image>
+        }
+      }
+    </div>
+    <div class="flex items-center justify-center space-x-4 my-10">
+      <button (click)="prevPage()" class="p-3 text-white bg-slate-600 w-[100px] rounded-lg">
+        ←
+      </button>
+      <p *ngIf="!isManhwa">{{ pages[currentPageIndex].slug }} / {{ pages.length }}</p>
+      <button (click)="nextPage()" class="p-3 text-white bg-slate-600 w-[100px] rounded-lg">
+        →
+      </button>
+    </div>
+  }
+</div>

apps/NwaifuAnime/src/app/components/reader/reader.component.less

@@ -0,0 +1,5 @@
+:host {
+  overflow-y: auto;
+  height: 100%;
+  display: block;
+}

apps/NwaifuAnime/src/app/components/reader/reader.component.ts

@@ -0,0 +1,243 @@
+import { CommonModule, isPlatformBrowser } from "@angular/common";
+import {
+  AfterViewInit,
+  Component,
+  ElementRef,
+  HostListener,
+  Inject,
+  OnDestroy,
+  PLATFORM_ID,
+} from "@angular/core";
+import { ActivatedRoute, Router, RouterLink } from "@angular/router";
+import { Subject, takeUntil } from "rxjs";
+import { Chapter, Page } from "../../services/parsers/rulib/rulib.chapter.dto";
+import { IRulibChapter } from "../../services/parsers/rulib/rulib.chapters.dto";
+import { SearchService } from "../../services/search.service";
+import { ScaleImageComponent } from "../scale-image/scale-image.component";
+import { CachedPage, CachedPages } from "./reader.dto";
+
+@Component({
+  selector: "app-reader",
+  templateUrl: "./reader.component.html",
+  styleUrls: ["./reader.component.less"],
+  standalone: true,
+  imports: [CommonModule, ScaleImageComponent, RouterLink],
+})
+export class ReaderComponent implements AfterViewInit, OnDestroy {
+  //FIXME: Scrolling to top when manhwa
+  pages: Page[] = [];
+  currentPageIndex = 0;
+  cachedPages: CachedPages = new Map<number, CachedPage>();
+  imageUrl: string = "";
+  isManhwa = false;
+  currentChapterInfo: Chapter | null = null;
+  url = "";
+  private chaptersInfo: IRulibChapter[] = [];
+  private chapterNum: number = 0;
+  private chapterVol: number = 0;
+  private fromTowards = false;
+  private destroy$ = new Subject<void>();
+
+  constructor(
+    private route: ActivatedRoute,
+    private router: Router,
+    private searchService: SearchService,
+    public host: ElementRef,
+    @Inject(PLATFORM_ID) private platformId: object,
+  ) {}
+  ngOnDestroy(): void {
+    this.destroy$.next();
+    this.destroy$.complete();
+  }
+
+  get manhwaPages() {
+    return this.cachedPages.values();
+  }
+
+  ngAfterViewInit(): void {
+    this.route.queryParams.pipe(takeUntil(this.destroy$)).subscribe((params) => {
+      const url = params["url"];
+      const chapter = params["chapter"];
+      const volume = params["volume"];
+      const fromTowards = params["from_towards"];
+      if (url && chapter && volume) {
+        if (fromTowards) this.fromTowards = Boolean(+fromTowards);
+        else this.fromTowards = false;
+        this.chapterNum = +chapter;
+        this.chapterVol = +volume;
+        this.url = url;
+        this.searchService
+          .getChapters(url)
+          .pipe(takeUntil(this.destroy$))
+          .subscribe((data) => {
+            this.chaptersInfo = data.data;
+          });
+        this.searchService
+          .isManhwa(url)
+          .pipe(takeUntil(this.destroy$))
+          .subscribe((data) => {
+            this.isManhwa = data;
+            this.loadChapter(url, chapter, volume);
+          });
+      } else {
+        this.router.navigate(["/"]);
+      }
+    });
+  }
+
+  public isHostScrollable(): boolean {
+    if (isPlatformBrowser(this.platformId)) {
+      const style = window.getComputedStyle(this.host.nativeElement);
+      return (
+        style.getPropertyValue("overflow") === "auto" ||
+        style.getPropertyValue("overflow-y") === "scroll"
+      );
+    }
+
+    return false;
+  }
+
+  backToTitle() {
+    this.router.navigate(["/", "detail"], { queryParams: { url: this.url } });
+  }
+
+  loadChapter(url: string, chapter: string, volume: string) {
+    this.searchService
+      .getChapter(url, chapter, volume)
+      .pipe(takeUntil(this.destroy$))
+      .subscribe({
+        next: (data) => {
+          this.currentChapterInfo = data.data;
+          this.pages = data.data.pages;
+          this.pages.forEach((page, index) => {
+            this.cachedPages.set(index, {
+              ...page,
+              imageUrl: "",
+              isManhwa: this.isManhwa,
+              index,
+            });
+          });
+          this.loadPage(0);
+          if (this.fromTowards) {
+            this.currentPageIndex = this.pages.length - 1;
+            this.loadPage(this.pages.length - 1); // Загрузить последнюю страницу при открытии главы
+          } else this.loadPage(0); // Загрузить первую страницу при открытии главы
+        },
+        error: (error) => {
+          console.log(error);
+          this.router.navigate(["/", "detail"], { queryParams: { url: this.url } });
+        },
+      });
+  }
+
+  public intersectionLoadPage(id: number) {
+    const data = Array.from(this.cachedPages.values()).find((page) => page.id === id)!;
+    this.fetchPage(data);
+  }
+
+  private loadPageByIndex(index: number) {
+    const data = this.cachedPages.get(index)!;
+    this.fetchPage(data);
+  }
+
+  get currentPage() {
+    return this.cachedPages.get(this.currentPageIndex);
+  }
+
+  private fetchPage(page: CachedPage) {
+    if (!page.imageUrl)
+      this.searchService
+        .getImageData(this.searchService.getImageServer() + page.url)
+        .pipe(takeUntil(this.destroy$))
+        .subscribe((data) => {
+          const url = this.getImageUrl(data);
+          this.cachedPages.set(page.index, {
+            ...page,
+            imageUrl: url,
+          });
+        });
+  }
+
+  private cachePage(index: number) {
+    for (let i = index; i < Math.min(index + 2, this.cachedPages.size); i++) {
+      this.loadPageByIndex(i);
+    }
+  }
+
+  private clearCache(index: number) {
+    for (let i = 0; i <= index; i++) {
+      this.cachedPages.get(i)!.imageUrl = "";
+    }
+  }
+
+  loadPage(index: number) {
+    if (index >= 0 && index < this.pages.length) {
+      this.currentPageIndex = index;
+      this.cachePage(index);
+      this.clearCache(index - 2);
+    } else if (index == this.cachedPages.size) {
+      const thisChapterIndex = this.chaptersInfo.findIndex((chapter) => {
+        return +chapter.number === this.chapterNum && +chapter.volume === this.chapterVol;
+      });
+      const nextChapterIndex = Math.min(thisChapterIndex + 1, this.chaptersInfo.length - 1);
+      const nextChapter = this.chaptersInfo[nextChapterIndex];
+      if (nextChapter !== this.chaptersInfo[thisChapterIndex]) {
+        this.cachedPages.clear();
+        this.router.navigate(["/", "reader"], {
+          queryParams: {
+            url: this.url,
+            chapter: nextChapter.number,
+            volume: nextChapter.volume,
+          },
+        });
+      }
+    } else if (index == -1) {
+      const thisChapterIndex = this.chaptersInfo.findIndex((chapter) => {
+        return +chapter.number === this.chapterNum && +chapter.volume === this.chapterVol;
+      });
+      const prevChapterIndex = Math.max(thisChapterIndex - 1, 0);
+      const prevChapter = this.chaptersInfo[prevChapterIndex];
+      if (prevChapter !== this.chaptersInfo[thisChapterIndex]) {
+        this.cachedPages.clear();
+        this.router.navigate(["/", "reader"], {
+          queryParams: {
+            url: this.url,
+            chapter: prevChapter.number,
+            volume: prevChapter.volume,
+            from_towards: 1,
+          },
+        });
+      }
+    }
+  }
+
+  @HostListener("window:keydown", ["$event"])
+  onKeydown(event: KeyboardEvent) {
+    if (event.key === "ArrowRight") {
+      this.nextPage();
+    } else if (event.key === "ArrowLeft") {
+      this.prevPage();
+    }
+  }
+
+  private getImageUrl(imageData?: Uint8Array): string {
+    if (!imageData) {
+      return "";
+    }
+    const blob = new Blob([imageData], { type: "image/jpeg" });
+    const urlCreator = window.URL || window.webkitURL;
+    return urlCreator.createObjectURL(blob);
+  }
+
+  nextPage() {
+    this.loadPage(this.currentPageIndex + 1);
+  }
+
+  prevPage() {
+    this.loadPage(this.currentPageIndex - 1);
+  }
+
+  get imageContainerClass() {
+    return `${this.isManhwa ? "h-auto" : "h-[70vh]"} w-[95vw] md:w-[450px] flex flex-col`;
+  }
+}

apps/NwaifuAnime/src/app/components/reader/reader.dto.ts

@@ -0,0 +1,10 @@
+import { Page } from "../../services/parsers/rulib/rulib.chapter.dto";
+
+export interface CachedPage extends Page {
+  imageData?: Uint8Array;
+  imageUrl: string;
+  index: number;
+  isManhwa: boolean;
+}
+
+export type CachedPages = Map<number, CachedPage>;

apps/NwaifuAnime/src/app/components/scale-image/scale-image.component.html

@@ -0,0 +1,7 @@
+<div class="image-container" #container>
+  @if (imageSrc) {
+    <img #image [src]="imageSrc" (load)="onImageLoad()" alt="Manga page" />
+  } @else {
+    <div class="h-screen flex flex-col items-center justify-center"><h1>Loading...</h1></div>
+  }
+</div>

apps/NwaifuAnime/src/app/components/scale-image/scale-image.component.less

@@ -0,0 +1,12 @@
+.image-container {
+  width: 100%;
+  height: 100%;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+}
+img {
+  max-width: 100%;
+  max-height: 100%;
+  object-fit: contain;
+}

apps/NwaifuAnime/src/app/components/scale-image/scale-image.component.ts

@@ -0,0 +1,91 @@
+import {
+  AfterViewInit,
+  Component,
+  ElementRef,
+  EventEmitter,
+  Input,
+  OnDestroy,
+  Output,
+  ViewChild,
+} from "@angular/core";
+import { Subscription, debounceTime, fromEvent } from "rxjs";
+
+@Component({
+  selector: "app-scale-image",
+  templateUrl: "./scale-image.component.html",
+  styleUrls: ["./scale-image.component.less"],
+  standalone: true,
+})
+export class ScaleImageComponent implements AfterViewInit, OnDestroy {
+  @Input({ required: true }) imageSrc: string = "";
+  @ViewChild("container", { static: true }) containerRef: ElementRef | null = null;
+  @ViewChild("image", { static: true }) imageRef: ElementRef | null = null;
+  @Output() view = new EventEmitter<void>();
+  @Input() host: ElementRef | null = null;
+  @Input() hostScrollable: boolean = false;
+
+  private resizeSubscription: Subscription = new Subscription();
+  private observer!: IntersectionObserver;
+
+  ngAfterViewInit(): void {
+    this.setupResizeListener();
+    if (this.host) {
+      this.observer = new IntersectionObserver(
+        ([entry]) => entry.isIntersecting && this.view.emit(),
+        {
+          root: this.hostScrollable ? this.host.nativeElement : null,
+          rootMargin: "1000px",
+        },
+      );
+      if (this.containerRef) this.observer.observe(this.containerRef.nativeElement);
+    }
+  }
+
+  ngOnDestroy(): void {
+    if (this.resizeSubscription) this.resizeSubscription.unsubscribe();
+    if (this.observer) this.observer.disconnect();
+  }
+
+  onImageLoad() {
+    this.scaleImage();
+  }
+
+  private setupResizeListener() {
+    this.resizeSubscription = fromEvent(window, "resize")
+      .pipe(debounceTime(200))
+      .subscribe(() => this.scaleImage());
+  }
+
+  private scaleImage() {
+    if (this.containerRef && this.imageRef) {
+      const container = this.containerRef.nativeElement;
+      const img = this.imageRef.nativeElement;
+
+      const containerWidth = container.clientWidth;
+      const containerHeight = container.clientHeight;
+      const imgRatio = img.naturalWidth / img.naturalHeight;
+      const containerRatio = containerWidth / containerHeight;
+
+      let newWidth, newHeight;
+
+      if (imgRatio > containerRatio) {
+        newWidth = containerWidth;
+        newHeight = containerWidth / imgRatio;
+      } else {
+        newHeight = containerHeight;
+        newWidth = containerHeight * imgRatio;
+      }
+
+      newWidth = Math.min(newWidth, img.naturalWidth);
+      newHeight = Math.min(newHeight, img.naturalHeight);
+
+      if (img.naturalHeight / img.naturalWidth >= 5) {
+        img.style.width = "100%";
+        img.style.height = "auto";
+      } else {
+        img.style.width = `${newWidth}px`;
+        img.style.height = `${newHeight}px`;
+      }
+    }
+  }
+}

apps/NwaifuAnime/src/app/services/notification/notification.dto.ts

@@ -0,0 +1,6 @@
+export interface INotification {
+  message: string;
+  isError: boolean;
+  time: number;
+  name: string;
+}

apps/NwaifuAnime/src/app/services/notification/notification.service.ts

@@ -0,0 +1,36 @@
+import { Injectable, OnDestroy } from "@angular/core";
+import { Subject } from "rxjs";
+import { INotification } from "./notification.dto";
+
+@Injectable({
+  providedIn: "root",
+})
+export class NotificationService implements OnDestroy {
+  readonly notification$ = new Subject<INotification>();
+
+  private sendNotification(message: INotification) {
+    this.notification$.next(message);
+  }
+
+  info(message: string, title: string = "", time = 3000) {
+    this.sendNotification({
+      message,
+      isError: false,
+      time: time,
+      name: title,
+    });
+  }
+
+  error(message: string, title: string = "", time = 3000) {
+    this.sendNotification({
+      message,
+      isError: true,
+      time: time,
+      name: title,
+    });
+  }
+
+  ngOnDestroy(): void {
+    this.notification$.complete();
+  }
+}

apps/NwaifuAnime/src/app/services/parsers/decorators/parser.decorator.ts

@@ -0,0 +1,19 @@
+export function ParserDecorator({
+  site_name,
+  url,
+  nsfw = false,
+  site_id = 1,
+}: {
+  site_name: string;
+  url: string;
+  nsfw?: boolean;
+  site_id?: number;
+}) {
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  return function (constructor: Function) {
+    constructor.prototype.site_name = site_name;
+    constructor.prototype.nsfw = nsfw;
+    constructor.prototype.api_url = url;
+    constructor.prototype.site_id = site_id;
+  };
+}

apps/NwaifuAnime/src/app/services/parsers/parser.ts

@@ -0,0 +1,18 @@
+import { HttpClient } from "@angular/common/http";
+import { Injectable } from "@angular/core";
+import { Observable } from "rxjs";
+
+@Injectable({ providedIn: "root" })
+export abstract class Parser {
+  constructor(protected http: HttpClient) {}
+
+  protected abstract url: string;
+
+  abstract searchManga(query: string): Observable<object>;
+
+  abstract getDetails(slug_url: string): Observable<object>;
+
+  abstract getChapters(url: string): Observable<object>;
+
+  abstract getChapter(url: string, chapter: string, volume: string): Observable<object>;
+}

apps/NwaifuAnime/src/app/services/parsers/rulib/lib.social.parser.service.ts

@@ -0,0 +1,101 @@
+import { HttpClient } from "@angular/common/http";
+import { Injectable } from "@angular/core";
+import { Observable, catchError, map, throwError } from "rxjs";
+import { Parser } from "../parser";
+import { RulibAuthService } from "./rulib.auth.service";
+import { IRulibChapterResult } from "./rulib.chapter.dto";
+import { IRulibChaptersResult } from "./rulib.chapters.dto";
+import { IRulibDetailResult } from "./rulib.detail.dto";
+import { IRulibSearchResult } from "./rulib.search.dto";
+
+//TODO: Make abstract classes
+@Injectable({
+  providedIn: "root",
+})
+export class LibSocialParserService extends Parser {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  protected url = (this as any).api_url;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private site_id = (this as any).site_id;
+  get imageServer() {
+    return "https://img33.imgslib.link";
+  }
+
+  constructor(
+    private rulibAuthService: RulibAuthService,
+    override http: HttpClient,
+  ) {
+    super(http);
+  }
+
+  searchManga(query: string): Observable<IRulibSearchResult> {
+    return this.http
+      .get(
+        `${this.url}/api/manga?fields[]=rate_avg&fields[]=rate&q=${query}&site_id[]=${this.site_id}`,
+      )
+      .pipe(
+        map((data: object) => {
+          return data as IRulibSearchResult;
+        }),
+        catchError((error) => {
+          return throwError(() => `Now found ${error}`);
+        }),
+      );
+  }
+
+  getDetails(slug_url: string): Observable<IRulibDetailResult> {
+    return this.http
+      .get(
+        `${this.url}/api/manga/${slug_url}?fields[]=summary&fields[]=genres&fields[]=tags&fields[]=authors`,
+        { headers: { Authorization: "Bearer " + this.rulibAuthService.getToken() } },
+      )
+      .pipe(
+        map((data: object) => {
+          return data as IRulibDetailResult;
+        }),
+        catchError((error) => {
+          return throwError(() => `Now found ${error}`);
+        }),
+      );
+  }
+
+  getChapters(url: string): Observable<IRulibChaptersResult> {
+    return this.http
+      .get(`${this.url}/api/manga/${url}/chapters`, {
+        headers: { Authorization: "Bearer " + this.rulibAuthService.getToken() },
+      })
+      .pipe(
+        map((data) => {
+          return data as IRulibChaptersResult;
+        }),
+        catchError((error) => {
+          return throwError(() => `Now found ${error}`);
+        }),
+      );
+  }
+
+  getChapter(url: string, chapter: string, volume: string): Observable<IRulibChapterResult> {
+    return this.http
+      .get(`${this.url}/api/manga/${url}/chapter?number=${chapter}&volume=${volume}`, {
+        headers: { Authorization: "Bearer " + this.rulibAuthService.getToken() },
+      })
+      .pipe(
+        map((data) => data as IRulibChapterResult),
+        catchError((error) => throwError(() => `Now found ${error}`)),
+      );
+  }
+
+  isManhwa(slug_url: string): Observable<boolean> {
+    return this.http
+      .get(
+        `${this.url}/api/manga/${slug_url}?fields[]=summary&fields[]=genres&fields[]=tags&fields[]=authors`,
+      )
+      .pipe(
+        map((data) => {
+          const res = data as IRulibDetailResult;
+          return [5, 6, 4].includes(res.data.type.id);
+        }),
+        catchError((error) => throwError(() => `Now found ${error}`)),
+      );
+  }
+}

apps/NwaifuAnime/src/app/services/parsers/rulib/mangalib.parser.service.ts

@@ -0,0 +1,10 @@
+import { Injectable } from "@angular/core";
+import { ParserDecorator } from "../decorators/parser.decorator";
+import { ESiteUrls } from "../urls";
+import { LibSocialParserService } from "./lib.social.parser.service";
+
+@Injectable({
+  providedIn: "root",
+})
+@ParserDecorator({ site_name: "MangaLib", url: ESiteUrls.MANGALIB, site_id: 1 })
+export class MangalibParserService extends LibSocialParserService {}

apps/NwaifuAnime/src/app/services/parsers/rulib/rulib.auth.service.ts

@@ -0,0 +1,47 @@
+import { HttpClient } from "@angular/common/http";
+import { Injectable, OnDestroy } from "@angular/core";
+import { Observable, Subject, catchError, map, of, takeUntil } from "rxjs";
+import { IToken } from "../token.dto";
+@Injectable({
+  providedIn: "root",
+})
+export class RulibAuthService implements OnDestroy {
+  private destroy$ = new Subject<void>();
+  private api_url = "https://api.lib.social";
+  constructor(private http: HttpClient) {}
+
+  setToken(token: string): Observable<boolean> {
+    return this.checkToken(token).pipe(
+      takeUntil(this.destroy$),
+      map((data) => {
+        if (!data) return false;
+        const token_data: IToken = JSON.parse(localStorage.getItem("token") ?? "{}");
+        token_data.rulib_token = token;
+        localStorage.setItem("token", JSON.stringify(token_data));
+        return true;
+      }),
+    );
+  }
+
+  getToken(): string {
+    const token_data: IToken = JSON.parse(localStorage.getItem("token") ?? "{}");
+    return token_data.rulib_token ?? "";
+  }
+
+  checkToken(token: string): Observable<boolean> {
+    return this.http
+      .get(this.api_url + "/api/auth/me", {
+        headers: { Authorization: `Bearer ${token}` },
+      })
+      .pipe(
+        takeUntil(this.destroy$),
+        map(() => true),
+        catchError(() => of(false)),
+      );
+  }
+
+  ngOnDestroy(): void {
+    this.destroy$.next();
+    this.destroy$.complete();
+  }
+}

apps/NwaifuAnime/src/app/services/parsers/rulib/rulib.chapter.dto.ts

@@ -0,0 +1,62 @@
+export interface IRulibChapterResult {
+  data: Chapter;
+}
+
+export interface Chapter {
+  id: number;
+  type: string;
+  volume: string;
+  number: string;
+  number_secondary: string;
+  name: string;
+  slug: string;
+  branch_id: null;
+  manga_id: number;
+  created_at: Date;
+  moderated: Moderated;
+  likes_count: number;
+  teams: Team[];
+  pages: Page[];
+}
+
+export interface Moderated {
+  id: number;
+  label: string;
+}
+
+export interface Page {
+  id: number;
+  image: string;
+  slug: number;
+  external: number;
+  chunks: number;
+  chapter_id: number;
+  created_at: Date;
+  updated_at: UpdatedAt;
+  height: number;
+  width: number;
+  url: string;
+  ratio: string;
+}
+
+export enum UpdatedAt {
+  The0000011130T000000000000Z = "-000001-11-30T00:00:00.000000Z",
+}
+
+export interface Team {
+  id: number;
+  slug: string;
+  slug_url: string;
+  model: string;
+  name: string;
+  cover: Cover;
+  vk: null;
+  discord: null;
+}
+
+export interface Cover {
+  filename: null;
+  thumbnail: string;
+  default: string;
+  md: string;
+}

apps/NwaifuAnime/src/app/services/parsers/rulib/rulib.chapters.dto.ts

@@ -0,0 +1,85 @@
+export interface IRulibChaptersResult {
+  data: IRulibChapter[];
+}
+
+export interface IRulibChapter {
+  id: number;
+  index: number;
+  item_number: number;
+  volume: string;
+  number: string;
+  number_secondary: string;
+  name: string;
+  branches_count: number;
+  branches: Branch[];
+}
+
+export interface Branch {
+  id: number;
+  branch_id: null;
+  created_at: Date;
+  teams: Team[];
+  user: User;
+}
+
+export interface Team {
+  id: number;
+  slug: Slug;
+  slug_url: SlugURL;
+  model: Model;
+  name: Name;
+  cover: Cover;
+}
+
+export interface Cover {
+  filename: null | string;
+  thumbnail: Thumbnail;
+  default: Default;
+  md: Default;
+}
+
+export enum Default {
+  StaticImagesPlaceholdersUserAvatarPNG = "/static/images/placeholders/user_avatar.png",
+  UploadsTeamAnyasyavaCoverJSazXO7JdAKV250X350Jpg = "/uploads/team/anyasyava/cover/jSazXO7JdAKV_250x350.jpg",
+}
+
+export enum Thumbnail {
+  StaticImagesPlaceholdersUserAvatarPNG = "/static/images/placeholders/user_avatar.png",
+  UploadsTeamAnyasyavaCoverJSazXO7JdAKVThumbJpg = "/uploads/team/anyasyava/cover/jSazXO7JdAKV_thumb.jpg",
+}
+
+export enum Model {
+  Team = "team",
+}
+
+export enum Name {
+  Abame = "abame",
+  Anyasyava = "ANYASYAVA",
+  Cabel = "Cabel",
+  Deadvm = "deadvm",
+}
+
+export enum Slug {
+  Abame = "abame",
+  Anyasyava = "anyasyava",
+  Cabel = "cabel",
+  Deadvm = "deadvm",
+}
+
+export enum SlugURL {
+  The13801Anyasyava = "13801--anyasyava",
+  The33106Abame = "33106--abame",
+  The42374Cabel = "42374--cabel",
+  The45635Deadvm = "45635--deadvm",
+}
+
+export interface User {
+  username: Username;
+  id: number;
+}
+
+export enum Username {
+  Deadvm = "deadvm",
+  Gjunyaa = "gjunyaa ❤️\ud83e\ude79",
+  Oksas = "oksas",
+}

apps/NwaifuAnime/src/app/services/parsers/rulib/rulib.detail.dto.ts

@@ -0,0 +1,69 @@
+export interface IRulibDetailResult {
+  data: Data;
+  meta: Meta;
+}
+
+export interface Data {
+  id: number;
+  name: string;
+  rus_name: string;
+  eng_name: string;
+  slug: string;
+  slug_url: string;
+  cover: Cover;
+  ageRestriction: AgeRestriction;
+  site: number;
+  type: AgeRestriction;
+  summary: string;
+  is_licensed: boolean;
+  genres: Genre[];
+  tags: Genre[];
+  authors: Author[];
+  model: string;
+  status: AgeRestriction;
+  releaseDateString: string;
+}
+
+export interface AgeRestriction {
+  id: number;
+  label: string;
+}
+
+export interface Author {
+  id: number;
+  slug: string;
+  slug_url: string;
+  model: string;
+  name: string;
+  rus_name: null;
+  alt_name: null;
+  cover: Cover;
+  subscription: Subscription;
+  confirmed: null;
+  user_id: number;
+}
+
+export interface Cover {
+  filename: null | string;
+  thumbnail: string;
+  default: string;
+  md: string;
+}
+
+export interface Subscription {
+  is_subscribed: boolean;
+  source_type: string;
+  source_id: number;
+  relation: null;
+}
+
+export interface Genre {
+  id: number;
+  name: string;
+  adult: boolean;
+  alert: boolean;
+}
+
+export interface Meta {
+  country: string;
+}

apps/NwaifuAnime/src/app/services/parsers/rulib/rulib.search.dto.ts

@@ -0,0 +1,79 @@
+export interface IRulibSearchResult {
+  data: Datum[];
+  links: Links;
+  meta: Meta;
+}
+
+//TODO: Make normal namings
+export interface Datum {
+  id: number;
+  name: string;
+  rus_name: string;
+  eng_name: string;
+  slug: string;
+  slug_url: string;
+  cover: Cover;
+  ageRestriction: AgeRestriction;
+  site: number;
+  type: AgeRestriction;
+  rating: Rating;
+  is_licensed: boolean;
+  model: Model;
+  status: AgeRestriction;
+  releaseDateString: string;
+}
+
+export interface AgeRestriction {
+  id: number;
+  label: Label;
+}
+
+export enum Label {
+  The12 = "12+",
+  The6 = "6+",
+  Завершён = "Завершён",
+  КомиксЗападный = "Комикс западный",
+  Манга = "Манга",
+  Манхва = "Манхва",
+  Маньхуа = "Маньхуа",
+  Нет = "Нет",
+  Онгоинг = "Онгоинг",
+  Приостановлен = "Приостановлен",
+}
+
+export interface Cover {
+  filename: string;
+  thumbnail: string;
+  default: string;
+  md: string;
+}
+
+export enum Model {
+  Manga = "manga",
+}
+
+export interface Rating {
+  average: string;
+  averageFormated: string;
+  votes: number;
+  votesFormated: string;
+  user: number;
+}
+
+export interface Links {
+  first: string;
+  last: null;
+  prev: null;
+  next: string;
+}
+
+export interface Meta {
+  current_page: number;
+  from: number;
+  path: string;
+  per_page: number;
+  to: number;
+  page: number;
+  has_next_page: boolean;
+  seed: string;
+}

apps/NwaifuAnime/src/app/services/parsers/token.dto.ts

@@ -0,0 +1,3 @@
+export interface IToken {
+  rulib_token?: string;
+}

apps/NwaifuAnime/src/app/services/parsers/urls.ts

@@ -0,0 +1,4 @@
+export enum ESiteUrls {
+  LIB_SOCIAL = "https://api.lib.social",
+  MANGALIB = "https://api.mangalib.me",
+}

apps/NwaifuAnime/src/app/services/search.service.ts

@@ -0,0 +1,66 @@
+import { HttpClient } from "@angular/common/http";
+import { Injectable } from "@angular/core";
+import { BehaviorSubject, Observable, map } from "rxjs";
+import { MangalibParserService } from "./parsers/rulib/mangalib.parser.service";
+import { IRulibChapterResult } from "./parsers/rulib/rulib.chapter.dto";
+import { IRulibChaptersResult } from "./parsers/rulib/rulib.chapters.dto";
+import { IRulibDetailResult } from "./parsers/rulib/rulib.detail.dto";
+import { Datum, IRulibSearchResult } from "./parsers/rulib/rulib.search.dto";
+
+@Injectable({ providedIn: "root" })
+export class SearchService {
+  private itemsTerm = new BehaviorSubject<Datum[]>([]);
+  currentItemsTerm = this.itemsTerm.asObservable();
+  constructor(
+    private parser: MangalibParserService,
+    private http: HttpClient,
+  ) {}
+
+  search(query: string): Observable<IRulibSearchResult> {
+    return this.parser.searchManga(query).pipe(
+      map((data) => {
+        return data;
+      }),
+    );
+  }
+
+  getDetails(slug_url: string): Observable<IRulibDetailResult> {
+    return this.parser.getDetails(slug_url).pipe(
+      map((data) => {
+        return data;
+      }),
+    );
+  }
+
+  getChapters(url: string): Observable<IRulibChaptersResult> {
+    return this.parser.getChapters(url).pipe(
+      map((data) => {
+        return data;
+      }),
+    );
+  }
+
+  getChapter(url: string, chapter: string, volume: string): Observable<IRulibChapterResult> {
+    return this.parser.getChapter(url, chapter, volume).pipe(
+      map((data) => {
+        return data;
+      }),
+    );
+  }
+
+  getImageServer() {
+    return this.parser.imageServer;
+  }
+
+  getImageData(imageUrl: string): Observable<Uint8Array> {
+    return this.http.get(imageUrl, { responseType: "arraybuffer" }).pipe(
+      map((arrayBuffer: ArrayBuffer) => {
+        return new Uint8Array(arrayBuffer);
+      }),
+    );
+  }
+
+  isManhwa(url: string): Observable<boolean> {
+    return this.parser.isManhwa(url);
+  }
+}

apps/NwaifuAnime/src/styles.less

@@ -1,3 +1,6 @@
 @tailwind base;
 @tailwind components;
 @tailwind utilities;
+body {
+  overflow-y: hidden;
+}