@techsquidtv/eslint-plugin-structured-logging 0.1.0

package/lib/rules/logger/require-logger-primitive-attributes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-logger-primitive-attributes.js","names":[],"sources":["../../../src/rules/logger/require-logger-primitive-attributes.ts"],"sourcesContent":["import { createRule } from \"@/utils\";\nimport {\n\tDEFAULT_LOGGER_MATCHER_OPTIONS,\n\tLOGGER_MATCHER_OPTION_SCHEMA_PROPERTIES,\n\tbuildLoggerMatcherSets,\n\tcollectAttrsEntries,\n\tgetLoggerArguments,\n\tisDisallowedAttributeValue,\n\ttype LoggerMatcherOptions,\n} from \"@/rules/logger/utils\";\n\ntype MessageIds = \"primitiveAttributeValue\";\n\n/** Options for primitive logger attribute enforcement. */\nexport interface RequireLoggerPrimitiveAttributesOptions extends LoggerMatcherOptions {\n\t/**\n\t * Reject expressions whose static value shape is unknown instead of\n\t * allowing them as attribute values.\n\t */\n\tdisallowUnknownAttributeValues?: boolean;\n}\n\ntype RuleOptions = [RequireLoggerPrimitiveAttributesOptions];\n\n/** Enforces primitive values (or arrays of primitives) for logger attributes. */\nexport const requireLoggerPrimitiveAttributes = createRule<\n\tRuleOptions,\n\tMessageIds\n>({\n\tname: \"require-logger-primitive-attributes\",\n\tmeta: {\n\t\ttype: \"problem\",\n\t\tdocs: {\n\t\t\tdescription:\n\t\t\t\t\"Require logger attribute values to be primitives or arrays of primitives.\",\n\t\t\trecommended: true,\n\t\t},\n\t\tmessages: {\n\t\t\tprimitiveAttributeValue:\n\t\t\t\t'Attribute \"{{key}}\" must be a primitive or an array of primitives. Use a string, number, or boolean (or an array of those), or flatten nested data into separate attributes.',\n\t\t},\n\t\tschema: [\n\t\t\t{\n\t\t\t\ttype: \"object\",\n\t\t\t\tproperties: {\n\t\t\t\t\t...LOGGER_MATCHER_OPTION_SCHEMA_PROPERTIES,\n\t\t\t\t\tdisallowUnknownAttributeValues: {\n\t\t\t\t\t\tdescription:\n\t\t\t\t\t\t\t\"Reject expressions whose static value shape is unknown instead of allowing them as attribute values.\",\n\t\t\t\t\t\ttype: \"boolean\",\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t\tadditionalProperties: false,\n\t\t\t},\n\t\t],\n\t\tdefaultOptions: [\n\t\t\t{\n\t\t\t\t...DEFAULT_LOGGER_MATCHER_OPTIONS,\n\t\t\t\tdisallowUnknownAttributeValues: false,\n\t\t\t},\n\t\t],\n\t},\n\tcreate(context) {\n\t\tconst sets = buildLoggerMatcherSets(context.options[0]);\n\n\t\treturn {\n\t\t\tCallExpression(node) {\n\t\t\t\tconst args = getLoggerArguments(node, sets);\n\t\t\t\tif (!args) return;\n\n\t\t\t\tconst entries = collectAttrsEntries(args.attrsArg);\n\t\t\t\tif (!entries) return;\n\n\t\t\t\tfor (const entry of entries) {\n\t\t\t\t\tif (isDisallowedAttributeValue(entry.valueNode, context.options[0])) {\n\t\t\t\t\t\tcontext.report({\n\t\t\t\t\t\t\tnode: entry.valueNode,\n\t\t\t\t\t\t\tmessageId: \"primitiveAttributeValue\",\n\t\t\t\t\t\t\tdata: { key: entry.key },\n\t\t\t\t\t\t});\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t},\n\t\t};\n\t},\n});\n"],"mappings":";;;;AAyBA,MAAa,mCAAmC,WAG9C;CACD,MAAM;CACN,MAAM;EACL,MAAM;EACN,MAAM;GACL,aACC;GACD,aAAa;EACd;EACA,UAAU,EACT,yBACC,iLACF;EACA,QAAQ,CACP;GACC,MAAM;GACN,YAAY;IACX,GAAG;IACH,gCAAgC;KAC/B,aACC;KACD,MAAM;IACP;GACD;GACA,sBAAsB;EACvB,CACD;EACA,gBAAgB,CACf;GACC,GAAG;GACH,gCAAgC;EACjC,CACD;CACD;CACA,OAAO,SAAS;EACf,MAAM,OAAO,uBAAuB,QAAQ,QAAQ,EAAE;EAEtD,OAAO,EACN,eAAe,MAAM;GACpB,MAAM,OAAO,mBAAmB,MAAM,IAAI;GAC1C,IAAI,CAAC,MAAM;GAEX,MAAM,UAAU,oBAAoB,KAAK,QAAQ;GACjD,IAAI,CAAC,SAAS;GAEd,KAAK,MAAM,SAAS,SACnB,IAAI,2BAA2B,MAAM,WAAW,QAAQ,QAAQ,EAAE,GACjE,QAAQ,OAAO;IACd,MAAM,MAAM;IACZ,WAAW;IACX,MAAM,EAAE,KAAK,MAAM,IAAI;GACxB,CAAC;EAGJ,EACD;CACD;AACD,CAAC"}

package/lib/rules/logger/require-logger-scoped-dot-notation.d.ts

@@ -0,0 +1,21 @@
+import { LoggerMatcherOptions } from "./utils.js";
+import { StructuredLoggingPluginDocs } from "../../utils.js";
+
+//#region src/rules/logger/require-logger-scoped-dot-notation.d.ts
+type MessageIds = "dottedSnakeCaseAttributeKey" | "dottedSnakeCaseMessage";
+type DottedSnakeCaseFormat = "dotted-snake-case" | "off";
+/** Options for dotted snake case logger message and attribute enforcement. */
+interface RequireLoggerScopedDotNotationOptions extends LoggerMatcherOptions {
+  /** Format required for inline attribute keys. */
+  attributeKeyFormat?: DottedSnakeCaseFormat;
+  /** Format required for logger messages. */
+  messageFormat?: DottedSnakeCaseFormat;
+}
+type RuleOptions = [RequireLoggerScopedDotNotationOptions];
+/** Enforces dotted snake case for logger messages and attribute keys. */
+declare const requireLoggerScopedDotNotation: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, RuleOptions, StructuredLoggingPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+  name: string;
+};
+//#endregion
+export { DottedSnakeCaseFormat, RequireLoggerScopedDotNotationOptions, requireLoggerScopedDotNotation };
+//# sourceMappingURL=require-logger-scoped-dot-notation.d.ts.map

package/lib/rules/logger/require-logger-scoped-dot-notation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-logger-scoped-dot-notation.d.ts","names":[],"sources":["../../../src/rules/logger/require-logger-scoped-dot-notation.ts"],"mappings":";;;;KAaK,UAAA;AAAA,KACO,qBAAA;;UAGK,qCAAA,SAA8C,oBAAA;EAJhD;EAMd,kBAAA,GAAqB,qBAAA;EANP;EAQd,aAAA,GAAgB,qBAAA;AAAA;AAAA,KAGZ,WAAA,IAAe,qCAAqC;;cAoD5C,8BAAA,+CAA8B,UAAA,CAAA,UAAA,EAAA,WAAA,EAAA,2BAAA,+CAAA,YAAA"}

package/lib/rules/logger/require-logger-scoped-dot-notation.js

