@logtape/lint 2.2.0-dev.0

package/dist/rules/no-message-interpolation.cjs

@@ -0,0 +1,52 @@
+const require_ast = require('../core/ast.cjs');
+const require_utils = require('../utils.cjs');
+
+//#region src/rules/no-message-interpolation.ts
+/**
+* ESLint rule that detects string template literals with `${}` interpolation
+* passed as the message argument to LogTape log methods.
+*
+* Users should use message templates with structured properties instead:
+*
+* ```ts
+* // Incorrect:
+* logger.info(`User ${userId} logged in.`);
+*
+* // Correct:
+* logger.info("User {userId} logged in.", { userId });
+* ```
+*/
+const noMessageInterpolation = {
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow string template literal interpolation in LogTape log message arguments",
+			recommended: true,
+			url: "https://logtape.org/lint/no-message-interpolation"
+		},
+		schema: [],
+		messages: { noInterpolation: "Avoid using template literal interpolation in log messages. Use a message template string with structured properties instead: logger.info(\"User {userId} logged in.\", { userId })." }
+	},
+	create(context) {
+		const scope = require_utils.createLogtapeScope(context);
+		return {
+			ImportDeclaration: scope.ImportDeclaration,
+			CallExpression(node) {
+				const { callee } = node;
+				if (!scope.isLogtapeCall(callee, node)) return;
+				const propertyName = require_ast.logMethodName(callee);
+				if (!propertyName || !require_ast.LOG_METHODS.has(propertyName)) return;
+				const firstArg = require_ast.unwrapTypeAssertion(node.arguments[0]);
+				if (!firstArg || firstArg.type !== "TemplateLiteral") return;
+				if (firstArg.expressions.length === 0) return;
+				context.report({
+					node: firstArg,
+					messageId: "noInterpolation"
+				});
+			}
+		};
+	}
+};
+
+//#endregion
+exports.noMessageInterpolation = noMessageInterpolation;

package/dist/rules/no-message-interpolation.d.cts

@@ -0,0 +1,23 @@
+import { Rule } from "eslint";
+
+//#region src/rules/no-message-interpolation.d.ts
+
+/**
+ * ESLint rule that detects string template literals with `${}` interpolation
+ * passed as the message argument to LogTape log methods.
+ *
+ * Users should use message templates with structured properties instead:
+ *
+ * ```ts
+ * // Incorrect:
+ * logger.info(`User ${userId} logged in.`);
+ *
+ * // Correct:
+ * logger.info("User {userId} logged in.", { userId });
+ * ```
+ */
+declare const noMessageInterpolation: Rule.RuleModule;
+//# sourceMappingURL=no-message-interpolation.d.ts.map
+//#endregion
+export { noMessageInterpolation };
+//# sourceMappingURL=no-message-interpolation.d.cts.map

package/dist/rules/no-message-interpolation.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-message-interpolation.d.cts","names":[],"sources":["../../src/rules/no-message-interpolation.ts"],"sourcesContent":[],"mappings":";;;;;;AAsBA;;;;;;;;;;;;cAAa,wBAAwB,IAAA,CAAK"}

package/dist/rules/no-message-interpolation.d.ts

@@ -0,0 +1,23 @@
+import { Rule } from "eslint";
+
+//#region src/rules/no-message-interpolation.d.ts
+
+/**
+ * ESLint rule that detects string template literals with `${}` interpolation
+ * passed as the message argument to LogTape log methods.
+ *
+ * Users should use message templates with structured properties instead:
+ *
+ * ```ts
+ * // Incorrect:
+ * logger.info(`User ${userId} logged in.`);
+ *
+ * // Correct:
+ * logger.info("User {userId} logged in.", { userId });
+ * ```
+ */
+declare const noMessageInterpolation: Rule.RuleModule;
+//# sourceMappingURL=no-message-interpolation.d.ts.map
+//#endregion
+export { noMessageInterpolation };
+//# sourceMappingURL=no-message-interpolation.d.ts.map

package/dist/rules/no-message-interpolation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-message-interpolation.d.ts","names":[],"sources":["../../src/rules/no-message-interpolation.ts"],"sourcesContent":[],"mappings":";;;;;;AAsBA;;;;;;;;;;;;cAAa,wBAAwB,IAAA,CAAK"}

package/dist/rules/no-message-interpolation.js

@@ -0,0 +1,53 @@
+import { LOG_METHODS, logMethodName, unwrapTypeAssertion } from "../core/ast.js";
+import { createLogtapeScope } from "../utils.js";
+
+//#region src/rules/no-message-interpolation.ts
+/**
+* ESLint rule that detects string template literals with `${}` interpolation
+* passed as the message argument to LogTape log methods.
+*
+* Users should use message templates with structured properties instead:
+*
+* ```ts
+* // Incorrect:
+* logger.info(`User ${userId} logged in.`);
+*
+* // Correct:
+* logger.info("User {userId} logged in.", { userId });
+* ```
+*/
+const noMessageInterpolation = {
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow string template literal interpolation in LogTape log message arguments",
+			recommended: true,
+			url: "https://logtape.org/lint/no-message-interpolation"
+		},
+		schema: [],
+		messages: { noInterpolation: "Avoid using template literal interpolation in log messages. Use a message template string with structured properties instead: logger.info(\"User {userId} logged in.\", { userId })." }
+	},
+	create(context) {
+		const scope = createLogtapeScope(context);
+		return {
+			ImportDeclaration: scope.ImportDeclaration,
+			CallExpression(node) {
+				const { callee } = node;
+				if (!scope.isLogtapeCall(callee, node)) return;
+				const propertyName = logMethodName(callee);
+				if (!propertyName || !LOG_METHODS.has(propertyName)) return;
+				const firstArg = unwrapTypeAssertion(node.arguments[0]);
+				if (!firstArg || firstArg.type !== "TemplateLiteral") return;
+				if (firstArg.expressions.length === 0) return;
+				context.report({
+					node: firstArg,
+					messageId: "noInterpolation"
+				});
+			}
+		};
+	}
+};
+
+//#endregion
+export { noMessageInterpolation };
+//# sourceMappingURL=no-message-interpolation.js.map

