@schukai/monster 3.51.5 → 3.52.0

package/source/types/mediatype.mjs

@@ -33,92 +33,92 @@ const internal = Symbol("internal");
  * @memberOf Monster.Types
  */
 class MediaType extends Base {
-    /**
-     *
-     * @param {String} type
-     * @param {String} subtype
-     * @param {Monster.Types.Parameter[]} parameter
-     */
-    constructor(type, subtype, parameter) {
-        super();
-
-        this[internal] = {
-            type: validateString(type).toLowerCase(),
-            subtype: validateString(subtype).toLowerCase(),
-            parameter: [],
-        };
-
-        if (parameter !== undefined) {
-            this[internal]["parameter"] = validateArray(parameter);
-        }
-    }
-
-    /**
-     * This method is called by the `instanceof` operator.
-     * @returns {symbol}
-     * @since 2.1.0
-     */
-    static get [instanceSymbol]() {
-        return Symbol.for("@schukai/monster/types/media-type");
-    }
-
-    /**
-     * @return {String}
-     */
-    get type() {
-        return this[internal].type;
-    }
-
-    /**
-     * @return {String}
-     */
-    get subtype() {
-        return this[internal].subtype;
-    }
-
-    /**
-     * @return {Monster.Types.Parameter[]}
-     */
-    get parameter() {
-        return this[internal].parameter;
-    }
-
-    /**
-     *
-     *
-     * @return {Map}
-     */
-    get parameter() {
-        const result = new Map();
-
-        this[internal]["parameter"].forEach((p) => {
-            let value = p.value;
-
-            // internally special values are partly stored with quotes, this function removes them.
-            if (value.startsWith('"') && value.endsWith('"')) {
-                value = value.substring(1, value.length - 1);
-            }
-
-            result.set(p.key, value);
-        });
-
-        return result;
-    }
-
-    /**
-     *
-     * @return {string}
-     */
-    toString() {
-        let parameter = [];
-        for (let a of this[internal].parameter) {
-            parameter.push(`${a.key}=${a.value}`);
-        }
-
-        return `${this[internal].type}/${this[internal].subtype}${
-            parameter.length > 0 ? `;${parameter.join(";")}` : ""
-        }`;
-    }
+	/**
+	 *
+	 * @param {String} type
+	 * @param {String} subtype
+	 * @param {Monster.Types.Parameter[]} parameter
+	 */
+	constructor(type, subtype, parameter) {
+		super();
+
+		this[internal] = {
+			type: validateString(type).toLowerCase(),
+			subtype: validateString(subtype).toLowerCase(),
+			parameter: [],
+		};
+
+		if (parameter !== undefined) {
+			this[internal]["parameter"] = validateArray(parameter);
+		}
+	}
+
+	/**
+	 * This method is called by the `instanceof` operator.
+	 * @returns {symbol}
+	 * @since 2.1.0
+	 */
+	static get [instanceSymbol]() {
+		return Symbol.for("@schukai/monster/types/media-type");
+	}
+
+	/**
+	 * @return {String}
+	 */
+	get type() {
+		return this[internal].type;
+	}
+
+	/**
+	 * @return {String}
+	 */
+	get subtype() {
+		return this[internal].subtype;
+	}
+
+	// /**
+	//  * @return {Monster.Types.Parameter[]}
+	//  */
+	// get parameter() {
+	// 	return this[internal].parameter;
+	// }
+
+	/**
+	 *
+	 *
+	 * @return {Map}
+	 */
+	get parameter() {
+		const result = new Map();
+
+		this[internal]["parameter"].forEach((p) => {
+			let value = p.value;
+
+			// internally special values are partly stored with quotes, this function removes them.
+			if (value.startsWith('"') && value.endsWith('"')) {
+				value = value.substring(1, value.length - 1);
+			}
+
+			result.set(p.key, value);
+		});
+
+		return result;
+	}
+
+	/**
+	 *
+	 * @return {string}
+	 */
+	toString() {
+		const parameter = [];
+		for (const a of this[internal].parameter) {
+			parameter.push(`${a.key}=${a.value}`);
+		}
+
+		return `${this[internal].type}/${this[internal].subtype}${
+			parameter.length > 0 ? `;${parameter.join(";")}` : ""
+		}`;
+	}
 }
 
 /**
@@ -158,24 +158,24 @@ class MediaType extends Base {
  * @memberOf Monster.Types
  */
 function parseMediaType(mediatype) {
-    const regex =
-        /(?<type>[A-Za-z]+|\*)\/(?<subtype>([a-zA-Z0-9.\+_\-]+)|\*|)(?<parameter>\s*;\s*([a-zA-Z0-9]+)\s*(=\s*("?[A-Za-z0-9_\-]+"?))?)*/g;
-    const result = regex.exec(validateString(mediatype));
+	const regex =
+		/(?<type>[A-Za-z]+|\*)\/(?<subtype>([a-zA-Z0-9.\+_\-]+)|\*|)(?<parameter>\s*;\s*([a-zA-Z0-9]+)\s*(=\s*("?[A-Za-z0-9_\-]+"?))?)*/g;
+	const result = regex.exec(validateString(mediatype));
 
-    const groups = result?.["groups"];
-    if (groups === undefined) {
-        throw new TypeError("the mimetype can not be parsed");
-    }
+	const groups = result?.["groups"];
+	if (groups === undefined) {
+		throw new TypeError("the mimetype can not be parsed");
+	}
 
-    const type = groups?.["type"];
-    const subtype = groups?.["subtype"];
-    const parameter = groups?.["parameter"];
+	const type = groups?.["type"];
+	const subtype = groups?.["subtype"];
+	const parameter = groups?.["parameter"];
 
-    if (subtype === "" || type === "") {
-        throw new TypeError("blank value is not allowed");
-    }
+	if (subtype === "" || type === "") {
+		throw new TypeError("blank value is not allowed");
+	}
 
-    return new MediaType(type, subtype, parseParameter(parameter));
+	return new MediaType(type, subtype, parseParameter(parameter));
 }
 
 /**
@@ -187,29 +187,29 @@ function parseMediaType(mediatype) {
  * @memberOf Monster.Types
  */
 function parseParameter(parameter) {
-    if (!isString(parameter)) {
-        return undefined;
-    }
+	if (!isString(parameter)) {
+		return undefined;
+	}
 
-    let result = [];
+	const result = [];
 
-    parameter.split(";").forEach((entry) => {
-        entry = entry.trim();
-        if (entry === "") {
-            return;
-        }
+	parameter.split(";").forEach((entry) => {
+		entry = entry.trim();
+		if (entry === "") {
+			return;
+		}
 
-        const kv = entry.split("=");
+		const kv = entry.split("=");
 
-        let key = validateString(kv?.[0]).trim();
-        let value = validateString(kv?.[1]).trim();
+		const key = validateString(kv?.[0]).trim();
+		const value = validateString(kv?.[1]).trim();
 
-        // if values are quoted, they remain so internally
-        result.push({
-            key: key,
-            value: value,
-        });
-    });
+		// if values are quoted, they remain so internally
+		result.push({
+			key: key,
+			value: value,
+		});
+	});
 
-    return result;
+	return result;
 }

