@schukai/monster 3.51.5 → 3.52.1

package/source/text/formatter.mjs

@@ -109,115 +109,117 @@ const workingDataSymbol = Symbol("workingData");
  * @memberOf Monster.Text
  */
 class Formatter extends BaseWithOptions {
-    /**
-     * Default values for the markers are `${` and `}`
-     *
-     * @param {object} object
-     * @throws {TypeError} value is not a object
-     */
-    constructor(object, options) {
-        super(options);
-        this[internalObjectSymbol] = object || {};
-        this[markerOpenIndexSymbol] = 0;
-        this[markerCloseIndexSymbol] = 0;
-    }
-
-    /**
-     * @property {object} marker
-     * @property {array} marker.open=["${"]
-     * @property {array} marker.close=["${"]
-     * @property {object} parameter
-     * @property {string} parameter.delimiter="::"
-     * @property {string} parameter.assignment="="
-     * @property {object} callbacks={}
-     */
-    get defaults() {
-        return extend({}, super.defaults, {
-            marker: {
-                open: ["${"],
-                close: ["}"],
-            },
-            parameter: {
-                delimiter: "::",
-                assignment: "=",
-            },
-            callbacks: {},
-        });
-    }
-
-    /**
-     * Set new Parameter Character
-     *
-     * Default values for the chars are `::` and `=`
-     *
-     * ```
-     * formatter.setParameterChars('#');
-     * formatter.setParameterChars('[',']');
-     * formatter.setParameterChars('i18n{','}');
-     * ```
-     *
-     * @param {string} delimiter
-     * @param {string} assignment
-     * @return {Formatter}
-     * @since 1.24.0
-     * @throws {TypeError} value is not a string
-     */
-    setParameterChars(delimiter, assignment) {
-        if (delimiter !== undefined) {
-            this[internalSymbol]["parameter"]["delimiter"] = validateString(delimiter);
-        }
-
-        if (assignment !== undefined) {
-            this[internalSymbol]["parameter"]["assignment"] = validateString(assignment);
-        }
-
-        return this;
-    }
-
-    /**
-     * Set new Marker
-     *
-     * Default values for the markers are `${` and `}`
-     *
-     * ```
-     * formatter.setMarker('#'); // open and close are both #
-     * formatter.setMarker('[',']');
-     * formatter.setMarker('i18n{','}');
-     * ```
-     *
-     * @param {array|string} open
-     * @param {array|string|undefined} close
-     * @return {Formatter}
-     * @since 1.12.0
-     * @throws {TypeError} value is not a string
-     */
-    setMarker(open, close) {
-        if (close === undefined) {
-            close = open;
-        }
-
-        if (isString(open)) open = [open];
-        if (isString(close)) close = [close];
-
-        this[internalSymbol]["marker"]["open"] = validateArray(open);
-        this[internalSymbol]["marker"]["close"] = validateArray(close);
-        return this;
-    }
-
-    /**
-     *
-     * @param {string} text
-     * @return {string}
-     * @throws {TypeError} value is not a string
-     * @throws {Error} too deep nesting
-     */
-    format(text) {
-        this[watchdogSymbol] = 0;
-        this[markerOpenIndexSymbol] = 0;
-        this[markerCloseIndexSymbol] = 0;
-        this[workingDataSymbol] = {};
-        return format.call(this, text);
-    }
+	/**
+	 * Default values for the markers are `${` and `}`
+	 *
+	 * @param {object} object
+	 * @throws {TypeError} value is not a object
+	 */
+	constructor(object, options) {
+		super(options);
+		this[internalObjectSymbol] = object || {};
+		this[markerOpenIndexSymbol] = 0;
+		this[markerCloseIndexSymbol] = 0;
+	}
+
+	/**
+	 * @property {object} marker
+	 * @property {array} marker.open=["${"]
+	 * @property {array} marker.close=["${"]
+	 * @property {object} parameter
+	 * @property {string} parameter.delimiter="::"
+	 * @property {string} parameter.assignment="="
+	 * @property {object} callbacks={}
+	 */
+	get defaults() {
+		return extend({}, super.defaults, {
+			marker: {
+				open: ["${"],
+				close: ["}"],
+			},
+			parameter: {
+				delimiter: "::",
+				assignment: "=",
+			},
+			callbacks: {},
+		});
+	}
+
+	/**
+	 * Set new Parameter Character
+	 *
+	 * Default values for the chars are `::` and `=`
+	 *
+	 * ```
+	 * formatter.setParameterChars('#');
+	 * formatter.setParameterChars('[',']');
+	 * formatter.setParameterChars('i18n{','}');
+	 * ```
+	 *
+	 * @param {string} delimiter
+	 * @param {string} assignment
+	 * @return {Formatter}
+	 * @since 1.24.0
+	 * @throws {TypeError} value is not a string
+	 */
+	setParameterChars(delimiter, assignment) {
+		if (delimiter !== undefined) {
+			this[internalSymbol]["parameter"]["delimiter"] =
+				validateString(delimiter);
+		}
+
+		if (assignment !== undefined) {
+			this[internalSymbol]["parameter"]["assignment"] =
+				validateString(assignment);
+		}
+
+		return this;
+	}
+
+	/**
+	 * Set new Marker
+	 *
+	 * Default values for the markers are `${` and `}`
+	 *
+	 * ```
+	 * formatter.setMarker('#'); // open and close are both #
+	 * formatter.setMarker('[',']');
+	 * formatter.setMarker('i18n{','}');
+	 * ```
+	 *
+	 * @param {array|string} open
+	 * @param {array|string|undefined} close
+	 * @return {Formatter}
+	 * @since 1.12.0
+	 * @throws {TypeError} value is not a string
+	 */
+	setMarker(open, close) {
+		if (close === undefined) {
+			close = open;
+		}
+
+		if (isString(open)) open = [open];
+		if (isString(close)) close = [close];
+
+		this[internalSymbol]["marker"]["open"] = validateArray(open);
+		this[internalSymbol]["marker"]["close"] = validateArray(close);
+		return this;
+	}
+
+	/**
+	 *
+	 * @param {string} text
+	 * @return {string}
+	 * @throws {TypeError} value is not a string
+	 * @throws {Error} too deep nesting
+	 */
+	format(text) {
+		this[watchdogSymbol] = 0;
+		this[markerOpenIndexSymbol] = 0;
+		this[markerCloseIndexSymbol] = 0;
+		this[workingDataSymbol] = {};
+		return format.call(this, text);
+	}
 }
 
 /**
@@ -225,34 +227,43 @@ class Formatter extends BaseWithOptions {
  * @return {string}
  */
 function format(text) {
-    const self = this;
-
-    self[watchdogSymbol]++;
-    if (this[watchdogSymbol] > 20) {
-        throw new Error("too deep nesting");
-    }
-
-    let openMarker = self[internalSymbol]["marker"]["open"]?.[this[markerOpenIndexSymbol]];
-    let closeMarker = self[internalSymbol]["marker"]["close"]?.[this[markerCloseIndexSymbol]];
-
-    // contains no placeholders
-    if (text.indexOf(openMarker) === -1 || text.indexOf(closeMarker) === -1) {
-        return text;
-    }
-
-    let result = tokenize.call(this, validateString(text), openMarker, closeMarker);
-
-    if (self[internalSymbol]["marker"]["open"]?.[this[markerOpenIndexSymbol] + 1]) {
-        this[markerOpenIndexSymbol]++;
-    }
-
-    if (self[internalSymbol]["marker"]["close"]?.[this[markerCloseIndexSymbol] + 1]) {
-        this[markerCloseIndexSymbol]++;
-    }
-
-    result = format.call(self, result);
-
-    return result;
+	this[watchdogSymbol]++;
+	if (this[watchdogSymbol] > 20) {
+		throw new Error("too deep nesting");
+	}
+
+	const openMarker =
+		this[internalSymbol]["marker"]["open"]?.[this[markerOpenIndexSymbol]];
+	const closeMarker =
+		this[internalSymbol]["marker"]["close"]?.[this[markerCloseIndexSymbol]];
+
+	// contains no placeholders
+	if (text.indexOf(openMarker) === -1 || text.indexOf(closeMarker) === -1) {
+		return text;
+	}
+
+	let result = tokenize.call(
+		this,
+		validateString(text),
+		openMarker,
+		closeMarker,
+	);
+
+	if (
+		this[internalSymbol]["marker"]["open"]?.[this[markerOpenIndexSymbol] + 1]
+	) {
+		this[markerOpenIndexSymbol]++;
+	}
+
+	if (
+		this[internalSymbol]["marker"]["close"]?.[this[markerCloseIndexSymbol] + 1]
+	) {
+		this[markerCloseIndexSymbol]++;
+	}
+
+	result = format.call(this, result);
+
+	return result;
 }
 
 /**
@@ -263,77 +274,91 @@ function format(text) {
  * @return {string}
  */
 function tokenize(text, openMarker, closeMarker) {
-    const self = this;
-
-    let formatted = [];
-
-    const parameterAssignment = self[internalSymbol]["parameter"]["assignment"];
-    const parameterDelimiter = self[internalSymbol]["parameter"]["delimiter"];
-    const callbacks = self[internalSymbol]["callbacks"];
-
-    while (true) {
-        let startIndex = text.indexOf(openMarker);
-        // no marker
-        if (startIndex === -1) {
-            formatted.push(text);
-            break;
-        } else if (startIndex > 0) {
-            formatted.push(text.substring(0, startIndex));
-            text = text.substring(startIndex);
-        }
-
-        let endIndex = text.substring(openMarker.length).indexOf(closeMarker);
-        if (endIndex !== -1) endIndex += openMarker.length;
-        let insideStartIndex = text.substring(openMarker.length).indexOf(openMarker);
-        if (insideStartIndex !== -1) {
-            insideStartIndex += openMarker.length;
-            if (insideStartIndex < endIndex) {
-                let result = tokenize.call(self, text.substring(insideStartIndex), openMarker, closeMarker);
-                text = text.substring(0, insideStartIndex) + result;
-                endIndex = text.substring(openMarker.length).indexOf(closeMarker);
-                if (endIndex !== -1) endIndex += openMarker.length;
-            }
-        }
-
-        if (endIndex === -1) {
-            throw new Error("syntax error in formatter template");
-        }
-
-        let key = text.substring(openMarker.length, endIndex);
-        let parts = key.split(parameterDelimiter);
-        let currentPipe = parts.shift();
-
-        self[workingDataSymbol] = extend({}, self[internalObjectSymbol], self[workingDataSymbol]);
-
-        for (const kv of parts) {
-            const [k, v] = kv.split(parameterAssignment);
-            self[workingDataSymbol][k] = v;
-        }
-
-        const t1 = key.split("|").shift().trim(); // pipe symbol
-        const t2 = t1.split("::").shift().trim(); // key value delimiter
-        const t3 = t2.split(".").shift().trim(); // path delimiter
-        let prefix = self[workingDataSymbol]?.[t3] ? "path:" : "static:";
-
-        let command = "";
-        if (prefix && key.indexOf(prefix) !== 0 && key.indexOf("path:") !== 0 && key.indexOf("static:") !== 0) {
-            command = prefix;
-        }
-
-        command += currentPipe;
-
-        const pipe = new Pipe(command);
-
-        if (isObject(callbacks)) {
-            for (const [name, callback] of Object.entries(callbacks)) {
-                pipe.setCallback(name, callback);
-            }
-        }
-
-        formatted.push(validateString(pipe.run(self[workingDataSymbol])));
-
-        text = text.substring(endIndex + closeMarker.length);
-    }
-
-    return formatted.join("");
+	const formatted = [];
+
+	const parameterAssignment = this[internalSymbol]["parameter"]["assignment"];
+	const parameterDelimiter = this[internalSymbol]["parameter"]["delimiter"];
+	const callbacks = this[internalSymbol]["callbacks"];
+
+	while (true) {
+		const startIndex = text.indexOf(openMarker);
+		// no marker
+		if (startIndex === -1) {
+			formatted.push(text);
+			break;
+		} else if (startIndex > 0) {
+			formatted.push(text.substring(0, startIndex));
+			text = text.substring(startIndex);
+		}
+
+		let endIndex = text.substring(openMarker.length).indexOf(closeMarker);
+		if (endIndex !== -1) endIndex += openMarker.length;
+		let insideStartIndex = text
+			.substring(openMarker.length)
+			.indexOf(openMarker);
+		if (insideStartIndex !== -1) {
+			insideStartIndex += openMarker.length;
+			if (insideStartIndex < endIndex) {
+				const result = tokenize.call(
+					this,
+					text.substring(insideStartIndex),
+					openMarker,
+					closeMarker,
+				);
+				text = text.substring(0, insideStartIndex) + result;
+				endIndex = text.substring(openMarker.length).indexOf(closeMarker);
+				if (endIndex !== -1) endIndex += openMarker.length;
+			}
+		}
+
+		if (endIndex === -1) {
+			throw new Error("syntax error in formatter template");
+		}
+
+		const key = text.substring(openMarker.length, endIndex);
+		const parts = key.split(parameterDelimiter);
+		const currentPipe = parts.shift();
+
+		this[workingDataSymbol] = extend(
+			{},
+			this[internalObjectSymbol],
+			this[workingDataSymbol],
+		);
+
+		for (const kv of parts) {
+			const [k, v] = kv.split(parameterAssignment);
+			this[workingDataSymbol][k] = v;
+		}
+
+		const t1 = key.split("|").shift().trim(); // pipe symbol
+		const t2 = t1.split("::").shift().trim(); // key value delimiter
+		const t3 = t2.split(".").shift().trim(); // path delimiter
+		const prefix = this[workingDataSymbol]?.[t3] ? "path:" : "static:";
+
+		let command = "";
+		if (
+			prefix &&
+			key.indexOf(prefix) !== 0 &&
+			key.indexOf("path:") !== 0 &&
+			key.indexOf("static:") !== 0
+		) {
+			command = prefix;
+		}
+
+		command += currentPipe;
+
+		const pipe = new Pipe(command);
+
+		if (isObject(callbacks)) {
+			for (const [name, callback] of Object.entries(callbacks)) {
+				pipe.setCallback(name, callback);
+			}
+		}
+
+		formatted.push(validateString(pipe.run(this[workingDataSymbol])));
+
+		text = text.substring(endIndex + closeMarker.length);
+	}
+
+	return formatted.join("");
 }

