@logtape/lint 2.2.0-dev.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"require-meta-sink.d.cts","names":[],"sources":["../../src/rules/require-meta-sink.ts"],"sourcesContent":[],"mappings":";;;;;;AAyBA;;;;;;;;;;;;;;;;cAAa,iBAAiB,IAAA,CAAK"}

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

@@ -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.ts.map

package/dist/rules/require-meta-sink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-meta-sink.d.ts","names":[],"sources":["../../src/rules/require-meta-sink.ts"],"sourcesContent":[],"mappings":";;;;;;AAyBA;;;;;;;;;;;;;;;;cAAa,iBAAiB,IAAA,CAAK"}

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

@@ -0,0 +1,76 @@
+import { configNeedsMetaSink, isLogtapeImportSource, unwrapTypeAssertion } from "../core/ast.js";
+
+//#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 (!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 = unwrapTypeAssertion(node.arguments[0]);
+				if (configNeedsMetaSink(configArg)) context.report({
+					node,
+					messageId: "requireMeta"
+				});
+			}
+		};
+	}
+};
+
+//#endregion
+export { requireMetaSink };
+//# sourceMappingURL=require-meta-sink.js.map

package/dist/rules/require-meta-sink.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-meta-sink.js","names":["requireMetaSink: Rule.RuleModule","cur: any","calleeVar: any","d: any"],"sources":["../../src/rules/require-meta-sink.ts"],"sourcesContent":["import type { Rule } from \"eslint\";\nimport {\n  configNeedsMetaSink,\n  isLogtapeImportSource,\n  unwrapTypeAssertion,\n} from \"../core/ast.ts\";\n\n/**\n * ESLint rule that detects `configure()` / `configureSync()` calls imported\n * from `@logtape/logtape` that lack a dedicated sink for the meta logger.\n *\n * ```ts\n * // Incorrect (missing meta sink):\n * await configure({ sinks: { main: s }, loggers: [{ category: [], sinks: [\"main\"] }] });\n *\n * // Correct:\n * await configure({\n *   sinks: { console: getConsoleSink(), main: s },\n *   loggers: [\n *     { category: [\"logtape\", \"meta\"], sinks: [\"console\"] },\n *     { category: [], sinks: [\"main\"] },\n *   ],\n * });\n * ```\n */\nexport const requireMetaSink: Rule.RuleModule = {\n  meta: {\n    type: \"suggestion\",\n    docs: {\n      description:\n        \"Require a dedicated sink for the LogTape meta logger in configure() calls\",\n      recommended: true,\n      url: \"https://logtape.org/lint/require-meta-sink\",\n    },\n    schema: [],\n    messages: {\n      requireMeta: \"Add a dedicated sink for the meta logger \" +\n        '(category: [\"logtape\"] or [\"logtape\", \"meta\"]) ' +\n        \"to handle LogTape's own diagnostic messages.\",\n    },\n  },\n\n  create(context) {\n    // Track local names of configure/configureSync imported from @logtape/logtape\n    const configFns = new Set<string>();\n\n    return {\n      ImportDeclaration(node) {\n        // deno-lint-ignore no-explicit-any\n        if (!isLogtapeImportSource((node as any).source?.value)) return;\n        // deno-lint-ignore no-explicit-any\n        for (const specifier of (node as any).specifiers ?? []) {\n          if (specifier.type !== \"ImportSpecifier\") continue;\n          const imported = specifier.imported?.name;\n          if (imported === \"configure\" || imported === \"configureSync\") {\n            configFns.add(specifier.local?.name);\n          }\n        }\n      },\n\n      CallExpression(node) {\n        if (configFns.size === 0) return;\n\n        const { callee } = node;\n        if (callee.type !== \"Identifier\") return;\n        // deno-lint-ignore no-explicit-any\n        const calleeName = (callee as any).name as string;\n        if (!configFns.has(calleeName)) return;\n\n        // Verify the callee resolves to the actual import, not a shadow\n        // (e.g. a function parameter also named configure).\n        // deno-lint-ignore no-explicit-any\n        const scope = (context as any).sourceCode?.getScope?.(node) ??\n          // deno-lint-ignore no-explicit-any\n          (context as any).getScope?.();\n        if (scope) {\n          // deno-lint-ignore no-explicit-any\n          let cur: any = scope;\n          // deno-lint-ignore no-explicit-any\n          let calleeVar: any = null;\n          while (cur) {\n            const v = cur.set?.get(calleeName);\n            if (v) {\n              calleeVar = v;\n              break;\n            }\n            cur = cur.upper;\n          }\n          if (\n            // deno-lint-ignore no-explicit-any\n            !calleeVar?.defs?.some((d: any) => d.type === \"ImportBinding\")\n          ) return;\n        }\n\n        // Unwrap a TypeScript type assertion (e.g. `configure({ ... } as const)`).\n        const configArg = unwrapTypeAssertion(node.arguments[0]);\n        if (configNeedsMetaSink(configArg)) {\n          context.report({ node, messageId: \"requireMeta\" });\n        }\n      },\n    };\n  },\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAyBA,MAAaA,kBAAmC;CAC9C,MAAM;EACJ,MAAM;EACN,MAAM;GACJ,aACE;GACF,aAAa;GACb,KAAK;EACN;EACD,QAAQ,CAAE;EACV,UAAU,EACR,aAAa,6IAGd;CACF;CAED,OAAO,SAAS;EAEd,MAAM,4BAAY,IAAI;AAEtB,SAAO;GACL,kBAAkB,MAAM;AAEtB,SAAK,sBAAuB,KAAa,QAAQ,MAAM,CAAE;AAEzD,SAAK,MAAM,aAAc,KAAa,cAAc,CAAE,GAAE;AACtD,SAAI,UAAU,SAAS,kBAAmB;KAC1C,MAAM,WAAW,UAAU,UAAU;AACrC,SAAI,aAAa,eAAe,aAAa,gBAC3C,WAAU,IAAI,UAAU,OAAO,KAAK;IAEvC;GACF;GAED,eAAe,MAAM;AACnB,QAAI,UAAU,SAAS,EAAG;IAE1B,MAAM,EAAE,QAAQ,GAAG;AACnB,QAAI,OAAO,SAAS,aAAc;IAElC,MAAM,aAAc,OAAe;AACnC,SAAK,UAAU,IAAI,WAAW,CAAE;IAKhC,MAAM,QAAQ,AAAC,QAAgB,YAAY,WAAW,KAAK,IAEzD,AAAC,QAAgB,YAAY;AAC/B,QAAI,OAAO;KAET,IAAIC,MAAW;KAEf,IAAIC,YAAiB;AACrB,YAAO,KAAK;MACV,MAAM,IAAI,IAAI,KAAK,IAAI,WAAW;AAClC,UAAI,GAAG;AACL,mBAAY;AACZ;MACD;AACD,YAAM,IAAI;KACX;AACD,UAEG,WAAW,MAAM,KAAK,CAACC,MAAW,EAAE,SAAS,gBAAgB,CAC9D;IACH;IAGD,MAAM,YAAY,oBAAoB,KAAK,UAAU,GAAG;AACxD,QAAI,oBAAoB,UAAU,CAChC,SAAQ,OAAO;KAAE;KAAM,WAAW;IAAe,EAAC;GAErD;EACF;CACF;AACF"}

