taglib-wasm 0.3.13 → 0.3.15

package/dist/src/wasm-workers.ts

@@ -1,176 +0,0 @@
-/**
- * @fileoverview WebAssembly module interface for Cloudflare Workers
- */
-
-import type { TagLibConfig, TagLibModule } from "./types.ts";
-import { TagLibInitializationError } from "./errors.ts";
-
-// Re-export TagLibModule for convenience
-export type { TagLibModule };
-
-/**
- * Default configuration for taglib-wasm module in Workers environment
- * Reduced memory limits to fit within Workers constraints
- */
-const DEFAULT_WORKERS_CONFIG: Required<TagLibConfig> = {
-  memory: {
-    initial: 8 * 1024 * 1024, // 8MB (reduced from 16MB)
-    maximum: 64 * 1024 * 1024, // 64MB (reduced from 256MB)
-  },
-  debug: false,
-};
-
-/**
- * Load and initialize the TagLib WebAssembly module for Cloudflare Workers
- *
- * @param wasmBinary - The WebAssembly binary as Uint8Array
- * @param config - Optional configuration for the Wasm module
- * @returns Promise resolving to initialized TagLib module
- *
- * @example
- * ```typescript
- * import wasmBinary from "../build/taglib.wasm";
- *
- * const taglib = await loadTagLibModuleForWorkers(wasmBinary);
- * ```
- */
-export async function loadTagLibModuleForWorkers(
-  wasmBinary: Uint8Array,
-  config: TagLibConfig = {},
-): Promise<TagLibModule> {
-  const mergedConfig = { ...DEFAULT_WORKERS_CONFIG, ...config };
-
-  // Create Emscripten module configuration for Workers
-  const moduleConfig = {
-    wasmBinary,
-    wasmMemory: new WebAssembly.Memory({
-      initial: mergedConfig.memory.initial! / (64 * 1024),
-      maximum: mergedConfig.memory.maximum! / (64 * 1024),
-    }),
-    print: mergedConfig.debug ? console.log : () => {},
-    printErr: mergedConfig.debug ? console.error : () => {},
-    onRuntimeInitialized: () => {
-      if (mergedConfig.debug) {
-        console.log("taglib-wasm module initialized in Workers");
-      }
-    },
-    // Workers-specific settings
-    locateFile: () => {
-      // Return empty string since we're providing wasmBinary directly
-      return "";
-    },
-    // Disable file system access
-    noFSInit: true,
-    noExitRuntime: true,
-  };
-
-  try {
-    // For Workers, we need to use a modified version of the Emscripten output
-    // that doesn't include Node.js/CommonJS dependencies
-    const TagLibWasm = await createWorkersCompatibleModule();
-
-    if (typeof TagLibWasm !== "function") {
-      throw new TagLibInitializationError(
-        "Failed to load taglib-wasm module for Workers. " +
-          "The module may not be properly bundled for the Workers environment.",
-      );
-    }
-
-    const wasmInstance = await TagLibWasm(moduleConfig);
-
-    // Ensure proper memory arrays are set up
-    if (!wasmInstance.HEAPU8) {
-      const buffer = wasmInstance.buffer || wasmInstance.wasmMemory?.buffer;
-      if (buffer) {
-        wasmInstance.HEAPU8 = new Uint8Array(buffer);
-        wasmInstance.HEAP8 = new Int8Array(buffer);
-        wasmInstance.HEAP16 = new Int16Array(buffer);
-        wasmInstance.HEAP32 = new Int32Array(buffer);
-        wasmInstance.HEAPU16 = new Uint16Array(buffer);
-        wasmInstance.HEAPU32 = new Uint32Array(buffer);
-        wasmInstance.HEAPF32 = new Float32Array(buffer);
-        wasmInstance.HEAPF64 = new Float64Array(buffer);
-      }
-    }
-
-    return wasmInstance as TagLibModule;
-  } catch (error) {
-    if (error instanceof TagLibInitializationError) {
-      throw error;
-    }
-    throw new TagLibInitializationError(
-      `Failed to load taglib-wasm for Workers: ${(error as Error).message}`,
-      { error: (error as Error).message },
-    );
-  }
-}
-
-/**
- * Create a Workers-compatible version of the Emscripten module
- * This function loads the Wasm module without Node.js/CommonJS dependencies
- */
-async function createWorkersCompatibleModule(): Promise<any> {
-  // In a real Workers environment, you would typically:
-  // 1. Use a build process to create a Workers-compatible version of taglib.js
-  // 2. Or inline the essential parts of the Emscripten runtime here
-  // 3. Or use dynamic import with proper bundling
-
-  // For now, we'll attempt to load the existing module with Workers compatibility
-  try {
-    // Try to import the existing module
-    const wasmModule = await import("../build/taglib-wrapper.js");
-    return wasmModule.default || wasmModule;
-  } catch (error) {
-    // If that fails, provide a fallback implementation
-    throw new TagLibInitializationError(
-      "Workers-compatible Wasm module not available. " +
-        "Please build with Workers target or use a bundler that supports Wasm modules. " +
-        `Original error: ${(error as Error).message}`,
-      { error: (error as Error).message },
-    );
-  }
-}
-
-/**
- * Convert a C string pointer to JavaScript string (Workers-compatible)
- */
-export function cStringToJS(module: TagLibModule, ptr: number): string {
-  if (ptr === 0) return "";
-
-  const view = new Uint8Array(module.HEAPU8.buffer, ptr);
-  let length = 0;
-  while (view[length] !== 0) length++;
-
-  return new TextDecoder().decode(view.subarray(0, length));
-}
-
-/**
- * Convert JavaScript string to C string (Workers-compatible)
- */
-export function jsToCString(module: TagLibModule, str: string): number {
-  const encoder = new TextEncoder();
-  const bytes = encoder.encode(str + "\0");
-
-  // Use allocate if available, otherwise use _malloc
-  if (module.allocate && module.ALLOC_NORMAL !== undefined) {
-    return module.allocate(bytes, module.ALLOC_NORMAL);
-  } else {
-    const ptr = module._malloc(bytes.length);
-    module.HEAPU8.set(bytes, ptr);
-    return ptr;
-  }
-}
-
-/**
- * Utility function to check if we're running in Cloudflare Workers
- */
-export function isCloudflareWorkers(): boolean {
-  return (
-    typeof globalThis !== "undefined" &&
-    typeof globalThis.caches !== "undefined" &&
-    typeof globalThis.Request !== "undefined" &&
-    typeof globalThis.Response !== "undefined" &&
-    typeof (globalThis as any).process === "undefined" &&
-    typeof (globalThis as any).Deno === "undefined"
-  );
-}

