@logtape/lint 2.2.0-dev.0

package/dist/deno/plugin.js

@@ -0,0 +1,333 @@
+import { LOG_METHODS, canInsertAwait, configNeedsMetaSink, containsAwaitOrYield, isAsyncFunctionExpr, isLogPromiseHandled, isLogtapeImportSource, isPromiseReturningCallback, logMethodName, propsHaveEagerCall, selectLazyPropsObject, unwrapTypeAssertion } from "../core/ast.js";
+
+//#region src/deno/plugin.ts
+function extractIdentifiers(node, names) {
+	if (!node) return;
+	if (node.type === "Identifier") names.add(node.name);
+	else if (node.type === "ObjectPattern") {
+		for (const prop of node.properties ?? []) if (prop.type === "Property") extractIdentifiers(prop.value, names);
+		else if (prop.type === "RestElement") extractIdentifiers(prop.argument, names);
+	} else if (node.type === "ArrayPattern") for (const elem of node.elements ?? []) extractIdentifiers(elem, names);
+	else if (node.type === "AssignmentPattern") extractIdentifiers(node.left, names);
+	else if (node.type === "RestElement") extractIdentifiers(node.argument, names);
+	else if (node.type === "TSParameterProperty") extractIdentifiers(node.parameter, names);
+}
+/**
+* Creates a scope tracker for LogTape logger variable bindings.
+*
+* The Deno Lint plugin API does not expose a scope manager, so this hand-rolls
+* one with a scope stack (Map<name, isLogger>) to correctly handle:
+* - Function parameters that shadow logger names (tracked as false)
+* - Local variables that re-declare logger names with non-logger values
+* - Block scoping via BlockStatement enter/exit
+*
+* Returns a `visitors` object to spread into a rule's visitor map, plus the
+* scope-aware predicates the rule's `CallExpression` handler needs.
+*/
+function makeLoggerScope() {
+	const getterNames = /* @__PURE__ */ new Set();
+	const lazyNames = /* @__PURE__ */ new Set();
+	const scopeStack = [/* @__PURE__ */ new Map()];
+	const shadowedGetterStack = [/* @__PURE__ */ new Set()];
+	const shadowedLazyStack = [/* @__PURE__ */ new Set()];
+	const asyncFnStack = [/* @__PURE__ */ new Map()];
+	function pushScope() {
+		scopeStack.push(/* @__PURE__ */ new Map());
+		shadowedGetterStack.push(/* @__PURE__ */ new Set());
+		shadowedLazyStack.push(/* @__PURE__ */ new Set());
+		asyncFnStack.push(/* @__PURE__ */ new Map());
+	}
+	function popScope() {
+		if (scopeStack.length > 1) scopeStack.pop();
+		if (shadowedGetterStack.length > 1) shadowedGetterStack.pop();
+		if (shadowedLazyStack.length > 1) shadowedLazyStack.pop();
+		if (asyncFnStack.length > 1) asyncFnStack.pop();
+	}
+	function isLoggerName(name) {
+		for (let i = scopeStack.length - 1; i >= 0; i--) if (scopeStack[i].has(name)) return scopeStack[i].get(name);
+		return false;
+	}
+	function isAsyncFunctionName(name) {
+		for (let i = asyncFnStack.length - 1; i >= 0; i--) if (asyncFnStack[i].has(name)) return asyncFnStack[i].get(name);
+		return false;
+	}
+	function isGetterShadowed(name) {
+		for (let i = shadowedGetterStack.length - 1; i >= 0; i--) if (shadowedGetterStack[i].has(name)) return true;
+		return false;
+	}
+	function isLazyShadowed(name) {
+		for (let i = shadowedLazyStack.length - 1; i >= 0; i--) if (shadowedLazyStack[i].has(name)) return true;
+		return false;
+	}
+	function recordImportShadow(name) {
+		shadowedGetterStack[shadowedGetterStack.length - 1].add(name);
+		shadowedLazyStack[shadowedLazyStack.length - 1].add(name);
+	}
+	function effectiveLazyNames() {
+		if (lazyNames.size === 0) return lazyNames;
+		const result = /* @__PURE__ */ new Set();
+		for (const name of lazyNames) if (!isLazyShadowed(name)) result.add(name);
+		return result;
+	}
+	function handleFunctionEnter(node) {
+		if (node.type === "FunctionDeclaration" && node.id?.type === "Identifier") {
+			recordImportShadow(node.id.name);
+			scopeStack[scopeStack.length - 1].set(node.id.name, false);
+			asyncFnStack[asyncFnStack.length - 1].set(node.id.name, node.async === true || isPromiseReturningCallback(node));
+		}
+		pushScope();
+		const names = /* @__PURE__ */ new Set();
+		if (node.type === "FunctionExpression" && node.id?.type === "Identifier") names.add(node.id.name);
+		for (const param of node.params ?? []) extractIdentifiers(param, names);
+		for (const name of names) {
+			scopeStack[scopeStack.length - 1].set(name, false);
+			recordImportShadow(name);
+			asyncFnStack[asyncFnStack.length - 1].set(name, false);
+		}
+	}
+	function handleBlockEnter(node) {
+		pushScope();
+		for (const stmt of node.body ?? []) if (stmt?.type === "FunctionDeclaration" && stmt.id?.type === "Identifier") {
+			recordImportShadow(stmt.id.name);
+			scopeStack[scopeStack.length - 1].set(stmt.id.name, false);
+			asyncFnStack[asyncFnStack.length - 1].set(stmt.id.name, stmt.async === true || isPromiseReturningCallback(stmt));
+		}
+	}
+	function handleCatchEnter(node) {
+		pushScope();
+		if (!node.param) return;
+		const names = /* @__PURE__ */ new Set();
+		extractIdentifiers(node.param, names);
+		for (const name of names) {
+			scopeStack[scopeStack.length - 1].set(name, false);
+			recordImportShadow(name);
+			asyncFnStack[asyncFnStack.length - 1].set(name, false);
+		}
+	}
+	function isLoggerExpr(node, depth = 0) {
+		if (depth > 16 || !node) return false;
+		if (node.type === "CallExpression" && node.callee?.type === "Identifier" && getterNames.has(node.callee.name) && !isGetterShadowed(node.callee.name)) return true;
+		if (node.type === "CallExpression" && node.callee?.type === "MemberExpression" && !node.callee.computed && node.callee.property?.type === "Identifier" && (node.callee.property.name === "with" || node.callee.property.name === "getChild")) return isLoggerExpr(node.callee.object, depth + 1);
+		if (node.type === "Identifier") return isLoggerName(node.name);
+		return false;
+	}
+	function isLogtapeCallee(callee) {
+		if (!callee || callee.type !== "MemberExpression") return false;
+		return isLoggerExpr(callee.object);
+	}
+	return {
+		visitors: {
+			ImportDeclaration(node) {
+				if (!isLogtapeImportSource(node.source?.value)) return;
+				for (const spec of node.specifiers ?? []) {
+					if (spec.type !== "ImportSpecifier") continue;
+					if (spec.imported?.name === "getLogger") getterNames.add(spec.local?.name);
+					else if (spec.imported?.name === "lazy") lazyNames.add(spec.local?.name);
+				}
+			},
+			VariableDeclarator(node) {
+				if (node.id?.type === "Identifier") {
+					const name = node.id.name;
+					const init = node.init;
+					const isLogger = isLoggerExpr(init);
+					if (isLogger) scopeStack[scopeStack.length - 1].set(name, true);
+					else if (isLoggerName(name)) scopeStack[scopeStack.length - 1].set(name, false);
+					recordImportShadow(name);
+					asyncFnStack[asyncFnStack.length - 1].set(name, isAsyncFunctionExpr(init) || isPromiseReturningCallback(init));
+				} else {
+					const names = /* @__PURE__ */ new Set();
+					extractIdentifiers(node.id, names);
+					for (const name of names) {
+						if (isLoggerName(name)) scopeStack[scopeStack.length - 1].set(name, false);
+						recordImportShadow(name);
+						asyncFnStack[asyncFnStack.length - 1].set(name, false);
+					}
+				}
+			},
+			FunctionDeclaration: handleFunctionEnter,
+			"FunctionDeclaration:exit": popScope,
+			FunctionExpression: handleFunctionEnter,
+			"FunctionExpression:exit": popScope,
+			ArrowFunctionExpression: handleFunctionEnter,
+			"ArrowFunctionExpression:exit": popScope,
+			Program: handleBlockEnter,
+			"Program:exit": popScope,
+			BlockStatement: handleBlockEnter,
+			"BlockStatement:exit": popScope,
+			TSModuleBlock: handleBlockEnter,
+			"TSModuleBlock:exit": popScope,
+			ForStatement: pushScope,
+			"ForStatement:exit": popScope,
+			ForInStatement: pushScope,
+			"ForInStatement:exit": popScope,
+			ForOfStatement: pushScope,
+			"ForOfStatement:exit": popScope,
+			SwitchStatement: pushScope,
+			"SwitchStatement:exit": popScope,
+			CatchClause: handleCatchEnter,
+			"CatchClause:exit": popScope
+		},
+		isLogtapeCallee,
+		isAsyncFunctionName,
+		lazyNames,
+		effectiveLazyNames
+	};
+}
+/**
+* Deno Lint plugin providing LogTape lint rules.
+*
+* > [!WARNING]
+* > The Deno Lint plugin API is experimental.  This plugin may break between
+* > Deno releases while the API is stabilised.
+*/
+const logtapePlugin = {
+	name: "logtape",
+	rules: {
+		"no-message-interpolation": { create(ctx) {
+			const scope = makeLoggerScope();
+			return {
+				...scope.visitors,
+				CallExpression(node) {
+					if (!scope.isLogtapeCallee(node.callee)) return;
+					const methodName = logMethodName(node.callee);
+					if (!methodName || !LOG_METHODS.has(methodName)) return;
+					const firstArg = unwrapTypeAssertion(node.arguments?.[0]);
+					if (!firstArg || firstArg.type !== "TemplateLiteral") return;
+					if (!firstArg.expressions?.length) return;
+					ctx.report({
+						node: firstArg,
+						message: "Avoid using template literal interpolation in log messages. Use a message template string with structured properties instead: logger.info(\"User {userId} logged in.\", { userId })."
+					});
+				}
+			};
+		} },
+		"prefer-lazy-evaluation": { create(ctx) {
+			const scope = makeLoggerScope();
+			return {
+				...scope.visitors,
+				CallExpression(node) {
+					if (!scope.isLogtapeCallee(node.callee)) return;
+					const methodName = logMethodName(node.callee);
+					if (!methodName || !LOG_METHODS.has(methodName)) return;
+					const selected = selectLazyPropsObject(node.arguments);
+					if (!selected) return;
+					const { propsObject, fixTarget, propertiesOnly } = selected;
+					if (!propsHaveEagerCall(propsObject, scope.effectiveLazyNames())) return;
+					const hasAsyncSyntax = containsAwaitOrYield(propsObject);
+					ctx.report({
+						node: propsObject,
+						message: "Wrap the properties object in a lazy callback to avoid unnecessary computation: logger.debug(\"msg\", () => ({ ... })).",
+						fix: hasAsyncSyntax ? void 0 : (fixer) => {
+							const sourceCode = ctx.sourceCode ?? ctx.getSourceCode?.();
+							const text = typeof sourceCode === "string" && fixTarget.range ? sourceCode.slice(fixTarget.range[0], fixTarget.range[1]) : sourceCode?.getText?.(fixTarget);
+							if (!text) return null;
+							return fixer.replaceText(fixTarget, propertiesOnly ? `"{*}", () => (${text})` : `() => (${text})`);
+						}
+					});
+				}
+			};
+		} },
+		"no-unawaited-log": { create(ctx) {
+			const scope = makeLoggerScope();
+			return {
+				...scope.visitors,
+				CallExpression(node) {
+					if (!scope.isLogtapeCallee(node.callee)) return;
+					const methodName = logMethodName(node.callee);
+					if (!methodName || !LOG_METHODS.has(methodName)) return;
+					const secondArg = unwrapTypeAssertion(node.arguments?.[1]);
+					if (!secondArg) return;
+					const isAsyncCallback = isAsyncFunctionExpr(secondArg) || isPromiseReturningCallback(secondArg) || secondArg.type === "Identifier" && scope.isAsyncFunctionName(secondArg.name);
+					if (!isAsyncCallback) return;
+					if (isLogPromiseHandled(node)) return;
+					ctx.report({
+						node,
+						message: "Async lazy callbacks must be awaited to ensure the log is flushed: await logger.debug(\"msg\", async () => ({ ... })).",
+						fix: canInsertAwait(node) ? (fixer) => fixer.insertTextBefore(node, "await ") : void 0
+					});
+				}
+			};
+		} },
+		"require-meta-sink": { create(ctx) {
+			const configFns = /* @__PURE__ */ new Set();
+			const shadowedConfigScopes = [/* @__PURE__ */ new Set()];
+			function pushConfigScope() {
+				shadowedConfigScopes.push(/* @__PURE__ */ new Set());
+			}
+			function popConfigScope() {
+				if (shadowedConfigScopes.length > 1) shadowedConfigScopes.pop();
+			}
+			function isConfigShadowed(name) {
+				for (let i = shadowedConfigScopes.length - 1; i >= 0; i--) if (shadowedConfigScopes[i].has(name)) return true;
+				return false;
+			}
+			function handleFnEnter(node) {
+				if (node.type === "FunctionDeclaration" && node.id?.type === "Identifier" && configFns.has(node.id.name)) shadowedConfigScopes[shadowedConfigScopes.length - 1].add(node.id.name);
+				pushConfigScope();
+				const names = /* @__PURE__ */ new Set();
+				if (node.type === "FunctionExpression" && node.id?.type === "Identifier") names.add(node.id.name);
+				for (const param of node.params ?? []) extractIdentifiers(param, names);
+				for (const name of names) if (configFns.has(name)) shadowedConfigScopes[shadowedConfigScopes.length - 1].add(name);
+			}
+			function handleBlockEnter(node) {
+				pushConfigScope();
+				for (const stmt of node.body ?? []) if (stmt?.type === "FunctionDeclaration" && stmt.id?.type === "Identifier") shadowedConfigScopes[shadowedConfigScopes.length - 1].add(stmt.id.name);
+			}
+			function handleCatchEnter(node) {
+				pushConfigScope();
+				if (!node.param) return;
+				const names = /* @__PURE__ */ new Set();
+				extractIdentifiers(node.param, names);
+				for (const name of names) if (configFns.has(name)) shadowedConfigScopes[shadowedConfigScopes.length - 1].add(name);
+			}
+			return {
+				ImportDeclaration(node) {
+					if (!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);
+					}
+				},
+				FunctionDeclaration: handleFnEnter,
+				"FunctionDeclaration:exit": popConfigScope,
+				FunctionExpression: handleFnEnter,
+				"FunctionExpression:exit": popConfigScope,
+				ArrowFunctionExpression: handleFnEnter,
+				"ArrowFunctionExpression:exit": popConfigScope,
+				Program: handleBlockEnter,
+				"Program:exit": popConfigScope,
+				BlockStatement: handleBlockEnter,
+				"BlockStatement:exit": popConfigScope,
+				TSModuleBlock: handleBlockEnter,
+				"TSModuleBlock:exit": popConfigScope,
+				SwitchStatement: pushConfigScope,
+				"SwitchStatement:exit": popConfigScope,
+				CatchClause: handleCatchEnter,
+				"CatchClause:exit": popConfigScope,
+				VariableDeclarator(node) {
+					const names = /* @__PURE__ */ new Set();
+					extractIdentifiers(node.id, names);
+					for (const name of names) if (configFns.has(name)) shadowedConfigScopes[shadowedConfigScopes.length - 1].add(name);
+				},
+				CallExpression(node) {
+					if (configFns.size === 0) return;
+					const { callee } = node;
+					const calleeName = callee.type === "Identifier" ? callee.name : null;
+					if (!calleeName || !configFns.has(calleeName)) return;
+					if (isConfigShadowed(calleeName)) return;
+					const configArg = unwrapTypeAssertion(node.arguments?.[0]);
+					if (configNeedsMetaSink(configArg)) ctx.report({
+						node,
+						message: "Add a dedicated sink for the meta logger (category: [\"logtape\"] or [\"logtape\", \"meta\"]) to handle LogTape's own diagnostic messages."
+					});
+				}
+			};
+		} }
+	}
+};
+var plugin_default = logtapePlugin;
+
+//#endregion
+export { plugin_default as default };
+//# sourceMappingURL=plugin.js.map