package/dist/utils.cjs

@@ -0,0 +1,82 @@
+const require_ast = require('./core/ast.cjs');
+
+//#region src/utils.ts
+/**
+* Returns visitor hooks and a scope-aware checker for detecting LogTape log
+* method calls.  Uses ESLint's scope manager to resolve variable bindings,
+* so parameter- and local-variable shadowing are handled correctly.
+*
+* Wire the returned `ImportDeclaration` hook into your rule's visitor object,
+* then call `isLogtapeCall(node.callee, node)` inside `CallExpression`.
+*/
+function createLogtapeScope(context) {
+	const getterNames = /* @__PURE__ */ new Set();
+	const lazyNames = /* @__PURE__ */ new Set();
+	function resolveVariable(scope, name) {
+		let current = scope;
+		while (current) {
+			const variable = current.set?.get(name);
+			if (variable) return variable;
+			current = current.upper;
+		}
+		return null;
+	}
+	function resolvesToImportedGetter(name, scope) {
+		if (!getterNames.has(name)) return false;
+		const calleeVar = resolveVariable(scope, name);
+		return calleeVar?.defs?.some((d) => d.type === "ImportBinding") ?? false;
+	}
+	function isLoggerExpression(node, scope, depth = 0) {
+		if (depth > 16 || !node) return false;
+		if (node.type === "CallExpression" && node.callee?.type === "Identifier") return resolvesToImportedGetter(node.callee.name, scope);
+		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 isLoggerExpression(node.callee.object, scope, depth + 1);
+		if (node.type === "Identifier") {
+			const variable = resolveVariable(scope, node.name);
+			if (!variable) return false;
+			return variable.defs?.some((def) => {
+				if (def.type !== "Variable") return false;
+				return isLoggerExpression(def.node?.init, variable.scope ?? scope, depth + 1);
+			}) ?? false;
+		}
+		return false;
+	}
+	function isLogtapeCall(callee, callNode) {
+		if (!callee || callee.type !== "MemberExpression") return false;
+		const scope = context.sourceCode?.getScope?.(callNode) ?? context.getScope?.();
+		return isLoggerExpression(callee.object, scope);
+	}
+	function effectiveLazyNames(callNode) {
+		if (lazyNames.size === 0) return lazyNames;
+		const scope = context.sourceCode?.getScope?.(callNode) ?? context.getScope?.();
+		const result = /* @__PURE__ */ new Set();
+		for (const name of lazyNames) {
+			const variable = resolveVariable(scope, name);
+			const isImport = variable?.defs?.some((d) => d.type === "ImportBinding") ?? false;
+			if (isImport) result.add(name);
+		}
+		return result;
+	}
+	return {
+		ImportDeclaration(node) {
+			if (!require_ast.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);
+			}
+		},
+		isLogtapeCall,
+		lazyNames,
+		effectiveLazyNames
+	};
+}
+/**
+* Get the SourceCode object from a rule context (v8/v9 compatible).
+*/
+function getSourceCode(context) {
+	return context.sourceCode ?? context.getSourceCode?.();
+}
+
+//#endregion
+exports.createLogtapeScope = createLogtapeScope;
+exports.getSourceCode = getSourceCode;

