taglib-wasm/dist/src/errors.js

TagLib for TypeScript platforms: Deno, Node.js, Bun, Electron, browsers, and Cloudflare Workers

const SUPPORTED_FORMATS = [
  "MP3",
  "MP4",
  "M4A",
  "FLAC",
  "OGG",
  "WAV"
];
class TagLibError extends Error {
  constructor(code, message, details) {
    super(message);
    this.code = code;
    this.details = details;
    this.name = "TagLibError";
    Object.setPrototypeOf(this, TagLibError.prototype);
  }
}
class TagLibInitializationError extends TagLibError {
  constructor(message, details) {
    super(
      "INITIALIZATION",
      createErrorMessage("Failed to initialize TagLib Wasm module", message),
      details
    );
    this.name = "TagLibInitializationError";
    Object.setPrototypeOf(this, TagLibInitializationError.prototype);
  }
}
class InvalidFormatError extends TagLibError {
  constructor(message, bufferSize, details) {
    const errorDetails = [`Invalid audio file format: ${message}`];
    if (bufferSize !== void 0) {
      errorDetails.push(`Buffer size: ${formatFileSize(bufferSize)}`);
      if (bufferSize < 1024) {
        errorDetails.push(
          "Audio files must be at least 1KB to contain valid headers."
        );
      }
    }
    super(
      "INVALID_FORMAT",
      errorDetails.join(". "),
      { ...details, bufferSize }
    );
    this.bufferSize = bufferSize;
    this.name = "InvalidFormatError";
    Object.setPrototypeOf(this, InvalidFormatError.prototype);
  }
}
class UnsupportedFormatError extends TagLibError {
  constructor(format, supportedFormats = SUPPORTED_FORMATS, details) {
    super(
      "UNSUPPORTED_FORMAT",
      `Unsupported audio format: ${format}. Supported formats: ${supportedFormats.join(", ")}`,
      { ...details, format, supportedFormats }
    );
    this.format = format;
    this.supportedFormats = supportedFormats;
    this.name = "UnsupportedFormatError";
    Object.setPrototypeOf(this, UnsupportedFormatError.prototype);
  }
}
class FileOperationError extends TagLibError {
  constructor(operation, message, path, details) {
    const errorDetails = [`Failed to ${operation} file`];
    if (path) {
      errorDetails.push(`Path: ${path}`);
    }
    errorDetails.push(message);
    super(
      "FILE_OPERATION",
      errorDetails.join(". "),
      { ...details, operation, path }
    );
    this.operation = operation;
    this.path = path;
    this.name = "FileOperationError";
    Object.setPrototypeOf(this, FileOperationError.prototype);
  }
}
class MetadataError extends TagLibError {
  constructor(operation, message, field, details) {
    const errorDetails = [`Failed to ${operation} metadata`];
    if (field) {
      errorDetails.push(`Field: ${field}`);
    }
    errorDetails.push(message);
    super(
      "METADATA",
      errorDetails.join(". "),
      { ...details, operation, field }
    );
    this.operation = operation;
    this.field = field;
    this.name = "MetadataError";
    Object.setPrototypeOf(this, MetadataError.prototype);
  }
}
class MemoryError extends TagLibError {
  constructor(message, details) {
    super(
      "MEMORY",
      createErrorMessage("Memory allocation failed", message),
      details
    );
    this.name = "MemoryError";
    Object.setPrototypeOf(this, MemoryError.prototype);
  }
}
class EnvironmentError extends TagLibError {
  constructor(environment, reason, requiredFeature) {
    const message = requiredFeature ? `Environment '${environment}' ${reason}. Required feature: ${requiredFeature}.` : `Environment '${environment}' ${reason}.`;
    super("ENVIRONMENT", message);
    this.environment = environment;
    this.reason = reason;
    this.requiredFeature = requiredFeature;
    this.name = "EnvironmentError";
    Object.setPrototypeOf(this, EnvironmentError.prototype);
  }
}
class WorkerError extends TagLibError {
  constructor(message, details) {
    super("WORKER", message, details);
    this.name = "WorkerError";
    Object.setPrototypeOf(this, WorkerError.prototype);
  }
}
function createErrorMessage(prefix, details) {
  return `${prefix}: ${details}`;
}
function formatFileSize(bytes) {
  if (bytes < 1024) return `${bytes} bytes`;
  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
}
function isTagLibError(error) {
  return error instanceof TagLibError;
}
function isInvalidFormatError(error) {
  return error instanceof InvalidFormatError;
}
function isUnsupportedFormatError(error) {
  return error instanceof UnsupportedFormatError;
}
function isFileOperationError(error) {
  return error instanceof FileOperationError;
}
function isMetadataError(error) {
  return error instanceof MetadataError;
}
function isMemoryError(error) {
  return error instanceof MemoryError;
}
function isEnvironmentError(error) {
  return error instanceof EnvironmentError;
}
export {
  EnvironmentError,
  FileOperationError,
  InvalidFormatError,
  MemoryError,
  MetadataError,
  SUPPORTED_FORMATS,
  TagLibError,
  TagLibInitializationError,
  UnsupportedFormatError,
  WorkerError,
  isEnvironmentError,
  isFileOperationError,
  isInvalidFormatError,
  isMemoryError,
  isMetadataError,
  isTagLibError,
  isUnsupportedFormatError
};