@nemu.pm/tachiyomi-runtime 0.1.0

package/src/image-codec.node.ts

@@ -0,0 +1,119 @@
+/**
+ * Image codec for Node.js/Bun environments.
+ * Uses the `canvas` package (node-canvas).
+ */
+
+import { createCanvas, loadImage, ImageData } from "canvas";
+
+export async function decodeImageAsync(base64: string): Promise<{ width: number; height: number; pixels: string } | null> {
+  try {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+
+    const img = await loadImage(Buffer.from(bytes));
+    const canvas = createCanvas(img.width, img.height);
+    const ctx = canvas.getContext("2d");
+    ctx.drawImage(img, 0, 0);
+    const imageData = ctx.getImageData(0, 0, img.width, img.height);
+
+    // Convert RGBA to ARGB (Android Bitmap format)
+    const pixels = new Int32Array(img.width * img.height);
+    const rgba = imageData.data;
+    for (let i = 0; i < pixels.length; i++) {
+      const r = rgba[i * 4];
+      const g = rgba[i * 4 + 1];
+      const b = rgba[i * 4 + 2];
+      const a = rgba[i * 4 + 3];
+      pixels[i] = ((a << 24) | (r << 16) | (g << 8) | b) | 0;
+    }
+
+    // Convert to base64
+    const pixelBuffer = new Uint8Array(pixels.buffer);
+    let pixelBase64 = "";
+    const CHUNK_SIZE = 32768;
+    for (let i = 0; i < pixelBuffer.length; i += CHUNK_SIZE) {
+      const chunk = pixelBuffer.subarray(i, Math.min(i + CHUNK_SIZE, pixelBuffer.length));
+      pixelBase64 += String.fromCharCode.apply(null, chunk as unknown as number[]);
+    }
+
+    return { width: img.width, height: img.height, pixels: btoa(pixelBase64) };
+  } catch (e) {
+    console.error("[ImageCodec] decode error:", e);
+    return null;
+  }
+}
+
+export async function encodeImageAsync(
+  pixelsBase64: string,
+  width: number,
+  height: number,
+  format: string,
+  quality: number
+): Promise<string | null> {
+  try {
+    const binary = atob(pixelsBase64);
+    const pixelBuffer = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      pixelBuffer[i] = binary.charCodeAt(i);
+    }
+    const pixels = new Int32Array(pixelBuffer.buffer);
+
+    // Convert ARGB to RGBA
+    const rgba = new Uint8ClampedArray(width * height * 4);
+    for (let i = 0; i < pixels.length; i++) {
+      const pixel = pixels[i];
+      rgba[i * 4] = (pixel >> 16) & 0xff;
+      rgba[i * 4 + 1] = (pixel >> 8) & 0xff;
+      rgba[i * 4 + 2] = pixel & 0xff;
+      rgba[i * 4 + 3] = (pixel >> 24) & 0xff;
+    }
+
+    const canvas = createCanvas(width, height);
+    const ctx = canvas.getContext("2d");
+    const imageData = new ImageData(rgba, width, height);
+    ctx.putImageData(imageData, 0, 0);
+
+    const buffer = format === "jpeg"
+      ? canvas.toBuffer("image/jpeg", { quality: quality / 100 })
+      : canvas.toBuffer("image/png");
+
+    const outputBytes = new Uint8Array(buffer);
+    let result = "";
+    const CHUNK_SIZE = 32768;
+    for (let i = 0; i < outputBytes.length; i += CHUNK_SIZE) {
+      const chunk = outputBytes.subarray(i, Math.min(i + CHUNK_SIZE, outputBytes.length));
+      result += String.fromCharCode.apply(null, chunk as unknown as number[]);
+    }
+    return btoa(result);
+  } catch (e) {
+    console.error("[ImageCodec] encode error:", e);
+    return null;
+  }
+}
+
+// Sync wrappers - in Node we can't truly block, so these return null
+// Tests should use async versions directly
+function decodeImageSync(base64: string): { width: number; height: number; pixels: string } | null {
+  console.warn("[ImageCodec] Sync decode not supported in Node.js, use decodeImageAsync instead");
+  return null;
+}
+
+function encodeImageSync(
+  pixelsBase64: string,
+  width: number,
+  height: number,
+  format: string,
+  quality: number
+): string | null {
+  console.warn("[ImageCodec] Sync encode not supported in Node.js, use encodeImageAsync instead");
+  return null;
+}
+
+export function registerImageCodec(): void {
+  (globalThis as Record<string, unknown>).tachiyomiDecodeImage = decodeImageSync;
+  (globalThis as Record<string, unknown>).tachiyomiEncodeImage = encodeImageSync;
+}
+