package/dist/rules/no-message-interpolation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-message-interpolation.js","names":["noMessageInterpolation: Rule.RuleModule"],"sources":["../../src/rules/no-message-interpolation.ts"],"sourcesContent":["import type { Rule } from \"eslint\";\nimport {\n  LOG_METHODS,\n  logMethodName,\n  unwrapTypeAssertion,\n} from \"../core/ast.ts\";\nimport { createLogtapeScope } from \"../utils.ts\";\n\n/**\n * ESLint rule that detects string template literals with `${}` interpolation\n * passed as the message argument to LogTape log methods.\n *\n * Users should use message templates with structured properties instead:\n *\n * ```ts\n * // Incorrect:\n * logger.info(`User ${userId} logged in.`);\n *\n * // Correct:\n * logger.info(\"User {userId} logged in.\", { userId });\n * ```\n */\nexport const noMessageInterpolation: Rule.RuleModule = {\n  meta: {\n    type: \"problem\",\n    docs: {\n      description:\n        \"Disallow string template literal interpolation in LogTape log message arguments\",\n      recommended: true,\n      url: \"https://logtape.org/lint/no-message-interpolation\",\n    },\n    schema: [],\n    messages: {\n      noInterpolation:\n        \"Avoid using template literal interpolation in log messages. \" +\n        \"Use a message template string with structured properties instead: \" +\n        'logger.info(\"User {userId} logged in.\", { userId }).',\n    },\n  },\n\n  create(context) {\n    const scope = createLogtapeScope(context);\n\n    return {\n      ImportDeclaration: scope.ImportDeclaration,\n      CallExpression(node) {\n        const { callee } = node;\n        if (!scope.isLogtapeCall(callee, node)) return;\n        const propertyName = logMethodName(callee);\n        if (!propertyName || !LOG_METHODS.has(propertyName)) return;\n\n        const firstArg = unwrapTypeAssertion(node.arguments[0]);\n        if (!firstArg || firstArg.type !== \"TemplateLiteral\") return;\n        if (firstArg.expressions.length === 0) return;\n\n        context.report({\n          node: firstArg,\n          messageId: \"noInterpolation\",\n        });\n      },\n    };\n  },\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAsBA,MAAaA,yBAA0C;CACrD,MAAM;EACJ,MAAM;EACN,MAAM;GACJ,aACE;GACF,aAAa;GACb,KAAK;EACN;EACD,QAAQ,CAAE;EACV,UAAU,EACR,iBACE,uLAGH;CACF;CAED,OAAO,SAAS;EACd,MAAM,QAAQ,mBAAmB,QAAQ;AAEzC,SAAO;GACL,mBAAmB,MAAM;GACzB,eAAe,MAAM;IACnB,MAAM,EAAE,QAAQ,GAAG;AACnB,SAAK,MAAM,cAAc,QAAQ,KAAK,CAAE;IACxC,MAAM,eAAe,cAAc,OAAO;AAC1C,SAAK,iBAAiB,YAAY,IAAI,aAAa,CAAE;IAErD,MAAM,WAAW,oBAAoB,KAAK,UAAU,GAAG;AACvD,SAAK,YAAY,SAAS,SAAS,kBAAmB;AACtD,QAAI,SAAS,YAAY,WAAW,EAAG;AAEvC,YAAQ,OAAO;KACb,MAAM;KACN,WAAW;IACZ,EAAC;GACH;EACF;CACF;AACF"}

package/dist/rules/no-unawaited-log.cjs