package/dist/deno/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.js","names":["node: any","names: Set<string>","scopeStack: Array<Map<string, boolean>>","shadowedGetterStack: Array<Set<string>>","shadowedLazyStack: Array<Set<string>>","asyncFnStack: Array<Map<string, boolean>>","name: string","callee: any","logtapePlugin: { name: string; rules: Record<string, unknown> }","ctx: any","fixer: any","shadowedConfigScopes: Array<Set<string>>"],"sources":["../../src/deno/plugin.ts"],"sourcesContent":["/**\n * Deno Lint plugin for LogTape lint rules.\n *\n * > [!NOTE]\n * > The Deno Lint plugin API is currently experimental (unstable).\n * > This plugin requires Deno 2.2.0 or later with the `--unstable-lint` flag\n * > or the `\"unstable\": [\"lint\"]` option in your `deno.json`.\n *\n * Add this plugin to your `deno.json`:\n * ```json\n * {\n *   \"lint\": {\n *     \"plugins\": [\"jsr:@logtape/lint/deno\"],\n *     \"rules\": {\n *       \"include\": [\n *         \"logtape/no-message-interpolation\",\n *         \"logtape/prefer-lazy-evaluation\",\n *         \"logtape/no-unawaited-log\",\n *         \"logtape/require-meta-sink\"\n *       ]\n *     }\n *   }\n * }\n * ```\n *\n * The rule detection logic is shared with the ESLint rules via `../core/ast.ts`;\n * only the scope tracking (which the Deno Lint API does not provide a manager\n * for) and the report/fix wiring are implemented here.\n *\n * @module\n */\n\n// deno-lint-ignore-file no-explicit-any\n\nimport {\n  canInsertAwait,\n  configNeedsMetaSink,\n  containsAwaitOrYield,\n  isAsyncFunctionExpr,\n  isLogPromiseHandled,\n  isLogtapeImportSource,\n  isPromiseReturningCallback,\n  LOG_METHODS,\n  logMethodName,\n  propsHaveEagerCall,\n  selectLazyPropsObject,\n  unwrapTypeAssertion,\n} from \"../core/ast.ts\";\n\n// Collect every identifier name bound by a (possibly destructured) binding\n// target: a plain parameter, an object/array pattern, a default, or a rest.\nfunction extractIdentifiers(node: any, names: Set<string>): void {\n  if (!node) return;\n  if (node.type === \"Identifier\") {\n    names.add(node.name);\n  } else if (node.type === \"ObjectPattern\") {\n    for (const prop of node.properties ?? []) {\n      if (prop.type === \"Property\") {\n        extractIdentifiers(prop.value, names);\n      } else if (prop.type === \"RestElement\") {\n        extractIdentifiers(prop.argument, names);\n      }\n    }\n  } else if (node.type === \"ArrayPattern\") {\n    for (const elem of node.elements ?? []) {\n      extractIdentifiers(elem, names);\n    }\n  } else if (node.type === \"AssignmentPattern\") {\n    extractIdentifiers(node.left, names);\n  } else if (node.type === \"RestElement\") {\n    extractIdentifiers(node.argument, names);\n  } else if (node.type === \"TSParameterProperty\") {\n    // A constructor parameter property (`constructor(private logger: Logger)`)\n    // wraps the actual binding under `.parameter`.\n    extractIdentifiers(node.parameter, names);\n  }\n}\n\n/**\n * Creates a scope tracker for LogTape logger variable bindings.\n *\n * The Deno Lint plugin API does not expose a scope manager, so this hand-rolls\n * one with a scope stack (Map<name, isLogger>) to correctly handle:\n * - Function parameters that shadow logger names (tracked as false)\n * - Local variables that re-declare logger names with non-logger values\n * - Block scoping via BlockStatement enter/exit\n *\n * Returns a `visitors` object to spread into a rule's visitor map, plus the\n * scope-aware predicates the rule's `CallExpression` handler needs.\n */\nfunction makeLoggerScope(): {\n  visitors: Record<string, (node: any) => void>;\n  isLogtapeCallee: (callee: any) => boolean;\n  isAsyncFunctionName: (name: string) => boolean;\n  lazyNames: Set<string>;\n  effectiveLazyNames: () => Set<string>;\n} {\n  const getterNames = new Set<string>();\n  // Local names of `lazy` imported from @logtape/logtape; a lazy() value is\n  // already deferred and must not be treated as an eager call.\n  const lazyNames = new Set<string>();\n  // Each Map entry: true = logger binding, false = shadowing non-logger\n  const scopeStack: Array<Map<string, boolean>> = [new Map()];\n  // Tracks scopes where a getter name is shadowed by a parameter or local\n  const shadowedGetterStack: Array<Set<string>> = [new Set()];\n  // Tracks scopes where an imported `lazy` name is shadowed by a local binding\n  const shadowedLazyStack: Array<Set<string>> = [new Set()];\n  // Per-scope promise-callback bindings: true = bound to a function that yields\n  // a promise (async, or non-async but syntactically promise-returning), false\n  // = bound to something else (a parameter, plain sync local, etc.) that\n  // shadows an outer binding.  Lookups stop at the nearest binding, so an outer\n  // name does not leak into an inner scope that rebinds it.\n  const asyncFnStack: Array<Map<string, boolean>> = [new Map()];\n\n  function pushScope() {\n    scopeStack.push(new Map());\n    shadowedGetterStack.push(new Set());\n    shadowedLazyStack.push(new Set());\n    asyncFnStack.push(new Map());\n  }\n\n  function popScope() {\n    if (scopeStack.length > 1) scopeStack.pop();\n    if (shadowedGetterStack.length > 1) shadowedGetterStack.pop();\n    if (shadowedLazyStack.length > 1) shadowedLazyStack.pop();\n    if (asyncFnStack.length > 1) asyncFnStack.pop();\n  }\n\n  function isLoggerName(name: string): boolean {\n    for (let i = scopeStack.length - 1; i >= 0; i--) {\n      if (scopeStack[i].has(name)) return scopeStack[i].get(name)!;\n    }\n    return false;\n  }\n\n  // Whether `name` resolves to a binding that yields a promise (an async\n  // function or a non-async promise-returning one) in the current scope chain.\n  function isAsyncFunctionName(name: string): boolean {\n    for (let i = asyncFnStack.length - 1; i >= 0; i--) {\n      if (asyncFnStack[i].has(name)) return asyncFnStack[i].get(name)!;\n    }\n    return false;\n  }\n\n  function isGetterShadowed(name: string): boolean {\n    for (let i = shadowedGetterStack.length - 1; i >= 0; i--) {\n      if (shadowedGetterStack[i].has(name)) return true;\n    }\n    return false;\n  }\n\n  function isLazyShadowed(name: string): boolean {\n    for (let i = shadowedLazyStack.length - 1; i >= 0; i--) {\n      if (shadowedLazyStack[i].has(name)) return true;\n    }\n    return false;\n  }\n\n  // Record that `name`, a local binding in the current scope, shadows the\n  // imported getLogger and/or lazy.  Names are recorded unconditionally rather\n  // than gated on getterNames/lazyNames: this also runs during the Program\n  // pre-scan, before the ImportDeclaration visitor has populated those sets, so\n  // gating would miss a top-level shadow.  Recording extra names is harmless,\n  // since the stacks are only ever queried for the imported getLogger/lazy\n  // names.\n  function recordImportShadow(name: string) {\n    shadowedGetterStack[shadowedGetterStack.length - 1].add(name);\n    shadowedLazyStack[shadowedLazyStack.length - 1].add(name);\n  }\n\n  // The subset of lazyNames not shadowed by a local binding in the current\n  // scope chain, so a shadowed `lazy(...)` is treated as an ordinary eager\n  // call rather than LogTape's deferred wrapper.\n  function effectiveLazyNames(): Set<string> {\n    if (lazyNames.size === 0) return lazyNames;\n    const result = new Set<string>();\n    for (const name of lazyNames) {\n      if (!isLazyShadowed(name)) result.add(name);\n    }\n    return result;\n  }\n\n  function handleFunctionEnter(node: any) {\n    // A named function declaration binds its name in the ENCLOSING scope, so\n    // record getter shadowing and promise-returning-ness there before pushing\n    // the new scope: `async function props() {}`, or a non-async\n    // `function props() { return p.then(...) }`, makes `props` a promise\n    // callback.\n    if (\n      node.type === \"FunctionDeclaration\" &&\n      node.id?.type === \"Identifier\"\n    ) {\n      recordImportShadow(node.id.name);\n      // A function declaration named like a logger shadows it: it is a\n      // function, never a LogTape logger.\n      scopeStack[scopeStack.length - 1].set(node.id.name, false);\n      asyncFnStack[asyncFnStack.length - 1].set(\n        node.id.name,\n        node.async === true || isPromiseReturningCallback(node),\n      );\n    }\n    pushScope();\n    const names = new Set<string>();\n    // A named function expression binds its own name inside its body, shadowing\n    // any outer binding of that name (a logger, getLogger, etc.).\n    if (node.type === \"FunctionExpression\" && node.id?.type === \"Identifier\") {\n      names.add(node.id.name);\n    }\n    for (const param of node.params ?? []) {\n      extractIdentifiers(param, names);\n    }\n    for (const name of names) {\n      scopeStack[scopeStack.length - 1].set(name, false);\n      recordImportShadow(name);\n      // A parameter rebinds the name, shadowing any outer async-callback\n      // binding so it does not leak into the function body.\n      asyncFnStack[asyncFnStack.length - 1].set(name, false);\n    }\n  }\n\n  // Function declarations are hoisted to the top of their block, so a local\n  // `function getLogger() {}` shadows the import for the whole block, including\n  // statements that appear before it.  Pre-scan the block's direct statements\n  // on entry and record those shadows before any statement is visited.\n  function handleBlockEnter(node: any) {\n    pushScope();\n    for (const stmt of node.body ?? []) {\n      if (\n        stmt?.type === \"FunctionDeclaration\" && stmt.id?.type === \"Identifier\"\n      ) {\n        recordImportShadow(stmt.id.name);\n        // A hoisted function declaration named like a logger shadows it for the\n        // whole block, including earlier statements; it is never a logger.\n        scopeStack[scopeStack.length - 1].set(stmt.id.name, false);\n        // Hoist promise-returning-ness too, so a callback referencing a\n        // function declared later in the block is still recognized.\n        asyncFnStack[asyncFnStack.length - 1].set(\n          stmt.id.name,\n          stmt.async === true || isPromiseReturningCallback(stmt),\n        );\n      }\n    }\n  }\n\n  // A catch parameter binds names in the catch scope, the same as function\n  // parameters; record them as non-logger bindings so a `catch (logger) {}`\n  // does not resolve to an outer LogTape logger.\n  function handleCatchEnter(node: any) {\n    pushScope();\n    if (!node.param) return;\n    const names = new Set<string>();\n    extractIdentifiers(node.param, names);\n    for (const name of names) {\n      scopeStack[scopeStack.length - 1].set(name, false);\n      recordImportShadow(name);\n      // A catch parameter rebinds the name, shadowing any outer async binding.\n      asyncFnStack[asyncFnStack.length - 1].set(name, false);\n    }\n  }\n\n  // Is `node` an expression that evaluates to a LogTape logger?  Handles\n  // direct getLogger(...) calls (unless the getter name is shadowed),\n  // identifiers already bound to a logger in scope, and contextual or child\n  // loggers produced by chaining Logger.with(...) or Logger.getChild(...).\n  function isLoggerExpr(node: any, depth = 0): boolean {\n    if (depth > 16 || !node) return false;\n    // getLogger(...) — direct call to the (unshadowed) imported getter.\n    if (\n      node.type === \"CallExpression\" &&\n      node.callee?.type === \"Identifier\" &&\n      getterNames.has(node.callee.name) &&\n      !isGetterShadowed(node.callee.name)\n    ) return true;\n    // logger.with(...) / logger.getChild(...) — these return a Logger, so the\n    // whole call expression is itself a logger expression.\n    if (\n      node.type === \"CallExpression\" &&\n      node.callee?.type === \"MemberExpression\" &&\n      !node.callee.computed &&\n      node.callee.property?.type === \"Identifier\" &&\n      (node.callee.property.name === \"with\" ||\n        node.callee.property.name === \"getChild\")\n    ) {\n      return isLoggerExpr(node.callee.object, depth + 1);\n    }\n    // An identifier already bound to a logger in the current scope chain.\n    if (node.type === \"Identifier\") return isLoggerName(node.name);\n    return false;\n  }\n\n  function isLogtapeCallee(callee: any): boolean {\n    if (!callee || callee.type !== \"MemberExpression\") return false;\n    // The object may be a logger identifier, an inline getLogger(...) call, or\n    // a contextual/child logger chain such as getLogger(\"app\").with({ ... }).\n    return isLoggerExpr(callee.object);\n  }\n\n  return {\n    visitors: {\n      ImportDeclaration(node: any) {\n        if (!isLogtapeImportSource(node.source?.value)) return;\n        for (const spec of node.specifiers ?? []) {\n          if (spec.type !== \"ImportSpecifier\") continue;\n          if (spec.imported?.name === \"getLogger\") {\n            getterNames.add(spec.local?.name);\n          } else if (spec.imported?.name === \"lazy\") {\n            lazyNames.add(spec.local?.name);\n          }\n        }\n      },\n      VariableDeclarator(node: any) {\n        if (node.id?.type === \"Identifier\") {\n          const name = node.id.name;\n          const init = node.init;\n          const isLogger = isLoggerExpr(init);\n          if (isLogger) {\n            scopeStack[scopeStack.length - 1].set(name, true);\n          } else if (isLoggerName(name)) {\n            // Explicit non-logger assignment shadows the outer logger binding\n            scopeStack[scopeStack.length - 1].set(name, false);\n          }\n          // A local declaration shadows an imported getLogger or lazy, so a\n          // later inline getLogger()/lazy() in this scope is the local binding,\n          // not the import.\n          recordImportShadow(name);\n          // Record whether this local is bound to a function literal that\n          // yields a promise (async, or non-async but promise-returning) so a\n          // lazy callback passed by reference is detected; any other binding\n          // shadows an outer promise-callback binding of the same name.\n          asyncFnStack[asyncFnStack.length - 1].set(\n            name,\n            isAsyncFunctionExpr(init) || isPromiseReturningCallback(init),\n          );\n        } else {\n          // Destructured declaration (e.g. const { logger } = obj): shadow any\n          // matching names to avoid false positives.\n          const names = new Set<string>();\n          extractIdentifiers(node.id, names);\n          for (const name of names) {\n            if (isLoggerName(name)) {\n              scopeStack[scopeStack.length - 1].set(name, false);\n            }\n            // A destructured getLogger/lazy name is likewise a local,\n            // non-import binding.\n            recordImportShadow(name);\n            // A destructured binding is not a known async function and shadows\n            // any outer async binding of the same name.\n            asyncFnStack[asyncFnStack.length - 1].set(name, false);\n          }\n        }\n      },\n      FunctionDeclaration: handleFunctionEnter,\n      \"FunctionDeclaration:exit\": popScope,\n      FunctionExpression: handleFunctionEnter,\n      \"FunctionExpression:exit\": popScope,\n      ArrowFunctionExpression: handleFunctionEnter,\n      \"ArrowFunctionExpression:exit\": popScope,\n      // Program is a block-like scope: pre-scan it too so a top-level function\n      // declared below a callback that references it is still hoisted.\n      Program: handleBlockEnter,\n      \"Program:exit\": popScope,\n      BlockStatement: handleBlockEnter,\n      \"BlockStatement:exit\": popScope,\n      // A TypeScript namespace body (TSModuleBlock) is a lexical scope whose\n      // statements are not wrapped in a block statement, so track it like a\n      // block.  A class static block needs no separate handling: its body is\n      // itself a BlockStatement, already covered above.\n      TSModuleBlock: handleBlockEnter,\n      \"TSModuleBlock:exit\": popScope,\n      ForStatement: pushScope,\n      \"ForStatement:exit\": popScope,\n      ForInStatement: pushScope,\n      \"ForInStatement:exit\": popScope,\n      ForOfStatement: pushScope,\n      \"ForOfStatement:exit\": popScope,\n      // A switch block is a single lexical scope for its let/const\n      // declarations, so push/pop one for it like a block.\n      SwitchStatement: pushScope,\n      \"SwitchStatement:exit\": popScope,\n      CatchClause: handleCatchEnter,\n      \"CatchClause:exit\": popScope,\n    },\n    isLogtapeCallee,\n    isAsyncFunctionName,\n    lazyNames,\n    effectiveLazyNames,\n  };\n}\n\n/**\n * Deno Lint plugin providing LogTape lint rules.\n *\n * > [!WARNING]\n * > The Deno Lint plugin API is experimental.  This plugin may break between\n * > Deno releases while the API is stabilised.\n */\nconst logtapePlugin: { name: string; rules: Record<string, unknown> } = {\n  name: \"logtape\",\n\n  rules: {\n    /** Disallow template literal interpolation in log message arguments. */\n    \"no-message-interpolation\": {\n      create(ctx: any) {\n        const scope = makeLoggerScope();\n        return {\n          ...scope.visitors,\n          CallExpression(node: any) {\n            if (!scope.isLogtapeCallee(node.callee)) return;\n            const methodName = logMethodName(node.callee);\n            if (!methodName || !LOG_METHODS.has(methodName)) return;\n            const firstArg = unwrapTypeAssertion(node.arguments?.[0]);\n            if (!firstArg || firstArg.type !== \"TemplateLiteral\") return;\n            if (!firstArg.expressions?.length) return;\n            ctx.report({\n              node: firstArg,\n              message:\n                \"Avoid using template literal interpolation in log messages. \" +\n                'Use a message template string with structured properties instead: logger.info(\"User {userId} logged in.\", { userId }).',\n            });\n          },\n        };\n      },\n    },\n\n    /** Prefer lazy evaluation callbacks over eager property objects. */\n    \"prefer-lazy-evaluation\": {\n      create(ctx: any) {\n        const scope = makeLoggerScope();\n        return {\n          ...scope.visitors,\n          CallExpression(node: any) {\n            if (!scope.isLogtapeCallee(node.callee)) return;\n            const methodName = logMethodName(node.callee);\n            if (!methodName || !LOG_METHODS.has(methodName)) return;\n            // The eager properties object is the second argument in the\n            // message+properties form, logger.debug(\"msg\", { ... }), or the\n            // first 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            // Use the lazy names that still resolve to the import in this\n            // scope, so a shadowed local `lazy(...)` is treated as eager.\n            if (!propsHaveEagerCall(propsObject, scope.effectiveLazyNames())) {\n              return;\n            }\n            const hasAsyncSyntax = containsAwaitOrYield(propsObject);\n            ctx.report({\n              node: propsObject,\n              message:\n                \"Wrap the properties object in a lazy callback to avoid unnecessary computation: \" +\n                'logger.debug(\"msg\", () => ({ ... })).',\n              // Wrap the whole argument (fixTarget), including any `as const` /\n              // `satisfies` wrapper, so the assertion ends up inside the\n              // callback instead of dangling on it.\n              fix: hasAsyncSyntax ? undefined : (fixer: any) => {\n                const sourceCode = ctx.sourceCode ?? ctx.getSourceCode?.();\n                // Only slice by range when the source is a raw string and the\n                // node actually carries a range; otherwise fall back to\n                // getText so a missing range cannot throw.\n                const text = typeof sourceCode === \"string\" && fixTarget.range\n                  ? sourceCode.slice(fixTarget.range[0], fixTarget.range[1])\n                  : sourceCode?.getText?.(fixTarget);\n                if (!text) return null;\n                // The properties-only overload needs the \"{*}\" message inserted\n                // so the lazy callback is still read as properties.\n                return fixer.replaceText(\n                  fixTarget,\n                  propertiesOnly ? `\"{*}\", () => (${text})` : `() => (${text})`,\n                );\n              },\n            });\n          },\n        };\n      },\n    },\n\n    /** Require await on log calls that use async lazy callbacks. */\n    \"no-unawaited-log\": {\n      create(ctx: any) {\n        const scope = makeLoggerScope();\n        return {\n          ...scope.visitors,\n          CallExpression(node: any) {\n            if (!scope.isLogtapeCallee(node.callee)) return;\n            const methodName = logMethodName(node.callee);\n            if (!methodName || !LOG_METHODS.has(methodName)) return;\n            const secondArg = unwrapTypeAssertion(node.arguments?.[1]);\n            if (!secondArg) return;\n            const isAsyncCallback = isAsyncFunctionExpr(secondArg) ||\n              isPromiseReturningCallback(secondArg) ||\n              (secondArg.type === \"Identifier\" &&\n                scope.isAsyncFunctionName(secondArg.name));\n            if (!isAsyncCallback) return;\n            // Walk the ancestor chain to check if the promise is handled\n            // (awaited, returned, chained with .then(), or in Promise.all()).\n            if (isLogPromiseHandled(node)) return;\n            ctx.report({\n              node,\n              message:\n                \"Async lazy callbacks must be awaited to ensure the log is flushed: \" +\n                'await logger.debug(\"msg\", async () => ({ ... })).',\n              // Only autofix a standalone statement.  Inserting `await` where\n              // the call's value is used would change a Promise<void> into void\n              // and can break code that uses that promise.\n              fix: canInsertAwait(node)\n                ? (fixer: any) => fixer.insertTextBefore(node, \"await \")\n                : undefined,\n            });\n          },\n        };\n      },\n    },\n\n    /** Require a meta sink in configure() / configureSync() calls. */\n    \"require-meta-sink\": {\n      create(ctx: any) {\n        const configFns = new Set<string>();\n        // Tracks scopes where a configure/configureSync name is shadowed\n        const shadowedConfigScopes: Array<Set<string>> = [new Set()];\n\n        function pushConfigScope() {\n          shadowedConfigScopes.push(new Set());\n        }\n\n        function popConfigScope() {\n          if (shadowedConfigScopes.length > 1) shadowedConfigScopes.pop();\n        }\n\n        function isConfigShadowed(name: string): boolean {\n          for (let i = shadowedConfigScopes.length - 1; i >= 0; i--) {\n            if (shadowedConfigScopes[i].has(name)) return true;\n          }\n          return false;\n        }\n\n        function handleFnEnter(node: any) {\n          // A named function declaration binds its name in the ENCLOSING scope,\n          // so a local `function configure()` shadows the import; record that\n          // before pushing the new scope.\n          if (\n            node.type === \"FunctionDeclaration\" &&\n            node.id?.type === \"Identifier\" &&\n            configFns.has(node.id.name)\n          ) {\n            shadowedConfigScopes[shadowedConfigScopes.length - 1].add(\n              node.id.name,\n            );\n          }\n          pushConfigScope();\n          const names = new Set<string>();\n          // A named function expression binds its own name inside its body,\n          // shadowing an imported configure/configureSync of the same name.\n          if (\n            node.type === \"FunctionExpression\" && node.id?.type === \"Identifier\"\n          ) {\n            names.add(node.id.name);\n          }\n          for (const param of node.params ?? []) {\n            extractIdentifiers(param, names);\n          }\n          for (const name of names) {\n            if (configFns.has(name)) {\n              shadowedConfigScopes[shadowedConfigScopes.length - 1].add(name);\n            }\n          }\n        }\n\n        // Function declarations are hoisted to the top of their block, so a\n        // local `function configure() {}` shadows the import for the whole\n        // block, including earlier statements.  Pre-scan the block's direct\n        // statements on entry and record those shadows first.\n        //\n        // The name is recorded unconditionally rather than gated on configFns:\n        // this handler also runs for the Program node, which is entered before\n        // the top-level ImportDeclaration populates configFns, so gating would\n        // miss a top-level shadow.  Recording extra names is harmless because\n        // isConfigShadowed is only consulted for names already known to be\n        // imported configure/configureSync, and each name is scoped to its\n        // block via push/popConfigScope.\n        function handleBlockEnter(node: any) {\n          pushConfigScope();\n          for (const stmt of node.body ?? []) {\n            if (\n              stmt?.type === \"FunctionDeclaration\" &&\n              stmt.id?.type === \"Identifier\"\n            ) {\n              shadowedConfigScopes[shadowedConfigScopes.length - 1].add(\n                stmt.id.name,\n              );\n            }\n          }\n        }\n\n        // A catch parameter named like an imported configure function shadows\n        // it within the catch scope, so record it before visiting the body.\n        function handleCatchEnter(node: any) {\n          pushConfigScope();\n          if (!node.param) return;\n          const names = new Set<string>();\n          extractIdentifiers(node.param, names);\n          for (const name of names) {\n            if (configFns.has(name)) {\n              shadowedConfigScopes[shadowedConfigScopes.length - 1].add(name);\n            }\n          }\n        }\n\n        return {\n          ImportDeclaration(node: any) {\n            if (!isLogtapeImportSource(node.source?.value)) return;\n            for (const specifier of node.specifiers ?? []) {\n              if (specifier.type !== \"ImportSpecifier\") continue;\n              const imported = specifier.imported?.name;\n              if (\n                imported === \"configure\" || imported === \"configureSync\"\n              ) {\n                configFns.add(specifier.local?.name);\n              }\n            }\n          },\n          FunctionDeclaration: handleFnEnter,\n          \"FunctionDeclaration:exit\": popConfigScope,\n          FunctionExpression: handleFnEnter,\n          \"FunctionExpression:exit\": popConfigScope,\n          ArrowFunctionExpression: handleFnEnter,\n          \"ArrowFunctionExpression:exit\": popConfigScope,\n          // Program is pre-scanned too so a top-level `function configure()`\n          // declared below its call still shadows the import.\n          Program: handleBlockEnter,\n          \"Program:exit\": popConfigScope,\n          BlockStatement: handleBlockEnter,\n          \"BlockStatement:exit\": popConfigScope,\n          // A TypeScript namespace body (TSModuleBlock) is a lexical scope\n          // whose statements are not wrapped in a block statement.  A class\n          // static block needs no separate handling: its body is itself a\n          // BlockStatement, already covered above.\n          TSModuleBlock: handleBlockEnter,\n          \"TSModuleBlock:exit\": popConfigScope,\n          // A switch block is a single lexical scope for its let/const\n          // declarations, so push/pop one for it like a block.\n          SwitchStatement: pushConfigScope,\n          \"SwitchStatement:exit\": popConfigScope,\n          CatchClause: handleCatchEnter,\n          \"CatchClause:exit\": popConfigScope,\n          VariableDeclarator(node: any) {\n            // A local declaration shadows any imported configure/configureSync\n            // with the same name, so we must not flag it as a LogTape call.\n            const names = new Set<string>();\n            extractIdentifiers(node.id, names);\n            for (const name of names) {\n              if (configFns.has(name)) {\n                shadowedConfigScopes[shadowedConfigScopes.length - 1].add(name);\n              }\n            }\n          },\n          CallExpression(node: any) {\n            if (configFns.size === 0) return;\n            const { callee } = node;\n            const calleeName = callee.type === \"Identifier\"\n              ? callee.name\n              : null;\n            if (!calleeName || !configFns.has(calleeName)) return;\n            if (isConfigShadowed(calleeName)) return;\n            // Unwrap a TypeScript type assertion (e.g. configure({ ... } as T)).\n            const configArg = unwrapTypeAssertion(node.arguments?.[0]);\n            if (configNeedsMetaSink(configArg)) {\n              ctx.report({\n                node,\n                message:\n                  'Add a dedicated sink for the meta logger (category: [\"logtape\"] or [\"logtape\", \"meta\"]) ' +\n                  \"to handle LogTape's own diagnostic messages.\",\n              });\n            }\n          },\n        };\n      },\n    },\n  },\n};\n\nexport default logtapePlugin;\n"],"mappings":"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"}