@@ -0,0 +1,111 @@
+import { createRule } from "../../utils.js";
+import { DEFAULT_LOGGER_MATCHER_OPTIONS, DOTTED_SNAKE_CASE_SEGMENT_RE, LOGGER_MATCHER_OPTION_SCHEMA_PROPERTIES, buildLoggerMatcherSets, collectAttrsEntries, getLoggerArguments } from "./utils.js";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region src/rules/logger/require-logger-scoped-dot-notation.ts
+const DOTTED_SNAKE_CASE_FORMAT = "dotted-snake-case";
+/** Converts one dotted snake case segment to lower snake_case. */
+function toDottedSnakeCaseSegment(segment) {
+	return segment.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/[-\s]+/g, "_").toLowerCase();
+}
+/** Converts every existing segment of a dotted name to lower snake_case. */
+function toDottedSnakeCaseName(name) {
+	return name.split(".").map(toDottedSnakeCaseSegment).join(".");
+}
+/** Returns a safe dotted snake case autofix, or null when no safe fix exists. */
+function getDottedSnakeCaseFix(name) {
+	const fixedName = toDottedSnakeCaseName(name);
+	return fixedName.includes(".") && isDottedSnakeCaseName(fixedName) ? fixedName : null;
+}
+/** Returns whether a static logger name is dotted lower snake_case. */
+function isDottedSnakeCaseName(name) {
+	const segments = name.split(".");
+	return segments.length >= 2 && segments.every((segment) => segment.length > 0 && DOTTED_SNAKE_CASE_SEGMENT_RE.test(segment));
+}
+/**
+* Quotes an autofixed string literal using the original quote style and escapes
+* backslashes plus matching quote characters.
+*/
+function quoteStringLike(raw, value) {
+	const quote = raw.startsWith("'") ? "'" : "\"";
+	return `${quote}${value.replace(/\\/g, "\\\\").replace(new RegExp(quote, "g"), `\\${quote}`)}${quote}`;
+}
+/** Enforces dotted snake case for logger messages and attribute keys. */
+const requireLoggerScopedDotNotation = createRule({
+	name: "require-logger-scoped-dot-notation",
+	meta: {
+		type: "problem",
+		fixable: "code",
+		docs: {
+			description: "Require logger messages and attribute keys to use dotted snake case.",
+			recommended: true
+		},
+		messages: {
+			dottedSnakeCaseAttributeKey: "Attribute key must use dotted snake case: \"{{name}}\". Use at least two lowercase dotted segments, for example \"payment.id\".",
+			dottedSnakeCaseMessage: "Logger message must use dotted snake case: \"{{name}}\". Use at least two lowercase dotted segments, for example \"payment.capture.failed\"."
+		},
+		schema: [{
+			type: "object",
+			properties: {
+				...LOGGER_MATCHER_OPTION_SCHEMA_PROPERTIES,
+				attributeKeyFormat: {
+					description: "Format required for inline attribute keys.",
+					enum: [DOTTED_SNAKE_CASE_FORMAT, "off"],
+					type: "string"
+				},
+				messageFormat: {
+					description: "Format required for logger messages.",
+					enum: [DOTTED_SNAKE_CASE_FORMAT, "off"],
+					type: "string"
+				}
+			},
+			additionalProperties: false
+		}],
+		defaultOptions: [{
+			...DEFAULT_LOGGER_MATCHER_OPTIONS,
+			attributeKeyFormat: DOTTED_SNAKE_CASE_FORMAT,
+			messageFormat: DOTTED_SNAKE_CASE_FORMAT
+		}]
+	},
+	create(context) {
+		const options = context.options[0];
+		const sets = buildLoggerMatcherSets(options);
+		const sourceCode = context.sourceCode;
+		return { CallExpression(node) {
+			const args = getLoggerArguments(node, sets);
+			if (!args) return;
+			const messageArg = args.messageArg;
+			if (options.messageFormat === DOTTED_SNAKE_CASE_FORMAT && messageArg?.type === AST_NODE_TYPES.Literal && typeof messageArg.value === "string" && !isDottedSnakeCaseName(messageArg.value)) {
+				const fixedMessage = getDottedSnakeCaseFix(messageArg.value);
+				context.report({
+					node: messageArg,
+					messageId: "dottedSnakeCaseMessage",
+					data: { name: messageArg.value },
+					fix: fixedMessage ? (fixer) => fixer.replaceText(messageArg, quoteStringLike(sourceCode.getText(messageArg), fixedMessage)) : null
+				});
+			}
+			if (options.attributeKeyFormat === DOTTED_SNAKE_CASE_FORMAT) {
+				const entries = collectAttrsEntries(args.attrsArg);
+				if (!entries) return;
+				for (const entry of entries) {
+					if (isDottedSnakeCaseName(entry.key)) continue;
+					const fixedKey = getDottedSnakeCaseFix(entry.key);
+					context.report({
+						node: entry.keyNode,
+						messageId: "dottedSnakeCaseAttributeKey",
+						data: { name: entry.key },
+						fix: fixedKey ? (fixer) => {
+							const keyText = sourceCode.getText(entry.keyNode);
+							if (entry.keyNode.type === AST_NODE_TYPES.Identifier && entry.valueNode.type === AST_NODE_TYPES.Identifier && entry.keyNode.range[0] === entry.valueNode.range[0] && entry.keyNode.range[1] === entry.valueNode.range[1]) return fixer.replaceText(entry.keyNode, `${fixedKey}: ${keyText}`);
+							if (entry.keyNode.type === AST_NODE_TYPES.Literal) return fixer.replaceText(entry.keyNode, quoteStringLike(keyText, fixedKey));
+							return fixer.replaceText(entry.keyNode, fixedKey);
+						} : null
+					});
+				}
+			}
+		} };
+	}
+});
+//#endregion
+export { requireLoggerScopedDotNotation };
+
+//# sourceMappingURL=require-logger-scoped-dot-notation.js.map