package/src/image-codec.ts

@@ -0,0 +1,5 @@
+/**
+ * Image codec - re-exports browser implementation as default.
+ * Node.js users get the node version via conditional exports.
+ */
+export { decodeImageAsync, encodeImageAsync, registerImageCodec } from "./image-codec.browser.js";

package/src/index.node.ts

@@ -0,0 +1,50 @@
+/**
+ * @tachiyomi-js/runtime - Node.js/Bun entry point
+ * 
+ * Uses the `canvas` package for image manipulation.
+ * Install with: npm install canvas@next
+ */
+
+// Register node image codec on import
+import { registerImageCodec } from './image-codec.node';
+registerImageCodec();
+
+// Re-export everything from the main module (types + runtime)
+export type {
+  Manga,
+  Chapter,
+  Page,
+  MangasPage,
+  SourceInfo,
+  ExtensionManifest,
+  Author,
+  FilterState,
+  FilterHeader,
+  FilterSeparator,
+  FilterText,
+  FilterCheckBox,
+  FilterTriState,
+  FilterSort,
+  FilterSelect,
+  FilterGroup,
+  FilterStateUpdate,
+  SettingsSchema,
+  PreferenceSchema,
+} from './types';
+
+export { MangaStatus, filterToStateUpdate, buildFilterStateJson } from './types';
+
+export type {
+  HttpBridge,
+  HttpRequest,
+  HttpResponse,
+} from './http';
+
+export {
+  TachiyomiRuntime,
+  createRuntime,
+  type ExtensionInstance,
+} from './runtime';
+
+// Also export async image functions (useful for testing in Node)
+export { decodeImageAsync, encodeImageAsync } from './image-codec.node';

package/src/index.ts

@@ -0,0 +1,75 @@
+/**
+ * @tachiyomi-js/runtime
+ * 
+ * Runtime for loading and executing Tachiyomi extensions compiled to JavaScript.
+ * 
+ * @example
+ * ```typescript
+ * import { createRuntime, type Manga, type MangasPage } from '@tachiyomi-js/runtime';
+ * 
+ * // Create runtime with your HTTP implementation
+ * const runtime = createRuntime({
+ *   request(req, wantBytes) {
+ *     // Implement sync HTTP (e.g., XMLHttpRequest in a Web Worker)
+ *     return { status: 200, statusText: 'OK', headers: {}, body: '...' };
+ *   }
+ * });
+ * 
+ * // Load an extension
+ * const ext = runtime.loadExtension(extensionJsCode);
+ * 
+ * // Get sources
+ * const sources = ext.getSources();
+ * console.log(sources[0].name); // "MangaDex"
+ * 
+ * // Fetch manga
+ * const popular: MangasPage = ext.getPopularManga(sources[0].id, 1);
+ * console.log(popular.mangas[0].title);
+ * ```
+ * 
+ * @packageDocumentation
+ */
+
+// Register browser image codec on import
+import { registerImageCodec } from './image-codec.browser';
+registerImageCodec();
+
+// Types
+export type {
+  Manga,
+  Chapter,
+  Page,
+  MangasPage,
+  SourceInfo,
+  ExtensionManifest,
+  Author,
+  FilterState,
+  FilterHeader,
+  FilterSeparator,
+  FilterText,
+  FilterCheckBox,
+  FilterTriState,
+  FilterSort,
+  FilterSelect,
+  FilterGroup,
+  FilterStateUpdate,
+  SettingsSchema,
+  PreferenceSchema,
+} from './types';
+
+// Enums and functions (exported as values)
+export { MangaStatus, filterToStateUpdate, buildFilterStateJson } from './types';
+
+// HTTP Bridge
+export type {
+  HttpBridge,
+  HttpRequest,
+  HttpResponse,
+} from './http';
+
+// Runtime
+export {
+  TachiyomiRuntime,
+  createRuntime,
+  type ExtensionInstance,
+} from './runtime';