package/dist/eslint/plugin.cjs

@@ -0,0 +1,51 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_no_message_interpolation = require('../rules/no-message-interpolation.cjs');
+const require_no_unawaited_log = require('../rules/no-unawaited-log.cjs');
+const require_prefer_lazy_evaluation = require('../rules/prefer-lazy-evaluation.cjs');
+const require_require_meta_sink = require('../rules/require-meta-sink.cjs');
+
+//#region src/eslint/plugin.ts
+/**
+* All LogTape lint rules.
+*/
+const rules = {
+	"no-message-interpolation": require_no_message_interpolation.noMessageInterpolation,
+	"prefer-lazy-evaluation": require_prefer_lazy_evaluation.preferLazyEvaluation,
+	"no-unawaited-log": require_no_unawaited_log.noUnawaitedLog,
+	"require-meta-sink": require_require_meta_sink.requireMetaSink
+};
+const plugin = {
+	meta: { name: "@logtape/lint" },
+	rules,
+	configs: {}
+};
+/**
+* Recommended ESLint v9 flat config preset.
+*
+* Enables all LogTape rules with their recommended severity levels:
+* - `no-message-interpolation`: error
+* - `prefer-lazy-evaluation`: warn
+* - `no-unawaited-log`: error
+* - `require-meta-sink`: warn
+*/
+const recommended = {
+	plugins: { logtape: plugin },
+	rules: {
+		"logtape/no-message-interpolation": "error",
+		"logtape/prefer-lazy-evaluation": "warn",
+		"logtape/no-unawaited-log": "error",
+		"logtape/require-meta-sink": "warn"
+	}
+};
+plugin.configs.recommended = recommended;
+var plugin_default = plugin;
+
+//#endregion
+exports.default = plugin_default;
+exports.noMessageInterpolation = require_no_message_interpolation.noMessageInterpolation;
+exports.noUnawaitedLog = require_no_unawaited_log.noUnawaitedLog;
+exports.plugin = plugin;
+exports.preferLazyEvaluation = require_prefer_lazy_evaluation.preferLazyEvaluation;
+exports.recommended = recommended;
+exports.requireMetaSink = require_require_meta_sink.requireMetaSink;
+exports.rules = rules;

