taglib-wasm 0.2.7 → 0.3.1

package/src/enhanced-api.ts

@@ -1,296 +0,0 @@
-/**
- * Enhanced API patterns inspired by node-taglib
- *
- * This file demonstrates potential API improvements that could be added
- * to taglib-wasm to improve developer experience.
- */
-
-import type { AudioFile, TagLibConfig } from "./types";
-
-/**
- * Enhanced error handling with error codes
- */
-export interface TagLibError extends Error {
-  code:
-    | "FILE_NOT_FOUND"
-    | "INVALID_FORMAT"
-    | "MEMORY_ERROR"
-    | "PERMISSION_DENIED"
-    | "WASM_ERROR";
-  path?: string;
-  format?: string;
-  details?: string;
-}
-
-/**
- * Callback-style async operations (Node.js pattern)
- */
-export type TagLibCallback<T> = (err: TagLibError | null, result?: T) => void;
-
-/**
- * Enhanced input types
- */
-export type AudioInput =
-  | string // File path (Node.js/Deno/Bun only)
-  | Uint8Array // Raw bytes
-  | ArrayBuffer // ArrayBuffer
-  | Buffer // Node.js Buffer
-  | File; // Browser File object
-
-/**
- * Enhanced TagLib class with multiple API patterns
- */
-export class EnhancedTagLib {
-  /**
-   * Synchronous initialization (for server environments)
-   */
-  static initializeSync(config?: TagLibConfig): EnhancedTagLib {
-    // Implementation would be synchronous version
-    throw new Error("Not implemented");
-  }
-
-  /**
-   * Asynchronous initialization (current pattern)
-   */
-  static async initialize(config?: TagLibConfig): Promise<EnhancedTagLib> {
-    // Current implementation
-    throw new Error("Not implemented");
-  }
-
-  /**
-   * Open file with flexible input types
-   */
-  openFile(input: AudioInput): EnhancedAudioFile {
-    if (typeof input === "string") {
-      return this.openFileFromPath(input);
-    } else if (input instanceof File) {
-      return this.openFileFromBrowserFile(input);
-    } else if (input instanceof ArrayBuffer) {
-      return this.openFileFromBuffer(new Uint8Array(input));
-    } else if (Buffer && Buffer.isBuffer(input)) {
-      return this.openFileFromBuffer(new Uint8Array(input));
-    } else {
-      return this.openFileFromBuffer(input);
-    }
-  }
-
-  /**
-   * Async file opening with callback pattern
-   */
-  openFileAsync(
-    input: AudioInput,
-    callback: TagLibCallback<EnhancedAudioFile>,
-  ): void {
-    try {
-      const file = this.openFile(input);
-      callback(null, file);
-    } catch (error) {
-      const tagLibError: TagLibError = {
-        name: "TagLibError",
-        message: (error as Error).message,
-        code: "INVALID_FORMAT",
-        details: (error as Error).stack,
-      };
-      callback(tagLibError);
-    }
-  }
-
-  /**
-   * Sync file opening (Node.js/Bun/Deno only)
-   */
-  openFileSync(path: string): EnhancedAudioFile {
-    // Runtime-specific implementation
-    if (typeof (globalThis as any).Deno !== "undefined") {
-      const data = (globalThis as any).Deno.readFileSync(path);
-      return this.openFileFromBuffer(data);
-    } else if (typeof (globalThis as any).Bun !== "undefined") {
-      const file = (globalThis as any).Bun.file(path);
-      const data = new Uint8Array(file.arrayBufferSync());
-      return this.openFileFromBuffer(data);
-    } else if (typeof require !== "undefined") {
-      const fs = require("fs");
-      const data = fs.readFileSync(path);
-      return this.openFileFromBuffer(new Uint8Array(data));
-    } else {
-      throw new Error(
-        "Synchronous file reading not supported in browser environment",
-      );
-    }
-  }
-
-  private openFileFromPath(path: string): EnhancedAudioFile {
-    throw new Error("Not implemented");
-  }
-
-  private openFileFromBrowserFile(file: File): EnhancedAudioFile {
-    throw new Error("Not implemented - requires async operation");
-  }
-
-  private openFileFromBuffer(buffer: Uint8Array): EnhancedAudioFile {
-    throw new Error("Not implemented");
-  }
-}
-
-/**
- * Enhanced AudioFile with property accessors and better error handling
- */
-export class EnhancedAudioFile {
-  // Property accessors (more intuitive than method calls)
-  get title(): string | undefined {
-    return this.tag().title;
-  }
-
-  set title(value: string | undefined) {
-    if (value !== undefined) {
-      this.setTitle(value);
-    }
-  }
-
-  get artist(): string | undefined {
-    return this.tag().artist;
-  }
-
-  set artist(value: string | undefined) {
-    if (value !== undefined) {
-      this.setArtist(value);
-    }
-  }
-
-  get album(): string | undefined {
-    return this.tag().album;
-  }
-
-  set album(value: string | undefined) {
-    if (value !== undefined) {
-      this.setAlbum(value);
-    }
-  }
-
-  // Async operations with callbacks
-  tagAsync(callback: TagLibCallback<any>): void {
-    try {
-      const tags = this.tag();
-      callback(null, tags);
-    } catch (error) {
-      const tagLibError: TagLibError = {
-        name: "TagLibError",
-        message: (error as Error).message,
-        code: "MEMORY_ERROR",
-      };
-      callback(tagLibError);
-    }
-  }
-
-  saveAsync(callback: TagLibCallback<boolean>): void {
-    try {
-      const result = this.save();
-      callback(null, result);
-    } catch (error) {
-      const tagLibError: TagLibError = {
-        name: "TagLibError",
-        message: (error as Error).message,
-        code: "PERMISSION_DENIED",
-      };
-      callback(tagLibError);
-    }
-  }
-
-  // Bulk tag setting (convenience method)
-  setTags(tags: {
-    title?: string;
-    artist?: string;
-    album?: string;
-    year?: number;
-    genre?: string;
-    track?: number;
-    comment?: string;
-  }): void {
-    Object.entries(tags).forEach(([key, value]) => {
-      if (value !== undefined) {
-        (this as any)[key] = value;
-      }
-    });
-  }
-
-  // Enhanced error handling for save operations
-  saveWithValidation(): { success: boolean; errors: TagLibError[] } {
-    const errors: TagLibError[] = [];
-
-    try {
-      // Validate before saving
-      if (!this.isValid()) {
-        errors.push({
-          name: "TagLibError",
-          message: "File is not valid for writing",
-          code: "INVALID_FORMAT",
-        });
-      }
-
-      const success = this.save();
-      return { success, errors };
-    } catch (error) {
-      errors.push({
-        name: "TagLibError",
-        message: (error as Error).message,
-        code: "PERMISSION_DENIED",
-      });
-      return { success: false, errors };
-    }
-  }
-
-  // Method stubs (would delegate to existing implementation)
-  private tag(): any {
-    throw new Error("Not implemented");
-  }
-  private setTitle(title: string): void {
-    throw new Error("Not implemented");
-  }
-  private setArtist(artist: string): void {
-    throw new Error("Not implemented");
-  }
-  private setAlbum(album: string): void {
-    throw new Error("Not implemented");
-  }
-  private save(): boolean {
-    throw new Error("Not implemented");
-  }
-  private isValid(): boolean {
-    throw new Error("Not implemented");
-  }
-}
-
-/**
- * Usage examples demonstrating enhanced API
- */
-export function demonstrateEnhancedAPI() {
-  // Example 1: Property-based access
-  const file = new EnhancedAudioFile();
-  file.title = "New Song";
-  file.artist = "New Artist";
-  console.log(`${file.artist} - ${file.title}`);
-
-  // Example 2: Bulk tag setting
-  file.setTags({
-    title: "Song Title",
-    artist: "Artist Name",
-    album: "Album Name",
-    year: 2024,
-  });
-
-  // Example 3: Enhanced error handling
-  const result = file.saveWithValidation();
-  if (!result.success) {
-    result.errors.forEach((error) => {
-      console.error(`Error ${error.code}: ${error.message}`);
-    });
-  }
-
-  // Example 4: Callback-style async operations
-  file.tagAsync((err, tags) => {
-    if (err) {
-      console.error(`Failed to read tags: ${err.message}`);
-      return;
-    }
-    console.log("Tags:", tags);
-  });
-}