package/src/runtime.ts

@@ -0,0 +1,314 @@
+/**
+ * Tachiyomi Extension Runtime
+ * 
+ * Provides a clean API for loading and executing Tachiyomi extensions.
+ */
+
+import type { HttpBridge, KotlinHttpResult } from './http';
+import type {
+  Manga,
+  Chapter,
+  Page,
+  MangasPage,
+  SourceInfo,
+  FilterState,
+  SettingsSchema,
+} from './types';
+
+// ============================================================================
+// Extension Instance Interface
+// ============================================================================
+
+/**
+ * A loaded extension instance with methods to interact with sources.
+ */
+export interface ExtensionInstance {
+  /** Get all sources provided by this extension */
+  getSources(): SourceInfo[];
+  
+  /** Get popular manga from a source */
+  getPopularManga(sourceId: string, page: number): MangasPage;
+  
+  /** Get latest updates from a source */
+  getLatestUpdates(sourceId: string, page: number): MangasPage;
+  
+  /** Search for manga */
+  searchManga(sourceId: string, page: number, query: string): MangasPage;
+  
+  /** Get full manga details */
+  getMangaDetails(sourceId: string, manga: Pick<Manga, 'url'>): Manga;
+  
+  /** Get chapter list for a manga */
+  getChapterList(sourceId: string, manga: Pick<Manga, 'url'>): Chapter[];
+  
+  /** Get page list for a chapter */
+  getPageList(sourceId: string, chapter: Pick<Chapter, 'url'>): Page[];
+  
+  /** Get available filters for a source */
+  getFilterList(sourceId: string): FilterState[];
+  
+  /** Reset filters to default state */
+  resetFilters(sourceId: string): void;
+  
+  /** Apply filter state (for stateful filters) */
+  applyFilterState(sourceId: string, filterState: FilterState[]): void;
+  
+  /** Get settings schema for a source */
+  getSettingsSchema(sourceId: string): SettingsSchema | null;
+  
+  /** Update a preference value */
+  setPreference(sourceId: string, key: string, value: unknown): void;
+  
+  /** Get source headers (includes Referer from headersBuilder) */
+  getHeaders(sourceId: string): Record<string, string>;
+  
+  /** 
+   * Fetch image through source's client with interceptors.
+   * Required for sources with image descrambling/protection.
+   * Returns base64-encoded image bytes.
+   */
+  fetchImage(sourceId: string, pageUrl: string, imageUrl: string): string;
+}
+
+// ============================================================================
+// Kotlin/JS Exports Interface
+// ============================================================================
+
+/** Internal interface matching what Kotlin/JS exports */
+interface KotlinExports {
+  getManifest(): string;
+  getPopularManga(sourceId: string, page: number): string;
+  getLatestUpdates(sourceId: string, page: number): string;
+  searchManga(sourceId: string, page: number, query: string): string;
+  getMangaDetails(sourceId: string, mangaUrl: string): string;
+  getChapterList(sourceId: string, mangaUrl: string): string;
+  getPageList(sourceId: string, chapterUrl: string): string;
+  getFilterList(sourceId: string): string;
+  resetFilters(sourceId: string): string;
+  applyFilterState(sourceId: string, filterStateJson: string): string;
+  getHeaders(sourceId: string): string;
+  fetchImage(sourceId: string, pageUrl: string, imageUrl: string): string;
+  getSettingsSchema?(sourceId: string): string;
+  setPreference?(sourceId: string, key: string, valueJson: string): string;
+}
+
+// ============================================================================
+// Result Unwrapping
+// ============================================================================
+
+interface KotlinResult<T> {
+  ok: boolean;
+  data?: T;
+  error?: unknown;
+}
+
+function unwrapResult<T>(json: string): T {
+  const result: KotlinResult<T> = JSON.parse(json);
+  if (!result.ok) {
+    const errMsg = typeof result.error === 'string' 
+      ? result.error 
+      : JSON.stringify(result.error);
+    throw new Error(errMsg || 'Unknown extension error');
+  }
+  return result.data as T;
+}
+
+// ============================================================================
+// Runtime Implementation
+// ============================================================================
+
+/**
+ * Tachiyomi extension runtime.
+ * 
+ * Create one runtime per application, then use it to load extensions.
+ */
+export class TachiyomiRuntime {
+  private httpBridge: HttpBridge;
+  
+  constructor(httpBridge: HttpBridge) {
+    this.httpBridge = httpBridge;
+    this.installHttpBridge();
+  }
+  
+  /**
+   * Install the HTTP bridge on globalThis for Kotlin/JS to call.
+   */
+  private installHttpBridge(): void {
+    const bridge = this.httpBridge;
+    
+    (globalThis as any).tachiyomiHttpRequest = (
+      url: string,
+      method: string,
+      headersJson: string,
+      body: string | null,
+      wantBytes: boolean
+    ): KotlinHttpResult => {
+      try {
+        const headers = JSON.parse(headersJson || '{}');
+        const response = bridge.request({ url, method, headers, body }, wantBytes);
+        
+        return {
+          status: response.status,
+          statusText: response.statusText,
+          headersJson: JSON.stringify(response.headers),
+          body: response.body,
+          error: null,
+        };
+      } catch (e: any) {
+        return {
+          status: 0,
+          statusText: '',
+          headersJson: '{}',
+          body: '',
+          error: e.message || 'HTTP request failed',
+        };
+      }
+    };
+  }
+  
+  /**
+   * Load an extension from its JavaScript code.
+   * 
+   * @param code - The compiled extension JavaScript
+   * @returns An ExtensionInstance for interacting with the extension's sources
+   */
+  loadExtension(code: string): ExtensionInstance {
+    // Execute the extension code
+    const fn = new Function(code);
+    fn();
+    
+    // Find the exports in globalThis
+    // Extensions export to globalThis['moduleName'].tachiyomi.generated
+    const g = globalThis as any;
+    let exports: KotlinExports | null = null;
+    
+    for (const key of Object.keys(g)) {
+      if (g[key]?.tachiyomi?.generated) {
+        exports = g[key].tachiyomi.generated;
+        break;
+      }
+    }
+    
+    if (!exports || typeof exports.getManifest !== 'function') {
+      throw new Error('Invalid extension: could not find tachiyomi.generated exports');
+    }
+    
+    return new ExtensionInstanceImpl(exports);
+  }
+}
+
+/**
+ * Internal implementation of ExtensionInstance
+ */
+class ExtensionInstanceImpl implements ExtensionInstance {
+  private exports: KotlinExports;
+  private sourcesCache: SourceInfo[] | null = null;
+  
+  constructor(exports: KotlinExports) {
+    this.exports = exports;
+  }
+  
+  getSources(): SourceInfo[] {
+    if (this.sourcesCache) return this.sourcesCache;
+    const json = this.exports.getManifest();
+    this.sourcesCache = unwrapResult<SourceInfo[]>(json);
+    return this.sourcesCache;
+  }
+  
+  getPopularManga(sourceId: string, page: number): MangasPage {
+    const json = this.exports.getPopularManga(sourceId, page);
+    return unwrapResult<MangasPage>(json);
+  }
+  
+  getLatestUpdates(sourceId: string, page: number): MangasPage {
+    const json = this.exports.getLatestUpdates(sourceId, page);
+    return unwrapResult<MangasPage>(json);
+  }
+  
+  searchManga(sourceId: string, page: number, query: string): MangasPage {
+    const json = this.exports.searchManga(sourceId, page, query);
+    return unwrapResult<MangasPage>(json);
+  }
+  
+  getMangaDetails(sourceId: string, manga: Pick<Manga, 'url'>): Manga {
+    const json = this.exports.getMangaDetails(sourceId, manga.url);
+    return unwrapResult<Manga>(json);
+  }
+  
+  getChapterList(sourceId: string, manga: Pick<Manga, 'url'>): Chapter[] {
+    const json = this.exports.getChapterList(sourceId, manga.url);
+    return unwrapResult<Chapter[]>(json);
+  }
+  
+  getPageList(sourceId: string, chapter: Pick<Chapter, 'url'>): Page[] {
+    const json = this.exports.getPageList(sourceId, chapter.url);
+    return unwrapResult<Page[]>(json);
+  }
+  
+  getFilterList(sourceId: string): FilterState[] {
+    const json = this.exports.getFilterList(sourceId);
+    return unwrapResult<FilterState[]>(json);
+  }
+  
+  resetFilters(sourceId: string): void {
+    const json = this.exports.resetFilters(sourceId);
+    unwrapResult<{ ok: boolean }>(json);
+  }
+  
+  applyFilterState(sourceId: string, filterState: FilterState[]): void {
+    const json = this.exports.applyFilterState(sourceId, JSON.stringify(filterState));
+    unwrapResult<{ ok: boolean }>(json);
+  }
+  
+  getSettingsSchema(sourceId: string): SettingsSchema | null {
+    if (!this.exports.getSettingsSchema) return null;
+    try {
+      const json = this.exports.getSettingsSchema(sourceId);
+      return unwrapResult<SettingsSchema>(json);
+    } catch {
+      return null;
+    }
+  }
+  
+  setPreference(sourceId: string, key: string, value: unknown): void {
+    if (!this.exports.setPreference) return;
+    const json = this.exports.setPreference(sourceId, key, JSON.stringify(value));
+    unwrapResult<{ ok: boolean }>(json);
+  }
+  
+  getHeaders(sourceId: string): Record<string, string> {
+    const json = this.exports.getHeaders(sourceId);
+    return unwrapResult<Record<string, string>>(json);
+  }
+  
+  fetchImage(sourceId: string, pageUrl: string, imageUrl: string): string {
+    const json = this.exports.fetchImage(sourceId, pageUrl, imageUrl);
+    return unwrapResult<string>(json);
+  }
+}
+
+/**
+ * Create a Tachiyomi runtime with the given HTTP bridge.
+ * 
+ * @example
+ * ```typescript
+ * import { createRuntime } from '@tachiyomi-js/runtime';
+ * 
+ * const runtime = createRuntime({
+ *   request(req, wantBytes) {
+ *     // Your HTTP implementation here
+ *     const xhr = new XMLHttpRequest();
+ *     xhr.open(req.method, req.url, false);
+ *     // ...
+ *     return { status: 200, body: '...', headers: {}, statusText: 'OK' };
+ *   }
+ * });
+ * 
+ * const ext = runtime.loadExtension(extensionCode);
+ * const sources = ext.getSources();
+ * ```
+ */
+export function createRuntime(httpBridge: HttpBridge): TachiyomiRuntime {
+  return new TachiyomiRuntime(httpBridge);
+}
+