package/dist/eslint/plugin.d.cts

@@ -0,0 +1,26 @@
+import { noMessageInterpolation } from "../rules/no-message-interpolation.cjs";
+import { noUnawaitedLog } from "../rules/no-unawaited-log.cjs";
+import { preferLazyEvaluation } from "../rules/prefer-lazy-evaluation.cjs";
+import { requireMetaSink } from "../rules/require-meta-sink.cjs";
+import { Linter, Rule } from "eslint";
+
+//#region src/eslint/plugin.d.ts
+
+/**
+ * All LogTape lint rules.
+ */
+declare const rules: Record<string, Rule.RuleModule>;
+declare const plugin: any;
+/**
+ * Recommended ESLint v9 flat config preset.
+ *
+ * Enables all LogTape rules with their recommended severity levels:
+ * - `no-message-interpolation`: error
+ * - `prefer-lazy-evaluation`: warn
+ * - `no-unawaited-log`: error
+ * - `require-meta-sink`: warn
+ */
+declare const recommended: Linter.Config;
+//#endregion
+export { plugin as default, plugin, noMessageInterpolation, noUnawaitedLog, preferLazyEvaluation, recommended, requireMetaSink, rules };
+//# sourceMappingURL=plugin.d.cts.map

package/dist/eslint/plugin.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.cts","names":[],"sources":["../../src/eslint/plugin.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;cA6Ca,OAAO,eAAe,IAAA,CAAK;cAS3B;;;;;;;;;;cAeA,aAAa,MAAA,CAAO"}

