whatwg mimetype

Analyse, sérialiser et manipuler les types de mime

Ce package analysera les types de mime dans un format structuré, qui peut ensuite être manipulé et sérialisé:

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

L'analyse est un processus assez complexe; Voir la spécification pour plus de détails (et de la même manière pour la sérialisation).

Les algorithmes de ce package sont conformes à ceux de la norme de reniflement de Whatwg MIME et sont alignés pour commettre 8E9A7DD.

API MIMEType

L’exportation par défaut du module principal de ce package est une classe, MIMEType . Son constructeur prend une chaîne qu'il tentera d'analyser un type MIME; Si l'analyse échoue, une Error sera lancée.

La méthode d'usine statique parse()

Comme alternative au constructeur, vous pouvez utiliser MIMEType.parse(string) . La seule différence est que parse() retournera null sur l'analyse ratée, tandis que le constructeur lancera. Il est donc le plus judicieux d'utiliser le constructeur dans les cas où les types de mime inégalables seraient exceptionnels et utilisent parse() lorsqu'ils traitent de la contribution d'une source sans contrainte.

Propriétés

• type : le type du type mime, par exemple "text"
• subtype : le sous-type du type mime, par exemple "html"
• essence : l'essence du type mime, par exemple "text/html"
• parameters : une instance de MIMETypeParameters , contenant les paramètres de ce type MIME

type et subtype peuvent être modifiés. Ils seront validés comme non vides et ne contiendront que des points de code de jeton HTTP.

essence n'est qu'un getteur et ne peut pas être modifiée.

parameters sont également un Getter, mais le contenu de l'objet MIMETypeParameters est mutable, comme décrit ci-dessous.

Méthodes

• toString() sérialise le type mime à une chaîne
• isHTML() : Renvoie True si cette instance représente un type HTML MIME
• isXML() : renvoie true si cette instance représente un type de mime xml
• isJavaScript({ prohibitParameters }) : renvoie true si cette instance représente un type de mime javascript. prohibitParameters peuvent être définis sur true pour interdire tous les paramètres, c'est-à-dire pour tester si la sérialisation du type MIME est une correspondance d'essence de type mime javascript.

Remarque: les méthodes isHTML() , isXML() et isJavaScript() sont spéculatives et peuvent être supprimées ou modifiées dans les futures versions majeures. Voir Whatswg / Mimesniff # 48 pour un brainstorming dans ce domaine. Actuellement, nous les mettons en œuvre principalement parce qu'ils sont utiles dans JSDom.

API MIMETypeParameters

La classe MIMETypeParameters , dont les instances sont renvoyées par mimeType.parameters , a une API de surface équivalente à une Map JavaScript.

Cependant, les méthodes MIMETypeParameters interpréteront toujours leurs arguments, comme approprié pour les types de mime, par exemple, les noms de paramètres seront classés inférieurs, et tenter de définir des caractères invalides.

Quelques exemples:

 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 à analyse / sérialisation brutes

Si vous voulez des primitives sur lesquelles créer votre propre API, vous pouvez obtenir un accès direct aux algorithmes d'analyse et de sérialisation comme suit:

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

parse(string) Renvoie un objet contenant les chaînes type et subtype , plus parameters , qui est une Map . Il s'agit à peu près de notre équivalent de l'enregistrement de type MIME de la spécification. Si l'analyse échoue, il renvoie à la place null .

serialize(record) fonctionne sur un tel objet, en redonnant une chaîne en fonction de l'algorithme de sérialisation.