normalizeMimeType

import normalizeMimeType from "./normalizeMimeType.ts";

function normalizeMimeType(mime: string): string

import normalizeMimeType from "./normalizeMimeType.ts";

// Normalize legacy audio MIME type
const normalized = normalizeMimeType("audio/x-wav");
console.log(normalized); // "audio/wav"

// Normalize font MIME type
const fontMime = normalizeMimeType("application/x-font-ttf");
console.log(fontMime); // "font/ttf"

// No normalization needed - returns original
const standard = normalizeMimeType("image/png");
console.log(standard); // "image/png"

import mime from "mime";
import normalizeMimeType from "./normalizeMimeType.ts";

function detectFileType(filename: string): string {
  const detectedMime = mime.getType(filename) || "application/octet-stream";
  return normalizeMimeType(detectedMime);
}

const type1 = detectFileType("song.wav");
// Even if mime library returns "audio/x-wav", we get "audio/wav"

const type2 = detectFileType("font.woff2");
// Normalizes to "font/woff2" regardless of detected variant

import mime from "mime";
import normalizeMimeType from "../normalizeMimeType.ts";
import CommonFormats from "src/CommonFormats.ts";

class FFmpegHandler implements FormatHandler {
  async init() {
    // Get MIME types from file-type library and normalize them
    const formats = await this.detectFormats();
    
    this.supportedFormats = formats.map(format => {
      const detectedMime = mime.getType(format.extension);
      const normalizedMime = normalizeMimeType(detectedMime || "");
      
      return {
        ...format,
        mime: normalizedMime
      };
    });
  }
}

import normalizeMimeType from "./normalizeMimeType.ts";

function isSameFormat(mime1: string, mime2: string): boolean {
  return normalizeMimeType(mime1) === normalizeMimeType(mime2);
}

// These are considered the same format
console.log(isSameFormat("audio/x-wav", "audio/wav")); // true
console.log(isSameFormat("audio/vnd.wave", "audio/wav")); // true

// These are different
console.log(isSameFormat("audio/wav", "audio/mp3")); // false

import normalizeMimeType from "./normalizeMimeType.ts";

function processUpload(file: File) {
  // Browser-provided MIME types can vary
  const browserMime = file.type;
  const standardMime = normalizeMimeType(browserMime);
  
  // Use standardMime for consistent format handling
  return {
    name: file.name,
    mime: standardMime,
    size: file.size
  };
}

import normalizeMimeType from "./normalizeMimeType.ts";
import type { FileFormat, FormatHandler } from "../FormatHandler.ts";

class CustomHandler implements FormatHandler {
  name = "CustomHandler";
  supportedFormats: FileFormat[] = [];
  ready = false;

  async init() {
    const inputMimes = [
      "audio/x-flac",
      "application/x-font-woff2",
      "image/x-icon"
    ];

    this.supportedFormats = inputMimes.map(mime => ({
      name: "Custom Format",
      format: "custom",
      extension: "custom",
      mime: normalizeMimeType(mime), // Normalized for consistency
      internal: "custom",
      from: true,
      to: true,
      lossless: false
    }));
    
    this.ready = true;
  }

  async doConvert(/* ... */) {
    // Implementation
  }
}

// BAD: Direct MIME comparison without normalization
if (file.type === "audio/wav") {
  // Fails if file.type is "audio/x-wav" or "audio/vnd.wave"
}

// GOOD: Normalize before comparison
if (normalizeMimeType(file.type) === "audio/wav") {
  // Works with all WAV variants
}

import normalizeMimeType from "./normalizeMimeType.ts";

// BAD: Trust external MIME types directly
function handleUpload(mimeType: string) {
  return lookupHandler(mimeType); // May fail with non-standard types
}

// GOOD: Normalize first
function handleUpload(mimeType: string) {
  const normalized = normalizeMimeType(mimeType);
  return lookupHandler(normalized);
}