package/source/text/generate-range-comparison-expression.mjs

@@ -56,38 +56,60 @@ export { generateRangeComparisonExpression };
  * @memberOf Monster.Text
  * @summary Generates a comparison expression based on a range of values.
  */
-function generateRangeComparisonExpression(expression, valueName, options = {}) {
-    const { urlEncode = false, andOp = "&&", orOp = "||", eqOp = "==", geOp = ">=", leOp = "<=" } = options;
-    const ranges = expression.split(",");
-    let comparison = "";
-    for (let i = 0; i < ranges.length; i++) {
-        const range = ranges[i].trim();
-        if (range === "") {
-            throw new Error(`Invalid range '${range}'`);
-        } else if (range.includes("-")) {
-            const [start, end] = range.split("-").map((s) => (s === "" ? null : parseFloat(s)));
-            if ((start !== null && isNaN(start)) || (end !== null && isNaN(end))) {
-                throw new Error(`Invalid value in range '${range}'`);
-            }
-            if (start !== null && end !== null && start > end) {
-                throw new Error(`Invalid range '${range}'`);
-            }
-            const compStart =
-                start !== null ? `${valueName}${urlEncode ? encodeURIComponent(geOp) : geOp}${start}` : "";
-            const compEnd = end !== null ? `${valueName}${urlEncode ? encodeURIComponent(leOp) : leOp}${end}` : "";
-            const compRange = `${compStart}${compStart && compEnd ? ` ${andOp} ` : ""}${compEnd}`;
-            comparison += ranges.length > 1 ? `(${compRange})` : compRange;
-        } else {
-            const value = parseFloat(range);
-            if (isNaN(value)) {
-                throw new Error(`Invalid value '${range}'`);
-            }
-            const compValue = `${valueName}${urlEncode ? encodeURIComponent(eqOp) : eqOp}${value}`;
-            comparison += ranges.length > 1 ? `(${compValue})` : compValue;
-        }
-        if (i < ranges.length - 1) {
-            comparison += ` ${orOp} `;
-        }
-    }
-    return comparison;
+function generateRangeComparisonExpression(
+	expression,
+	valueName,
+	options = {},
+) {
+	const {
+		urlEncode = false,
+		andOp = "&&",
+		orOp = "||",
+		eqOp = "==",
+		geOp = ">=",
+		leOp = "<=",
+	} = options;
+	const ranges = expression.split(",");
+	let comparison = "";
+	for (let i = 0; i < ranges.length; i++) {
+		const range = ranges[i].trim();
+		if (range === "") {
+			throw new Error(`Invalid range '${range}'`);
+		} else if (range.includes("-")) {
+			const [start, end] = range
+				.split("-")
+				.map((s) => (s === "" ? null : parseFloat(s)));
+			if ((start !== null && isNaN(start)) || (end !== null && isNaN(end))) {
+				throw new Error(`Invalid value in range '${range}'`);
+			}
+			if (start !== null && end !== null && start > end) {
+				throw new Error(`Invalid range '${range}'`);
+			}
+			const compStart =
+				start !== null
+					? `${valueName}${urlEncode ? encodeURIComponent(geOp) : geOp}${start}`
+					: "";
+			const compEnd =
+				end !== null
+					? `${valueName}${urlEncode ? encodeURIComponent(leOp) : leOp}${end}`
+					: "";
+			const compRange = `${compStart}${
+				compStart && compEnd ? ` ${andOp} ` : ""
+			}${compEnd}`;
+			comparison += ranges.length > 1 ? `(${compRange})` : compRange;
+		} else {
+			const value = parseFloat(range);
+			if (isNaN(value)) {
+				throw new Error(`Invalid value '${range}'`);
+			}
+			const compValue = `${valueName}${
+				urlEncode ? encodeURIComponent(eqOp) : eqOp
+			}${value}`;
+			comparison += ranges.length > 1 ? `(${compValue})` : compValue;
+		}
+		if (i < ranges.length - 1) {
+			comparison += ` ${orOp} `;
+		}
+	}
+	return comparison;
 }

package/source/text/namespace.mjs

@@ -4,7 +4,7 @@
  */
 
 /**
- * Namespace for texts.
+ * Namespace for all text related functions.
  *
  * @namespace Monster.Text
  * @memberOf Monster