@@ -0,0 +1,67 @@
+const require_ast = require('../core/ast.cjs');
+const require_utils = require('../utils.cjs');
+
+//#region src/rules/no-unawaited-log.ts
+/**
+* ESLint rule that detects async lazy callbacks passed to LogTape log methods
+* without `await`.  The resulting `Promise<void>` would be silently ignored.
+*
+* ```ts
+* // Incorrect:
+* logger.debug("msg", async () => ({ data: await fetchData() }));
+*
+* // Correct:
+* await logger.debug("msg", async () => ({ data: await fetchData() }));
+* ```
+*/
+const noUnawaitedLog = {
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Require await on LogTape log calls that use async lazy callbacks",
+			recommended: true,
+			url: "https://logtape.org/lint/no-unawaited-log"
+		},
+		fixable: "code",
+		schema: [],
+		messages: { requireAwait: "Async lazy callbacks must be awaited to ensure the log is flushed: await logger.debug(\"msg\", async () => ({ ... }))." }
+	},
+	create(context) {
+		const scope = require_utils.createLogtapeScope(context);
+		function resolvesToPromiseCallback(idNode, callNode) {
+			let cur = context.sourceCode?.getScope?.(callNode) ?? context.getScope?.();
+			while (cur) {
+				const variable = cur.set?.get(idNode.name);
+				if (variable) return variable.defs?.some((d) => {
+					if (d.type === "Variable") return require_ast.isAsyncFunctionExpr(d.node?.init) || require_ast.isPromiseReturningCallback(d.node?.init);
+					if (d.type === "FunctionName") return d.node?.async === true || require_ast.isPromiseReturningCallback(d.node);
+					return false;
+				}) ?? false;
+				cur = cur.upper;
+			}
+			return false;
+		}
+		return {
+			ImportDeclaration: scope.ImportDeclaration,
+			CallExpression(node) {
+				const { callee } = node;
+				if (!scope.isLogtapeCall(callee, node)) return;
+				const propertyName = require_ast.logMethodName(callee);
+				if (!propertyName || !require_ast.LOG_METHODS.has(propertyName)) return;
+				const secondArg = require_ast.unwrapTypeAssertion(node.arguments[1]);
+				if (!secondArg) return;
+				const isAsyncCallback = require_ast.isAsyncFunctionExpr(secondArg) || require_ast.isPromiseReturningCallback(secondArg) || secondArg.type === "Identifier" && resolvesToPromiseCallback(secondArg, node);
+				if (!isAsyncCallback) return;
+				if (require_ast.isLogPromiseHandled(node)) return;
+				context.report({
+					node,
+					messageId: "requireAwait",
+					fix: require_ast.canInsertAwait(node) ? (fixer) => fixer.insertTextBefore(node, "await ") : void 0
+				});
+			}
+		};
+	}
+};
+
+//#endregion
+exports.noUnawaitedLog = noUnawaitedLog;

package/dist/rules/no-unawaited-log.d.cts

@@ -0,0 +1,21 @@
+import { Rule } from "eslint";
+
+//#region src/rules/no-unawaited-log.d.ts
+
+/**
+ * ESLint rule that detects async lazy callbacks passed to LogTape log methods
+ * without `await`.  The resulting `Promise<void>` would be silently ignored.
+ *
+ * ```ts
+ * // Incorrect:
+ * logger.debug("msg", async () => ({ data: await fetchData() }));
+ *
+ * // Correct:
+ * await logger.debug("msg", async () => ({ data: await fetchData() }));
+ * ```
+ */
+declare const noUnawaitedLog: Rule.RuleModule;
+//# sourceMappingURL=no-unawaited-log.d.ts.map
+//#endregion
+export { noUnawaitedLog };
+//# sourceMappingURL=no-unawaited-log.d.cts.map

package/dist/rules/no-unawaited-log.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-unawaited-log.d.cts","names":[],"sources":["../../src/rules/no-unawaited-log.ts"],"sourcesContent":[],"mappings":";;;;;;AAwBA;;;;;;;;;;cAAa,gBAAgB,IAAA,CAAK"}

package/dist/rules/no-unawaited-log.d.ts

@@ -0,0 +1,21 @@
+import { Rule } from "eslint";
+
+//#region src/rules/no-unawaited-log.d.ts
+
+/**
+ * ESLint rule that detects async lazy callbacks passed to LogTape log methods
+ * without `await`.  The resulting `Promise<void>` would be silently ignored.
+ *
+ * ```ts
+ * // Incorrect:
+ * logger.debug("msg", async () => ({ data: await fetchData() }));
+ *
+ * // Correct:
+ * await logger.debug("msg", async () => ({ data: await fetchData() }));
+ * ```
+ */
+declare const noUnawaitedLog: Rule.RuleModule;
+//# sourceMappingURL=no-unawaited-log.d.ts.map
+//#endregion
+export { noUnawaitedLog };
+//# sourceMappingURL=no-unawaited-log.d.ts.map

package/dist/rules/no-unawaited-log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-unawaited-log.d.ts","names":[],"sources":["../../src/rules/no-unawaited-log.ts"],"sourcesContent":[],"mappings":";;;;;;AAwBA;;;;;;;;;;cAAa,gBAAgB,IAAA,CAAK"}

package/dist/rules/no-unawaited-log.js

