Convert Figma logo to code with AI

jshttp logomime-types

The ultimate javascript content-type utility.

1,314
128
1,314
10

Top Related Projects

2,161

Mime types for JavaScript

1,090

Media Type Database

Detect the file type of a file, stream, or data

Quick Overview

mime-types is a JavaScript library for working with MIME types. It provides a comprehensive database of MIME types and utilities for parsing, matching, and manipulating MIME type strings. This library is widely used in Node.js applications for handling content types in HTTP requests and responses.

Pros

  • Extensive database of MIME types
  • Easy-to-use API for working with MIME types
  • Regularly updated to include new MIME types
  • Lightweight and has no dependencies

Cons

  • Limited to MIME type operations only
  • May require manual updates to stay current with the latest MIME types
  • Not suitable for complex content type negotiations
  • Doesn't handle custom or non-standard MIME types out of the box

Code Examples

  1. Getting the extension for a MIME type:
const mime = require('mime-types');

const extension = mime.extension('text/html');
console.log(extension); // Output: html
  1. Getting the MIME type for a file extension:
const mime = require('mime-types');

const mimeType = mime.lookup('json');
console.log(mimeType); // Output: application/json
  1. Checking if a MIME type is valid:
const mime = require('mime-types');

console.log(mime.types['text/html']); // Output: html
console.log(mime.types['application/json']); // Output: json
console.log(mime.types['invalid/type']); // Output: undefined

Getting Started

To use mime-types in your project, follow these steps:

  1. Install the library using npm:
npm install mime-types
  1. Import the library in your JavaScript file:
const mime = require('mime-types');
  1. Start using the library's functions:
const mimeType = mime.lookup('file.txt');
const extension = mime.extension('text/plain');
const charset = mime.charset('text/html');

console.log(mimeType); // Output: text/plain
console.log(extension); // Output: txt
console.log(charset); // Output: UTF-8

Now you can use the various functions provided by mime-types to work with MIME types in your application.

Competitor Comparisons

2,161

Mime types for JavaScript

Pros of mime

  • Smaller package size and fewer dependencies
  • Faster performance for certain operations
  • More frequent updates and active maintenance

Cons of mime

  • Less comprehensive MIME type database
  • Fewer utility functions for working with MIME types
  • Not as widely adopted in the ecosystem

Code Comparison

mime-types:

const mime = require('mime-types');
mime.lookup('json');              // 'application/json'
mime.extension('application/json'); // 'json'
mime.charset('text/plain');       // 'UTF-8'

mime:

const mime = require('mime');
mime.getType('json');             // 'application/json'
mime.getExtension('application/json'); // 'json'
// No built-in charset lookup

Both libraries provide similar core functionality for MIME type lookups, but mime-types offers additional features like charset lookup. mime focuses on a more streamlined API and faster performance.

mime-types relies on a more extensive MIME type database, which can be beneficial for less common file types. However, this comes at the cost of a larger package size.

mime's simpler codebase and fewer dependencies make it easier to maintain and potentially more suitable for projects where package size is a concern. However, it may not cover all edge cases that mime-types handles.

The choice between these libraries depends on specific project requirements, such as the need for comprehensive MIME type support versus optimized performance and smaller package size.

1,090

Media Type Database

Pros of mime-db

  • More comprehensive database of MIME types
  • Regularly updated with new MIME types
  • Can be used as a standalone module for MIME type information

Cons of mime-db

  • Requires more setup and configuration for basic MIME type lookups
  • Larger file size due to comprehensive database

Code Comparison

mime-db:

const db = require('mime-db')
const mimeType = db['application/json']
console.log(mimeType.extensions) // ['json', 'map']

mime-types:

const mime = require('mime-types')
const extension = mime.extension('application/json')
console.log(extension) // 'json'

Summary

mime-db is a comprehensive database of MIME types, offering more detailed information and regular updates. It's ideal for applications requiring in-depth MIME type data. However, it may be overkill for simple lookups and has a larger file size.

mime-types, on the other hand, is a higher-level module that provides a simpler API for common MIME type operations. It's more suitable for basic tasks like getting file extensions from MIME types or vice versa.

Both projects are maintained by the same organization (jshttp) and complement each other. mime-types actually uses mime-db as its underlying database, providing a more user-friendly interface for common use cases.

