taglib-wasm 0.2.6 → 0.2.8

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/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);
-}

package/src/wasm-embind.ts

@@ -1,55 +0,0 @@
-/**
- * WebAssembly module interface for Embind version
- */
-export interface WasmModule {
-  // Memory access
-  HEAP8: Int8Array;
-  HEAP16: Int16Array;
-  HEAP32: Int32Array;
-  HEAPU8: Uint8Array;
-  HEAPU16: Uint16Array;
-  HEAPU32: Uint32Array;
-  HEAPF32: Float32Array;
-  HEAPF64: Float64Array;
-
-  // Runtime methods
-  allocate: (size: number, type: number) => number;
-  _malloc: (size: number) => number;
-  _free: (ptr: number) => void;
-  getValue: (ptr: number, type: string) => number;
-  setValue: (ptr: number, value: number, type: string) => void;
-  UTF8ToString: (ptr: number) => string;
-  stringToUTF8: (str: string, outPtr: number, maxBytesToWrite: number) => void;
-  lengthBytesUTF8: (str: string) => number;
-
-  // Allocation types
-  ALLOC_NORMAL: number;
-  ALLOC_STACK: number;
-
-  // Embind classes (these will be available after module loads)
-  FileHandle: any;
-  TagWrapper: any;
-  AudioPropertiesWrapper: any;
-  createFileHandle: () => any;
-}
-
-/**
- * Extended module interface with our Embind classes
- */
-export interface TagLibModule extends WasmModule {
-  // These are the actual class constructors from Embind
-  FileHandle: {
-    new(): any;
-  };
-  
-  TagWrapper: {
-    new(tagPtr: number): any;
-  };
-  
-  AudioPropertiesWrapper: {
-    new(propsPtr: number): any;
-  };
-  
-  // Factory function
-  createFileHandle: () => any;
-}