package/dist/eslint/plugin.d.ts

@@ -0,0 +1,26 @@
+import { noMessageInterpolation } from "../rules/no-message-interpolation.js";
+import { noUnawaitedLog } from "../rules/no-unawaited-log.js";
+import { preferLazyEvaluation } from "../rules/prefer-lazy-evaluation.js";
+import { requireMetaSink } from "../rules/require-meta-sink.js";
+import { Linter, Rule } from "eslint";
+
+//#region src/eslint/plugin.d.ts
+
+/**
+ * All LogTape lint rules.
+ */
+declare const rules: Record<string, Rule.RuleModule>;
+declare const plugin: any;
+/**
+ * Recommended ESLint v9 flat config preset.
+ *
+ * Enables all LogTape rules with their recommended severity levels:
+ * - `no-message-interpolation`: error
+ * - `prefer-lazy-evaluation`: warn
+ * - `no-unawaited-log`: error
+ * - `require-meta-sink`: warn
+ */
+declare const recommended: Linter.Config;
+//#endregion
+export { plugin as default, plugin, noMessageInterpolation, noUnawaitedLog, preferLazyEvaluation, recommended, requireMetaSink, rules };
+//# sourceMappingURL=plugin.d.ts.map

package/dist/eslint/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","names":[],"sources":["../../src/eslint/plugin.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;cA6Ca,OAAO,eAAe,IAAA,CAAK;cAS3B;;;;;;;;;;cAeA,aAAa,MAAA,CAAO"}