@@ -0,0 +1,68 @@
+import { LOG_METHODS, canInsertAwait, isAsyncFunctionExpr, isLogPromiseHandled, isPromiseReturningCallback, logMethodName, unwrapTypeAssertion } from "../core/ast.js";
+import { createLogtapeScope } from "../utils.js";
+
+//#region src/rules/no-unawaited-log.ts
+/**
+* ESLint rule that detects async lazy callbacks passed to LogTape log methods
+* without `await`.  The resulting `Promise<void>` would be silently ignored.
+*
+* ```ts
+* // Incorrect:
+* logger.debug("msg", async () => ({ data: await fetchData() }));
+*
+* // Correct:
+* await logger.debug("msg", async () => ({ data: await fetchData() }));
+* ```
+*/
+const noUnawaitedLog = {
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Require await on LogTape log calls that use async lazy callbacks",
+			recommended: true,
+			url: "https://logtape.org/lint/no-unawaited-log"
+		},
+		fixable: "code",
+		schema: [],
+		messages: { requireAwait: "Async lazy callbacks must be awaited to ensure the log is flushed: await logger.debug(\"msg\", async () => ({ ... }))." }
+	},
+	create(context) {
+		const scope = createLogtapeScope(context);
+		function resolvesToPromiseCallback(idNode, callNode) {
+			let cur = context.sourceCode?.getScope?.(callNode) ?? context.getScope?.();
+			while (cur) {
+				const variable = cur.set?.get(idNode.name);
+				if (variable) return variable.defs?.some((d) => {
+					if (d.type === "Variable") return isAsyncFunctionExpr(d.node?.init) || isPromiseReturningCallback(d.node?.init);
+					if (d.type === "FunctionName") return d.node?.async === true || isPromiseReturningCallback(d.node);
+					return false;
+				}) ?? false;
+				cur = cur.upper;
+			}
+			return false;
+		}
+		return {
+			ImportDeclaration: scope.ImportDeclaration,
+			CallExpression(node) {
+				const { callee } = node;
+				if (!scope.isLogtapeCall(callee, node)) return;
+				const propertyName = logMethodName(callee);
+				if (!propertyName || !LOG_METHODS.has(propertyName)) return;
+				const secondArg = unwrapTypeAssertion(node.arguments[1]);
+				if (!secondArg) return;
+				const isAsyncCallback = isAsyncFunctionExpr(secondArg) || isPromiseReturningCallback(secondArg) || secondArg.type === "Identifier" && resolvesToPromiseCallback(secondArg, node);
+				if (!isAsyncCallback) return;
+				if (isLogPromiseHandled(node)) return;
+				context.report({
+					node,
+					messageId: "requireAwait",
+					fix: canInsertAwait(node) ? (fixer) => fixer.insertTextBefore(node, "await ") : void 0
+				});
+			}
+		};
+	}
+};
+
+//#endregion
+export { noUnawaitedLog };
+//# sourceMappingURL=no-unawaited-log.js.map