package/dist/utils.js

@@ -0,0 +1,82 @@
+import { isLogtapeImportSource } from "./core/ast.js";
+
+//#region src/utils.ts
+/**
+* Returns visitor hooks and a scope-aware checker for detecting LogTape log
+* method calls.  Uses ESLint's scope manager to resolve variable bindings,
+* so parameter- and local-variable shadowing are handled correctly.
+*
+* Wire the returned `ImportDeclaration` hook into your rule's visitor object,
+* then call `isLogtapeCall(node.callee, node)` inside `CallExpression`.
+*/
+function createLogtapeScope(context) {
+	const getterNames = /* @__PURE__ */ new Set();
+	const lazyNames = /* @__PURE__ */ new Set();
+	function resolveVariable(scope, name) {
+		let current = scope;
+		while (current) {
+			const variable = current.set?.get(name);
+			if (variable) return variable;
+			current = current.upper;
+		}
+		return null;
+	}
+	function resolvesToImportedGetter(name, scope) {
+		if (!getterNames.has(name)) return false;
+		const calleeVar = resolveVariable(scope, name);
+		return calleeVar?.defs?.some((d) => d.type === "ImportBinding") ?? false;
+	}
+	function isLoggerExpression(node, scope, depth = 0) {
+		if (depth > 16 || !node) return false;
+		if (node.type === "CallExpression" && node.callee?.type === "Identifier") return resolvesToImportedGetter(node.callee.name, scope);
+		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 isLoggerExpression(node.callee.object, scope, depth + 1);
+		if (node.type === "Identifier") {
+			const variable = resolveVariable(scope, node.name);
+			if (!variable) return false;
+			return variable.defs?.some((def) => {
+				if (def.type !== "Variable") return false;
+				return isLoggerExpression(def.node?.init, variable.scope ?? scope, depth + 1);
+			}) ?? false;
+		}
+		return false;
+	}
+	function isLogtapeCall(callee, callNode) {
+		if (!callee || callee.type !== "MemberExpression") return false;
+		const scope = context.sourceCode?.getScope?.(callNode) ?? context.getScope?.();
+		return isLoggerExpression(callee.object, scope);
+	}
+	function effectiveLazyNames(callNode) {
+		if (lazyNames.size === 0) return lazyNames;
+		const scope = context.sourceCode?.getScope?.(callNode) ?? context.getScope?.();
+		const result = /* @__PURE__ */ new Set();
+		for (const name of lazyNames) {
+			const variable = resolveVariable(scope, name);
+			const isImport = variable?.defs?.some((d) => d.type === "ImportBinding") ?? false;
+			if (isImport) result.add(name);
+		}
+		return result;
+	}
+	return {
+		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);
+			}
+		},
+		isLogtapeCall,
+		lazyNames,
+		effectiveLazyNames
+	};
+}
+/**
+* Get the SourceCode object from a rule context (v8/v9 compatible).
+*/
+function getSourceCode(context) {
+	return context.sourceCode ?? context.getSourceCode?.();
+}
+
+//#endregion
+export { createLogtapeScope, getSourceCode };
+//# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":["context: Rule.RuleContext","scope: AnyNode","name: string","d: AnyNode","node: AnyNode","def: AnyNode","callee: AnyNode","callNode: AnyNode"],"sources":["../src/utils.ts"],"sourcesContent":["import type { Rule } from \"eslint\";\nimport { isLogtapeImportSource } from \"./core/ast.ts\";\n\n// deno-lint-ignore no-explicit-any\ntype AnyNode = any;\n\n/**\n * Returns visitor hooks and a scope-aware checker for detecting LogTape log\n * method calls.  Uses ESLint's scope manager to resolve variable bindings,\n * so parameter- and local-variable shadowing are handled correctly.\n *\n * Wire the returned `ImportDeclaration` hook into your rule's visitor object,\n * then call `isLogtapeCall(node.callee, node)` inside `CallExpression`.\n */\nexport function createLogtapeScope(context: Rule.RuleContext): {\n  ImportDeclaration(node: AnyNode): void;\n  isLogtapeCall(callee: AnyNode, callNode: AnyNode): boolean;\n  lazyNames: Set<string>;\n  effectiveLazyNames(callNode: AnyNode): 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, so the eager-call rules must not treat it as eager.\n  const lazyNames = new Set<string>();\n\n  function resolveVariable(scope: AnyNode, name: string): AnyNode {\n    let current = scope;\n    while (current) {\n      const variable = current.set?.get(name);\n      if (variable) return variable;\n      current = current.upper;\n    }\n    return null;\n  }\n\n  // Does `name`, resolved from `scope`, refer to the actual imported\n  // getLogger (an ImportBinding) rather than a shadow such as a parameter?\n  function resolvesToImportedGetter(name: string, scope: AnyNode): boolean {\n    if (!getterNames.has(name)) return false;\n    const calleeVar = resolveVariable(scope, name);\n    return calleeVar?.defs?.some(\n      (d: AnyNode) => d.type === \"ImportBinding\",\n    ) ?? false;\n  }\n\n  // Is `node` an expression that evaluates to a LogTape logger?  Handles\n  // direct getLogger(...) calls, identifiers bound to a logger via a variable\n  // declaration, and contextual/child loggers produced by chaining\n  // Logger.with(...) or Logger.getChild(...).\n  function isLoggerExpression(\n    node: AnyNode,\n    scope: AnyNode,\n    depth = 0,\n  ): boolean {\n    if (depth > 16 || !node) return false;\n\n    // getLogger(...) — direct call to the imported getter.\n    if (node.type === \"CallExpression\" && node.callee?.type === \"Identifier\") {\n      return resolvesToImportedGetter(node.callee.name, scope);\n    }\n\n    // logger.with(...) / logger.getChild(...) — contextual or child loggers,\n    // which return a Logger and so are themselves logger expressions.\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 isLoggerExpression(node.callee.object, scope, depth + 1);\n    }\n\n    // An identifier bound to a logger by a variable declaration.\n    if (node.type === \"Identifier\") {\n      const variable = resolveVariable(scope, node.name);\n      if (!variable) return false;\n      // Parameters have def.type === \"Parameter\"; only \"Variable\" defs from\n      // VariableDeclarator nodes carry an initializer to inspect.  Resolve the\n      // initializer in the variable's declaration scope (variable.scope) so a\n      // logger declared in an outer scope is still recognised when a closer\n      // scope shadows getLogger.\n      return variable.defs?.some((def: AnyNode) => {\n        if (def.type !== \"Variable\") return false;\n        return isLoggerExpression(\n          def.node?.init,\n          variable.scope ?? scope,\n          depth + 1,\n        );\n      }) ?? false;\n    }\n\n    return false;\n  }\n\n  function isLogtapeCall(callee: AnyNode, callNode: AnyNode): boolean {\n    if (!callee || callee.type !== \"MemberExpression\") return false;\n\n    // Use ESLint's scope manager to resolve variable bindings at the call site.\n    const scope =\n      // deno-lint-ignore no-explicit-any\n      (context as any).sourceCode?.getScope?.(callNode) ??\n        // deno-lint-ignore no-explicit-any\n        (context as any).getScope?.();\n\n    return isLoggerExpression(callee.object, scope);\n  }\n\n  // The subset of lazyNames that, at `callNode`, still resolve to the imported\n  // `lazy` rather than a shadowing local binding (e.g. a parameter named\n  // `lazy`).  The eager-call rules use this so a shadowed `lazy(...)` is\n  // treated as an ordinary eager call, not LogTape's deferred wrapper.\n  function effectiveLazyNames(callNode: AnyNode): Set<string> {\n    if (lazyNames.size === 0) return lazyNames;\n    const scope =\n      // deno-lint-ignore no-explicit-any\n      (context as any).sourceCode?.getScope?.(callNode) ??\n        // deno-lint-ignore no-explicit-any\n        (context as any).getScope?.();\n    const result = new Set<string>();\n    for (const name of lazyNames) {\n      const variable = resolveVariable(scope, name);\n      const isImport = variable?.defs?.some(\n        (d: AnyNode) => d.type === \"ImportBinding\",\n      ) ?? false;\n      if (isImport) result.add(name);\n    }\n    return result;\n  }\n\n  return {\n    ImportDeclaration(node: AnyNode): void {\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    isLogtapeCall,\n    lazyNames,\n    effectiveLazyNames,\n  };\n}\n\n/**\n * Get the SourceCode object from a rule context (v8/v9 compatible).\n */\nexport function getSourceCode(\n  context: Rule.RuleContext,\n): Rule.RuleContext[\"sourceCode\"] {\n  // deno-lint-ignore no-explicit-any\n  return (context as any).sourceCode ?? context.getSourceCode?.();\n}\n"],"mappings":";;;;;;;;;;;AAcA,SAAgB,mBAAmBA,SAKjC;CACA,MAAM,8BAAc,IAAI;CAGxB,MAAM,4BAAY,IAAI;CAEtB,SAAS,gBAAgBC,OAAgBC,MAAuB;EAC9D,IAAI,UAAU;AACd,SAAO,SAAS;GACd,MAAM,WAAW,QAAQ,KAAK,IAAI,KAAK;AACvC,OAAI,SAAU,QAAO;AACrB,aAAU,QAAQ;EACnB;AACD,SAAO;CACR;CAID,SAAS,yBAAyBA,MAAcD,OAAyB;AACvE,OAAK,YAAY,IAAI,KAAK,CAAE,QAAO;EACnC,MAAM,YAAY,gBAAgB,OAAO,KAAK;AAC9C,SAAO,WAAW,MAAM,KACtB,CAACE,MAAe,EAAE,SAAS,gBAC5B,IAAI;CACN;CAMD,SAAS,mBACPC,MACAH,OACA,QAAQ,GACC;AACT,MAAI,QAAQ,OAAO,KAAM,QAAO;AAGhC,MAAI,KAAK,SAAS,oBAAoB,KAAK,QAAQ,SAAS,aAC1D,QAAO,yBAAyB,KAAK,OAAO,MAAM,MAAM;AAK1D,MACE,KAAK,SAAS,oBACd,KAAK,QAAQ,SAAS,uBACrB,KAAK,OAAO,YACb,KAAK,OAAO,UAAU,SAAS,iBAC9B,KAAK,OAAO,SAAS,SAAS,UAC7B,KAAK,OAAO,SAAS,SAAS,YAEhC,QAAO,mBAAmB,KAAK,OAAO,QAAQ,OAAO,QAAQ,EAAE;AAIjE,MAAI,KAAK,SAAS,cAAc;GAC9B,MAAM,WAAW,gBAAgB,OAAO,KAAK,KAAK;AAClD,QAAK,SAAU,QAAO;AAMtB,UAAO,SAAS,MAAM,KAAK,CAACI,QAAiB;AAC3C,QAAI,IAAI,SAAS,WAAY,QAAO;AACpC,WAAO,mBACL,IAAI,MAAM,MACV,SAAS,SAAS,OAClB,QAAQ,EACT;GACF,EAAC,IAAI;EACP;AAED,SAAO;CACR;CAED,SAAS,cAAcC,QAAiBC,UAA4B;AAClE,OAAK,UAAU,OAAO,SAAS,mBAAoB,QAAO;EAG1D,MAAM,QAEJ,AAAC,QAAgB,YAAY,WAAW,SAAS,IAE/C,AAAC,QAAgB,YAAY;AAEjC,SAAO,mBAAmB,OAAO,QAAQ,MAAM;CAChD;CAMD,SAAS,mBAAmBA,UAAgC;AAC1D,MAAI,UAAU,SAAS,EAAG,QAAO;EACjC,MAAM,QAEJ,AAAC,QAAgB,YAAY,WAAW,SAAS,IAE/C,AAAC,QAAgB,YAAY;EACjC,MAAM,yBAAS,IAAI;AACnB,OAAK,MAAM,QAAQ,WAAW;GAC5B,MAAM,WAAW,gBAAgB,OAAO,KAAK;GAC7C,MAAM,WAAW,UAAU,MAAM,KAC/B,CAACJ,MAAe,EAAE,SAAS,gBAC5B,IAAI;AACL,OAAI,SAAU,QAAO,IAAI,KAAK;EAC/B;AACD,SAAO;CACR;AAED,QAAO;EACL,kBAAkBC,MAAqB;AACrC,QAAK,sBAAsB,KAAK,QAAQ,MAAM,CAAE;AAChD,QAAK,MAAM,QAAQ,KAAK,cAAc,CAAE,GAAE;AACxC,QAAI,KAAK,SAAS,kBAAmB;AACrC,QAAI,KAAK,UAAU,SAAS,YAC1B,aAAY,IAAI,KAAK,OAAO,KAAK;aACxB,KAAK,UAAU,SAAS,OACjC,WAAU,IAAI,KAAK,OAAO,KAAK;GAElC;EACF;EACD;EACA;EACA;CACD;AACF;;;;AAKD,SAAgB,cACdJ,SACgC;AAEhC,QAAQ,QAAgB,cAAc,QAAQ,iBAAiB;AAChE"}

