whatwg mimetype

Analizar, serializar y manipular los tipos de mime

Este paquete analizará los tipos de mime en un formato estructurado, que luego se puede manipular y serializar:

 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 ) ;

El análisis es un proceso bastante complejo; Consulte la especificación para obtener detalles (y de manera similar para la serialización).

Los algoritmos de este paquete se ajustan a los del estándar Whatwg Mime Sffing, y está alineado para cometer 8E9A7DD.

MIMEType API

La exportación predeterminada del módulo principal de este paquete es una clase, MIMEType . Su constructor toma una cadena que intentará analizar un tipo mime; Si el análisis falla, se lanzará un Error .

El método de fábrica estática parse()

Como alternativa al constructor, puede usar MIMEType.parse(string) . La única diferencia es que parse() devolverá null al análisis fallido, mientras que el constructor lanzará. Por lo tanto, tiene más sentido usar el constructor en los casos en que los tipos de MIME incomparables serían excepcionales y usarían parse() cuando se trata de aportes de alguna fuente no restringida.

Propiedades

• type : el tipo de tipo mime, por ejemplo, "text"
• subtype : el subtipo de tipo mime, por ejemplo, "html"
• essence : la esencia del tipo mime, por ejemplo, "text/html"
• parameters : una instancia de MIMETypeParameters , que contiene los parámetros de este tipo mime

type y subtype se pueden cambiar. Serán validados para que no sean vacíos y solo contengan puntos de código HTTP Token.

essence es solo un Getter y no se puede cambiar.

parameters también son un getter, pero el contenido del objeto MIMETypeParameters es mutable, como se describe a continuación.

Métodos

• toString() serializa el tipo mime a una cadena
• isHTML() : devuelve verdadero si esta instancia representa un tipo HTML MIME
• isXML() : devuelve verdadero si esta instancia representa un tipo XML MIME
• isJavaScript({ prohibitParameters }) : devuelve verdadero si esta instancia representa un tipo de mime javaScript. prohibitParameters se puede establecer en verdadero para no permitir cualquier parámetro, es decir, para probar si la serialización del tipo de mime es una coincidencia de esencia de tipo MIME JavaScript.

Nota: Los métodos isHTML() , isXML() e isJavaScript() son especulativos y pueden eliminarse o cambiar en futuras versiones principales. Vea Whatwg/Mimesniff#48 para una lluvia de ideas en esta área. Actualmente implementamos estos principalmente porque son útiles en JSDOM.

MIMETypeParameters API

La clase MIMETypeParameters , cuyas casas son devueltas por mimeType.parameters , tiene una API de superficie equivalente a un Map de JavaScript.

Sin embargo, los métodos MIMETypeParameters siempre interpretarán sus argumentos como apropiados para los tipos de MIME, por lo que los nombres de parámetros por ejemplo se reducirán e intentar establecer caracteres no válidos.

Algunos ejemplos:

 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" ) ; 

API de análisis crudo/serialización

Si desea primitivas para construir su propia API, puede obtener acceso directo a los algoritmos de análisis y serialización de la siguiente manera:

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

parse(string) Devuelve un objeto que contiene el type y las cadenas subtype , más parameters , que es un Map . Este es aproximadamente nuestro equivalente del registro de tipo MIME de la especificación. Si el análisis falla, en su lugar devuelve null .

serialize(record) funciona en el este objeto, devolviendo una cadena de acuerdo con el algoritmo de serialización.