package/dist/rules/no-unawaited-log.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-unawaited-log.js","names":["noUnawaitedLog: Rule.RuleModule","idNode: any","callNode: any","cur: any","d: any"],"sources":["../../src/rules/no-unawaited-log.ts"],"sourcesContent":["import type { Rule } from \"eslint\";\nimport {\n  canInsertAwait,\n  isAsyncFunctionExpr,\n  isLogPromiseHandled,\n  isPromiseReturningCallback,\n  LOG_METHODS,\n  logMethodName,\n  unwrapTypeAssertion,\n} from \"../core/ast.ts\";\nimport { createLogtapeScope } from \"../utils.ts\";\n\n/**\n * ESLint rule that detects async lazy callbacks passed to LogTape log methods\n * without `await`.  The resulting `Promise<void>` would be silently ignored.\n *\n * ```ts\n * // Incorrect:\n * logger.debug(\"msg\", async () => ({ data: await fetchData() }));\n *\n * // Correct:\n * await logger.debug(\"msg\", async () => ({ data: await fetchData() }));\n * ```\n */\nexport const noUnawaitedLog: Rule.RuleModule = {\n  meta: {\n    type: \"problem\",\n    docs: {\n      description:\n        \"Require await on LogTape log calls that use async lazy callbacks\",\n      recommended: true,\n      url: \"https://logtape.org/lint/no-unawaited-log\",\n    },\n    fixable: \"code\",\n    schema: [],\n    messages: {\n      requireAwait:\n        \"Async lazy callbacks must be awaited to ensure the log is flushed: \" +\n        'await logger.debug(\"msg\", async () => ({ ... })).',\n    },\n  },\n\n  create(context) {\n    const scope = createLogtapeScope(context);\n\n    // Does the identifier argument resolve to a binding whose value yields a\n    // promise: an async function, or a non-async function that syntactically\n    // returns one?  This catches a callback passed by reference in both the\n    // variable form (`const props = async () => ({ ... })` or\n    // `const props = () => fetchData().then(...)`) and the function-declaration\n    // form (`async function props() {}` or `function props() { return p.then(...) }`).\n    // deno-lint-ignore no-explicit-any\n    function resolvesToPromiseCallback(idNode: any, callNode: any): boolean {\n      // deno-lint-ignore no-explicit-any\n      let cur: any = (context as any).sourceCode?.getScope?.(callNode) ??\n        // deno-lint-ignore no-explicit-any\n        (context as any).getScope?.();\n      while (cur) {\n        const variable = cur.set?.get(idNode.name);\n        if (variable) {\n          // deno-lint-ignore no-explicit-any\n          return variable.defs?.some((d: any) => {\n            if (d.type === \"Variable\") {\n              return isAsyncFunctionExpr(d.node?.init) ||\n                isPromiseReturningCallback(d.node?.init);\n            }\n            // function props() {} is a FunctionName def.\n            if (d.type === \"FunctionName\") {\n              return d.node?.async === true ||\n                isPromiseReturningCallback(d.node);\n            }\n            return false;\n          }) ?? false;\n        }\n        cur = cur.upper;\n      }\n      return false;\n    }\n\n    return {\n      ImportDeclaration: scope.ImportDeclaration,\n      CallExpression(node) {\n        const { callee } = node;\n        if (!scope.isLogtapeCall(callee, node)) return;\n        const propertyName = logMethodName(callee);\n        if (!propertyName || !LOG_METHODS.has(propertyName)) return;\n\n        const secondArg = unwrapTypeAssertion(node.arguments[1]);\n        if (!secondArg) return;\n\n        const isAsyncCallback = isAsyncFunctionExpr(secondArg) ||\n          isPromiseReturningCallback(secondArg) ||\n          (secondArg.type === \"Identifier\" &&\n            resolvesToPromiseCallback(secondArg, node));\n        if (!isAsyncCallback) return;\n\n        // Walk the ancestor chain to check if the promise is handled (awaited,\n        // returned, chained with .then(), or consumed by Promise.all()).\n        if (isLogPromiseHandled(node)) return;\n\n        context.report({\n          node,\n          messageId: \"requireAwait\",\n          // Only autofix a standalone statement.  Inserting `await` where the\n          // call's value is used (assigned, passed as an argument, returned)\n          // would change a Promise<void> into void and can break code that\n          // uses that promise, so those contexts are reported without a fix.\n          fix: canInsertAwait(node)\n            ? (fixer) => fixer.insertTextBefore(node, \"await \")\n            : undefined,\n        });\n      },\n    };\n  },\n};\n"],"mappings":";;;;;;;;;;;;;;;;AAwBA,MAAaA,iBAAkC;CAC7C,MAAM;EACJ,MAAM;EACN,MAAM;GACJ,aACE;GACF,aAAa;GACb,KAAK;EACN;EACD,SAAS;EACT,QAAQ,CAAE;EACV,UAAU,EACR,cACE,yHAEH;CACF;CAED,OAAO,SAAS;EACd,MAAM,QAAQ,mBAAmB,QAAQ;EASzC,SAAS,0BAA0BC,QAAaC,UAAwB;GAEtE,IAAIC,MAAW,AAAC,QAAgB,YAAY,WAAW,SAAS,IAE9D,AAAC,QAAgB,YAAY;AAC/B,UAAO,KAAK;IACV,MAAM,WAAW,IAAI,KAAK,IAAI,OAAO,KAAK;AAC1C,QAAI,SAEF,QAAO,SAAS,MAAM,KAAK,CAACC,MAAW;AACrC,SAAI,EAAE,SAAS,WACb,QAAO,oBAAoB,EAAE,MAAM,KAAK,IACtC,2BAA2B,EAAE,MAAM,KAAK;AAG5C,SAAI,EAAE,SAAS,eACb,QAAO,EAAE,MAAM,UAAU,QACvB,2BAA2B,EAAE,KAAK;AAEtC,YAAO;IACR,EAAC,IAAI;AAER,UAAM,IAAI;GACX;AACD,UAAO;EACR;AAED,SAAO;GACL,mBAAmB,MAAM;GACzB,eAAe,MAAM;IACnB,MAAM,EAAE,QAAQ,GAAG;AACnB,SAAK,MAAM,cAAc,QAAQ,KAAK,CAAE;IACxC,MAAM,eAAe,cAAc,OAAO;AAC1C,SAAK,iBAAiB,YAAY,IAAI,aAAa,CAAE;IAErD,MAAM,YAAY,oBAAoB,KAAK,UAAU,GAAG;AACxD,SAAK,UAAW;IAEhB,MAAM,kBAAkB,oBAAoB,UAAU,IACpD,2BAA2B,UAAU,IACpC,UAAU,SAAS,gBAClB,0BAA0B,WAAW,KAAK;AAC9C,SAAK,gBAAiB;AAItB,QAAI,oBAAoB,KAAK,CAAE;AAE/B,YAAQ,OAAO;KACb;KACA,WAAW;KAKX,KAAK,eAAe,KAAK,GACrB,CAAC,UAAU,MAAM,iBAAiB,MAAM,SAAS;IAEtD,EAAC;GACH;EACF;CACF;AACF"}

package/dist/rules/prefer-lazy-evaluation.cjs