package/dist/src/wasm.ts

@@ -1,133 +0,0 @@
-/**
- * @fileoverview WebAssembly module interface types for Emscripten
- */
-
-// Basic Emscripten module interface
-export interface EmscriptenModule {
-  // Memory
-  HEAP8: Int8Array;
-  HEAP16: Int16Array;
-  HEAP32: Int32Array;
-  HEAPU8: Uint8Array;
-  HEAPU16: Uint16Array;
-  HEAPU32: Uint32Array;
-  HEAPF32: Float32Array;
-  HEAPF64: Float64Array;
-
-  // Memory management
-  _malloc(size: number): number;
-  _free(ptr: number): void;
-  allocate?(data: number[] | Uint8Array, allocator: number): number;
-  ALLOC_NORMAL?: number;
-
-  // String conversion
-  ccall?(
-    ident: string,
-    returnType: string,
-    argTypes: string[],
-    args: any[],
-  ): any;
-  cwrap?(
-    ident: string,
-    returnType: string,
-    argTypes: string[],
-  ): (...args: any[]) => any;
-
-  // File system (if enabled)
-  FS?: any;
-
-  // Runtime
-  then?(callback: (module: EmscriptenModule) => void): void;
-  onRuntimeInitialized?: () => void;
-}
-
-// Embind class interfaces
-export interface FileHandle {
-  loadFromBuffer(data: Uint8Array): boolean;
-  isValid(): boolean;
-  save(): boolean;
-  getFormat(): string;
-  getProperties(): any;
-  setProperties(props: any): void;
-  getProperty(key: string): string;
-  setProperty(key: string, value: string): void;
-  isMP4(): boolean;
-  getMP4Item(key: string): string;
-  setMP4Item(key: string, value: string): void;
-  removeMP4Item(key: string): void;
-  getTag(): TagWrapper;
-  getAudioProperties(): AudioPropertiesWrapper;
-}
-
-export interface TagWrapper {
-  title(): string;
-  artist(): string;
-  album(): string;
-  comment(): string;
-  genre(): string;
-  year(): number;
-  track(): number;
-  setTitle(value: string): void;
-  setArtist(value: string): void;
-  setAlbum(value: string): void;
-  setComment(value: string): void;
-  setGenre(value: string): void;
-  setYear(value: number): void;
-  setTrack(value: number): void;
-}
-
-export interface AudioPropertiesWrapper {
-  lengthInSeconds(): number;
-  lengthInMilliseconds(): number;
-  bitrate(): number;
-  sampleRate(): number;
-  channels(): number;
-}
-
-export interface TagLibModule extends Omit<EmscriptenModule, "then"> {
-  // Embind classes
-  FileHandle: new () => FileHandle;
-  TagWrapper: new () => TagWrapper;
-  AudioPropertiesWrapper: new () => AudioPropertiesWrapper;
-
-  // Embind functions
-  createFileHandle(): FileHandle;
-
-  // C-style functions (optional - used by Workers API)
-  _taglib_file_new_from_buffer?(ptr: number, size: number): number;
-  _taglib_file_delete?(fileId: number): void;
-  _taglib_file_is_valid?(fileId: number): number;
-  _taglib_file_format?(fileId: number): number;
-  _taglib_file_tag?(fileId: number): number;
-  _taglib_file_audioproperties?(fileId: number): number;
-  _taglib_file_save?(fileId: number): number;
-
-  _taglib_tag_title?(tagPtr: number): number;
-  _taglib_tag_artist?(tagPtr: number): number;
-  _taglib_tag_album?(tagPtr: number): number;
-  _taglib_tag_comment?(tagPtr: number): number;
-  _taglib_tag_genre?(tagPtr: number): number;
-  _taglib_tag_year?(tagPtr: number): number;
-  _taglib_tag_track?(tagPtr: number): number;
-
-  _taglib_tag_set_title?(tagPtr: number, titlePtr: number): void;
-  _taglib_tag_set_artist?(tagPtr: number, artistPtr: number): void;
-  _taglib_tag_set_album?(tagPtr: number, albumPtr: number): void;
-  _taglib_tag_set_comment?(tagPtr: number, commentPtr: number): void;
-  _taglib_tag_set_genre?(tagPtr: number, genrePtr: number): void;
-  _taglib_tag_set_year?(tagPtr: number, year: number): void;
-  _taglib_tag_set_track?(tagPtr: number, track: number): void;
-
-  _taglib_audioproperties_length?(propsPtr: number): number;
-  _taglib_audioproperties_bitrate?(propsPtr: number): number;
-  _taglib_audioproperties_samplerate?(propsPtr: number): number;
-  _taglib_audioproperties_channels?(propsPtr: number): number;
-}
-
-export interface WasmModule extends EmscriptenModule {
-  // Alias for compatibility
-  FileHandle?: new () => FileHandle;
-  createFileHandle?(): FileHandle;
-}
-
-// Module loading function removed for modular imports

