mime 2.6.0

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify pkg:npm/mime@2.6.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/mime@2.6.0
Constraints:
  - executionContext: node
Required runtime conditions:
  - ecosystem: npm
  - language: javascript
  - moduleSystem: cjs
  - packageManager: npm@10.9.8
  - runtime: node@22.23.2

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:bb6191d88c4872ca4e9722e628ac9f5f30846c4b8f1f2dff2483a240aa3fd2f2","constraints":{"executionContext":"node"},"contract":["mime.getType returns the standard MIME content type for file extensions and paths","mime.getType returns null for unrecognized file extensions or extensionless paths","mime.getExtension returns the canonical file extension for a given MIME content type","mime.getExtension extracts file extensions from MIME type strings containing media parameters","mime.define allows registering and overriding custom MIME type and extension mappings","new Mime creates an isolated MIME registry with custom type definitions"],"goal":"verify pkg:npm/mime@2.6.0","kind":"HOW","packages":["pkg:npm/mime@2.6.0"],"schemaVersion":1},"contractCommand":["node","test/contract.js"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","executionContext":"node","language":"javascript","libc":"glibc","libcVersion":"2.39","moduleSystem":"cjs","os":"linux","osVersionBucket":"24","packageManager":"npm","packageManagerVersion":"10.9.8","runtime":"node","runtimeVersion":"22.23.2","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/mime@2.6.0"],"schemaVersion":1,"verifierAdapter":"node-typescript@1"}

{
  "name": "mime-sample",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "mime-sample",
      "version": "1.0.0",
      "dependencies": {
        "mime": "2.6.0"
      }
    },
    "node_modules/mime": {
      "version": "2.6.0",
      "resolved": "https://registry.npmjs.org/mime/-/mime-2.6.0.tgz",
      "integrity": "sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg==",
      "license": "MIT",
      "bin": {
        "mime": "cli.js"
      },
      "engines": {
        "node": ">=4.0.0"
      }
    }
  }
}