package/dist/eslint/plugin.js

@@ -0,0 +1,44 @@
+import { noMessageInterpolation } from "../rules/no-message-interpolation.js";
+import { noUnawaitedLog } from "../rules/no-unawaited-log.js";
+import { preferLazyEvaluation } from "../rules/prefer-lazy-evaluation.js";
+import { requireMetaSink } from "../rules/require-meta-sink.js";
+
+//#region src/eslint/plugin.ts
+/**
+* All LogTape lint rules.
+*/
+const rules = {
+	"no-message-interpolation": noMessageInterpolation,
+	"prefer-lazy-evaluation": preferLazyEvaluation,
+	"no-unawaited-log": noUnawaitedLog,
+	"require-meta-sink": requireMetaSink
+};
+const plugin = {
+	meta: { name: "@logtape/lint" },
+	rules,
+	configs: {}
+};
+/**
+* Recommended ESLint v9 flat config preset.
+*
+* Enables all LogTape rules with their recommended severity levels:
+* - `no-message-interpolation`: error
+* - `prefer-lazy-evaluation`: warn
+* - `no-unawaited-log`: error
+* - `require-meta-sink`: warn
+*/
+const recommended = {
+	plugins: { logtape: plugin },
+	rules: {
+		"logtape/no-message-interpolation": "error",
+		"logtape/prefer-lazy-evaluation": "warn",
+		"logtape/no-unawaited-log": "error",
+		"logtape/require-meta-sink": "warn"
+	}
+};
+plugin.configs.recommended = recommended;
+var plugin_default = plugin;
+
+//#endregion
+export { plugin_default as default, noMessageInterpolation, noUnawaitedLog, plugin, preferLazyEvaluation, recommended, requireMetaSink, rules };
+//# sourceMappingURL=plugin.js.map