package/src/simple-jsr.ts

@@ -1,201 +0,0 @@
-/**
- * @fileoverview JSR-compatible simple API (uses taglib-jsr.ts instead of taglib.ts)
- */
-
-import { TagLib } from "./taglib-jsr.ts";
-import type { AudioProperties, Tag } from "./types.ts";
-
-// Cached TagLib instance for auto-initialization
-let cachedTagLib: TagLib | null = null;
-
-/**
- * Get or create a TagLib instance with auto-initialization
- */
-async function getTagLib(): Promise<TagLib> {
-  if (!cachedTagLib) {
-    cachedTagLib = await TagLib.initialize({
-      debug: false,
-      memory: {
-        initial: 16 * 1024 * 1024, // 16MB default
-        maximum: 64 * 1024 * 1024, // 64MB max
-      },
-    });
-  }
-  return cachedTagLib;
-}
-
-/**
- * Read a file's data from various sources
- */
-async function readFileData(file: string | Uint8Array | ArrayBuffer | File): Promise<Uint8Array> {
-  // Already a Uint8Array
-  if (file instanceof Uint8Array) {
-    return file;
-  }
-  
-  // ArrayBuffer - convert to Uint8Array
-  if (file instanceof ArrayBuffer) {
-    return new Uint8Array(file);
-  }
-  
-  // File object (browser)
-  if (typeof File !== 'undefined' && file instanceof File) {
-    return new Uint8Array(await file.arrayBuffer());
-  }
-  
-  // String path - read from filesystem
-  if (typeof file === 'string') {
-    // Deno
-    if (typeof Deno !== 'undefined') {
-      return await Deno.readFile(file);
-    }
-    
-    throw new Error('File path reading not supported in this environment');
-  }
-  
-  throw new Error('Invalid file input type');
-}
-
-/**
- * Read metadata tags from an audio file
- */
-export async function readTags(file: string | Uint8Array | ArrayBuffer | File): Promise<Tag> {
-  const taglib = await getTagLib();
-  const audioData = await readFileData(file);
-  
-  const audioFile = taglib.openFile(audioData);
-  try {
-    if (!audioFile.isValid()) {
-      throw new Error('Invalid audio file');
-    }
-    
-    return audioFile.tag();
-  } finally {
-    audioFile.dispose();
-  }
-}
-
-/**
- * Write metadata tags to an audio file
- */
-export async function writeTags(
-  file: string | Uint8Array | ArrayBuffer | File, 
-  tags: Partial<Tag>, 
-  options?: number
-): Promise<Uint8Array> {
-  const taglib = await getTagLib();
-  const audioData = await readFileData(file);
-  
-  const audioFile = taglib.openFile(audioData);
-  try {
-    if (!audioFile.isValid()) {
-      throw new Error('Invalid audio file');
-    }
-    
-    // Write each tag if defined
-    if (tags.title !== undefined) audioFile.setTitle(tags.title);
-    if (tags.artist !== undefined) audioFile.setArtist(tags.artist);
-    if (tags.album !== undefined) audioFile.setAlbum(tags.album);
-    if (tags.comment !== undefined) audioFile.setComment(tags.comment);
-    if (tags.genre !== undefined) audioFile.setGenre(tags.genre);
-    if (tags.year !== undefined) audioFile.setYear(tags.year);
-    if (tags.track !== undefined) audioFile.setTrack(tags.track);
-    
-    // Save changes to in-memory buffer
-    if (!audioFile.save()) {
-      throw new Error('Failed to save changes');
-    }
-    
-    return audioData;
-  } finally {
-    audioFile.dispose();
-  }
-}
-
-/**
- * Read audio properties from a file
- */
-export async function readProperties(file: string | Uint8Array | ArrayBuffer | File): Promise<AudioProperties> {
-  const taglib = await getTagLib();
-  const audioData = await readFileData(file);
-  
-  const audioFile = taglib.openFile(audioData);
-  try {
-    if (!audioFile.isValid()) {
-      throw new Error('Invalid audio file');
-    }
-    
-    return audioFile.audioProperties();
-  } finally {
-    audioFile.dispose();
-  }
-}
-
-/**
- * Tag field constants for go-taglib compatibility
- */
-export const Title = "title";
-export const Artist = "artist";
-export const Album = "album";
-export const Comment = "comment";
-export const Genre = "genre";
-export const Year = "year";
-export const Track = "track";
-export const AlbumArtist = "albumartist";
-export const Composer = "composer";
-export const DiscNumber = "discnumber";
-
-/**
- * Check if a file is a valid audio file
- */
-export async function isValidAudioFile(file: string | Uint8Array | ArrayBuffer | File): Promise<boolean> {
-  try {
-    const taglib = await getTagLib();
-    const audioData = await readFileData(file);
-    
-    const audioFile = taglib.openFile(audioData);
-    const valid = audioFile.isValid();
-    audioFile.dispose();
-    
-    return valid;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Get the audio format of a file
- */
-export async function getFormat(file: string | Uint8Array | ArrayBuffer | File): Promise<string | undefined> {
-  const taglib = await getTagLib();
-  const audioData = await readFileData(file);
-  
-  const audioFile = taglib.openFile(audioData);
-  try {
-    if (!audioFile.isValid()) {
-      return undefined;
-    }
-    
-    return audioFile.format();
-  } finally {
-    audioFile.dispose();
-  }
-}
-
-/**
- * Clear all tags from a file
- */
-export async function clearTags(file: string | Uint8Array | ArrayBuffer | File): Promise<Uint8Array> {
-  return writeTags(file, {
-    title: "",
-    artist: "",
-    album: "",
-    comment: "",
-    genre: "",
-    year: 0,
-    track: 0,
-  });
-}
-
-// Type exports for convenience
-export type { Tag, AudioProperties } from "./types.ts";

package/src/taglib-embind.ts

@@ -1,231 +0,0 @@
-import type { TagLibModule, WasmModule } from "./wasm-embind.ts";
-import type { AudioFile as AudioFileInterface, AudioProperties, FileType, PropertyMap, Tag } from "./types.ts";
-
-/**
- * Audio file wrapper using Embind API
- */
-export class AudioFile implements AudioFileInterface {
-  private fileHandle: any;
-  private cachedTag: Tag | null = null;
-  private cachedAudioProperties: AudioProperties | null = null;
-
-  constructor(
-    private module: TagLibModule,
-    fileHandle: any,
-  ) {
-    this.fileHandle = fileHandle;
-  }
-
-  /**
-   * Get file format
-   */
-  getFormat(): FileType {
-    return this.fileHandle.getFormat() as FileType;
-  }
-
-  /**
-   * Get tag object for reading/writing metadata
-   */
-  tag(): Tag {
-    if (!this.cachedTag) {
-      const tagWrapper = this.fileHandle.getTag();
-      if (!tagWrapper) {
-        throw new Error("Failed to get tag from file");
-      }
-      
-      this.cachedTag = {
-        title: () => tagWrapper.title(),
-        artist: () => tagWrapper.artist(),
-        album: () => tagWrapper.album(),
-        comment: () => tagWrapper.comment(),
-        genre: () => tagWrapper.genre(),
-        year: () => tagWrapper.year(),
-        track: () => tagWrapper.track(),
-        
-        setTitle: (value: string) => tagWrapper.setTitle(value),
-        setArtist: (value: string) => tagWrapper.setArtist(value),
-        setAlbum: (value: string) => tagWrapper.setAlbum(value),
-        setComment: (value: string) => tagWrapper.setComment(value),
-        setGenre: (value: string) => tagWrapper.setGenre(value),
-        setYear: (value: number) => tagWrapper.setYear(value),
-        setTrack: (value: number) => tagWrapper.setTrack(value),
-      };
-    }
-    
-    return this.cachedTag;
-  }
-
-  /**
-   * Get audio properties
-   */
-  audioProperties(): AudioProperties | null {
-    if (!this.cachedAudioProperties) {
-      const propsWrapper = this.fileHandle.getAudioProperties();
-      if (!propsWrapper) {
-        return null;
-      }
-      
-      this.cachedAudioProperties = {
-        length: propsWrapper.lengthInSeconds(),
-        lengthInMilliseconds: propsWrapper.lengthInMilliseconds(),
-        bitrate: propsWrapper.bitrate(),
-        sampleRate: propsWrapper.sampleRate(),
-        channels: propsWrapper.channels(),
-      };
-    }
-    
-    return this.cachedAudioProperties;
-  }
-
-  /**
-   * Get all properties as a PropertyMap
-   */
-  properties(): PropertyMap {
-    const jsObj = this.fileHandle.getProperties();
-    const result: PropertyMap = {};
-    
-    // Convert from Emscripten val to plain object
-    const keys = Object.keys(jsObj);
-    for (const key of keys) {
-      result[key] = jsObj[key];
-    }
-    
-    return result;
-  }
-
-  /**
-   * Set properties from a PropertyMap
-   */
-  setProperties(properties: PropertyMap): void {
-    this.fileHandle.setProperties(properties);
-  }
-
-  /**
-   * Get a single property value
-   */
-  getProperty(key: string): string | undefined {
-    const value = this.fileHandle.getProperty(key);
-    return value === "" ? undefined : value;
-  }
-
-  /**
-   * Set a single property value
-   */
-  setProperty(key: string, value: string): void {
-    this.fileHandle.setProperty(key, value);
-  }
-
-  /**
-   * Check if this is an MP4 file
-   */
-  isMP4(): boolean {
-    return this.fileHandle.isMP4();
-  }
-
-  /**
-   * Get MP4-specific item
-   */
-  getMP4Item(key: string): string | undefined {
-    if (!this.isMP4()) {
-      throw new Error("Not an MP4 file");
-    }
-    const value = this.fileHandle.getMP4Item(key);
-    return value === "" ? undefined : value;
-  }
-
-  /**
-   * Set MP4-specific item
-   */
-  setMP4Item(key: string, value: string): void {
-    if (!this.isMP4()) {
-      throw new Error("Not an MP4 file");
-    }
-    this.fileHandle.setMP4Item(key, value);
-  }
-
-  /**
-   * Remove MP4-specific item
-   */
-  removeMP4Item(key: string): void {
-    if (!this.isMP4()) {
-      throw new Error("Not an MP4 file");
-    }
-    this.fileHandle.removeMP4Item(key);
-  }
-
-  /**
-   * Save changes to the file
-   */
-  save(): boolean {
-    // Clear caches since values may have changed
-    this.cachedTag = null;
-    this.cachedAudioProperties = null;
-    
-    return this.fileHandle.save();
-  }
-
-  /**
-   * Check if the file is valid
-   */
-  isValid(): boolean {
-    return this.fileHandle.isValid();
-  }
-
-  /**
-   * Free resources
-   */
-  dispose(): void {
-    if (this.fileHandle) {
-      // Embind will handle cleanup when the object goes out of scope
-      // But we can help by clearing our references
-      this.fileHandle = null;
-      this.cachedTag = null;
-      this.cachedAudioProperties = null;
-    }
-  }
-}
-
-/**
- * Main TagLib interface using Embind
- */
-export class TagLib {
-  private module: TagLibModule;
-
-  constructor(module: WasmModule) {
-    this.module = module as TagLibModule;
-  }
-
-  /**
-   * Open a file from a buffer
-   */
-  async openFile(buffer: ArrayBuffer): Promise<AudioFile> {
-    // Convert ArrayBuffer to string for Embind
-    const uint8Array = new Uint8Array(buffer);
-    const binaryString = Array.from(uint8Array, byte => String.fromCharCode(byte)).join('');
-    
-    // Create a new FileHandle
-    const fileHandle = this.module.createFileHandle();
-    
-    // Load the buffer
-    const success = fileHandle.loadFromBuffer(binaryString);
-    if (!success) {
-      throw new Error("Failed to load file from buffer");
-    }
-    
-    return new AudioFile(this.module, fileHandle);
-  }
-
-  /**
-   * Get version information
-   */
-  version(): string {
-    return "2.1.0"; // TagLib version we're using
-  }
-}
-
-/**
- * Create a TagLib instance
- */
-export async function createTagLib(module: WasmModule): Promise<TagLib> {
-  return new TagLib(module);
-}