@logtape/logtape 1.2.0-dev.354 → 1.2.0-dev.359

package/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@logtape/logtape",
-  "version": "1.2.0-dev.354+e11ec186",
+  "version": "1.2.0-dev.359+da6face5",
   "license": "MIT",
   "exports": "./src/mod.ts",
   "imports": {

package/dist/logger.cjs

@@ -330,10 +330,227 @@ var LoggerCtx = class LoggerCtx {
 */
 const metaLogger = LoggerImpl.getLogger(["logtape", "meta"]);
 /**
+* Check if a property access key contains nested access patterns.
+* @param key The property key to check.
+* @returns True if the key contains nested access patterns.
+*/
+function isNestedAccess(key) {
+	return key.includes(".") || key.includes("[") || key.includes("?.");
+}
+/**
+* Safely access an own property from an object, blocking prototype pollution.
+*
+* @param obj The object to access the property from.
+* @param key The property key to access.
+* @returns The property value or undefined if not accessible.
+*/
+function getOwnProperty(obj, key) {
+	if (key === "__proto__" || key === "prototype" || key === "constructor") return void 0;
+	if ((typeof obj === "object" || typeof obj === "function") && obj !== null) return Object.prototype.hasOwnProperty.call(obj, key) ? obj[key] : void 0;
+	return void 0;
+}
+/**
+* Parse the next segment from a property path string.
+*
+* @param path The full property path string.
+* @param fromIndex The index to start parsing from.
+* @returns The parsed segment and next index, or null if parsing fails.
+*/
+function parseNextSegment(path, fromIndex) {
+	const len = path.length;
+	let i = fromIndex;
+	if (i >= len) return null;
+	let segment;
+	if (path[i] === "[") {
+		i++;
+		if (i >= len) return null;
+		if (path[i] === "\"" || path[i] === "'") {
+			const quote = path[i];
+			i++;
+			let segmentStr = "";
+			while (i < len && path[i] !== quote) if (path[i] === "\\") {
+				i++;
+				if (i < len) {
+					const escapeChar = path[i];
+					switch (escapeChar) {
+						case "n":
+							segmentStr += "\n";
+							break;
+						case "t":
+							segmentStr += "	";
+							break;
+						case "r":
+							segmentStr += "\r";
+							break;
+						case "b":
+							segmentStr += "\b";
+							break;
+						case "f":
+							segmentStr += "\f";
+							break;
+						case "v":
+							segmentStr += "\v";
+							break;
+						case "0":
+							segmentStr += "\0";
+							break;
+						case "\\":
+							segmentStr += "\\";
+							break;
+						case "\"":
+							segmentStr += "\"";
+							break;
+						case "'":
+							segmentStr += "'";
+							break;
+						case "u":
+							if (i + 4 < len) {
+								const hex = path.slice(i + 1, i + 5);
+								const codePoint = Number.parseInt(hex, 16);
+								if (!Number.isNaN(codePoint)) {
+									segmentStr += String.fromCharCode(codePoint);
+									i += 4;
+								} else segmentStr += escapeChar;
+							} else segmentStr += escapeChar;
+							break;
+						default: segmentStr += escapeChar;
+					}
+					i++;
+				}
+			} else {
+				segmentStr += path[i];
+				i++;
+			}
+			if (i >= len) return null;
+			segment = segmentStr;
+			i++;
+		} else {
+			const startIndex = i;
+			while (i < len && path[i] !== "]" && path[i] !== "'" && path[i] !== "\"") i++;
+			if (i >= len) return null;
+			const indexStr = path.slice(startIndex, i);
+			if (indexStr.length === 0) return null;
+			const indexNum = Number(indexStr);
+			segment = Number.isNaN(indexNum) ? indexStr : indexNum;
+		}
+		while (i < len && path[i] !== "]") i++;
+		if (i < len) i++;
+	} else {
+		const startIndex = i;
+		while (i < len && path[i] !== "." && path[i] !== "[" && path[i] !== "?" && path[i] !== "]") i++;
+		segment = path.slice(startIndex, i);
+		if (segment.length === 0) return null;
+	}
+	if (i < len && path[i] === ".") i++;
+	return {
+		segment,
+		nextIndex: i
+	};
+}
+/**
+* Access a property or index on an object or array.
+*
+* @param obj The object or array to access.
+* @param segment The property key or array index.
+* @returns The accessed value or undefined if not accessible.
+*/
+function accessProperty(obj, segment) {
+	if (typeof segment === "string") return getOwnProperty(obj, segment);
+	if (Array.isArray(obj) && segment >= 0 && segment < obj.length) return obj[segment];
+	return void 0;
+}
+/**
+* Resolve a nested property path from an object.
+*
+* There are two types of property access patterns:
+* 1. Array/index access: [0] or ["prop"]
+* 2. Property access: prop or prop?.next
+*
+* @param obj The object to traverse.
+* @param path The property path (e.g., "user.name", "users[0].email", "user['full-name']").
+* @returns The resolved value or undefined if path doesn't exist.
+*/
+function resolvePropertyPath(obj, path) {
+	if (obj == null) return void 0;
+	if (path.length === 0 || path.endsWith(".")) return void 0;
+	let current = obj;
+	let i = 0;
+	const len = path.length;
+	while (i < len) {
+		const isOptional = path.slice(i, i + 2) === "?.";
+		if (isOptional) {
+			i += 2;
+			if (current == null) return void 0;
+		} else if (current == null) return void 0;
+		const result = parseNextSegment(path, i);
+		if (result === null) return void 0;
+		const { segment, nextIndex } = result;
+		i = nextIndex;
+		current = accessProperty(current, segment);
+		if (current === void 0) return void 0;
+	}
+	return current;
+}
+/**
 * Parse a message template into a message template array and a values array.
-* @param template The message template.
+*
+* Placeholders to be replaced with `values` are indicated by keys in curly braces
+* (e.g., `{value}`). The system supports both simple property access and nested
+* property access patterns:
+*
+* **Simple property access:**
+* ```ts
+* parseMessageTemplate("Hello, {user}!", { user: "foo" })
+* // Returns: ["Hello, ", "foo", "!"]
+* ```
+*
+* **Nested property access (dot notation):**
+* ```ts
+* parseMessageTemplate("Hello, {user.name}!", {
+*   user: { name: "foo", email: "foo@example.com" }
+* })
+* // Returns: ["Hello, ", "foo", "!"]
+* ```
+*
+* **Array indexing:**
+* ```ts
+* parseMessageTemplate("First: {users[0]}", {
+*   users: ["foo", "bar", "baz"]
+* })
+* // Returns: ["First: ", "foo", ""]
+* ```
+*
+* **Bracket notation for special property names:**
+* ```ts
+* parseMessageTemplate("Name: {user[\"full-name\"]}", {
+*   user: { "full-name": "foo bar" }
+* })
+* // Returns: ["Name: ", "foo bar", ""]
+* ```
+*
+* **Optional chaining for safe navigation:**
+* ```ts
+* parseMessageTemplate("Email: {user?.profile?.email}", {
+*   user: { name: "foo" }
+* })
+* // Returns: ["Email: ", undefined, ""]
+* ```
+*
+* **Wildcard patterns:**
+* - `{*}` - Replaced with the entire properties object
+* - `{ key-with-whitespace }` - Whitespace is trimmed when looking up keys
+*
+* **Escaping:**
+* - `{{` and `}}` are escaped literal braces
+*
+* **Error handling:**
+* - Non-existent paths return `undefined`
+* - Malformed expressions resolve to `undefined` without throwing errors
+* - Out of bounds array access returns `undefined`
+*
+* @param template The message template string containing placeholders.
 * @param properties The values to replace placeholders with.
-* @returns The message template array and the values array.
+* @returns The message template array with values interleaved between text segments.
 */
 function parseMessageTemplate(template, properties) {
 	const length = template.length;
@@ -357,8 +574,11 @@ function parseMessageTemplate(template, properties) {
 			let prop;
 			const trimmedKey = key.trim();
 			if (trimmedKey === "*") prop = key in properties ? properties[key] : "*" in properties ? properties["*"] : properties;
-			else if (key !== trimmedKey) prop = key in properties ? properties[key] : properties[trimmedKey];
-			else prop = properties[key];
+			else {
+				if (key !== trimmedKey) prop = key in properties ? properties[key] : properties[trimmedKey];
+				else prop = properties[key];
+				if (prop === void 0 && isNestedAccess(trimmedKey)) prop = resolvePropertyPath(properties, trimmedKey);
+			}
 			message.push(prop);
 			i = closeIndex;
 			startIndex = i + 1;

package/dist/logger.js

@@ -330,10 +330,227 @@ var LoggerCtx = class LoggerCtx {
 */
 const metaLogger = LoggerImpl.getLogger(["logtape", "meta"]);
 /**
+* Check if a property access key contains nested access patterns.
+* @param key The property key to check.
+* @returns True if the key contains nested access patterns.
+*/
+function isNestedAccess(key) {
+	return key.includes(".") || key.includes("[") || key.includes("?.");
+}
+/**
+* Safely access an own property from an object, blocking prototype pollution.
+*
+* @param obj The object to access the property from.
+* @param key The property key to access.
+* @returns The property value or undefined if not accessible.
+*/
+function getOwnProperty(obj, key) {
+	if (key === "__proto__" || key === "prototype" || key === "constructor") return void 0;
+	if ((typeof obj === "object" || typeof obj === "function") && obj !== null) return Object.prototype.hasOwnProperty.call(obj, key) ? obj[key] : void 0;
+	return void 0;
+}
+/**
+* Parse the next segment from a property path string.
+*
+* @param path The full property path string.
+* @param fromIndex The index to start parsing from.
+* @returns The parsed segment and next index, or null if parsing fails.
+*/
+function parseNextSegment(path, fromIndex) {
+	const len = path.length;
+	let i = fromIndex;
+	if (i >= len) return null;
+	let segment;
+	if (path[i] === "[") {
+		i++;
+		if (i >= len) return null;
+		if (path[i] === "\"" || path[i] === "'") {
+			const quote = path[i];
+			i++;
+			let segmentStr = "";
+			while (i < len && path[i] !== quote) if (path[i] === "\\") {
+				i++;
+				if (i < len) {
+					const escapeChar = path[i];
+					switch (escapeChar) {
+						case "n":
+							segmentStr += "\n";
+							break;
+						case "t":
+							segmentStr += "	";
+							break;
+						case "r":
+							segmentStr += "\r";
+							break;
+						case "b":
+							segmentStr += "\b";
+							break;
+						case "f":
+							segmentStr += "\f";
+							break;
+						case "v":
+							segmentStr += "\v";
+							break;
+						case "0":
+							segmentStr += "\0";
+							break;
+						case "\\":
+							segmentStr += "\\";
+							break;
+						case "\"":
+							segmentStr += "\"";
+							break;
+						case "'":
+							segmentStr += "'";
+							break;
+						case "u":
+							if (i + 4 < len) {
+								const hex = path.slice(i + 1, i + 5);
+								const codePoint = Number.parseInt(hex, 16);
+								if (!Number.isNaN(codePoint)) {
+									segmentStr += String.fromCharCode(codePoint);
+									i += 4;
+								} else segmentStr += escapeChar;
+							} else segmentStr += escapeChar;
+							break;
+						default: segmentStr += escapeChar;
+					}
+					i++;
+				}
+			} else {
+				segmentStr += path[i];
+				i++;
+			}
+			if (i >= len) return null;
+			segment = segmentStr;
+			i++;
+		} else {
+			const startIndex = i;
+			while (i < len && path[i] !== "]" && path[i] !== "'" && path[i] !== "\"") i++;
+			if (i >= len) return null;
+			const indexStr = path.slice(startIndex, i);
+			if (indexStr.length === 0) return null;
+			const indexNum = Number(indexStr);
+			segment = Number.isNaN(indexNum) ? indexStr : indexNum;
+		}
+		while (i < len && path[i] !== "]") i++;
+		if (i < len) i++;
+	} else {
+		const startIndex = i;
+		while (i < len && path[i] !== "." && path[i] !== "[" && path[i] !== "?" && path[i] !== "]") i++;
+		segment = path.slice(startIndex, i);
+		if (segment.length === 0) return null;
+	}
+	if (i < len && path[i] === ".") i++;
+	return {
+		segment,
+		nextIndex: i
+	};
+}
+/**
+* Access a property or index on an object or array.
+*
+* @param obj The object or array to access.
+* @param segment The property key or array index.
+* @returns The accessed value or undefined if not accessible.
+*/
+function accessProperty(obj, segment) {
+	if (typeof segment === "string") return getOwnProperty(obj, segment);
+	if (Array.isArray(obj) && segment >= 0 && segment < obj.length) return obj[segment];
+	return void 0;
+}
+/**
+* Resolve a nested property path from an object.
+*
+* There are two types of property access patterns:
+* 1. Array/index access: [0] or ["prop"]
+* 2. Property access: prop or prop?.next
+*
+* @param obj The object to traverse.
+* @param path The property path (e.g., "user.name", "users[0].email", "user['full-name']").
+* @returns The resolved value or undefined if path doesn't exist.
+*/
+function resolvePropertyPath(obj, path) {
+	if (obj == null) return void 0;
+	if (path.length === 0 || path.endsWith(".")) return void 0;
+	let current = obj;
+	let i = 0;
+	const len = path.length;
+	while (i < len) {
+		const isOptional = path.slice(i, i + 2) === "?.";
+		if (isOptional) {
+			i += 2;
+			if (current == null) return void 0;
+		} else if (current == null) return void 0;
+		const result = parseNextSegment(path, i);
+		if (result === null) return void 0;
+		const { segment, nextIndex } = result;
+		i = nextIndex;
+		current = accessProperty(current, segment);
+		if (current === void 0) return void 0;
+	}
+	return current;
+}
+/**
 * Parse a message template into a message template array and a values array.
-* @param template The message template.
+*
+* Placeholders to be replaced with `values` are indicated by keys in curly braces
+* (e.g., `{value}`). The system supports both simple property access and nested
+* property access patterns:
+*
+* **Simple property access:**
+* ```ts
+* parseMessageTemplate("Hello, {user}!", { user: "foo" })
+* // Returns: ["Hello, ", "foo", "!"]
+* ```
+*
+* **Nested property access (dot notation):**
+* ```ts
+* parseMessageTemplate("Hello, {user.name}!", {
+*   user: { name: "foo", email: "foo@example.com" }
+* })
+* // Returns: ["Hello, ", "foo", "!"]
+* ```
+*
+* **Array indexing:**
+* ```ts
+* parseMessageTemplate("First: {users[0]}", {
+*   users: ["foo", "bar", "baz"]
+* })
+* // Returns: ["First: ", "foo", ""]
+* ```
+*
+* **Bracket notation for special property names:**
+* ```ts
+* parseMessageTemplate("Name: {user[\"full-name\"]}", {
+*   user: { "full-name": "foo bar" }
+* })
+* // Returns: ["Name: ", "foo bar", ""]
+* ```
+*
+* **Optional chaining for safe navigation:**
+* ```ts
+* parseMessageTemplate("Email: {user?.profile?.email}", {
+*   user: { name: "foo" }
+* })
+* // Returns: ["Email: ", undefined, ""]
+* ```
+*
+* **Wildcard patterns:**
+* - `{*}` - Replaced with the entire properties object
+* - `{ key-with-whitespace }` - Whitespace is trimmed when looking up keys
+*
+* **Escaping:**
+* - `{{` and `}}` are escaped literal braces
+*
+* **Error handling:**
+* - Non-existent paths return `undefined`
+* - Malformed expressions resolve to `undefined` without throwing errors
+* - Out of bounds array access returns `undefined`
+*
+* @param template The message template string containing placeholders.
 * @param properties The values to replace placeholders with.
-* @returns The message template array and the values array.
+* @returns The message template array with values interleaved between text segments.
 */
 function parseMessageTemplate(template, properties) {
 	const length = template.length;
@@ -357,8 +574,11 @@ function parseMessageTemplate(template, properties) {
 			let prop;
 			const trimmedKey = key.trim();
 			if (trimmedKey === "*") prop = key in properties ? properties[key] : "*" in properties ? properties["*"] : properties;
-			else if (key !== trimmedKey) prop = key in properties ? properties[key] : properties[trimmedKey];
-			else prop = properties[key];
+			else {
+				if (key !== trimmedKey) prop = key in properties ? properties[key] : properties[trimmedKey];
+				else prop = properties[key];
+				if (prop === void 0 && isNestedAccess(trimmedKey)) prop = resolvePropertyPath(properties, trimmedKey);
+			}
 			message.push(prop);
 			i = closeIndex;
 			startIndex = i + 1;