@@ -0,0 +1,59 @@
+const require_ast = require('../core/ast.cjs');
+const require_utils = require('../utils.cjs');
+
+//#region src/rules/prefer-lazy-evaluation.ts
+/**
+* ESLint rule that detects computed expressions (function calls) inside the
+* properties object passed to LogTape log methods.  Wrapping in a lazy
+* callback prevents unnecessary computation when the log level is disabled.
+*
+* ```ts
+* // Incorrect:
+* logger.debug("User data: {userData}.", { userData: fetchUserData(userId) });
+*
+* // Correct:
+* logger.debug("User data: {userData}.", () => ({ userData: fetchUserData(userId) }));
+* ```
+*/
+const preferLazyEvaluation = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Prefer lazy evaluation callbacks over eager property objects in LogTape log calls",
+			recommended: true,
+			url: "https://logtape.org/lint/prefer-lazy-evaluation"
+		},
+		fixable: "code",
+		schema: [],
+		messages: { preferLazy: "Wrap the properties object in a lazy callback to avoid unnecessary computation: logger.debug(\"msg\", () => ({ ... }))." }
+	},
+	create(context) {
+		const scope = require_utils.createLogtapeScope(context);
+		return {
+			ImportDeclaration: scope.ImportDeclaration,
+			CallExpression(node) {
+				const { callee } = node;
+				if (!scope.isLogtapeCall(callee, node)) return;
+				const propertyName = require_ast.logMethodName(callee);
+				if (!propertyName || !require_ast.LOG_METHODS.has(propertyName)) return;
+				const selected = require_ast.selectLazyPropsObject(node.arguments);
+				if (!selected) return;
+				const { propsObject, fixTarget, propertiesOnly } = selected;
+				if (!require_ast.propsHaveEagerCall(propsObject, scope.effectiveLazyNames(node))) return;
+				const sourceCode = require_utils.getSourceCode(context);
+				const hasAsyncSyntax = require_ast.containsAwaitOrYield(propsObject);
+				context.report({
+					node: propsObject,
+					messageId: "preferLazy",
+					fix: hasAsyncSyntax ? void 0 : (fixer) => {
+						const objectText = sourceCode.getText(fixTarget);
+						return fixer.replaceText(fixTarget, propertiesOnly ? `"{*}", () => (${objectText})` : `() => (${objectText})`);
+					}
+				});
+			}
+		};
+	}
+};
+
+//#endregion
+exports.preferLazyEvaluation = preferLazyEvaluation;

package/dist/rules/prefer-lazy-evaluation.d.cts

@@ -0,0 +1,22 @@
+import { Rule } from "eslint";
+
+//#region src/rules/prefer-lazy-evaluation.d.ts
+
+/**
+ * ESLint rule that detects computed expressions (function calls) inside the
+ * properties object passed to LogTape log methods.  Wrapping in a lazy
+ * callback prevents unnecessary computation when the log level is disabled.
+ *
+ * ```ts
+ * // Incorrect:
+ * logger.debug("User data: {userData}.", { userData: fetchUserData(userId) });
+ *
+ * // Correct:
+ * logger.debug("User data: {userData}.", () => ({ userData: fetchUserData(userId) }));
+ * ```
+ */
+declare const preferLazyEvaluation: Rule.RuleModule;
+//# sourceMappingURL=prefer-lazy-evaluation.d.ts.map
+//#endregion
+export { preferLazyEvaluation };
+//# sourceMappingURL=prefer-lazy-evaluation.d.cts.map

package/dist/rules/prefer-lazy-evaluation.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-lazy-evaluation.d.cts","names":[],"sources":["../../src/rules/prefer-lazy-evaluation.ts"],"sourcesContent":[],"mappings":";;;;;;AAuBA;;;;;;;;;;;cAAa,sBAAsB,IAAA,CAAK"}

package/dist/rules/prefer-lazy-evaluation.d.ts

@@ -0,0 +1,22 @@
+import { Rule } from "eslint";
+
+//#region src/rules/prefer-lazy-evaluation.d.ts
+
+/**
+ * ESLint rule that detects computed expressions (function calls) inside the
+ * properties object passed to LogTape log methods.  Wrapping in a lazy
+ * callback prevents unnecessary computation when the log level is disabled.
+ *
+ * ```ts
+ * // Incorrect:
+ * logger.debug("User data: {userData}.", { userData: fetchUserData(userId) });
+ *
+ * // Correct:
+ * logger.debug("User data: {userData}.", () => ({ userData: fetchUserData(userId) }));
+ * ```
+ */
+declare const preferLazyEvaluation: Rule.RuleModule;
+//# sourceMappingURL=prefer-lazy-evaluation.d.ts.map
+//#endregion
+export { preferLazyEvaluation };
+//# sourceMappingURL=prefer-lazy-evaluation.d.ts.map

package/dist/rules/prefer-lazy-evaluation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-lazy-evaluation.d.ts","names":[],"sources":["../../src/rules/prefer-lazy-evaluation.ts"],"sourcesContent":[],"mappings":";;;;;;AAuBA;;;;;;;;;;;cAAa,sBAAsB,IAAA,CAAK"}

package/dist/rules/prefer-lazy-evaluation.js