package/dist/eslint/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.js","names":["rules: Record<string, Rule.RuleModule>","plugin: any","recommended: Linter.Config"],"sources":["../../src/eslint/plugin.ts"],"sourcesContent":["/**\n * ESLint + Oxlint plugin for LogTape lint rules.\n *\n * Works with ESLint v8 and v9+ flat config, as well as Oxlint which provides\n * an ESLint-compatible plugin API.\n *\n * **ESLint v9 flat config** (`eslint.config.js`):\n * ```js\n * import logtapePlugin from \"@logtape/lint/eslint\";\n * export default [\n *   {\n *     plugins: { logtape: logtapePlugin },\n *     rules: {\n *       \"logtape/no-message-interpolation\": \"error\",\n *       \"logtape/prefer-lazy-evaluation\": \"warn\",\n *       \"logtape/no-unawaited-log\": \"error\",\n *       \"logtape/require-meta-sink\": \"warn\",\n *     },\n *   },\n * ];\n * ```\n *\n * **Using the recommended preset**:\n * ```js\n * import { recommended } from \"@logtape/lint/eslint\";\n * export default [recommended];\n * ```\n *\n * @module\n */\n\nimport type { Linter, Rule } from \"eslint\";\nimport { noMessageInterpolation } from \"../rules/no-message-interpolation.ts\";\nimport { noUnawaitedLog } from \"../rules/no-unawaited-log.ts\";\nimport { preferLazyEvaluation } from \"../rules/prefer-lazy-evaluation.ts\";\nimport { requireMetaSink } from \"../rules/require-meta-sink.ts\";\n\nexport { noMessageInterpolation } from \"../rules/no-message-interpolation.ts\";\nexport { noUnawaitedLog } from \"../rules/no-unawaited-log.ts\";\nexport { preferLazyEvaluation } from \"../rules/prefer-lazy-evaluation.ts\";\nexport { requireMetaSink } from \"../rules/require-meta-sink.ts\";\n\n/**\n * All LogTape lint rules.\n */\nexport const rules: Record<string, Rule.RuleModule> = {\n  \"no-message-interpolation\": noMessageInterpolation,\n  \"prefer-lazy-evaluation\": preferLazyEvaluation,\n  \"no-unawaited-log\": noUnawaitedLog,\n  \"require-meta-sink\": requireMetaSink,\n};\n\n// Declare plugin before recommended to allow the circular reference.\n// deno-lint-ignore no-explicit-any\nexport const plugin: any = {\n  meta: { name: \"@logtape/lint\" },\n  rules,\n  configs: {},\n};\n\n/**\n * Recommended ESLint v9 flat config preset.\n *\n * Enables all LogTape rules with their recommended severity levels:\n * - `no-message-interpolation`: error\n * - `prefer-lazy-evaluation`: warn\n * - `no-unawaited-log`: error\n * - `require-meta-sink`: warn\n */\nexport const recommended: Linter.Config = {\n  plugins: { logtape: plugin },\n  rules: {\n    \"logtape/no-message-interpolation\": \"error\",\n    \"logtape/prefer-lazy-evaluation\": \"warn\",\n    \"logtape/no-unawaited-log\": \"error\",\n    \"logtape/require-meta-sink\": \"warn\",\n  },\n};\n\nplugin.configs.recommended = recommended;\n\nexport default plugin;\n"],"mappings":";;;;;;;;;AA6CA,MAAaA,QAAyC;CACpD,4BAA4B;CAC5B,0BAA0B;CAC1B,oBAAoB;CACpB,qBAAqB;AACtB;AAID,MAAaC,SAAc;CACzB,MAAM,EAAE,MAAM,gBAAiB;CAC/B;CACA,SAAS,CAAE;AACZ;;;;;;;;;;AAWD,MAAaC,cAA6B;CACxC,SAAS,EAAE,SAAS,OAAQ;CAC5B,OAAO;EACL,oCAAoC;EACpC,kCAAkC;EAClC,4BAA4B;EAC5B,6BAA6B;CAC9B;AACF;AAED,OAAO,QAAQ,cAAc;AAE7B,qBAAe"}