package/lib/rules/logger/require-logger-scoped-dot-notation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-logger-scoped-dot-notation.js","names":[],"sources":["../../../src/rules/logger/require-logger-scoped-dot-notation.ts"],"sourcesContent":["import { AST_NODE_TYPES } from \"@typescript-eslint/utils\";\n\nimport { createRule } from \"@/utils\";\nimport {\n\tLOGGER_MATCHER_OPTION_SCHEMA_PROPERTIES,\n\tDOTTED_SNAKE_CASE_SEGMENT_RE,\n\tDEFAULT_LOGGER_MATCHER_OPTIONS,\n\tbuildLoggerMatcherSets,\n\tcollectAttrsEntries,\n\tgetLoggerArguments,\n\ttype LoggerMatcherOptions,\n} from \"@/rules/logger/utils\";\n\ntype MessageIds = \"dottedSnakeCaseAttributeKey\" | \"dottedSnakeCaseMessage\";\nexport type DottedSnakeCaseFormat = \"dotted-snake-case\" | \"off\";\n\n/** Options for dotted snake case logger message and attribute enforcement. */\nexport interface RequireLoggerScopedDotNotationOptions extends LoggerMatcherOptions {\n\t/** Format required for inline attribute keys. */\n\tattributeKeyFormat?: DottedSnakeCaseFormat;\n\t/** Format required for logger messages. */\n\tmessageFormat?: DottedSnakeCaseFormat;\n}\n\ntype RuleOptions = [RequireLoggerScopedDotNotationOptions];\n\nconst DOTTED_SNAKE_CASE_FORMAT: DottedSnakeCaseFormat = \"dotted-snake-case\";\n\n/** Converts one dotted snake case segment to lower snake_case. */\nfunction toDottedSnakeCaseSegment(segment: string): string {\n\treturn segment\n\t\t.replace(/([a-z0-9])([A-Z])/g, \"$1_$2\")\n\t\t.replace(/([A-Z]+)([A-Z][a-z])/g, \"$1_$2\")\n\t\t.replace(/[-\\s]+/g, \"_\")\n\t\t.toLowerCase();\n}\n\n/** Converts every existing segment of a dotted name to lower snake_case. */\nfunction toDottedSnakeCaseName(name: string): string {\n\treturn name.split(\".\").map(toDottedSnakeCaseSegment).join(\".\");\n}\n\n/** Returns a safe dotted snake case autofix, or null when no safe fix exists. */\nfunction getDottedSnakeCaseFix(name: string): string | null {\n\tconst fixedName = toDottedSnakeCaseName(name);\n\treturn fixedName.includes(\".\") && isDottedSnakeCaseName(fixedName)\n\t\t? fixedName\n\t\t: null;\n}\n\n/** Returns whether a static logger name is dotted lower snake_case. */\nfunction isDottedSnakeCaseName(name: string): boolean {\n\tconst segments = name.split(\".\");\n\treturn (\n\t\tsegments.length >= 2 &&\n\t\tsegments.every(\n\t\t\t(segment) =>\n\t\t\t\tsegment.length > 0 && DOTTED_SNAKE_CASE_SEGMENT_RE.test(segment),\n\t\t)\n\t);\n}\n\n/**\n * Quotes an autofixed string literal using the original quote style and escapes\n * backslashes plus matching quote characters.\n */\nfunction quoteStringLike(raw: string, value: string): string {\n\tconst quote = raw.startsWith(\"'\") ? \"'\" : '\"';\n\tconst escaped = value\n\t\t.replace(/\\\\/g, \"\\\\\\\\\")\n\t\t.replace(new RegExp(quote, \"g\"), `\\\\${quote}`);\n\n\treturn `${quote}${escaped}${quote}`;\n}\n\n/** Enforces dotted snake case for logger messages and attribute keys. */\nexport const requireLoggerScopedDotNotation = createRule<\n\tRuleOptions,\n\tMessageIds\n>({\n\tname: \"require-logger-scoped-dot-notation\",\n\tmeta: {\n\t\ttype: \"problem\",\n\t\tfixable: \"code\",\n\t\tdocs: {\n\t\t\tdescription:\n\t\t\t\t\"Require logger messages and attribute keys to use dotted snake case.\",\n\t\t\trecommended: true,\n\t\t},\n\t\tmessages: {\n\t\t\tdottedSnakeCaseAttributeKey:\n\t\t\t\t'Attribute key must use dotted snake case: \"{{name}}\". Use at least two lowercase dotted segments, for example \"payment.id\".',\n\t\t\tdottedSnakeCaseMessage:\n\t\t\t\t'Logger message must use dotted snake case: \"{{name}}\". Use at least two lowercase dotted segments, for example \"payment.capture.failed\".',\n\t\t},\n\t\tschema: [\n\t\t\t{\n\t\t\t\ttype: \"object\",\n\t\t\t\tproperties: {\n\t\t\t\t\t...LOGGER_MATCHER_OPTION_SCHEMA_PROPERTIES,\n\t\t\t\t\tattributeKeyFormat: {\n\t\t\t\t\t\tdescription: \"Format required for inline attribute keys.\",\n\t\t\t\t\t\tenum: [DOTTED_SNAKE_CASE_FORMAT, \"off\"],\n\t\t\t\t\t\ttype: \"string\",\n\t\t\t\t\t},\n\t\t\t\t\tmessageFormat: {\n\t\t\t\t\t\tdescription: \"Format required for logger messages.\",\n\t\t\t\t\t\tenum: [DOTTED_SNAKE_CASE_FORMAT, \"off\"],\n\t\t\t\t\t\ttype: \"string\",\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t\tadditionalProperties: false,\n\t\t\t},\n\t\t],\n\t\tdefaultOptions: [\n\t\t\t{\n\t\t\t\t...DEFAULT_LOGGER_MATCHER_OPTIONS,\n\t\t\t\tattributeKeyFormat: DOTTED_SNAKE_CASE_FORMAT,\n\t\t\t\tmessageFormat: DOTTED_SNAKE_CASE_FORMAT,\n\t\t\t},\n\t\t],\n\t},\n\tcreate(context) {\n\t\tconst options = context.options[0];\n\t\tconst sets = buildLoggerMatcherSets(options);\n\t\tconst sourceCode = context.sourceCode;\n\n\t\treturn {\n\t\t\tCallExpression(node) {\n\t\t\t\tconst args = getLoggerArguments(node, sets);\n\t\t\t\tif (!args) return;\n\n\t\t\t\tconst messageArg = args.messageArg;\n\t\t\t\tif (\n\t\t\t\t\toptions.messageFormat === DOTTED_SNAKE_CASE_FORMAT &&\n\t\t\t\t\tmessageArg?.type === AST_NODE_TYPES.Literal &&\n\t\t\t\t\ttypeof messageArg.value === \"string\" &&\n\t\t\t\t\t!isDottedSnakeCaseName(messageArg.value)\n\t\t\t\t) {\n\t\t\t\t\tconst fixedMessage = getDottedSnakeCaseFix(messageArg.value);\n\t\t\t\t\tcontext.report({\n\t\t\t\t\t\tnode: messageArg,\n\t\t\t\t\t\tmessageId: \"dottedSnakeCaseMessage\",\n\t\t\t\t\t\tdata: { name: messageArg.value },\n\t\t\t\t\t\tfix: fixedMessage\n\t\t\t\t\t\t\t? (fixer) =>\n\t\t\t\t\t\t\t\t\tfixer.replaceText(\n\t\t\t\t\t\t\t\t\t\tmessageArg,\n\t\t\t\t\t\t\t\t\t\tquoteStringLike(\n\t\t\t\t\t\t\t\t\t\t\tsourceCode.getText(messageArg),\n\t\t\t\t\t\t\t\t\t\t\tfixedMessage,\n\t\t\t\t\t\t\t\t\t\t),\n\t\t\t\t\t\t\t\t\t)\n\t\t\t\t\t\t\t: null,\n\t\t\t\t\t});\n\t\t\t\t}\n\n\t\t\t\tif (options.attributeKeyFormat === DOTTED_SNAKE_CASE_FORMAT) {\n\t\t\t\t\tconst entries = collectAttrsEntries(args.attrsArg);\n\t\t\t\t\tif (!entries) return;\n\n\t\t\t\t\tfor (const entry of entries) {\n\t\t\t\t\t\tif (isDottedSnakeCaseName(entry.key)) {\n\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tconst fixedKey = getDottedSnakeCaseFix(entry.key);\n\t\t\t\t\t\tcontext.report({\n\t\t\t\t\t\t\tnode: entry.keyNode,\n\t\t\t\t\t\t\tmessageId: \"dottedSnakeCaseAttributeKey\",\n\t\t\t\t\t\t\tdata: { name: entry.key },\n\t\t\t\t\t\t\tfix: fixedKey\n\t\t\t\t\t\t\t\t? (fixer) => {\n\t\t\t\t\t\t\t\t\t\tconst keyText = sourceCode.getText(entry.keyNode);\n\n\t\t\t\t\t\t\t\t\t\tif (\n\t\t\t\t\t\t\t\t\t\t\tentry.keyNode.type === AST_NODE_TYPES.Identifier &&\n\t\t\t\t\t\t\t\t\t\t\tentry.valueNode.type === AST_NODE_TYPES.Identifier &&\n\t\t\t\t\t\t\t\t\t\t\tentry.keyNode.range[0] === entry.valueNode.range[0] &&\n\t\t\t\t\t\t\t\t\t\t\tentry.keyNode.range[1] === entry.valueNode.range[1]\n\t\t\t\t\t\t\t\t\t\t) {\n\t\t\t\t\t\t\t\t\t\t\treturn fixer.replaceText(\n\t\t\t\t\t\t\t\t\t\t\t\tentry.keyNode,\n\t\t\t\t\t\t\t\t\t\t\t\t`${fixedKey}: ${keyText}`,\n\t\t\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\tif (entry.keyNode.type === AST_NODE_TYPES.Literal) {\n\t\t\t\t\t\t\t\t\t\t\treturn fixer.replaceText(\n\t\t\t\t\t\t\t\t\t\t\t\tentry.keyNode,\n\t\t\t\t\t\t\t\t\t\t\t\tquoteStringLike(keyText, fixedKey),\n\t\t\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\treturn fixer.replaceText(entry.keyNode, fixedKey);\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t: null,\n\t\t\t\t\t\t});\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t},\n\t\t};\n\t},\n});\n"],"mappings":"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"}

package/lib/rules/logger/utils.d.ts