{
  "name": "mime-sample",
  "version": "1.0.0",
  "dependencies": {
    "mime": "2.6.0"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:npm/mime@2.6.0",
  "kind": "HOW",
  "packages": [
    "pkg:npm/mime@2.6.0"
  ],
  "constraints": {
    "executionContext": "node"
  },
  "runtimeConditions": {
    "ecosystem": "npm",
    "language": "javascript",
    "moduleSystem": "cjs",
    "packageManager": "npm@10.9.8",
    "runtime": "node@22.23.2"
  }
}

const mime = require('mime');
const Mime = require('mime/Mime');

/**
 * Gets the MIME type for a given file path or extension.
 *
 * @param {string} path - File path or extension (e.g. 'txt', 'file.html', 'dir/doc.pdf').
 * @returns {string|null} The MIME content type, or null if unrecognized.
 */
function getMimeType(path) {
  return mime.getType(path);
}

/**
 * Gets the canonical file extension for a given MIME type.
 *
 * @param {string} type - MIME type string (e.g. 'text/html', 'application/json; charset=utf-8').
 * @returns {string|null} The canonical extension (e.g. 'html', 'json'), or null if unrecognized.
 */
function getExtensionForType(type) {
  return mime.getExtension(type);
}

/**
 * Registers custom MIME type and extension mappings on the global mime instance.
 *
 * @param {Record<string, string[]>} typeMap - Map of MIME type to array of extensions.
 * @param {boolean} [force=false] - Whether to override existing mappings.
 */
function defineCustomTypes(typeMap, force = false) {
  mime.define(typeMap, force);
}

/**
 * Creates an isolated Mime registry instance with custom type mappings.
 *
 * @param {Record<string, string[]>} typeMap - Initial custom type mappings.
 * @returns {Mime} An isolated Mime registry instance.
 */
function createCustomRegistry(typeMap) {
  return new Mime(typeMap);
}

module.exports = {
  mime,
  Mime,
  getMimeType,
  getExtensionForType,
  defineCustomTypes,
  createCustomRegistry,
};

const assert = require('node:assert/strict');
const {
  mime,
  Mime,
  getMimeType,
  getExtensionForType,
  defineCustomTypes,
  createCustomRegistry,
} = require('../src/index.js');

function testGetTypeStandard() {
  // Test common extensions and full paths
  assert.strictEqual(mime.getType('txt'), 'text/plain');
  assert.strictEqual(mime.getType('html'), 'text/html');
  assert.strictEqual(mime.getType('index.html'), 'text/html');
  assert.strictEqual(mime.getType('/path/to/archive.json'), 'application/json');
  assert.strictEqual(mime.getType('images/photo.png'), 'image/png');
  assert.strictEqual(mime.getType('styles/app.css'), 'text/css');
  assert.strictEqual(mime.getType('binary.bin'), 'application/octet-stream');

  // Case insensitivity
  assert.strictEqual(mime.getType('PICTURE.PNG'), 'image/png');
  assert.strictEqual(mime.getType('DOCUMENT.PDF'), 'application/pdf');

  // Helper wrapper
  assert.strictEqual(getMimeType('data.json'), 'application/json');
}

function testGetTypeUnrecognized() {
  // Unrecognized extensions
  assert.strictEqual(mime.getType('file.unrecognized_extension_xyz123'), null);
  assert.strictEqual(mime.getType('unknownext'), null);

  // Path without extension
  assert.strictEqual(mime.getType('/path/to/noextension'), null);
  assert.strictEqual(mime.getType(''), null);

  // Helper wrapper
  assert.strictEqual(getMimeType('unknown_file.dummy'), null);
}

function testGetExtensionStandard() {
  // Standard types
  assert.strictEqual(mime.getExtension('text/html'), 'html');
  assert.strictEqual(mime.getExtension('text/plain'), 'txt');
  assert.strictEqual(mime.getExtension('application/json'), 'json');
  assert.strictEqual(mime.getExtension('image/png'), 'png');
  assert.strictEqual(mime.getExtension('image/jpeg'), 'jpeg');
  assert.strictEqual(mime.getExtension('application/pdf'), 'pdf');

  // Helper wrapper
  assert.strictEqual(getExtensionForType('application/json'), 'json');
}

function testGetExtensionWithParametersAndUnrecognized() {
  // MIME strings with parameters (e.g. charset)
  assert.strictEqual(mime.getExtension('text/html; charset=utf-8'), 'html');
  assert.strictEqual(mime.getExtension('application/json; boundary=something'), 'json');

  // Unrecognized MIME types
  assert.strictEqual(mime.getExtension('application/x-unknown-nonexistent-type'), null);
  assert.strictEqual(mime.getExtension('invalid-mime-format'), null);

  // Helper wrapper
  assert.strictEqual(getExtensionForType('text/html; charset=utf-8'), 'html');
  assert.strictEqual(getExtensionForType('unknown/type'), null);
}

function testDefineCustomTypes() {
  // Define custom type
  defineCustomTypes({ 'application/x-custom-report': ['rpt', 'report'] }, true);

  assert.strictEqual(mime.getType('document.rpt'), 'application/x-custom-report');
  assert.strictEqual(mime.getType('document.report'), 'application/x-custom-report');
  assert.strictEqual(mime.getExtension('application/x-custom-report'), 'rpt');
}

function testIsolatedMimeInstance() {
  // Create an isolated Mime instance
  const isolated = createCustomRegistry({
    'text/x-custom-format': ['cst', 'cstm'],
  });

  assert.ok(isolated instanceof Mime);
  assert.strictEqual(isolated.getType('file.cst'), 'text/x-custom-format');
  assert.strictEqual(isolated.getType('file.cstm'), 'text/x-custom-format');
  assert.strictEqual(isolated.getExtension('text/x-custom-format'), 'cst');

  // Standard types should not exist in this isolated instance without standard definitions
  assert.strictEqual(isolated.getType('file.txt'), null);
  assert.strictEqual(isolated.getType('index.html'), null);
}

function main() {
  testGetTypeStandard();
  testGetTypeUnrecognized();
  testGetExtensionStandard();
  testGetExtensionWithParametersAndUnrecognized();
  testDefineCustomTypes();
  testIsolatedMimeInstance();

  console.log('All pkg:npm/mime@2.6.0 contracts passed successfully.');
}

main();