package/dist/mod.cjs

@@ -0,0 +1,15 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_no_message_interpolation = require('./rules/no-message-interpolation.cjs');
+const require_no_unawaited_log = require('./rules/no-unawaited-log.cjs');
+const require_prefer_lazy_evaluation = require('./rules/prefer-lazy-evaluation.cjs');
+const require_require_meta_sink = require('./rules/require-meta-sink.cjs');
+const require_plugin = require('./eslint/plugin.cjs');
+
+exports.default = require_plugin.plugin;
+exports.noMessageInterpolation = require_no_message_interpolation.noMessageInterpolation;
+exports.noUnawaitedLog = require_no_unawaited_log.noUnawaitedLog;
+exports.plugin = require_plugin.plugin;
+exports.preferLazyEvaluation = require_prefer_lazy_evaluation.preferLazyEvaluation;
+exports.recommended = require_plugin.recommended;
+exports.requireMetaSink = require_require_meta_sink.requireMetaSink;
+exports.rules = require_plugin.rules;

package/dist/mod.d.cts

@@ -0,0 +1,6 @@
+import { noMessageInterpolation } from "./rules/no-message-interpolation.cjs";
+import { noUnawaitedLog } from "./rules/no-unawaited-log.cjs";
+import { preferLazyEvaluation } from "./rules/prefer-lazy-evaluation.cjs";
+import { requireMetaSink } from "./rules/require-meta-sink.cjs";
+import plugin, { recommended, rules } from "./eslint/plugin.cjs";
+export { plugin as default, noMessageInterpolation, noUnawaitedLog, plugin, preferLazyEvaluation, recommended, requireMetaSink, rules };

package/dist/mod.d.ts

@@ -0,0 +1,6 @@
+import { noMessageInterpolation } from "./rules/no-message-interpolation.js";
+import { noUnawaitedLog } from "./rules/no-unawaited-log.js";
+import { preferLazyEvaluation } from "./rules/prefer-lazy-evaluation.js";
+import { requireMetaSink } from "./rules/require-meta-sink.js";
+import plugin, { recommended, rules } from "./eslint/plugin.js";
+export { plugin as default, noMessageInterpolation, noUnawaitedLog, plugin, preferLazyEvaluation, recommended, requireMetaSink, rules };

package/dist/mod.js

@@ -0,0 +1,7 @@
+import { noMessageInterpolation } from "./rules/no-message-interpolation.js";
+import { noUnawaitedLog } from "./rules/no-unawaited-log.js";
+import { preferLazyEvaluation } from "./rules/prefer-lazy-evaluation.js";
+import { requireMetaSink } from "./rules/require-meta-sink.js";
+import { plugin, recommended, rules } from "./eslint/plugin.js";
+
+export { plugin as default, noMessageInterpolation, noUnawaitedLog, plugin, preferLazyEvaluation, recommended, requireMetaSink, rules };