whatwg mimetype

Analisar, serializar e manipular os tipos de mímica

Este pacote analisará os tipos de MIME em um formato estruturado, que pode ser manipulado e serializado:

 const MIMEType = require ( "whatwg-mimetype" ) ;

const mimeType = new MIMEType ( `Text/HTML;Charset="utf-8"` ) ;

console . assert ( mimeType . toString ( ) === "text/html;charset=utf-8" ) ;

console . assert ( mimeType . type === "text" ) ;
console . assert ( mimeType . subtype === "html" ) ;
console . assert ( mimeType . essence === "text/html" ) ;
console . assert ( mimeType . parameters . get ( "charset" ) === "utf-8" ) ;

mimeType . parameters . set ( "charset" , "windows-1252" ) ;
console . assert ( mimeType . parameters . get ( "charset" ) === "windows-1252" ) ;
console . assert ( mimeType . toString ( ) === "text/html;charset=windows-1252" ) ;

console . assert ( mimeType . isHTML ( ) === true ) ;
console . assert ( mimeType . isXML ( ) === false ) ;

A análise é um processo bastante complexo; Consulte a especificação para obter detalhes (e da mesma forma para serializar).

Os algoritmos deste pacote estão em conformidade com os do padrão Sniffing Whatwg Mime e está alinhado para cometer 8E9A7DD.

MIMEType API

A exportação padrão do módulo principal deste pacote é uma classe, MIMEType . Seu construtor pega uma string que tentará analisar um tipo MIME; Se a análise falhar, um Error será lançado.

O método de fábrica parse() estático

Como alternativa ao construtor, você pode usar MIMEType.parse(string) . A única diferença é que parse() retornará null na análise falhada, enquanto o construtor jogará. Assim, faz o maior sentido usar o construtor nos casos em que os tipos de MIME incomparáveis ​​seriam excepcionais e usariam parse() ao lidar com a entrada de alguma fonte irrestrita.

Propriedades

• type : o tipo MIME tipo, por exemplo, "text"
• subtype : o subtipo do tipo MIME, por exemplo, "html"
• essence : a essência do tipo MIME, por exemplo, "text/html"
• parameters : uma instância de MIMETypeParameters , contendo os parâmetros deste tipo MIME

type e subtype podem ser alterados. Eles serão validados para não ser vazios e conterão apenas pontos de código de token HTTP.

essence é apenas um getter e não pode ser alterada.

parameters também são um getter, mas o conteúdo do objeto MIMETypeParameters são mutáveis, conforme descrito abaixo.

Métodos

• toString() serializa o tipo MIME para uma string
• isHTML() : retorna true se esta instância representa um tipo MIME HTML
• isXML() : retorna true se esta instância representa um tipo de mímio XML
• isJavaScript({ prohibitParameters }) : retorna true se esta instância representa um tipo de MIME JavaScript. prohibitParameters pode ser definido como TRUE para proibir quaisquer parâmetros, ou seja, para testar se a serialização do tipo MIME é uma correspondência de essência do tipo MIME JavaScript.

NOTA: Os métodos isHTML() , isXML() e isJavaScript() são especulativos e podem ser removidos ou alterados em versões principais futuras. Veja Whatwg/Mimesniff#48 para brainstorming nesta área. Atualmente, implementamos principalmente isso porque são úteis no JSDOM.

API MIMETypeParameters

A classe MIMETypeParameters , cujas instâncias são retornadas pelo mimeType.parameters , possui API de superfície equivalente a um Map JavaScript.

No entanto, os métodos MIMETypeParameters sempre interpretarão seus argumentos conforme apropriado para os tipos de MIME, portanto, os nomes dos parâmetros serão mais baixos e a tentativa de definir caracteres inválidos jogará.

Alguns exemplos:

 const mimeType = new MIMEType ( `x/x;a=b;c=D;E="F"` ) ;

// Logs:
// a b
// c D
// e F
for ( const [ name , value ] of mimeType . parameters ) {
  console . log ( name , value ) ;
}

console . assert ( mimeType . parameters . has ( "a" ) ) ;
console . assert ( mimeType . parameters . has ( "A" ) ) ;
console . assert ( mimeType . parameters . get ( "A" ) === "b" ) ;

mimeType . parameters . set ( "Q" , "X" ) ;
console . assert ( mimeType . parameters . get ( "q" ) === "X" ) ;
console . assert ( mimeType . toString ( ) === "x/x;a=b;c=d;e=F;q=X" ) ;

// Throws:
mimeType . parameters . set ( "@" , "x" ) ; 

APIs de análise/serialização em bruto

Se você deseja primitivas sobre as quais construir sua própria API, pode obter acesso direto aos algoritmos de análise e serialização da seguinte forma:

 const parse = require ( "whatwg-mimetype/parser" ) ;
const serialize = require ( "whatwg-mimetype/serialize" ) ;

parse(string) retorna um objeto que contém as seqüências de strings type e subtype , além de parameters , que é um Map . Este é aproximadamente o nosso equivalente ao registro do tipo MIME da SPEC. Se a análise falhar, ele retornará null .

serialize(record) opera nesse objeto, devolvendo uma string de acordo com o algoritmo de serialização.