package/dist/src/web-utils.ts

@@ -1,347 +0,0 @@
-/**
- * @fileoverview Web browser utilities for working with cover art in taglib-wasm
- *
- * This module provides browser-specific helpers for integrating taglib-wasm
- * with web applications, including canvas integration and data URL support.
- *
- * @example
- * ```typescript
- * import { pictureToDataURL, setCoverArtFromCanvas } from "taglib-wasm/web-utils";
- *
- * // Display cover art in an <img> element
- * const pictures = await readPictures("song.mp3");
- * if (pictures.length > 0) {
- *   const dataURL = pictureToDataURL(pictures[0]);
- *   document.getElementById('cover').src = dataURL;
- * }
- *
- * // Set cover art from a canvas
- * const canvas = document.getElementById('myCanvas') as HTMLCanvasElement;
- * const modifiedBuffer = await setCoverArtFromCanvas("song.mp3", canvas);
- * ```
- */
-
-import type { Picture } from "./types.ts";
-import { PictureType } from "./types.ts";
-import { applyPictures, readPictures } from "./simple.ts";
-
-/**
- * Convert a Picture object to a data URL for display in web browsers
- *
- * @param picture - Picture object from taglib-wasm
- * @returns Data URL string that can be used as src for <img> elements
- *
- * @example
- * ```typescript
- * const pictures = await readPictures("song.mp3");
- * const imgElement = document.getElementById('coverArt') as HTMLImageElement;
- * imgElement.src = pictureToDataURL(pictures[0]);
- * ```
- */
-export function pictureToDataURL(picture: Picture): string {
-  // Convert Uint8Array to base64
-  const base64 = btoa(String.fromCharCode(...picture.data));
-  return `data:${picture.mimeType};base64,${base64}`;
-}
-
-/**
- * Convert a data URL to a Picture object
- *
- * @param dataURL - Data URL string (e.g., "data:image/jpeg;base64,...")
- * @param type - Picture type (defaults to FrontCover)
- * @param description - Optional description
- * @returns Picture object
- *
- * @example
- * ```typescript
- * const dataURL = canvas.toDataURL('image/jpeg');
- * const picture = dataURLToPicture(dataURL, PictureType.FrontCover);
- * const modifiedBuffer = await applyPictures("song.mp3", [picture]);
- * ```
- */
-export function dataURLToPicture(
-  dataURL: string,
-  type: PictureType = PictureType.FrontCover,
-  description?: string,
-): Picture {
-  // Parse data URL
-  const matches = dataURL.match(/^data:([^;]+);base64,(.+)$/);
-  if (!matches) {
-    throw new Error("Invalid data URL format");
-  }
-
-  const [, mimeType, base64] = matches;
-
-  // Convert base64 to Uint8Array
-  const binaryString = atob(base64);
-  const data = new Uint8Array(binaryString.length);
-  for (let i = 0; i < binaryString.length; i++) {
-    data[i] = binaryString.charCodeAt(i);
-  }
-
-  return {
-    mimeType,
-    data,
-    type,
-    description,
-  };
-}
-
-/**
- * Set cover art from an HTML canvas element
- *
- * @param file - File path, Uint8Array buffer, ArrayBuffer, or File object
- * @param canvas - HTMLCanvasElement containing the image
- * @param options - Options for image format and quality
- * @returns Modified file buffer with cover art from canvas
- *
- * @example
- * ```typescript
- * const canvas = document.getElementById('albumArt') as HTMLCanvasElement;
- * const modifiedBuffer = await setCoverArtFromCanvas("song.mp3", canvas, {
- *   format: 'image/jpeg',
- *   quality: 0.9
- * });
- * ```
- */
-export async function setCoverArtFromCanvas(
-  file: string | Uint8Array | ArrayBuffer | File,
-  canvas: HTMLCanvasElement,
-  options: {
-    format?: "image/jpeg" | "image/png" | "image/webp";
-    quality?: number;
-    type?: PictureType;
-    description?: string;
-  } = {},
-): Promise<Uint8Array> {
-  const {
-    format = "image/jpeg",
-    quality = 0.92,
-    type = PictureType.FrontCover,
-    description = "Front Cover",
-  } = options;
-
-  // Convert canvas to data URL
-  const dataURL = canvas.toDataURL(format, quality);
-
-  // Convert to Picture object
-  const picture = dataURLToPicture(dataURL, type, description);
-
-  // Apply to file
-  return applyPictures(file, [picture]);
-}
-
-/**
- * Convert canvas to Picture object using blob for better performance
- *
- * This is more efficient than toDataURL for large images as it avoids
- * the base64 encoding/decoding step.
- *
- * @param canvas - HTMLCanvasElement containing the image
- * @param options - Options for image format and quality
- * @returns Promise resolving to Picture object
- *
- * @example
- * ```typescript
- * const canvas = document.getElementById('albumArt') as HTMLCanvasElement;
- * const picture = await canvasToPicture(canvas, {
- *   format: 'image/png',
- *   type: PictureType.BackCover
- * });
- * ```
- */
-export async function canvasToPicture(
-  canvas: HTMLCanvasElement,
-  options: {
-    format?: "image/jpeg" | "image/png" | "image/webp";
-    quality?: number;
-    type?: PictureType;
-    description?: string;
-  } = {},
-): Promise<Picture> {
-  const {
-    format = "image/jpeg",
-    quality = 0.92,
-    type = PictureType.FrontCover,
-    description,
-  } = options;
-
-  return new Promise((resolve, reject) => {
-    canvas.toBlob(
-      async (blob) => {
-        if (!blob) {
-          reject(new Error("Failed to convert canvas to blob"));
-          return;
-        }
-
-        // Convert blob to Uint8Array
-        const arrayBuffer = await blob.arrayBuffer();
-        const data = new Uint8Array(arrayBuffer);
-
-        resolve({
-          mimeType: format,
-          data,
-          type,
-          description,
-        });
-      },
-      format,
-      quality,
-    );
-  });
-}
-
-/**
- * Load an image file into a Picture object
- *
- * @param file - File object from <input type="file"> or drag-and-drop
- * @param type - Picture type (defaults to FrontCover)
- * @param description - Optional description
- * @returns Promise resolving to Picture object
- *
- * @example
- * ```typescript
- * // From file input
- * const input = document.getElementById('fileInput') as HTMLInputElement;
- * input.addEventListener('change', async (e) => {
- *   const file = e.target.files[0];
- *   const picture = await imageFileToPicture(file);
- *   const modifiedBuffer = await applyPictures("song.mp3", [picture]);
- * });
- * ```
- */
-export async function imageFileToPicture(
-  file: File,
-  type: PictureType = PictureType.FrontCover,
-  description?: string,
-): Promise<Picture> {
-  const arrayBuffer = await file.arrayBuffer();
-  const data = new Uint8Array(arrayBuffer);
-
-  return {
-    mimeType: file.type,
-    data,
-    type,
-    description: description || file.name,
-  };
-}
-
-/**
- * Display a Picture in an HTML img element
- *
- * @param picture - Picture object from taglib-wasm
- * @param imgElement - HTMLImageElement to display the picture in
- *
- * @example
- * ```typescript
- * const pictures = await readPictures("song.mp3");
- * const img = document.getElementById('coverArt') as HTMLImageElement;
- * displayPicture(pictures[0], img);
- * ```
- */
-export function displayPicture(
-  picture: Picture,
-  imgElement: HTMLImageElement,
-): void {
-  // Clean up previous object URL if any
-  if (imgElement.src.startsWith("blob:")) {
-    URL.revokeObjectURL(imgElement.src);
-  }
-
-  // Create blob and object URL
-  const blob = new Blob([picture.data], { type: picture.mimeType });
-  const objectURL = URL.createObjectURL(blob);
-
-  // Set the src
-  imgElement.src = objectURL;
-
-  // Clean up object URL when image is no longer needed
-  imgElement.addEventListener("load", () => {
-    // Keep the URL alive for a bit to ensure image is rendered
-    setTimeout(() => URL.revokeObjectURL(objectURL), 100);
-  }, { once: true });
-}
-
-/**
- * Create a download link for a Picture
- *
- * @param picture - Picture object to download
- * @param filename - Suggested filename for download
- * @returns Temporary download URL (remember to revoke it after use)
- *
- * @example
- * ```typescript
- * const pictures = await readPictures("song.mp3");
- * const downloadUrl = createPictureDownloadURL(pictures[0], "cover.jpg");
- *
- * const link = document.createElement('a');
- * link.href = downloadUrl;
- * link.download = "cover.jpg";
- * link.click();
- *
- * // Clean up
- * URL.revokeObjectURL(downloadUrl);
- * ```
- */
-export function createPictureDownloadURL(
-  picture: Picture,
-  filename: string = "cover",
-): string {
-  const blob = new Blob([picture.data], { type: picture.mimeType });
-  return URL.createObjectURL(blob);
-}
-
-/**
- * Extract all pictures and create a gallery
- *
- * @param file - Audio file to extract pictures from
- * @param container - HTML element to append gallery items to
- * @param options - Gallery display options
- *
- * @example
- * ```typescript
- * const galleryDiv = document.getElementById('pictureGallery');
- * await createPictureGallery("song.mp3", galleryDiv, {
- *   className: 'album-art',
- *   includeDescription: true
- * });
- * ```
- */
-export async function createPictureGallery(
-  file: string | Uint8Array | ArrayBuffer | File,
-  container: HTMLElement,
-  options: {
-    className?: string;
-    includeDescription?: boolean;
-    onClick?: (picture: Picture, index: number) => void;
-  } = {},
-): Promise<void> {
-  const pictures = await readPictures(file);
-
-  // Clear container
-  container.innerHTML = "";
-
-  pictures.forEach((picture, index) => {
-    const wrapper = document.createElement("div");
-    wrapper.className = options.className || "picture-item";
-
-    const img = document.createElement("img");
-    displayPicture(picture, img);
-    img.alt = picture.description || `Picture ${index + 1}`;
-
-    if (options.onClick) {
-      img.style.cursor = "pointer";
-      img.addEventListener("click", () => options.onClick!(picture, index));
-    }
-
-    wrapper.appendChild(img);
-
-    if (options.includeDescription && picture.description) {
-      const caption = document.createElement("p");
-      caption.textContent = picture.description;
-      wrapper.appendChild(caption);
-    }
-
-    container.appendChild(wrapper);
-  });
-}