@@ -0,0 +1,60 @@
+import { LOG_METHODS, containsAwaitOrYield, logMethodName, propsHaveEagerCall, selectLazyPropsObject } from "../core/ast.js";
+import { createLogtapeScope, getSourceCode } from "../utils.js";
+
+//#region src/rules/prefer-lazy-evaluation.ts
+/**
+* ESLint rule that detects computed expressions (function calls) inside the
+* properties object passed to LogTape log methods.  Wrapping in a lazy
+* callback prevents unnecessary computation when the log level is disabled.
+*
+* ```ts
+* // Incorrect:
+* logger.debug("User data: {userData}.", { userData: fetchUserData(userId) });
+*
+* // Correct:
+* logger.debug("User data: {userData}.", () => ({ userData: fetchUserData(userId) }));
+* ```
+*/
+const preferLazyEvaluation = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Prefer lazy evaluation callbacks over eager property objects in LogTape log calls",
+			recommended: true,
+			url: "https://logtape.org/lint/prefer-lazy-evaluation"
+		},
+		fixable: "code",
+		schema: [],
+		messages: { preferLazy: "Wrap the properties object in a lazy callback to avoid unnecessary computation: logger.debug(\"msg\", () => ({ ... }))." }
+	},
+	create(context) {
+		const scope = createLogtapeScope(context);
+		return {
+			ImportDeclaration: scope.ImportDeclaration,
+			CallExpression(node) {
+				const { callee } = node;
+				if (!scope.isLogtapeCall(callee, node)) return;
+				const propertyName = logMethodName(callee);
+				if (!propertyName || !LOG_METHODS.has(propertyName)) return;
+				const selected = selectLazyPropsObject(node.arguments);
+				if (!selected) return;
+				const { propsObject, fixTarget, propertiesOnly } = selected;
+				if (!propsHaveEagerCall(propsObject, scope.effectiveLazyNames(node))) return;
+				const sourceCode = getSourceCode(context);
+				const hasAsyncSyntax = containsAwaitOrYield(propsObject);
+				context.report({
+					node: propsObject,
+					messageId: "preferLazy",
+					fix: hasAsyncSyntax ? void 0 : (fixer) => {
+						const objectText = sourceCode.getText(fixTarget);
+						return fixer.replaceText(fixTarget, propertiesOnly ? `"{*}", () => (${objectText})` : `() => (${objectText})`);
+					}
+				});
+			}
+		};
+	}
+};
+
+//#endregion
+export { preferLazyEvaluation };
+//# sourceMappingURL=prefer-lazy-evaluation.js.map

package/dist/rules/prefer-lazy-evaluation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-lazy-evaluation.js","names":["preferLazyEvaluation: Rule.RuleModule"],"sources":["../../src/rules/prefer-lazy-evaluation.ts"],"sourcesContent":["import type { Rule } from \"eslint\";\nimport {\n  containsAwaitOrYield,\n  LOG_METHODS,\n  logMethodName,\n  propsHaveEagerCall,\n  selectLazyPropsObject,\n} from \"../core/ast.ts\";\nimport { createLogtapeScope, getSourceCode } from \"../utils.ts\";\n\n/**\n * ESLint rule that detects computed expressions (function calls) inside the\n * properties object passed to LogTape log methods.  Wrapping in a lazy\n * callback prevents unnecessary computation when the log level is disabled.\n *\n * ```ts\n * // Incorrect:\n * logger.debug(\"User data: {userData}.\", { userData: fetchUserData(userId) });\n *\n * // Correct:\n * logger.debug(\"User data: {userData}.\", () => ({ userData: fetchUserData(userId) }));\n * ```\n */\nexport const preferLazyEvaluation: Rule.RuleModule = {\n  meta: {\n    type: \"suggestion\",\n    docs: {\n      description:\n        \"Prefer lazy evaluation callbacks over eager property objects in LogTape log calls\",\n      recommended: true,\n      url: \"https://logtape.org/lint/prefer-lazy-evaluation\",\n    },\n    fixable: \"code\",\n    schema: [],\n    messages: {\n      preferLazy:\n        \"Wrap the properties object in a lazy callback to avoid unnecessary computation: \" +\n        'logger.debug(\"msg\", () => ({ ... })).',\n    },\n  },\n\n  create(context) {\n    const scope = createLogtapeScope(context);\n\n    return {\n      ImportDeclaration: scope.ImportDeclaration,\n      CallExpression(node) {\n        const { callee } = node;\n        if (!scope.isLogtapeCall(callee, node)) return;\n        const propertyName = logMethodName(callee);\n        if (!propertyName || !LOG_METHODS.has(propertyName)) return;\n\n        // The eager properties object is the second argument in the\n        // message+properties form, logger.debug(\"msg\", { ... }), or the first\n        // argument in the properties-only form, logger.debug({ ... }).\n        const selected = selectLazyPropsObject(node.arguments);\n        if (!selected) return;\n        const { propsObject, fixTarget, propertiesOnly } = selected;\n\n        // Use the lazy names that still resolve to the import at this call, so\n        // a shadowed local `lazy(...)` is treated as an ordinary eager call.\n        if (!propsHaveEagerCall(propsObject, scope.effectiveLazyNames(node))) {\n          return;\n        }\n\n        const sourceCode = getSourceCode(context);\n        const hasAsyncSyntax = containsAwaitOrYield(propsObject);\n        context.report({\n          node: propsObject,\n          messageId: \"preferLazy\",\n          // Wrap the whole argument (fixTarget), including any `as const` /\n          // `satisfies` wrapper, so the assertion ends up inside the callback\n          // instead of dangling on it.\n          fix: hasAsyncSyntax ? undefined : (fixer) => {\n            const objectText = sourceCode.getText(fixTarget);\n            // The properties-only overload needs the \"{*}\" message inserted so\n            // the lazy callback is still read as properties, not as a message.\n            return fixer.replaceText(\n              fixTarget,\n              propertiesOnly\n                ? `\"{*}\", () => (${objectText})`\n                : `() => (${objectText})`,\n            );\n          },\n        });\n      },\n    };\n  },\n};\n"],"mappings":";;;;;;;;;;;;;;;;;AAuBA,MAAaA,uBAAwC;CACnD,MAAM;EACJ,MAAM;EACN,MAAM;GACJ,aACE;GACF,aAAa;GACb,KAAK;EACN;EACD,SAAS;EACT,QAAQ,CAAE;EACV,UAAU,EACR,YACE,0HAEH;CACF;CAED,OAAO,SAAS;EACd,MAAM,QAAQ,mBAAmB,QAAQ;AAEzC,SAAO;GACL,mBAAmB,MAAM;GACzB,eAAe,MAAM;IACnB,MAAM,EAAE,QAAQ,GAAG;AACnB,SAAK,MAAM,cAAc,QAAQ,KAAK,CAAE;IACxC,MAAM,eAAe,cAAc,OAAO;AAC1C,SAAK,iBAAiB,YAAY,IAAI,aAAa,CAAE;IAKrD,MAAM,WAAW,sBAAsB,KAAK,UAAU;AACtD,SAAK,SAAU;IACf,MAAM,EAAE,aAAa,WAAW,gBAAgB,GAAG;AAInD,SAAK,mBAAmB,aAAa,MAAM,mBAAmB,KAAK,CAAC,CAClE;IAGF,MAAM,aAAa,cAAc,QAAQ;IACzC,MAAM,iBAAiB,qBAAqB,YAAY;AACxD,YAAQ,OAAO;KACb,MAAM;KACN,WAAW;KAIX,KAAK,0BAA6B,CAAC,UAAU;MAC3C,MAAM,aAAa,WAAW,QAAQ,UAAU;AAGhD,aAAO,MAAM,YACX,WACA,kBACK,gBAAgB,WAAW,MAC3B,SAAS,WAAW,GAC1B;KACF;IACF,EAAC;GACH;EACF;CACF;AACF"}