Detect the file type of a file, stream, or data

Pros of file-type

  • Supports a wider range of file types, including audio, video, and archive formats
  • Provides more detailed file type information, including MIME type and extensions
  • Offers both synchronous and asynchronous APIs for flexibility

Cons of file-type

  • Larger package size due to more comprehensive file type detection
  • May have slightly slower performance for simple MIME type lookups
  • Requires Node.js v10 or later, while mime-types supports older versions

Code Comparison

mime-types:

const mime = require('mime-types');
const mimeType = mime.lookup('file.jpg');
console.log(mimeType); // 'image/jpeg'

file-type:

const FileType = require('file-type');
const buffer = readFileSync('file.jpg');
(async () => {
  const type = await FileType.fromBuffer(buffer);
  console.log(type); // { ext: 'jpg', mime: 'image/jpeg' }
})();

Summary

file-type offers more comprehensive file type detection and detailed information, making it suitable for applications requiring in-depth file analysis. However, it comes with a larger package size and slightly higher complexity. mime-types is simpler and more lightweight, focusing primarily on MIME type lookups based on file extensions. Choose file-type for advanced file type detection needs, and mime-types for basic MIME type lookups in simpler applications or environments with older Node.js versions.

Convert Figma logo designs to code with AI

Visual Copilot

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

mime-types

NPM Version NPM Downloads Node.js Version Build Status Test Coverage

The ultimate javascript content-type utility.

Similar to the mime@1.x module, except:

  • No fallbacks. Instead of naively returning the first available type, mime-types simply returns false, so do var type = mime.lookup('unrecognized') || 'application/octet-stream'.
  • No new Mime() business, so you could do var lookup = require('mime-types').lookup.
  • No .define() functionality
  • Bug fixes for .lookup(path)

Otherwise, the API is compatible with mime 1.x.

Install

This is a Node.js module available through the npm registry. Installation is done using the npm install command:

$ npm install mime-types

Note on MIME Type Data and Semver

This package considers the programmatic api as the semver compatibility. Additionally, the package which provides the MIME data for this package (mime-db) also considers it's programmatic api as the semver contract. This means the MIME type resolution is not considered in the semver bumps.

In the past the version of mime-db was pinned to give two decision points when adopting MIME data changes. This is no longer true. We still update the mime-db package here as a minor release when necessary, but will use a ^ range going forward. This means that if you want to pin your mime-db data you will need to do it in your application. While this expectation was not set in docs until now, it is how the pacakge operated, so we do not feel this is a breaking change.

If you wish to pin your mime-db version you can do that with overrides via your package manager of choice. See their documentation for how to correctly configure that.

Adding Types

All mime types are based on mime-db, so open a PR there if you'd like to add mime types.

API

var mime = require('mime-types')

All functions return false if input is invalid or not found.

mime.lookup(path)

Lookup the content-type associated with a file.

mime.lookup('json') // 'application/json'
mime.lookup('.md') // 'text/markdown'
mime.lookup('file.html') // 'text/html'
mime.lookup('folder/file.js') // 'application/javascript'
mime.lookup('folder/.htaccess') // false

mime.lookup('cats') // false

mime.contentType(type)

Create a full content-type header given a content-type or extension. When given an extension, mime.lookup is used to get the matching content-type, otherwise the given content-type is used. Then if the content-type does not already have a charset parameter, mime.charset is used to get the default charset and add to the returned content-type.

mime.contentType('markdown') // 'text/x-markdown; charset=utf-8'
mime.contentType('file.json') // 'application/json; charset=utf-8'
mime.contentType('text/html') // 'text/html; charset=utf-8'
mime.contentType('text/html; charset=iso-8859-1') // 'text/html; charset=iso-8859-1'

// from a full path
mime.contentType(path.extname('/path/to/file.json')) // 'application/json; charset=utf-8'

mime.extension(type)

Get the default extension for a content-type.

mime.extension('application/octet-stream') // 'bin'

mime.charset(type)

Lookup the implied default charset of a content-type.

mime.charset('text/markdown') // 'UTF-8'

var type = mime.types[extension]

A map of content-types by extension.

[extensions...] = mime.extensions[type]

A map of extensions by content-type.

License

MIT

NPM DownloadsLast 30 Days