package/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "@logtape/lint",
+  "version": "2.2.0-dev.0",
+  "description": "Lint rules for LogTape usage patterns (ESLint, Oxlint, Deno Lint)",
+  "keywords": [
+    "logging",
+    "log",
+    "logger",
+    "logtape",
+    "lint",
+    "eslint",
+    "eslint-plugin",
+    "oxlint",
+    "deno"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "Hong Minhee",
+    "email": "hong@minhee.org",
+    "url": "https://hongminhee.org/"
+  },
+  "homepage": "https://logtape.org/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dahlia/logtape.git",
+    "directory": "packages/lint/"
+  },
+  "bugs": {
+    "url": "https://github.com/dahlia/logtape/issues"
+  },
+  "funding": [
+    "https://github.com/sponsors/dahlia"
+  ],
+  "type": "module",
+  "module": "./dist/mod.js",
+  "main": "./dist/mod.cjs",
+  "types": "./dist/mod.d.ts",
+  "exports": {
+    ".": {
+      "types": {
+        "import": "./dist/mod.d.ts",
+        "require": "./dist/mod.d.cts"
+      },
+      "import": "./dist/mod.js",
+      "require": "./dist/mod.cjs"
+    },
+    "./eslint": {
+      "types": {
+        "import": "./dist/eslint/plugin.d.ts",
+        "require": "./dist/eslint/plugin.d.cts"
+      },
+      "import": "./dist/eslint/plugin.js",
+      "require": "./dist/eslint/plugin.cjs"
+    },
+    "./deno": {
+      "types": {
+        "import": "./dist/deno/plugin.d.ts",
+        "require": "./dist/deno/plugin.d.cts"
+      },
+      "import": "./dist/deno/plugin.js",
+      "require": "./dist/deno/plugin.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/"
+  ],
+  "sideEffects": false,
+  "peerDependencies": {
+    "eslint": ">=8.0.0"
+  },
+  "peerDependenciesMeta": {
+    "eslint": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "eslint": "^9.0.0",
+    "tsdown": "^0.12.7",
+    "typescript": "^5.8.3"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "prepublish": "tsdown",
+    "test": "tsdown && node --experimental-transform-types --test",
+    "test:bun": "tsdown && bun test",
+    "test:deno": "deno test --allow-run --allow-write --allow-read --allow-env",
+    "test-all": "tsdown && node --experimental-transform-types --test && bun test && deno test --allow-run --allow-write --allow-read --allow-env"
+  }
+}