package/dist/rules/require-meta-sink.cjs

@@ -0,0 +1,75 @@
+const require_ast = require('../core/ast.cjs');
+
+//#region src/rules/require-meta-sink.ts
+/**
+* ESLint rule that detects `configure()` / `configureSync()` calls imported
+* from `@logtape/logtape` that lack a dedicated sink for the meta logger.
+*
+* ```ts
+* // Incorrect (missing meta sink):
+* await configure({ sinks: { main: s }, loggers: [{ category: [], sinks: ["main"] }] });
+*
+* // Correct:
+* await configure({
+*   sinks: { console: getConsoleSink(), main: s },
+*   loggers: [
+*     { category: ["logtape", "meta"], sinks: ["console"] },
+*     { category: [], sinks: ["main"] },
+*   ],
+* });
+* ```
+*/
+const requireMetaSink = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Require a dedicated sink for the LogTape meta logger in configure() calls",
+			recommended: true,
+			url: "https://logtape.org/lint/require-meta-sink"
+		},
+		schema: [],
+		messages: { requireMeta: "Add a dedicated sink for the meta logger (category: [\"logtape\"] or [\"logtape\", \"meta\"]) to handle LogTape's own diagnostic messages." }
+	},
+	create(context) {
+		const configFns = /* @__PURE__ */ new Set();
+		return {
+			ImportDeclaration(node) {
+				if (!require_ast.isLogtapeImportSource(node.source?.value)) return;
+				for (const specifier of node.specifiers ?? []) {
+					if (specifier.type !== "ImportSpecifier") continue;
+					const imported = specifier.imported?.name;
+					if (imported === "configure" || imported === "configureSync") configFns.add(specifier.local?.name);
+				}
+			},
+			CallExpression(node) {
+				if (configFns.size === 0) return;
+				const { callee } = node;
+				if (callee.type !== "Identifier") return;
+				const calleeName = callee.name;
+				if (!configFns.has(calleeName)) return;
+				const scope = context.sourceCode?.getScope?.(node) ?? context.getScope?.();
+				if (scope) {
+					let cur = scope;
+					let calleeVar = null;
+					while (cur) {
+						const v = cur.set?.get(calleeName);
+						if (v) {
+							calleeVar = v;
+							break;
+						}
+						cur = cur.upper;
+					}
+					if (!calleeVar?.defs?.some((d) => d.type === "ImportBinding")) return;
+				}
+				const configArg = require_ast.unwrapTypeAssertion(node.arguments[0]);
+				if (require_ast.configNeedsMetaSink(configArg)) context.report({
+					node,
+					messageId: "requireMeta"
+				});
+			}
+		};
+	}
+};
+
+//#endregion
+exports.requireMetaSink = requireMetaSink;

package/dist/rules/require-meta-sink.d.cts

@@ -0,0 +1,27 @@
+import { Rule } from "eslint";
+
+//#region src/rules/require-meta-sink.d.ts
+
+/**
+ * ESLint rule that detects `configure()` / `configureSync()` calls imported
+ * from `@logtape/logtape` that lack a dedicated sink for the meta logger.
+ *
+ * ```ts
+ * // Incorrect (missing meta sink):
+ * await configure({ sinks: { main: s }, loggers: [{ category: [], sinks: ["main"] }] });
+ *
+ * // Correct:
+ * await configure({
+ *   sinks: { console: getConsoleSink(), main: s },
+ *   loggers: [
+ *     { category: ["logtape", "meta"], sinks: ["console"] },
+ *     { category: [], sinks: ["main"] },
+ *   ],
+ * });
+ * ```
+ */
+declare const requireMetaSink: Rule.RuleModule;
+//# sourceMappingURL=require-meta-sink.d.ts.map
+//#endregion
+export { requireMetaSink };
+//# sourceMappingURL=require-meta-sink.d.cts.map