@d1g1tal/media-type 4.1.0 → 5.0.1

package/src/media-type.js

@@ -1,7 +1,6 @@
+import { _type } from '@d1g1tal/chrysalis';
 import MediaTypeParameters from './media-type-parameters.js';
-import parse from './parser.js';
-import serialize from './serializer.js';
-import { asciiLowercase, solelyContainsHTTPTokenCodePoints } from './utils.js';
+import MediaTypeParser from './media-type-parser.js';
 
 /**
  * Class used to parse media types.
@@ -24,33 +23,15 @@ export default class MediaType {
 	 * @param {Object} [parameters] Optional parameters.
 	 */
 	constructor(mediaType, parameters = {}) {
-		const { type, subtype, parameters: parsedParameters } = parse(mediaType);
-		this.#type = type;
-		this.#subtype = subtype;
-		this.#parameters = new MediaTypeParameters([...parsedParameters, ...Object.entries(parameters).map(([name, value]) => [asciiLowercase(name), asciiLowercase(value)])]);
+		if (_type(parameters) != Object) { throw new TypeError('The parameters argument must be an object') }
+		({ type: this.#type, subtype: this.#subtype, parameters: this.#parameters } = MediaTypeParser.parse(mediaType));
+		for (const [ name, value ] of Object.entries(parameters)) { this.#parameters.set(name, value) }
 	}
 
-	/**
-	 * Static factory method for parsing a media type.
-	 *
-	 * @param {string} string The media type to parse.
-	 * @returns {MediaType} The parsed {@link MediaType} object or null if the string could not be parsed.
-	 */
-	static parse(string) {
-		try {
-			return new MediaType(string);
-		} catch (e) {
-			throw new Error(`Could not parse media type string '${string}'`);
-		}
-	}
+	static parse(mediaType) {
+		try {	return new MediaType(mediaType) } catch(e) { /* ignore */ }
 
-	/**
-	 * Gets the media type essence (type/subtype).
-	 *
-	 * @returns {string} The media type without any parameters
-	 */
-	get essence() {
-		return `${this.#type}/${this.#subtype}`;
+		return null;
 	}
 
 	/**
@@ -62,22 +43,6 @@ export default class MediaType {
 		return this.#type;
 	}
 
-	/**
-	 * Sets the type.
-	 */
-	set type(value) {
-		value = asciiLowercase(String(value));
-
-		if (value.length === 0) {
-			throw new Error('Invalid type: must be a non-empty string');
-		}
-		if (!solelyContainsHTTPTokenCodePoints(value)) {
-			throw new Error(`Invalid type ${value}: must contain only HTTP token code points`);
-		}
-
-		this.#type = value;
-	}
-
 	/**
 	 * Gets the subtype.
 	 *
@@ -88,19 +53,12 @@ export default class MediaType {
 	}
 
 	/**
-	 * Sets the subtype.
+	 * Gets the media type essence (type/subtype).
+	 *
+	 * @returns {string} The media type without any parameters
 	 */
-	set subtype(value) {
-		value = asciiLowercase(String(value));
-
-		if (value.length === 0) {
-			throw new Error('Invalid subtype: must be a non-empty string');
-		}
-		if (!solelyContainsHTTPTokenCodePoints(value)) {
-			throw new Error(`Invalid subtype ${value}: must contain only HTTP token code points`);
-		}
-
-		this.#subtype = value;
+	get essence() {
+		return `${this.#type}/${this.#subtype}`;
 	}
 
 	/**
@@ -113,71 +71,23 @@ export default class MediaType {
 	}
 
 	/**
-	 * Gets the serialized version of the media type.
-	 *
-	 * @returns {string} The serialized media type.
-	 */
-	toString() {
-		// The serialize function works on both 'media type records' (i.e. the results of parse) and on this class, since
-		// this class's interface is identical.
-		return serialize(this);
-	}
-
-	/**
-	 * Determines if this instance is a JavaScript media type.
-	 *
-	 * @param {Object} [options] Optional options.
-	 * @param {boolean} [options.prohibitParameters=false] The option to prohibit parameters when checking if the media type is JavaScript.
-	 * @returns {boolean} true if this instance represents a JavaScript media type, false otherwise.
-	 */
-	isJavaScript({prohibitParameters = false} = {}) {
-		switch (this.#type) {
-			case 'text': {
-				switch (this.#subtype) {
-					case 'ecmascript':
-					case 'javascript':
-					case 'javascript1.0':
-					case 'javascript1.1':
-					case 'javascript1.2':
-					case 'javascript1.3':
-					case 'javascript1.4':
-					case 'javascript1.5':
-					case 'jscript':
-					case 'livescript':
-					case 'x-ecmascript':
-					case 'x-javascript': return !prohibitParameters || this.#parameters.size === 0;
-					default: return false;
-				}
-			}
-			case 'application': {
-				switch (this.#subtype) {
-					case 'ecmascript':
-					case 'javascript':
-					case 'x-ecmascript':
-					case 'x-javascript': return !prohibitParameters || this.#parameters.size === 0;
-					default: return false;
-				}
-			}
-			default: return false;
-		}
-	}
-
-	/**
-	 * Determines if this instance is an XML media type.
+	 * Checks if the media type matches the specified type.
 	 *
-	 * @returns {boolean} true if this instance represents an XML media type, false otherwise.
+	 * @todo Fix string handling to parse the type and subtype from the string.
+	 * @param {MediaType|string} mediaType The media type to check.
+	 * @returns {boolean} true if the media type matches the specified type, false otherwise.
 	 */
-	isXML() {
-		return (this.#subtype === 'xml' && (this.#type === 'text' || this.#type === 'application')) || this.#subtype.endsWith('+xml');
+	matches(mediaType) {
+		return (this.#type === mediaType?.type && this.#subtype === mediaType?.subtype) || this.essence.includes(mediaType);
 	}
 
 	/**
-	 * Determines if this instance is an HTML media type.
+	 * Gets the serialized version of the media type.
 	 *
-	 * @returns {boolean} true if this instance represents an HTML media type, false otherwise.
+	 * @returns {string} The serialized media type.
 	 */
-	isHTML() {
-		return this.#subtype === 'html' && this.#type === 'text';
+	toString() {
+		return `${this.essence}${this.#parameters.toString()}`;
 	}
 
 	/**

package/src/utils.js

@@ -1,94 +1,3 @@
-/** @module utils */
-
-const whitespaceCharacters = [' ', '\t', '\n', '\r'];
-const leadingWhitespace = /^[ \t\n\r]+/u;
-const trailingWhitespace = /[ \t\n\r]+$/u;
 const httpTokenCodePoints = /^[-!#$%&'*+.^_`|~A-Za-z0-9]*$/u;
-const httpQuotedTokenCodePoints = /^[\t\u0020-\u007E\u0080-\u00FF]*$/u;
-
-/**
- * A function to remove any leading and trailing HTTP whitespace.
- *
- * @param {string} string The string to process.
- * @returns {string} The processed string.
- */
-const removeLeadingAndTrailingHTTPWhitespace = (string) => string.replace(leadingWhitespace, '').replace(trailingWhitespace, '');
-
-/**
- * A function to remove any trailing HTTP whitespace.
- *
- * @param {string} string The string to process.
- * @returns {string} The processed string.
- */
-const removeTrailingHTTPWhitespace = (string) => string.replace(trailingWhitespace, '');
-
-/**
- * Determines if the provided character is whitespace.
- *
- * @param {string} char The character to evaluate.
- * @returns {boolean} true if the character is whitespace, false otherwise.
- */
-const isHTTPWhitespaceChar = (char) => whitespaceCharacters.includes(char);
-
-/**
- * Determines if the provided string contains only HTTP token code points.
- *
- * @param {string} string The string to evaluate.
- * @returns {boolean} true if the string contains only HTTP token code points.
- */
-const solelyContainsHTTPTokenCodePoints = (string) => httpTokenCodePoints.test(string);
-
-/**
- * Determines if the provided string contains only quoted HTTP token code points.
- *
- * @param {string} string The string to evaluate.
- * @returns {boolean} true if the string contains only quoted HTTP token code points.
- */
-const solelyContainsHTTPQuotedStringTokenCodePoints = (string) => httpQuotedTokenCodePoints.test(string);
-
-/**
- * A function to lower case ASCII characters.
- * This implementation iterates over each element of the string, which is treated as an iterable.
- * The elements are destructured into [char, charCode] pairs, where char represents the character,
- * and charCode is assigned the character code using char.charCodeAt(0). If the charCode is not
- * provided, it falls back to the character code obtained from char.charCodeAt(0).
- *
- * @param {string} string The string to process.
- * @returns {string} The processed string with all ASCII characters lower cased.
- */
-const asciiLowercase = (string) => {
-	let result = '';
-	for (const [char, charCode = char.charCodeAt(0)] of string) {
-		result += charCode >= 65 && charCode <= 90 ? String.fromCharCode(charCode + 32) : char;
-	}
-
-	return result;
-};
-
-/**
- * Collects all the HTTP quoted strings.
- * This variant only implements it with the extract-value flag set.
- *
- * @param {string} input The string to process.
- * @param {number} position The starting position.
- * @returns {Array<string|number>} An array that includes the resulting string and updated position.
- */
-const collectAnHTTPQuotedString = (input, position) => {
-	let value = '';
-
-	for (let length = input.length, char; ++position < length;) {
-		char = input[position];
-
-		if (char == '\\') {
-			value += ++position < length ? input[position] : char;
-		} else if (char == '"') {
-			break;
-		} else {
-			value += char;
-		}
-	}
-
-	return [value, position];
-};
 
-export { removeLeadingAndTrailingHTTPWhitespace, removeTrailingHTTPWhitespace, isHTTPWhitespaceChar, solelyContainsHTTPTokenCodePoints, solelyContainsHTTPQuotedStringTokenCodePoints, asciiLowercase, collectAnHTTPQuotedString };
+export default httpTokenCodePoints;

package/index.d.ts

@@ -1,5 +0,0 @@
-export { default as MediaTypeParameters } from "./src/media-type-parameters.js";
-export { default as MediaType } from "./src/media-type.js";
-export { default as parse } from "./src/parser.js";
-export { default as serialize } from "./src/serializer.js";
-export * from "./src/utils.js";

package/index.js

@@ -1,5 +0,0 @@
-export { default as MediaTypeParameters } from './src/media-type-parameters.js';
-export { default as MediaType } from './src/media-type.js';
-export { default as parse } from './src/parser.js';
-export { default as serialize } from './src/serializer.js';
-export * from './src/utils.js';

package/src/media-type-parameters.d.ts

@@ -1,91 +0,0 @@
-/**
- * Class representing the parameters for a media type record.
- * This class has the equivalent surface API to a JavaScript {@link Map}.
- *
- * However, {@link MediaTypeParameters} methods will always interpret their arguments
- * as appropriate for media types, so parameter names will be lowercased,
- * and attempting to set invalid characters will throw an {@link Error}.
- *
- * @example charset=utf-8
- * @module MediaTypeParameters
- */
-export default class MediaTypeParameters {
-    /**
-     * Create a new MediaTypeParameters instance.
-     *
-     * @param {Map.<string, string>} map The map of parameters for a media type.
-     */
-    constructor(map: Map<string, string>);
-    _map: Map<string, string>;
-    /**
-     * Gets the number of media type parameters.
-     *
-     * @returns {number} The number of media type parameters
-     */
-    get size(): number;
-    /**
-     * Gets the media type parameter value for the supplied name.
-     *
-     * @param {string} name The name of the media type parameter to retrieve.
-     * @returns {string} The media type parameter value.
-     */
-    get(name: string): string;
-    /**
-     * Indicates whether the media type parameter with the specified name exists or not.
-     *
-     * @param {string} name The name of the media type parameter to check.
-     * @returns {boolean} true if the media type parameter exists, false otherwise.
-     */
-    has(name: string): boolean;
-    /**
-     * Adds a new media type parameter using the specified name and value to the MediaTypeParameters.
-     * If an parameter with the same name already exists, the parameter will be updated.
-     *
-     * @param {string} name The name of the media type parameter to set.
-     * @param {string} value The media type parameter value.
-     * @returns {MediaTypeParameters} This instance.
-     */
-    set(name: string, value: string): MediaTypeParameters;
-    /**
-     * Clears all the media type parameters.
-     */
-    clear(): void;
-    /**
-     * Removes the media type parameter using the specified name.
-     *
-     * @param {string} name The name of the media type parameter to delete.
-     * @returns {boolean} true if the parameter existed and has been removed, or false if the parameter does not exist.
-     */
-    delete(name: string): boolean;
-    /**
-     * Executes a provided function once per each name/value pair in the MediaTypeParameters, in insertion order.
-     *
-     * @param {function(string, string): void} callback The function called on each iteration.
-     * @param {*} [thisArg] Optional object when binding 'this' to the callback.
-     */
-    forEach(callback: (arg0: string, arg1: string) => void, thisArg?: any): void;
-    /**
-     * Returns an iterable of parameter names.
-     *
-     * @returns {IterableIterator<string>} The {@link IterableIterator} of media type parameter names.
-     */
-    keys(): IterableIterator<string>;
-    /**
-     * Returns an iterable of parameter values.
-     *
-     * @returns {IterableIterator<string>} The {@link IterableIterator} of media type parameter values.
-     */
-    values(): IterableIterator<string>;
-    /**
-     * Returns an iterable of name, value pairs for every parameter entry in the media type parameters.
-     *
-     * @returns {IterableIterator<Array<Array<string>>>} The media type parameter entries.
-     */
-    entries(): IterableIterator<Array<Array<string>>>;
-    /**
-     * A method that returns the default iterator for the {@link MediaTypeParameters}. Called by the semantics of the for-of statement.
-     *
-     * @returns {Iterator<string, string, undefined>} The {@link Symbol.iterator} for the media type parameters.
-     */
-    [Symbol.iterator](): Iterator<string, string, undefined>;
-}

package/src/media-type.d.ts

@@ -1,91 +0,0 @@
-/**
- * Class used to parse media types.
- *
- * @see https://mimesniff.spec.whatwg.org/#understanding-mime-types
- * @module MediaType
- */
-export default class MediaType {
-    /**
-     * Static factor method for parsing a media type.
-     *
-     * @param {string} string The media type to parse
-     * @returns {MediaType} The parsed {@link MediaType} object
-     */
-    static parse(string: string): MediaType;
-    /**
-     * Create a new MediaType instance from a string representation.
-     *
-     * @param {string} string The media type to parse
-     */
-    constructor(string: string);
-    _type: string;
-    _subtype: string;
-    _parameters: MediaTypeParameters;
-    /**
-     * Gets the media type essence (type/subtype).
-     *
-     * @returns {string} The media type without any parameters
-     */
-    get essence(): string;
-    /**
-     * Sets the type.
-     */
-    set type(arg: string);
-    /**
-     * Gets the type.
-     *
-     * @returns {string} The type.
-     */
-    get type(): string;
-    /**
-     * Sets the subtype.
-     */
-    set subtype(arg: string);
-    /**
-     * Gets the subtype.
-     *
-     * @returns {string} The subtype.
-     */
-    get subtype(): string;
-    /**
-     * Gets the parameters.
-     *
-     * @returns {MediaTypeParameters} The media type parameters.
-     */
-    get parameters(): MediaTypeParameters;
-    /**
-     * Gets the serialized version of the media type.
-     *
-     * @returns {string} The serialized media type.
-     */
-    toString(): string;
-    /**
-     * Determines if this instance is a JavaScript media type.
-     *
-     * @param {Object} [options] Optional options.
-     * @param {boolean} [options.prohibitParameters=false] The option to prohibit parameters when checking if the media type is JavaScript.
-     * @returns {boolean} true if this instance represents a JavaScript media type, false otherwise.
-     */
-    isJavaScript({ prohibitParameters }?: {
-        prohibitParameters?: boolean;
-    }): boolean;
-    /**
-     * Determines if this instance is an XML media type.
-     *
-     * @returns {boolean} true if this instance represents an XML media type, false otherwise.
-     */
-    isXML(): boolean;
-    /**
-     * Determines if this instance is an HTML media type.
-     *
-     * @returns {boolean} true if this instance represents an HTML media type, false otherwise.
-     */
-    isHTML(): boolean;
-    /**
-     * Gets the name of the class.
-     *
-     * @returns {string} The class name
-     */
-    get [Symbol.toStringTag](): string;
-}
-import MediaTypeParameters from "./media-type-parameters.js";

package/src/parser.d.ts

@@ -1,13 +0,0 @@
-export default parse;
-/**
- * Function to parse a media type.
- *
- * @module parser
- * @param {string} input The media type to parse
- * @returns {{ type: string, subtype: string, parameters: Map<string, string> }} An object populated with the parsed media type properties and any parameters.
- */
-declare function parse(input: string): {
-    type: string;
-    subtype: string;
-    parameters: Map<string, string>;
-};

package/src/parser.js

@@ -1,106 +0,0 @@
-import {
-	asciiLowercase,
-	collectAnHTTPQuotedString, isHTTPWhitespaceChar, removeLeadingAndTrailingHTTPWhitespace,
-	removeTrailingHTTPWhitespace, solelyContainsHTTPQuotedStringTokenCodePoints, solelyContainsHTTPTokenCodePoints
-} from './utils.js';
-
-/**
- * Function to parse a media type.
- *
- * @module parser
- * @param {string} input The media type to parse
- * @returns {{ type: string, subtype: string, parameters: Map<string, string> }} An object populated with the parsed media type properties and any parameters.
- */
-const parse = (input) => {
-	input = removeLeadingAndTrailingHTTPWhitespace(input);
-
-	let position = 0;
-	let type = '';
-	while (position < input.length && input[position] != '/') {
-		type += input[position];
-		++position;
-	}
-
-	if (type.length === 0 || !solelyContainsHTTPTokenCodePoints(type)) {
-		return null;
-	}
-
-	if (position >= input.length) {
-		return null;
-	}
-
-	// Skips past "/"
-	++position;
-
-	let subtype = '';
-	while (position < input.length && input[position] != ';') {
-		subtype += input[position];
-		++position;
-	}
-
-	subtype = removeTrailingHTTPWhitespace(subtype);
-
-	if (subtype.length === 0 || !solelyContainsHTTPTokenCodePoints(subtype)) {
-		return null;
-	}
-
-	const mediaType = {
-		type: asciiLowercase(type),
-		subtype: asciiLowercase(subtype),
-		parameters: new Map()
-	};
-
-	while (position < input.length) {
-		// Skip past ";"
-		++position;
-
-		while (isHTTPWhitespaceChar(input[position])) {
-			++position;
-		}
-
-		let parameterName = '';
-		while (position < input.length && input[position] != ';' && input[position] != '=') {
-			parameterName += input[position];
-			++position;
-		}
-		parameterName = asciiLowercase(parameterName);
-
-		if (position < input.length) {
-			if (input[position] == ';') {
-				continue;
-			}
-
-			// Skip past "="
-			++position;
-		}
-
-		let parameterValue = null;
-		if (input[position] == '"') {
-			[parameterValue, position] = collectAnHTTPQuotedString(input, position);
-
-			while (position < input.length && input[position] != ';') {
-				++position;
-			}
-		} else {
-			parameterValue = '';
-			while (position < input.length && input[position] != ';') {
-				parameterValue += input[position];
-				++position;
-			}
-
-			parameterValue = removeTrailingHTTPWhitespace(parameterValue);
-
-			if (parameterValue === '') {
-				continue;
-			}
-		}
-
-		if (parameterName.length > 0 &&	solelyContainsHTTPTokenCodePoints(parameterName) &&	solelyContainsHTTPQuotedStringTokenCodePoints(parameterValue) && !mediaType.parameters.has(parameterName)) {
-			mediaType.parameters.set(parameterName, parameterValue);
-		}
-	}
-
-	return mediaType;
-};
-
-export default parse;

package/src/serializer.d.ts

@@ -1,11 +0,0 @@
-export default serialize;
-export type MediaType = import('./media-type.js').default;
-/** @typedef { import('./media-type.js').default } MediaType */
-/**
- * A function that serializes the provided {@link mediaType} to a string.
- *
- * @module serializer
- * @param {MediaType} mediaType The media type to serialize.
- * @returns {string} The serialized media type.
- */
-declare function serialize(mediaType: MediaType): string;

package/src/serializer.js

@@ -1,32 +0,0 @@
-import { solelyContainsHTTPTokenCodePoints } from './utils.js';
-
-/** @typedef { import('./media-type.js').default } MediaType */
-
-/**
- * A function that serializes the provided {@link mediaType} to a string.
- *
- * @module serializer
- * @param {MediaType} mediaType The media type to serialize.
- * @returns {string} The serialized media type.
- */
-const serialize = (mediaType) => {
-	let serialization = `${mediaType.type}/${mediaType.subtype}`;
-
-	if (mediaType.parameters.size === 0) {
-		return serialization;
-	}
-
-	for (let [name, value] of mediaType.parameters) {
-		serialization += `;${name}=`;
-
-		if (!solelyContainsHTTPTokenCodePoints(value) || value.length === 0) {
-			value = `"${value.replace(/(["\\])/ug, '\\$1')}"`;
-		}
-
-		serialization += value;
-	}
-
-	return serialization;
-};
-
-export default serialize;

package/src/utils.d.ts

@@ -1,52 +0,0 @@
-/** @module utils */
-/**
- * A function to remove any leading and trailing HTTP whitespace.
- *
- * @param {string} string The string to process.
- * @returns {string} The processed string.
- */
-export function removeLeadingAndTrailingHTTPWhitespace(string: string): string;
-/**
- * A function to remove any trailing HTTP whitespace.
- *
- * @param {string} string The string to process.
- * @returns {string} The processed string.
- */
-export function removeTrailingHTTPWhitespace(string: string): string;
-/**
- * Determines if the provided character is whitespace.
- *
- * @param {string} char The character to evaluate.
- * @returns {boolean} true if the character is whitespace, false otherwise.
- */
-export function isHTTPWhitespaceChar(char: string): boolean;
-/**
- * Determines if the provided string contains only HTTP token code points.
- *
- * @param {string} string The string to evaluate.
- * @returns {boolean} true if the string contains only HTTP token code points.
- */
-export function solelyContainsHTTPTokenCodePoints(string: string): boolean;
-/**
- * Determines if the provided string contains only quoted HTTP token code points.
- *
- * @param {string} string The string to evaluate.
- * @returns {boolean} true if the string contains only quoted HTTP token code points.
- */
-export function solelyContainsHTTPQuotedStringTokenCodePoints(string: string): boolean;
-/**
- * A function to lower case ASCII characters.
- *
- * @param {string} string The string to process.
- * @returns {string} The processed string with all ASCII characters lower cased.
- */
-export function asciiLowercase(string: string): string;
-/**
- * Collects all the HTTP quoted strings.
- * This variant only implements it with the extract-value flag set.
- *
- * @param {string} input The string to process.
- * @param {number} position The starting position.
- * @returns {Array<string | number>} An array that includes the resulting string and updated position.
- */
-export function collectAnHTTPQuotedString(input: string, position: number): Array<string | number>;