@@ -0,0 +1,156 @@
+import { TSESTree } from "@typescript-eslint/utils";
+
+//#region src/rules/logger/utils.d.ts
+/** Matches a single lowercase snake_case dotted-name segment. */
+declare const DOTTED_SNAKE_CASE_SEGMENT_RE: RegExp;
+/** Shared JSON schema properties for rules that match logger calls. */
+declare const LOGGER_MATCHER_OPTION_SCHEMA_PROPERTIES: {
+  readonly allowedLoggerObjects: {
+    readonly description: "Fully-qualified logger object paths, such as `log.child`.";
+    readonly type: "array";
+    readonly items: {
+      readonly type: "string";
+    };
+  };
+  readonly allowedLoggerIdentifiers: {
+    readonly description: "Bare logger object identifiers accepted as logger callees.";
+    readonly type: "array";
+    readonly items: {
+      readonly type: "string";
+    };
+  };
+  readonly attributesFirstLoggerObjects: {
+    readonly description: "Logger object paths whose calls pass attributes before the message.";
+    readonly type: "array";
+    readonly items: {
+      readonly type: "string";
+    };
+  };
+  readonly attributesFirstLoggerIdentifiers: {
+    readonly description: "Logger identifiers whose calls pass attributes before the message.";
+    readonly type: "array";
+    readonly items: {
+      readonly type: "string";
+    };
+  };
+  readonly levelMethods: {
+    readonly description: "Method names treated as logger level calls, such as `info` or `error`.";
+    readonly type: "array";
+    readonly items: {
+      readonly type: "string";
+    };
+  };
+  readonly ignoreDynamicLevelMethods: {
+    readonly description: "Skip computed logger level methods such as `logger[level](...)` instead of matching them.";
+    readonly type: "boolean";
+  };
+};
+interface LoggerMatcherOptions {
+  /** Fully-qualified logger object paths, such as `log.child`. */
+  allowedLoggerObjects?: string[];
+  /** Bare logger object identifiers accepted as logger callees. */
+  allowedLoggerIdentifiers?: string[];
+  /** Logger object paths whose calls pass attributes before the message. */
+  attributesFirstLoggerObjects?: string[];
+  /** Logger identifiers whose calls pass attributes before the message. */
+  attributesFirstLoggerIdentifiers?: string[];
+  /** Method names treated as logger level calls, such as `info` or `error`. */
+  levelMethods?: string[];
+  /** Skip computed logger level methods such as `logger[level](...)` instead of matching them. */
+  ignoreDynamicLevelMethods?: boolean;
+}
+/**
+ * Pre-built sets derived from {@link LoggerMatcherOptions}.
+ * Construct once per file via {@link buildLoggerMatcherSets} in `create()` to
+ * avoid re-allocating on every `CallExpression` node visit.
+ */
+interface LoggerMatcherSets {
+  /** Pre-built set for fully-qualified logger object paths. */
+  allowedLoggerObjects: Set<string>;
+  /** Pre-built set for bare logger object identifiers. */
+  allowedLoggerIdentifiers: Set<string>;
+  /** Pre-built set for object paths using attributes-first argument order. */
+  attributesFirstLoggerObjects: Set<string>;
+  /** Pre-built set for identifiers using attributes-first argument order. */
+  attributesFirstLoggerIdentifiers: Set<string>;
+  /** Pre-built set of method names treated as logger level calls. */
+  levelMethods: Set<string>;
+  /** Whether to skip computed logger level methods instead of matching them. */
+  ignoreDynamicLevelMethods: boolean;
+}
+/** A statically-known key/value pair from an inline attributes object. */
+interface AttrEntry {
+  /** Attribute key exactly as written, with literal keys normalized to strings. */
+  key: string;
+  /** AST node for the attribute key, used as the report and fix target. */
+  keyNode: TSESTree.Node;
+  /** AST expression for the attribute value. */
+  valueNode: TSESTree.Expression;
+}
+/** Controls which malformed attribute shapes are reported while collecting. */
+interface CollectAttrsOptions {
+  /** Report spreads and computed keys found inside inline attributes. */
+  reportMalformedProperties?: boolean;
+  /** Report non-object attributes arguments that cannot be statically checked. */
+  reportNonLiteral?: boolean;
+  /** Called when a reportable violation is found inside the attribute object. */
+  report?: (node: TSESTree.Node, messageId: string, data?: Record<string, string>) => void;
+}
+/** Default {@link LoggerMatcherOptions} shared across the logger rules. */
+declare const DEFAULT_LOGGER_MATCHER_OPTIONS: Required<LoggerMatcherOptions>;
+/**
+ * Convert rule options into pre-built `Set`s. Call this once in `create()` so
+ * sets are not rebuilt for every `CallExpression` in the linted file.
+ *
+ * Back-fills {@link DEFAULT_LOGGER_MATCHER_OPTIONS} for direct callers of
+ * {@link isLoggerCall} that pass partial or omitted options; rule callers
+ * already receive fully-resolved options from `meta.defaultOptions`.
+ */
+declare function buildLoggerMatcherSets(options?: LoggerMatcherOptions): LoggerMatcherSets;
+/**
+ * Convenience wrapper for external callers that don't pre-build sets.
+ * Within this plugin's rules, prefer {@link getLoggerArguments} with
+ * pre-built sets from {@link buildLoggerMatcherSets}.
+ */
+declare function isLoggerCall(node: TSESTree.Node | null | undefined, options?: LoggerMatcherOptions): boolean;
+/**
+ * Returns the message and attributes arguments for a logger call, or `null`
+ * if the node is not a recognised logger call. Use pre-built sets from
+ * {@link buildLoggerMatcherSets} so sets are not reallocated per-node.
+ */
+declare function getLoggerArguments(node: TSESTree.CallExpression, sets: LoggerMatcherSets): {
+  attrsArg: TSESTree.Node | undefined;
+  messageArg: TSESTree.Node | undefined;
+} | null;
+/**
+ * Extracts key/value pairs from an attribute object literal.
+ * Returns `null` when the node cannot be analysed (not an ObjectExpression).
+ * Returns `[]` when there is no attributes argument at all.
+ */
+declare function collectAttrsEntries(attrsNode: TSESTree.Node | null | undefined, options?: CollectAttrsOptions): AttrEntry[] | null;
+/**
+ * Returns whether an attribute value should be rejected by primitive-value
+ * rules.
+ *
+ * @remarks
+ * Primitive values (string, number, boolean) are always allowed. Arrays are
+ * allowed when every element is itself a primitive value, so arrays of scalars
+ * such as `["a", "b"]` pass while nested arrays and arrays of objects do not.
+ * Objects, functions, and classes are always rejected. Unknown expressions
+ * (including array spreads) are rejected only when
+ * `disallowUnknownAttributeValues` is `true`.
+ */
+declare function isDisallowedAttributeValue(node: TSESTree.Node | null | undefined, options?: {
+  disallowUnknownAttributeValues?: boolean;
+}): boolean;
+/**
+ * Returns whether a candidate logger message is clearly not static text.
+ *
+ * @remarks
+ * This intentionally returns `false` for a missing node so callers can report a
+ * dedicated "message required" violation.
+ */
+declare function isClearlyNotMessage(node: TSESTree.Node | null | undefined): boolean;
+//#endregion
+export { AttrEntry, CollectAttrsOptions, DEFAULT_LOGGER_MATCHER_OPTIONS, DOTTED_SNAKE_CASE_SEGMENT_RE, LOGGER_MATCHER_OPTION_SCHEMA_PROPERTIES, LoggerMatcherOptions, LoggerMatcherSets, buildLoggerMatcherSets, collectAttrsEntries, getLoggerArguments, isClearlyNotMessage, isDisallowedAttributeValue, isLoggerCall };
+//# sourceMappingURL=utils.d.ts.map