package/source/types/namespace.mjs

@@ -4,7 +4,7 @@
  */
 
 /**
- * Namespace for types.
+ * Namespace for all types related functions.
  *
  * @namespace Monster.Types
  * @memberOf Monster

package/source/types/node.mjs

@@ -36,144 +36,153 @@ const treeStructureSymbol = Symbol("treeStructure");
  * @see https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Iteration_protocols
  */
 class Node extends Base {
-    /**
-     * @param {*} [value]
-     */
-    constructor(value) {
-        super();
-        this[internalValueSymbol] = value;
-
-        this[treeStructureSymbol] = {
-            parent: null,
-            childNodes: new NodeList(),
-            level: 0,
-        };
-    }
-
-    /**
-     * This method is called by the `instanceof` operator.
-     * @returns {symbol}
-     * @since 2.1.0
-     */
-    static get [instanceSymbol]() {
-        return Symbol.for("@schukai/monster/types/node");
-    }
-
-    /**
-     * @property {*}
-     */
-    get value() {
-        return this[internalValueSymbol];
-    }
-
-    /**
-     * @property {*}
-     */
-    set value(value) {
-        this[internalValueSymbol] = value;
-    }
-
-    /**
-     * @property {Monster.Types.Node|null}
-     */
-    get parent() {
-        return this[treeStructureSymbol].parent;
-    }
-
-    /**
-     * @property {integer}
-     */
-    get level() {
-        return this[treeStructureSymbol].level;
-    }
-
-    /**
-     *
-     * @property {NodeList}
-     */
-    get childNodes() {
-        return this[treeStructureSymbol].childNodes;
-    }
-
-    /**
-     *
-     * @property {NodeList}
-     */
-    set childNodes(childNodes) {
-        this[treeStructureSymbol].childNodes = validateInstance(childNodes, NodeList);
-        setChildLevelAndParent.call(this, this, 1);
-    }
-
-    /**
-     * @return {Monster.Types.Node}
-     * @param {Node} node
-     */
-    appendChild(node) {
-        this[treeStructureSymbol].childNodes.add(validateInstance(node, Node));
-        node[treeStructureSymbol].parent = this;
-
-        node[treeStructureSymbol].level = this.level + 1;
-        setChildLevelAndParent.call(this, node, 1);
-        return this;
-    }
-
-    /**
-     * @return {Monster.Types.Node}
-     * @param {Node} node
-     */
-    removeChild(node) {
-        this[treeStructureSymbol].childNodes.remove(validateInstance(node, Node));
-        node[treeStructureSymbol].parent = null;
-
-        node[treeStructureSymbol].level = 0;
-        setChildLevelAndParent.call(this, node, -1);
-        return this;
-    }
-
-    /**
-     *
-     * @return {boolean}
-     */
-    hasChildNodes() {
-        return this[treeStructureSymbol].childNodes.length > 0;
-    }
-
-    /**
-     * @return {Monster.Types.Node}
-     * @param {Node} node
-     */
-    hasChild(node) {
-        return this[treeStructureSymbol].childNodes.has(validateInstance(node, Node));
-    }
-
-    /**
-     * @since 1.28.0
-     * @return {string}
-     */
-    toString() {
-        let parts = [];
-        if (this[internalValueSymbol]) {
-            let label = this[internalValueSymbol];
-            if (!isPrimitive(label)) label = JSON.stringify(this[internalValueSymbol]);
-
-            parts.push(label);
-        }
-
-        if (!this.hasChildNodes()) {
-            return parts.join("\n");
-        }
-
-        let count = this.childNodes.length;
-        let counter = 0;
-
-        for (const node of this.childNodes) {
-            counter++;
-            const prefix = (count === counter ? "└" : "├").padStart(2 * node.level, " |");
-            parts.push(prefix + node.toString());
-        }
-
-        return parts.join("\n");
-    }
+	/**
+	 * @param {*} [value]
+	 */
+	constructor(value) {
+		super();
+		this[internalValueSymbol] = value;
+
+		this[treeStructureSymbol] = {
+			parent: null,
+			childNodes: new NodeList(),
+			level: 0,
+		};
+	}
+
+	/**
+	 * This method is called by the `instanceof` operator.
+	 * @returns {symbol}
+	 * @since 2.1.0
+	 */
+	static get [instanceSymbol]() {
+		return Symbol.for("@schukai/monster/types/node");
+	}
+
+	/**
+	 * @property {*}
+	 */
+	get value() {
+		return this[internalValueSymbol];
+	}
+
+	/**
+	 * @property {*}
+	 */
+	set value(value) {
+		this[internalValueSymbol] = value;
+	}
+
+	/**
+	 * @property {Monster.Types.Node|null}
+	 */
+	get parent() {
+		return this[treeStructureSymbol].parent;
+	}
+
+	/**
+	 * @property {integer}
+	 */
+	get level() {
+		return this[treeStructureSymbol].level;
+	}
+
+	/**
+	 *
+	 * @property {NodeList}
+	 */
+	get childNodes() {
+		return this[treeStructureSymbol].childNodes;
+	}
+
+	/**
+	 *
+	 * @property {NodeList}
+	 */
+	set childNodes(childNodes) {
+		this[treeStructureSymbol].childNodes = validateInstance(
+			childNodes,
+			NodeList,
+		);
+		setChildLevelAndParent.call(this, this, 1);
+	}
+
+	/**
+	 * @return {Monster.Types.Node}
+	 * @param {Node} node
+	 */
+	appendChild(node) {
+		this[treeStructureSymbol].childNodes.add(validateInstance(node, Node));
+		node[treeStructureSymbol].parent = this;
+
+		node[treeStructureSymbol].level = this.level + 1;
+		setChildLevelAndParent.call(this, node, 1);
+		return this;
+	}
+
+	/**
+	 * @return {Monster.Types.Node}
+	 * @param {Node} node
+	 */
+	removeChild(node) {
+		this[treeStructureSymbol].childNodes.remove(validateInstance(node, Node));
+		node[treeStructureSymbol].parent = null;
+
+		node[treeStructureSymbol].level = 0;
+		setChildLevelAndParent.call(this, node, -1);
+		return this;
+	}
+
+	/**
+	 *
+	 * @return {boolean}
+	 */
+	hasChildNodes() {
+		return this[treeStructureSymbol].childNodes.length > 0;
+	}
+
+	/**
+	 * @return {Monster.Types.Node}
+	 * @param {Node} node
+	 */
+	hasChild(node) {
+		return this[treeStructureSymbol].childNodes.has(
+			validateInstance(node, Node),
+		);
+	}
+
+	/**
+	 * @since 1.28.0
+	 * @return {string}
+	 */
+	toString() {
+		const parts = [];
+		if (this[internalValueSymbol]) {
+			let label = this[internalValueSymbol];
+			if (!isPrimitive(label))
+				label = JSON.stringify(this[internalValueSymbol]);
+
+			parts.push(label);
+		}
+
+		if (!this.hasChildNodes()) {
+			return parts.join("\n");
+		}
+
+		const count = this.childNodes.length;
+		let counter = 0;
+
+		for (const node of this.childNodes) {
+			counter++;
+			const prefix = (count === counter ? "└" : "├").padStart(
+				2 * node.level,
+				" |",
+			);
+			parts.push(prefix + node.toString());
+		}
+
+		return parts.join("\n");
+	}
 }
 
 /**
@@ -183,16 +192,17 @@ class Node extends Base {
  * @return {setChildLevelAndParent}
  */
 function setChildLevelAndParent(node, operand) {
-    const self = this;
-
-    if (node !== this) {
-        node[treeStructureSymbol].parent = this;
-    }
-
-    node[treeStructureSymbol].childNodes.forEach(function (child) {
-        child[treeStructureSymbol].parent = node;
-        child[treeStructureSymbol].level = node[treeStructureSymbol].level + operand;
-        setChildLevelAndParent.call(self, child, operand);
-    });
-    return this;
+	const self = this;
+
+	if (node !== this) {
+		node[treeStructureSymbol].parent = this;
+	}
+
+	node[treeStructureSymbol].childNodes.forEach(function (child) {
+		child[treeStructureSymbol].parent = node;
+		child[treeStructureSymbol].level =
+			node[treeStructureSymbol].level + operand;
+		setChildLevelAndParent.call(self, child, operand);
+	});
+	return this;
 }