package/lib/rules/logger/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","names":[],"sources":["../../../src/rules/logger/utils.ts"],"mappings":";;;;cAKa,4BAAA,EAA4B,MAAsB;AAA/D;AAAA,cA6Ba,uCAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAsCI,oBAAA;EAEhB;EAAA,oBAAA;EAIA;EAFA,wBAAA;EAMA;EAJA,4BAAA;EAMyB;EAJzB,gCAAA;EAYgB;EAVhB,YAAA;;EAEA,yBAAA;AAAA;;;;;;UAQgB,iBAAA;EAEM;EAAtB,oBAAA,EAAsB,GAAA;EAEI;EAA1B,wBAAA,EAA0B,GAAA;EAEI;EAA9B,4BAAA,EAA8B,GAAA;EAEI;EAAlC,gCAAA,EAAkC,GAAA;EAEpB;EAAd,YAAA,EAAc,GAAA;EAEW;EAAzB,yBAAA;AAAA;;UAIgB,SAAA;EAMc;EAJ9B,GAAA;EAEA;EAAA,OAAA,EAAS,QAAA,CAAS,IAAA;EAAA;EAElB,SAAA,EAAW,QAAA,CAAS,UAAU;AAAA;;UAId,mBAAA;EAJc;EAM9B,yBAAA;EAFmC;EAInC,gBAAA;EAKc;EAHd,MAAA,IACC,IAAA,EAAM,QAAA,CAAS,IAAA,EACf,SAAA,UACA,IAAA,GAAO,MAAM;AAAA;;cAcF,8BAAA,EAAgC,QAAQ,CAAC,oBAAA;;;;;;;AAdvB;AAc/B;iBAiBgB,sBAAA,CACf,OAAA,GAAS,oBAAA,GACP,iBAAiB;;;AAnBsD;AAiB1E;;iBAoJgB,YAAA,CACf,IAAA,EAAM,QAAA,CAAS,IAAA,qBACf,OAAA,GAAS,oBAAyB;;;;;;iBAUnB,kBAAA,CACf,IAAA,EAAM,QAAA,CAAS,cAAA,EACf,IAAA,EAAM,iBAAA;EAEN,QAAA,EAAU,QAAA,CAAS,IAAA;EACnB,UAAA,EAAY,QAAA,CAAS,IAAA;AAAA;;;;;;iBAeN,mBAAA,CACf,SAAA,EAAW,QAAA,CAAS,IAAA,qBACpB,OAAA,GAAS,mBAAA,GACP,SAAA;;AAjCgC;AAUnC;;;;;;;;;;iBA6HgB,0BAAA,CACf,IAAA,EAAM,QAAA,CAAS,IAAI,qBACnB,OAAA;EAAW,8BAAA;AAAA;;;;;;;;iBAsBI,mBAAA,CACf,IAAA,EAAM,QAAA,CAAS,IAAI"}

package/lib/rules/logger/utils.js

@@ -0,0 +1,271 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region src/rules/logger/utils.ts
+/** Matches a single lowercase snake_case dotted-name segment. */
+const DOTTED_SNAKE_CASE_SEGMENT_RE = /^[a-z][a-z0-9_]*$/;
+/**
+* Default logger severity methods matched as level calls. Covers the level
+* names shared by most structured loggers (pino, bunyan, and similar).
+* Libraries with extra levels (for example winston's `http`/`verbose`/`silly`)
+* can extend this set via the `levelMethods` rule option.
+*/
+const DEFAULT_LEVEL_METHODS = [
+	"trace",
+	"debug",
+	"info",
+	"warn",
+	"error",
+	"fatal"
+];
+/** Expression node shapes that are never valid primitive log attribute values. */
+const NON_PRIMITIVE_NODE_TYPES = /* @__PURE__ */ new Set([
+	AST_NODE_TYPES.ObjectExpression,
+	AST_NODE_TYPES.ArrayExpression,
+	AST_NODE_TYPES.FunctionExpression,
+	AST_NODE_TYPES.ArrowFunctionExpression,
+	AST_NODE_TYPES.ClassExpression
+]);
+/** Shared JSON schema properties for rules that match logger calls. */
+const LOGGER_MATCHER_OPTION_SCHEMA_PROPERTIES = {
+	allowedLoggerObjects: {
+		description: "Fully-qualified logger object paths, such as `log.child`.",
+		type: "array",
+		items: { type: "string" }
+	},
+	allowedLoggerIdentifiers: {
+		description: "Bare logger object identifiers accepted as logger callees.",
+		type: "array",
+		items: { type: "string" }
+	},
+	attributesFirstLoggerObjects: {
+		description: "Logger object paths whose calls pass attributes before the message.",
+		type: "array",
+		items: { type: "string" }
+	},
+	attributesFirstLoggerIdentifiers: {
+		description: "Logger identifiers whose calls pass attributes before the message.",
+		type: "array",
+		items: { type: "string" }
+	},
+	levelMethods: {
+		description: "Method names treated as logger level calls, such as `info` or `error`.",
+		type: "array",
+		items: { type: "string" }
+	},
+	ignoreDynamicLevelMethods: {
+		description: "Skip computed logger level methods such as `logger[level](...)` instead of matching them.",
+		type: "boolean"
+	}
+};
+/** Default {@link LoggerMatcherOptions} shared across the logger rules. */
+const DEFAULT_LOGGER_MATCHER_OPTIONS = {
+	allowedLoggerObjects: [],
+	allowedLoggerIdentifiers: ["logger", "log"],
+	attributesFirstLoggerObjects: [],
+	attributesFirstLoggerIdentifiers: [],
+	levelMethods: DEFAULT_LEVEL_METHODS,
+	ignoreDynamicLevelMethods: false
+};
+/**
+* Convert rule options into pre-built `Set`s. Call this once in `create()` so
+* sets are not rebuilt for every `CallExpression` in the linted file.
+*
+* Back-fills {@link DEFAULT_LOGGER_MATCHER_OPTIONS} for direct callers of
+* {@link isLoggerCall} that pass partial or omitted options; rule callers
+* already receive fully-resolved options from `meta.defaultOptions`.
+*/
+function buildLoggerMatcherSets(options = {}) {
+	const resolved = {
+		...DEFAULT_LOGGER_MATCHER_OPTIONS,
+		...options
+	};
+	return {
+		allowedLoggerObjects: new Set(resolved.allowedLoggerObjects),
+		allowedLoggerIdentifiers: new Set(resolved.allowedLoggerIdentifiers),
+		attributesFirstLoggerObjects: new Set(resolved.attributesFirstLoggerObjects),
+		attributesFirstLoggerIdentifiers: new Set(resolved.attributesFirstLoggerIdentifiers),
+		levelMethods: new Set(resolved.levelMethods),
+		ignoreDynamicLevelMethods: resolved.ignoreDynamicLevelMethods
+	};
+}
+/**
+* Removes optional-chaining wrapper nodes so logger-call analysis can inspect
+* the underlying callee.
+*/
+function unwrapChainExpression(node) {
+	if (node?.type === AST_NODE_TYPES.ChainExpression) return node.expression;
+	return node;
+}
+/**
+* Reads a statically-known member property name from dot or string-literal
+* bracket notation.
+*/
+function getStaticPropertyName(node) {
+	if (node?.type !== AST_NODE_TYPES.MemberExpression) return null;
+	if (!node.computed && node.property.type === AST_NODE_TYPES.Identifier) return node.property.name;
+	if (node.computed && node.property.type === AST_NODE_TYPES.Literal && typeof node.property.value === "string") return node.property.value;
+	return null;
+}
+/**
+* Converts a non-computed member expression chain into a dotted path such as
+* `log.child`.
+*/
+function getMemberPath(node) {
+	const segments = [];
+	let current = node;
+	while (current) {
+		if (current.type === AST_NODE_TYPES.Identifier) {
+			segments.unshift(current.name);
+			return segments.join(".");
+		}
+		if (current.type === AST_NODE_TYPES.MemberExpression && !current.computed) {
+			if (current.property.type !== AST_NODE_TYPES.Identifier) return null;
+			segments.unshift(current.property.name);
+			current = current.object;
+			continue;
+		}
+		return null;
+	}
+	return null;
+}
+/**
+* Matches a call expression against the configured logger objects and returns
+* its expected argument positions.
+*/
+function getLoggerCallConfig(node, sets) {
+	if (node?.type !== AST_NODE_TYPES.CallExpression) return false;
+	const callee = unwrapChainExpression(node.callee);
+	if (callee?.type !== AST_NODE_TYPES.MemberExpression) return false;
+	const objectPath = getMemberPath(callee.object);
+	const objectIdentifier = callee.object.type === AST_NODE_TYPES.Identifier ? callee.object.name : null;
+	if (!(objectPath !== null && sets.allowedLoggerObjects.has(objectPath) || objectIdentifier !== null && sets.allowedLoggerIdentifiers.has(objectIdentifier))) return false;
+	const method = getStaticPropertyName(callee);
+	if (!(method ? sets.levelMethods.has(method) : callee.computed && !sets.ignoreDynamicLevelMethods)) return false;
+	const attributesFirst = objectPath !== null && sets.attributesFirstLoggerObjects.has(objectPath) || objectIdentifier !== null && sets.attributesFirstLoggerIdentifiers.has(objectIdentifier);
+	return {
+		attributesArgumentIndex: attributesFirst ? 0 : 1,
+		messageArgumentIndex: attributesFirst ? 1 : 0
+	};
+}
+/**
+* Extracts a static object property key, rejecting computed keys that cannot be
+* checked safely by logger attribute rules.
+*/
+function getPropertyKey(prop) {
+	if (prop.computed) return null;
+	const key = prop.key;
+	if (key.type === AST_NODE_TYPES.Identifier) return key.name;
+	if (key.type === AST_NODE_TYPES.Literal) return String(key.value);
+	return null;
+}
+/**
+* Convenience wrapper for external callers that don't pre-build sets.
+* Within this plugin's rules, prefer {@link getLoggerArguments} with
+* pre-built sets from {@link buildLoggerMatcherSets}.
+*/
+function isLoggerCall(node, options = {}) {
+	return Boolean(getLoggerCallConfig(node, buildLoggerMatcherSets(options)));
+}
+/**
+* Returns the message and attributes arguments for a logger call, or `null`
+* if the node is not a recognised logger call. Use pre-built sets from
+* {@link buildLoggerMatcherSets} so sets are not reallocated per-node.
+*/
+function getLoggerArguments(node, sets) {
+	const config = getLoggerCallConfig(node, sets);
+	if (!config) return null;
+	return {
+		attrsArg: node.arguments[config.attributesArgumentIndex],
+		messageArg: node.arguments[config.messageArgumentIndex]
+	};
+}
+/**
+* Extracts key/value pairs from an attribute object literal.
+* Returns `null` when the node cannot be analysed (not an ObjectExpression).
+* Returns `[]` when there is no attributes argument at all.
+*/
+function collectAttrsEntries(attrsNode, options = {}) {
+	if (!attrsNode) return [];
+	const { reportMalformedProperties = false, reportNonLiteral = false, report } = options;
+	if (attrsNode.type !== AST_NODE_TYPES.ObjectExpression) {
+		if (reportNonLiteral) report?.(attrsNode, "nonInlineAttributes");
+		return null;
+	}
+	const entries = [];
+	for (const prop of attrsNode.properties) {
+		if (prop.type === AST_NODE_TYPES.SpreadElement) {
+			if (reportMalformedProperties) report?.(prop, "noAttributeSpread");
+			continue;
+		}
+		const key = getPropertyKey(prop);
+		if (!key) {
+			if (reportMalformedProperties) report?.(prop.key, "staticAttributeKeys");
+			continue;
+		}
+		entries.push({
+			key,
+			keyNode: prop.key,
+			valueNode: prop.value
+		});
+	}
+	return entries;
+}
+/** Returns whether a node is a literal string, number, or boolean value. */
+function isScalarLiteral(node) {
+	return node?.type === AST_NODE_TYPES.Literal && (typeof node.value === "string" || typeof node.value === "number" || typeof node.value === "boolean");
+}
+/**
+* Returns whether a node is a syntactic expression shape known to produce a
+* scalar log attribute without requiring type information.
+*/
+function isKnownScalarExpression(node) {
+	return isScalarLiteral(node) || node?.type === AST_NODE_TYPES.TemplateLiteral;
+}
+/**
+* Returns whether a single (non-array) attribute value should be rejected as a
+* primitive log value.
+*
+* @remarks
+* Objects, arrays, functions, classes, and non-scalar literals are always
+* rejected. Unknown expressions are rejected only when
+* `disallowUnknownAttributeValues` is `true`.
+*/
+function isDisallowedPrimitiveValue(node, options) {
+	if (node?.type !== void 0 && NON_PRIMITIVE_NODE_TYPES.has(node.type)) return true;
+	if (node?.type === AST_NODE_TYPES.Literal) return !isScalarLiteral(node);
+	return options.disallowUnknownAttributeValues === true && !isKnownScalarExpression(node);
+}
+/**
+* Returns whether an attribute value should be rejected by primitive-value
+* rules.
+*
+* @remarks
+* Primitive values (string, number, boolean) are always allowed. Arrays are
+* allowed when every element is itself a primitive value, so arrays of scalars
+* such as `["a", "b"]` pass while nested arrays and arrays of objects do not.
+* Objects, functions, and classes are always rejected. Unknown expressions
+* (including array spreads) are rejected only when
+* `disallowUnknownAttributeValues` is `true`.
+*/
+function isDisallowedAttributeValue(node, options = {}) {
+	if (node?.type === AST_NODE_TYPES.ArrayExpression) return node.elements.some((element) => {
+		if (element === null) return false;
+		if (element.type === AST_NODE_TYPES.SpreadElement) return options.disallowUnknownAttributeValues === true;
+		return isDisallowedPrimitiveValue(element, options);
+	});
+	return isDisallowedPrimitiveValue(node, options);
+}
+/**
+* Returns whether a candidate logger message is clearly not static text.
+*
+* @remarks
+* This intentionally returns `false` for a missing node so callers can report a
+* dedicated "message required" violation.
+*/
+function isClearlyNotMessage(node) {
+	if (!node) return false;
+	return node.type !== AST_NODE_TYPES.Literal || typeof node.value !== "string";
+}
+//#endregion
+export { DEFAULT_LOGGER_MATCHER_OPTIONS, DOTTED_SNAKE_CASE_SEGMENT_RE, LOGGER_MATCHER_OPTION_SCHEMA_PROPERTIES, buildLoggerMatcherSets, collectAttrsEntries, getLoggerArguments, isClearlyNotMessage, isDisallowedAttributeValue, isLoggerCall };
+
+//# sourceMappingURL=utils.js.map

package/lib/rules/logger/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":[],"sources":["../../../src/rules/logger/utils.ts"],"sourcesContent":["import { AST_NODE_TYPES, TSESTree } from \"@typescript-eslint/utils\";\n\n// ─── Constants ────────────────────────────────────────────────────────────────\n\n/** Matches a single lowercase snake_case dotted-name segment. */\nexport const DOTTED_SNAKE_CASE_SEGMENT_RE = /^[a-z][a-z0-9_]*$/;\n\n/**\n * Default logger severity methods matched as level calls. Covers the level\n * names shared by most structured loggers (pino, bunyan, and similar).\n * Libraries with extra levels (for example winston's `http`/`verbose`/`silly`)\n * can extend this set via the `levelMethods` rule option.\n */\nconst DEFAULT_LEVEL_METHODS = [\n\t\"trace\",\n\t\"debug\",\n\t\"info\",\n\t\"warn\",\n\t\"error\",\n\t\"fatal\",\n];\n\n/** Expression node shapes that are never valid primitive log attribute values. */\nconst NON_PRIMITIVE_NODE_TYPES = new Set<AST_NODE_TYPES>([\n\tAST_NODE_TYPES.ObjectExpression,\n\tAST_NODE_TYPES.ArrayExpression,\n\tAST_NODE_TYPES.FunctionExpression,\n\tAST_NODE_TYPES.ArrowFunctionExpression,\n\tAST_NODE_TYPES.ClassExpression,\n]);\n\n// ─── Shared option schema ─────────────────────────────────────────────────────\n\n/** Shared JSON schema properties for rules that match logger calls. */\nexport const LOGGER_MATCHER_OPTION_SCHEMA_PROPERTIES = {\n\tallowedLoggerObjects: {\n\t\tdescription: \"Fully-qualified logger object paths, such as `log.child`.\",\n\t\ttype: \"array\",\n\t\titems: { type: \"string\" },\n\t},\n\tallowedLoggerIdentifiers: {\n\t\tdescription: \"Bare logger object identifiers accepted as logger callees.\",\n\t\ttype: \"array\",\n\t\titems: { type: \"string\" },\n\t},\n\tattributesFirstLoggerObjects: {\n\t\tdescription:\n\t\t\t\"Logger object paths whose calls pass attributes before the message.\",\n\t\ttype: \"array\",\n\t\titems: { type: \"string\" },\n\t},\n\tattributesFirstLoggerIdentifiers: {\n\t\tdescription:\n\t\t\t\"Logger identifiers whose calls pass attributes before the message.\",\n\t\ttype: \"array\",\n\t\titems: { type: \"string\" },\n\t},\n\tlevelMethods: {\n\t\tdescription:\n\t\t\t\"Method names treated as logger level calls, such as `info` or `error`.\",\n\t\ttype: \"array\",\n\t\titems: { type: \"string\" },\n\t},\n\tignoreDynamicLevelMethods: {\n\t\tdescription:\n\t\t\t\"Skip computed logger level methods such as `logger[level](...)` instead of matching them.\",\n\t\ttype: \"boolean\",\n\t},\n} as const;\n\n// ─── Types ────────────────────────────────────────────────────────────────────\n\nexport interface LoggerMatcherOptions {\n\t/** Fully-qualified logger object paths, such as `log.child`. */\n\tallowedLoggerObjects?: string[];\n\t/** Bare logger object identifiers accepted as logger callees. */\n\tallowedLoggerIdentifiers?: string[];\n\t/** Logger object paths whose calls pass attributes before the message. */\n\tattributesFirstLoggerObjects?: string[];\n\t/** Logger identifiers whose calls pass attributes before the message. */\n\tattributesFirstLoggerIdentifiers?: string[];\n\t/** Method names treated as logger level calls, such as `info` or `error`. */\n\tlevelMethods?: string[];\n\t/** Skip computed logger level methods such as `logger[level](...)` instead of matching them. */\n\tignoreDynamicLevelMethods?: boolean;\n}\n\n/**\n * Pre-built sets derived from {@link LoggerMatcherOptions}.\n * Construct once per file via {@link buildLoggerMatcherSets} in `create()` to\n * avoid re-allocating on every `CallExpression` node visit.\n */\nexport interface LoggerMatcherSets {\n\t/** Pre-built set for fully-qualified logger object paths. */\n\tallowedLoggerObjects: Set<string>;\n\t/** Pre-built set for bare logger object identifiers. */\n\tallowedLoggerIdentifiers: Set<string>;\n\t/** Pre-built set for object paths using attributes-first argument order. */\n\tattributesFirstLoggerObjects: Set<string>;\n\t/** Pre-built set for identifiers using attributes-first argument order. */\n\tattributesFirstLoggerIdentifiers: Set<string>;\n\t/** Pre-built set of method names treated as logger level calls. */\n\tlevelMethods: Set<string>;\n\t/** Whether to skip computed logger level methods instead of matching them. */\n\tignoreDynamicLevelMethods: boolean;\n}\n\n/** A statically-known key/value pair from an inline attributes object. */\nexport interface AttrEntry {\n\t/** Attribute key exactly as written, with literal keys normalized to strings. */\n\tkey: string;\n\t/** AST node for the attribute key, used as the report and fix target. */\n\tkeyNode: TSESTree.Node;\n\t/** AST expression for the attribute value. */\n\tvalueNode: TSESTree.Expression;\n}\n\n/** Controls which malformed attribute shapes are reported while collecting. */\nexport interface CollectAttrsOptions {\n\t/** Report spreads and computed keys found inside inline attributes. */\n\treportMalformedProperties?: boolean;\n\t/** Report non-object attributes arguments that cannot be statically checked. */\n\treportNonLiteral?: boolean;\n\t/** Called when a reportable violation is found inside the attribute object. */\n\treport?: (\n\t\tnode: TSESTree.Node,\n\t\tmessageId: string,\n\t\tdata?: Record<string, string>,\n\t) => void;\n}\n\ninterface LoggerCallConfig {\n\t/** Zero-based index of the attributes argument for this logger call. */\n\tattributesArgumentIndex: number;\n\t/** Zero-based index of the message argument for this logger call. */\n\tmessageArgumentIndex: number;\n}\n\n// ─── Logger matcher set helpers ───────────────────────────────────────────────\n\n/** Default {@link LoggerMatcherOptions} shared across the logger rules. */\nexport const DEFAULT_LOGGER_MATCHER_OPTIONS: Required<LoggerMatcherOptions> = {\n\tallowedLoggerObjects: [],\n\tallowedLoggerIdentifiers: [\"logger\", \"log\"],\n\tattributesFirstLoggerObjects: [],\n\tattributesFirstLoggerIdentifiers: [],\n\tlevelMethods: DEFAULT_LEVEL_METHODS,\n\tignoreDynamicLevelMethods: false,\n};\n\n/**\n * Convert rule options into pre-built `Set`s. Call this once in `create()` so\n * sets are not rebuilt for every `CallExpression` in the linted file.\n *\n * Back-fills {@link DEFAULT_LOGGER_MATCHER_OPTIONS} for direct callers of\n * {@link isLoggerCall} that pass partial or omitted options; rule callers\n * already receive fully-resolved options from `meta.defaultOptions`.\n */\nexport function buildLoggerMatcherSets(\n\toptions: LoggerMatcherOptions = {},\n): LoggerMatcherSets {\n\tconst resolved = { ...DEFAULT_LOGGER_MATCHER_OPTIONS, ...options };\n\treturn {\n\t\tallowedLoggerObjects: new Set(resolved.allowedLoggerObjects),\n\t\tallowedLoggerIdentifiers: new Set(resolved.allowedLoggerIdentifiers),\n\t\tattributesFirstLoggerObjects: new Set(\n\t\t\tresolved.attributesFirstLoggerObjects,\n\t\t),\n\t\tattributesFirstLoggerIdentifiers: new Set(\n\t\t\tresolved.attributesFirstLoggerIdentifiers,\n\t\t),\n\t\tlevelMethods: new Set(resolved.levelMethods),\n\t\tignoreDynamicLevelMethods: resolved.ignoreDynamicLevelMethods,\n\t};\n}\n\n// ─── Internal AST helpers ─────────────────────────────────────────────────────\n\n/**\n * Removes optional-chaining wrapper nodes so logger-call analysis can inspect\n * the underlying callee.\n */\nfunction unwrapChainExpression(\n\tnode: TSESTree.Node | null | undefined,\n): TSESTree.Node | null | undefined {\n\tif (node?.type === AST_NODE_TYPES.ChainExpression) {\n\t\treturn node.expression;\n\t}\n\treturn node;\n}\n\n/**\n * Reads a statically-known member property name from dot or string-literal\n * bracket notation.\n */\nfunction getStaticPropertyName(\n\tnode: TSESTree.Node | null | undefined,\n): string | null {\n\tif (node?.type !== AST_NODE_TYPES.MemberExpression) return null;\n\tif (!node.computed && node.property.type === AST_NODE_TYPES.Identifier) {\n\t\treturn node.property.name;\n\t}\n\tif (\n\t\tnode.computed &&\n\t\tnode.property.type === AST_NODE_TYPES.Literal &&\n\t\ttypeof node.property.value === \"string\"\n\t) {\n\t\treturn node.property.value;\n\t}\n\treturn null;\n}\n\n/**\n * Converts a non-computed member expression chain into a dotted path such as\n * `log.child`.\n */\nfunction getMemberPath(node: TSESTree.Node | null | undefined): string | null {\n\tconst segments: string[] = [];\n\tlet current: TSESTree.Node | null | undefined = node;\n\n\twhile (current) {\n\t\tif (current.type === AST_NODE_TYPES.Identifier) {\n\t\t\tsegments.unshift(current.name);\n\t\t\treturn segments.join(\".\");\n\t\t}\n\n\t\tif (current.type === AST_NODE_TYPES.MemberExpression && !current.computed) {\n\t\t\t// Non-computed member expressions (a.b) always have an Identifier property.\n\t\t\t// PrivateIdentifiers (#field) are not valid logger paths.\n\t\t\tif (current.property.type !== AST_NODE_TYPES.Identifier) return null;\n\t\t\tsegments.unshift(current.property.name);\n\t\t\tcurrent = current.object;\n\t\t\tcontinue;\n\t\t}\n\n\t\treturn null;\n\t}\n\n\treturn null;\n}\n\n/**\n * Matches a call expression against the configured logger objects and returns\n * its expected argument positions.\n */\nfunction getLoggerCallConfig(\n\tnode: TSESTree.Node | null | undefined,\n\tsets: LoggerMatcherSets,\n): LoggerCallConfig | false {\n\tif (node?.type !== AST_NODE_TYPES.CallExpression) return false;\n\n\tconst callee = unwrapChainExpression(node.callee);\n\tif (callee?.type !== AST_NODE_TYPES.MemberExpression) return false;\n\n\tconst objectPath = getMemberPath(callee.object);\n\tconst objectIdentifier =\n\t\tcallee.object.type === AST_NODE_TYPES.Identifier\n\t\t\t? callee.object.name\n\t\t\t: null;\n\n\tconst isAllowedLoggerObject =\n\t\t(objectPath !== null && sets.allowedLoggerObjects.has(objectPath)) ||\n\t\t(objectIdentifier !== null &&\n\t\t\tsets.allowedLoggerIdentifiers.has(objectIdentifier));\n\n\tif (!isAllowedLoggerObject) return false;\n\n\tconst method = getStaticPropertyName(callee);\n\tconst isLevelMethod = method\n\t\t? sets.levelMethods.has(method)\n\t\t: callee.computed && !sets.ignoreDynamicLevelMethods;\n\n\tif (!isLevelMethod) return false;\n\n\tconst attributesFirst =\n\t\t(objectPath !== null &&\n\t\t\tsets.attributesFirstLoggerObjects.has(objectPath)) ||\n\t\t(objectIdentifier !== null &&\n\t\t\tsets.attributesFirstLoggerIdentifiers.has(objectIdentifier));\n\n\treturn {\n\t\tattributesArgumentIndex: attributesFirst ? 0 : 1,\n\t\tmessageArgumentIndex: attributesFirst ? 1 : 0,\n\t};\n}\n\n/**\n * Extracts a static object property key, rejecting computed keys that cannot be\n * checked safely by logger attribute rules.\n */\nfunction getPropertyKey(prop: TSESTree.Property): string | null {\n\tif (prop.computed) return null;\n\t// Widen to TSESTree.Node to avoid over-narrowing of the discriminated union.\n\tconst key = prop.key as TSESTree.Node;\n\tif (key.type === AST_NODE_TYPES.Identifier) return key.name;\n\tif (key.type === AST_NODE_TYPES.Literal) return String(key.value);\n\treturn null;\n}\n\n// ─── Public helpers ───────────────────────────────────────────────────────────\n\n/**\n * Convenience wrapper for external callers that don't pre-build sets.\n * Within this plugin's rules, prefer {@link getLoggerArguments} with\n * pre-built sets from {@link buildLoggerMatcherSets}.\n */\nexport function isLoggerCall(\n\tnode: TSESTree.Node | null | undefined,\n\toptions: LoggerMatcherOptions = {},\n): boolean {\n\treturn Boolean(getLoggerCallConfig(node, buildLoggerMatcherSets(options)));\n}\n\n/**\n * Returns the message and attributes arguments for a logger call, or `null`\n * if the node is not a recognised logger call. Use pre-built sets from\n * {@link buildLoggerMatcherSets} so sets are not reallocated per-node.\n */\nexport function getLoggerArguments(\n\tnode: TSESTree.CallExpression,\n\tsets: LoggerMatcherSets,\n): {\n\tattrsArg: TSESTree.Node | undefined;\n\tmessageArg: TSESTree.Node | undefined;\n} | null {\n\tconst config = getLoggerCallConfig(node, sets);\n\tif (!config) return null;\n\treturn {\n\t\tattrsArg: node.arguments[config.attributesArgumentIndex],\n\t\tmessageArg: node.arguments[config.messageArgumentIndex],\n\t};\n}\n\n/**\n * Extracts key/value pairs from an attribute object literal.\n * Returns `null` when the node cannot be analysed (not an ObjectExpression).\n * Returns `[]` when there is no attributes argument at all.\n */\nexport function collectAttrsEntries(\n\tattrsNode: TSESTree.Node | null | undefined,\n\toptions: CollectAttrsOptions = {},\n): AttrEntry[] | null {\n\tif (!attrsNode) return [];\n\n\tconst {\n\t\treportMalformedProperties = false,\n\t\treportNonLiteral = false,\n\t\treport,\n\t} = options;\n\n\tif (attrsNode.type !== AST_NODE_TYPES.ObjectExpression) {\n\t\tif (reportNonLiteral) {\n\t\t\treport?.(attrsNode, \"nonInlineAttributes\");\n\t\t}\n\t\treturn null;\n\t}\n\n\tconst entries: AttrEntry[] = [];\n\n\tfor (const prop of attrsNode.properties) {\n\t\tif (prop.type === AST_NODE_TYPES.SpreadElement) {\n\t\t\tif (reportMalformedProperties) {\n\t\t\t\treport?.(prop, \"noAttributeSpread\");\n\t\t\t}\n\t\t\tcontinue;\n\t\t}\n\n\t\t// ObjectExpression.properties is Property | SpreadElement; after the\n\t\t// SpreadElement branch above, prop is always a Property here.\n\t\tconst key = getPropertyKey(prop);\n\t\tif (!key) {\n\t\t\tif (reportMalformedProperties) {\n\t\t\t\treport?.(prop.key, \"staticAttributeKeys\");\n\t\t\t}\n\t\t\tcontinue;\n\t\t}\n\n\t\tentries.push({\n\t\t\tkey,\n\t\t\tkeyNode: prop.key,\n\t\t\tvalueNode: prop.value as TSESTree.Expression,\n\t\t});\n\t}\n\n\treturn entries;\n}\n\n// ─── Value-shape helpers ──────────────────────────────────────────────────────\n\n/** Returns whether a node is a literal string, number, or boolean value. */\nfunction isScalarLiteral(node: TSESTree.Node | null | undefined): boolean {\n\treturn (\n\t\tnode?.type === AST_NODE_TYPES.Literal &&\n\t\t(typeof node.value === \"string\" ||\n\t\t\ttypeof node.value === \"number\" ||\n\t\t\ttypeof node.value === \"boolean\")\n\t);\n}\n\n/**\n * Returns whether a node is a syntactic expression shape known to produce a\n * scalar log attribute without requiring type information.\n */\nfunction isKnownScalarExpression(\n\tnode: TSESTree.Node | null | undefined,\n): boolean {\n\treturn isScalarLiteral(node) || node?.type === AST_NODE_TYPES.TemplateLiteral;\n}\n\n/**\n * Returns whether a single (non-array) attribute value should be rejected as a\n * primitive log value.\n *\n * @remarks\n * Objects, arrays, functions, classes, and non-scalar literals are always\n * rejected. Unknown expressions are rejected only when\n * `disallowUnknownAttributeValues` is `true`.\n */\nfunction isDisallowedPrimitiveValue(\n\tnode: TSESTree.Node | null | undefined,\n\toptions: { disallowUnknownAttributeValues?: boolean },\n): boolean {\n\tif (node?.type !== undefined && NON_PRIMITIVE_NODE_TYPES.has(node.type))\n\t\treturn true;\n\tif (node?.type === AST_NODE_TYPES.Literal) return !isScalarLiteral(node);\n\treturn (\n\t\toptions.disallowUnknownAttributeValues === true &&\n\t\t!isKnownScalarExpression(node)\n\t);\n}\n\n/**\n * Returns whether an attribute value should be rejected by primitive-value\n * rules.\n *\n * @remarks\n * Primitive values (string, number, boolean) are always allowed. Arrays are\n * allowed when every element is itself a primitive value, so arrays of scalars\n * such as `[\"a\", \"b\"]` pass while nested arrays and arrays of objects do not.\n * Objects, functions, and classes are always rejected. Unknown expressions\n * (including array spreads) are rejected only when\n * `disallowUnknownAttributeValues` is `true`.\n */\nexport function isDisallowedAttributeValue(\n\tnode: TSESTree.Node | null | undefined,\n\toptions: { disallowUnknownAttributeValues?: boolean } = {},\n): boolean {\n\tif (node?.type === AST_NODE_TYPES.ArrayExpression) {\n\t\treturn node.elements.some((element) => {\n\t\t\t// Array holes (`[1, , 3]`) parse as null elements; treat them as empty.\n\t\t\tif (element === null) return false;\n\t\t\tif (element.type === AST_NODE_TYPES.SpreadElement) {\n\t\t\t\treturn options.disallowUnknownAttributeValues === true;\n\t\t\t}\n\t\t\treturn isDisallowedPrimitiveValue(element, options);\n\t\t});\n\t}\n\treturn isDisallowedPrimitiveValue(node, options);\n}\n\n/**\n * Returns whether a candidate logger message is clearly not static text.\n *\n * @remarks\n * This intentionally returns `false` for a missing node so callers can report a\n * dedicated \"message required\" violation.\n */\nexport function isClearlyNotMessage(\n\tnode: TSESTree.Node | null | undefined,\n): boolean {\n\tif (!node) return false;\n\treturn node.type !== AST_NODE_TYPES.Literal || typeof node.value !== \"string\";\n}\n"],"mappings":"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"}