@timmo001/oxlint-rules 0.1.4 → 0.2.1

package/README.md

@@ -2,7 +2,8 @@
 
 Shared Oxlint plugins and configs built around the unchanged
 [`dmmulroy/anti-slop`](https://github.com/dmmulroy/anti-slop) rules, with
-separately owned Effect rules under the `timmo-effect` namespace.
+locally owned generic rules under `timmo` and Effect rules under
+`timmo-effect`.
 
 Oxlint's JavaScript plugin API is alpha. Consumers must keep `oxlint` and
 `@oxlint/plugins` on the exact peer versions declared by this package.
@@ -49,10 +50,10 @@ Copy a reviewed snapshot when a repository should own the rule source:
 npx --yes @timmo001/oxlint-rules copy tools/oxlint/timmo-rules
 ```
 
-The command prints the three local plugin entry points and every discovered rule
-setting to merge into the target Oxlint config. Effect settings remain opt-in.
-It excludes tests and repository metadata, and refuses to replace an existing
-destination unless `--force` is passed.
+The command prints every copied plugin entry point and the rule settings from
+the package configs to merge into the target Oxlint config. Effect settings
+remain opt-in. It excludes tests and repository metadata, and refuses to
+replace an existing destination unless `--force` is passed.
 
 ## Rules
 
@@ -74,6 +75,12 @@ destination unless `--force` is passed.
 - `no-widen-then-assert`
 - `require-safety-comment-for-type-assertion`
 
+### `timmo`
+
+- `prefer-event-parameter-type`: reports assertions on a handler parameter's
+  `target` or `currentTarget`. Express the target type in the function signature
+  instead so every use sees the same contract.
+
 ### `anti-slop-effect`
 
 - `no-service-constructor-imports`

package/dist/cli.js

@@ -104,11 +104,67 @@ var timmoEffectPlugin = eslintCompatPlugin({
 });
 var effect_default = timmoEffectPlugin;
 
-// vendor/anti-slop/src/index.ts
+// vendor/anti-slop/src/effect/index.ts
 import { eslintCompatPlugin as eslintCompatPlugin2 } from "@oxlint/plugins";
 
-// vendor/anti-slop/src/rules/no-chained-type-assertions.ts
+// vendor/anti-slop/src/effect/rules/no-service-constructor-imports.ts
 import { defineRule as defineRule2 } from "@oxlint/plugins";
+var SERVICE_CONSTRUCTOR_NAME = /^make[A-Z]/u;
+var TEST_FILE = /\.(?:test|spec)\.[cm]?[jt]sx?$/u;
+function isProjectLocalImport(source) {
+  return source.startsWith("./") || source.startsWith("../");
+}
+function getImportedName(specifier) {
+  if (specifier.imported.type === "Identifier")
+    return specifier.imported.name;
+  return specifier.imported.value;
+}
+var noServiceConstructorImportsRule = defineRule2({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow project-local make<CapabilityName> imports outside test and spec files."
+    },
+    messages: {
+      serviceConstructorImport: 'Do not import Effect service constructor "{{name}}" into runtime code. Import the owning Layer, yield the contextual service, and allow its requirements to propagate to the composition root.'
+    }
+  },
+  create(context) {
+    const isTestFile = TEST_FILE.test(context.filename.replaceAll("\\", "/"));
+    return {
+      ImportDeclaration(node) {
+        if (isTestFile || !isProjectLocalImport(node.source.value))
+          return;
+        for (const specifier of node.specifiers) {
+          if (specifier.type !== "ImportSpecifier")
+            continue;
+          const importedName = getImportedName(specifier);
+          if (!SERVICE_CONSTRUCTOR_NAME.test(importedName))
+            continue;
+          context.report({
+            node: specifier,
+            messageId: "serviceConstructorImport",
+            data: { name: importedName }
+          });
+        }
+      }
+    };
+  }
+});
+
+// vendor/anti-slop/src/effect/index.ts
+var antiSlopEffectPlugin = eslintCompatPlugin2({
+  meta: { name: "anti-slop-effect" },
+  rules: {
+    "no-service-constructor-imports": noServiceConstructorImportsRule
+  }
+});
+var effect_default2 = antiSlopEffectPlugin;
+// vendor/anti-slop/src/index.ts
+import { eslintCompatPlugin as eslintCompatPlugin3 } from "@oxlint/plugins";
+
+// vendor/anti-slop/src/rules/no-chained-type-assertions.ts
+import { defineRule as defineRule3 } from "@oxlint/plugins";
 function isTypeAssertionExpression(node) {
   return node.type === "TSAsExpression" || node.type === "TSTypeAssertion";
 }
@@ -143,7 +199,7 @@ function isForbiddenAssertionChain(node) {
   }
   return assertionCount > 1 && hasNonConstAssertion;
 }
-var noChainedTypeAssertionsRule = defineRule2({
+var noChainedTypeAssertionsRule = defineRule3({
   meta: {
     type: "problem",
     docs: {
@@ -167,7 +223,7 @@ var noChainedTypeAssertionsRule = defineRule2({
 });
 
 // vendor/anti-slop/src/rules/no-conditional-empty-object-spread.ts
-import { defineRule as defineRule3 } from "@oxlint/plugins";
+import { defineRule as defineRule4 } from "@oxlint/plugins";
 function unwrapParentheses(node) {
   let current = node;
   while (current.type === "ParenthesizedExpression") {
@@ -182,7 +238,7 @@ function isConditionalEmptyObjectSpread(node) {
   const conditional = unwrapParentheses(node);
   return conditional.type === "ConditionalExpression" && (isEmptyObjectExpression(conditional.consequent) || isEmptyObjectExpression(conditional.alternate));
 }
-var noConditionalEmptyObjectSpreadRule = defineRule3({
+var noConditionalEmptyObjectSpreadRule = defineRule4({
   meta: {
     type: "suggestion",
     docs: {
@@ -206,7 +262,7 @@ var noConditionalEmptyObjectSpreadRule = defineRule3({
 });
 
 // vendor/anti-slop/src/rules/no-known-value-widening.ts
-import { defineRule as defineRule4 } from "@oxlint/plugins";
+import { defineRule as defineRule5 } from "@oxlint/plugins";
 
 // vendor/anti-slop/src/shared/lexical-type-parameters.ts
 function isNode(value) {
@@ -905,7 +961,7 @@ function isDictionaryAccumulatorTarget(destination) {
 function hasParentAssertion(node) {
   return node.parent?.type === "TSAsExpression" || node.parent?.type === "TSTypeAssertion";
 }
-var noKnownValueWideningRule = defineRule4({
+var noKnownValueWideningRule = defineRule5({
   meta: {
     type: "problem",
     docs: {
@@ -1018,7 +1074,7 @@ var noKnownValueWideningRule = defineRule4({
 });
 
 // vendor/anti-slop/src/rules/no-module-mocking.ts
-import { defineRule as defineRule5 } from "@oxlint/plugins";
+import { defineRule as defineRule6 } from "@oxlint/plugins";
 var moduleMockMethods = new Set(["doMock", "mock", "unstable_mockModule"]);
 function resolveVariable3(sourceCode, identifier) {
   let scope = sourceCode.getScope(identifier);
@@ -1063,7 +1119,7 @@ function moduleMockCall(sourceCode, callee) {
   const method = callee.computed ? property.type === "Literal" && (property.value === "doMock" || property.value === "mock" || property.value === "unstable_mockModule") ? property.value : null : property.type === "Identifier" ? property.name : null;
   return method !== null && moduleMockMethods.has(method);
 }
-var noModuleMockingRule = defineRule5({
+var noModuleMockingRule = defineRule6({
   meta: {
     type: "problem",
     docs: {
@@ -1087,8 +1143,8 @@ var noModuleMockingRule = defineRule5({
 });
 
 // vendor/anti-slop/src/rules/no-object-parameters.ts
-import { defineRule as defineRule6 } from "@oxlint/plugins";
-var noObjectParametersRule = defineRule6({
+import { defineRule as defineRule7 } from "@oxlint/plugins";
+var noObjectParametersRule = defineRule7({
   meta: {
     type: "problem",
     docs: {
@@ -1141,7 +1197,7 @@ var noObjectParametersRule = defineRule6({
 });
 
 // vendor/anti-slop/src/rules/no-reflect-apply.ts
-import { defineRule as defineRule7 } from "@oxlint/plugins";
+import { defineRule as defineRule8 } from "@oxlint/plugins";
 
 // vendor/anti-slop/src/shared/reflect-method.ts
 function resolveVariable4(sourceCode, identifier) {
@@ -1172,7 +1228,7 @@ function isGlobalReflectMethodCall(sourceCode, callee, methodName) {
 }
 
 // vendor/anti-slop/src/rules/no-reflect-apply.ts
-var noReflectApplyRule = defineRule7({
+var noReflectApplyRule = defineRule8({
   meta: {
     type: "problem",
     docs: {
@@ -1196,8 +1252,8 @@ var noReflectApplyRule = defineRule7({
 });
 
 // vendor/anti-slop/src/rules/no-reflect-get.ts
-import { defineRule as defineRule8 } from "@oxlint/plugins";
-var noReflectGetRule = defineRule8({
+import { defineRule as defineRule9 } from "@oxlint/plugins";
+var noReflectGetRule = defineRule9({
   meta: {
     type: "problem",
     docs: {
@@ -1221,7 +1277,7 @@ var noReflectGetRule = defineRule8({
 });
 
 // vendor/anti-slop/src/rules/no-runtime-typeof.ts
-import { defineRule as defineRule9 } from "@oxlint/plugins";
+import { defineRule as defineRule10 } from "@oxlint/plugins";
 function isRuntimeFunction(node) {
   return node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression";
 }
@@ -1244,7 +1300,7 @@ function isExistenceProbe(node) {
   const other = parent.left === node ? parent.right : parent.left;
   return other.type === "Literal" && other.value === "undefined";
 }
-var noRuntimeTypeofRule = defineRule9({
+var noRuntimeTypeofRule = defineRule10({
   meta: {
     type: "problem",
     docs: {
@@ -1278,7 +1334,7 @@ var noRuntimeTypeofRule = defineRule9({
 });
 
 // vendor/anti-slop/src/rules/no-shape-in-symbol-names.ts
-import { defineRule as defineRule10 } from "@oxlint/plugins";
+import { defineRule as defineRule11 } from "@oxlint/plugins";
 var FORBIDDEN_SYMBOL_NAME = "shape";
 function containsForbiddenSymbolName(name) {
   return name.toLowerCase().includes(FORBIDDEN_SYMBOL_NAME);
@@ -1289,7 +1345,7 @@ function isBorrowedMemberName(node) {
     return false;
   return parent.property === node && parent.computed === false;
 }
-var noForbiddenTermInSymbolNamesRule = defineRule10({
+var noForbiddenTermInSymbolNamesRule = defineRule11({
   meta: {
     type: "problem",
     docs: {
@@ -1318,12 +1374,12 @@ var noForbiddenTermInSymbolNamesRule = defineRule10({
 });
 
 // vendor/anti-slop/src/rules/no-unknown-parameters.ts
-import { defineRule as defineRule11 } from "@oxlint/plugins";
+import { defineRule as defineRule12 } from "@oxlint/plugins";
 function isTypePredicateSubject(owner, parameterName) {
   const predicate = owner.returnType?.typeAnnotation;
   return predicate?.type === "TSTypePredicate" && predicate.parameterName.type === "Identifier" && predicate.parameterName.name === parameterName;
 }
-var noUnknownParametersRule = defineRule11({
+var noUnknownParametersRule = defineRule12({
   meta: {
     type: "problem",
     docs: {
@@ -1367,8 +1423,8 @@ var noUnknownParametersRule = defineRule11({
 });
 
 // vendor/anti-slop/src/rules/no-unknown-returns.ts
-import { defineRule as defineRule12 } from "@oxlint/plugins";
-var noUnknownReturnsRule = defineRule12({
+import { defineRule as defineRule13 } from "@oxlint/plugins";
+var noUnknownReturnsRule = defineRule13({
   meta: {
     type: "problem",
     docs: {
@@ -1421,8 +1477,8 @@ var noUnknownReturnsRule = defineRule12({
 });
 
 // vendor/anti-slop/src/rules/no-unknown-type-aliases.ts
-import { defineRule as defineRule13 } from "@oxlint/plugins";
-var noUnknownTypeAliasesRule = defineRule13({
+import { defineRule as defineRule14 } from "@oxlint/plugins";
+var noUnknownTypeAliasesRule = defineRule14({
   meta: {
     type: "problem",
     docs: {
@@ -1460,7 +1516,7 @@ var noUnknownTypeAliasesRule = defineRule13({
 });
 
 // vendor/anti-slop/src/rules/no-unsafe-dictionary-type.ts
-import { defineRule as defineRule14 } from "@oxlint/plugins";
+import { defineRule as defineRule15 } from "@oxlint/plugins";
 var typeNodeKinds = new Set([
   "JSDocNonNullableType",
   "JSDocNullableType",
@@ -1547,7 +1603,7 @@ function shouldReportType(node, environment) {
   }
   return true;
 }
-var noUnsafeDictionaryTypeRule = defineRule14({
+var noUnsafeDictionaryTypeRule = defineRule15({
   meta: {
     type: "problem",
     docs: {
@@ -1589,7 +1645,7 @@ var noUnsafeDictionaryTypeRule = defineRule14({
 });
 
 // vendor/anti-slop/src/rules/no-widen-then-assert.ts
-import { defineRule as defineRule15 } from "@oxlint/plugins";
+import { defineRule as defineRule16 } from "@oxlint/plugins";
 var functionBoundaryTypes = new Set([
   "ArrowFunctionExpression",
   "FunctionDeclaration",
@@ -1785,7 +1841,7 @@ function assertionIsNarrower(sourceText, broadKind, evidence, assertedType) {
     return isDefinitelyObjectType(assertedType);
   return isDefinitelyNarrowerRecordType(assertedType);
 }
-var noWidenThenAssertRule = defineRule15({
+var noWidenThenAssertRule = defineRule16({
   meta: {
     type: "problem",
     docs: {
@@ -1825,7 +1881,7 @@ var noWidenThenAssertRule = defineRule15({
 });
 
 // vendor/anti-slop/src/rules/require-safety-comment-for-type-assertion.ts
-import { defineRule as defineRule16 } from "@oxlint/plugins";
+import { defineRule as defineRule17 } from "@oxlint/plugins";
 var DEFAULT_SAFETY_MARKERS = ["SAFETY"];
 var commentOwnerKinds = new Set([
   "ExpressionStatement",
@@ -1868,7 +1924,7 @@ function hasSafetyComment(sourceCode, node, pattern) {
     current = current.parent;
   }
 }
-var requireSafetyCommentForTypeAssertionRule = defineRule16({
+var requireSafetyCommentForTypeAssertionRule = defineRule17({
   meta: {
     type: "problem",
     docs: {
@@ -1918,7 +1974,7 @@ var requireSafetyCommentForTypeAssertionRule = defineRule16({
 });
 
 // vendor/anti-slop/src/index.ts
-var antiSlopPlugin = eslintCompatPlugin2({
+var antiSlopPlugin = eslintCompatPlugin3({
   meta: { name: "anti-slop" },
   rules: {
     "no-chained-type-assertions": noChainedTypeAssertionsRule,
@@ -1939,70 +1995,120 @@ var antiSlopPlugin = eslintCompatPlugin2({
   }
 });
 var src_default = antiSlopPlugin;
-// vendor/anti-slop/src/effect/index.ts
-import { eslintCompatPlugin as eslintCompatPlugin3 } from "@oxlint/plugins";
+// src/generic/index.ts
+import { eslintCompatPlugin as eslintCompatPlugin4 } from "@oxlint/plugins";
 
-// vendor/anti-slop/src/effect/rules/no-service-constructor-imports.ts
-import { defineRule as defineRule17 } from "@oxlint/plugins";
-var SERVICE_CONSTRUCTOR_NAME = /^make[A-Z]/u;
-var TEST_FILE = /\.(?:test|spec)\.[cm]?[jt]sx?$/u;
-function isProjectLocalImport(source) {
-  return source.startsWith("./") || source.startsWith("../");
+// src/generic/rules/prefer-event-parameter-type.ts
+import { defineRule as defineRule18 } from "@oxlint/plugins";
+function nearestEnclosingFunction2(node) {
+  let current = node.parent;
+  while (current) {
+    if (current.type === "FunctionDeclaration" || current.type === "FunctionExpression" || current.type === "ArrowFunctionExpression") {
+      return current;
+    }
+    current = current.parent;
+  }
+  return null;
 }
-function getImportedName(specifier) {
-  if (specifier.imported.type === "Identifier")
-    return specifier.imported.name;
-  return specifier.imported.value;
+function assertedEventParameter(node) {
+  const expression = node.expression;
+  if (expression.type !== "MemberExpression" || expression.computed || expression.object.type !== "Identifier" || expression.property.type !== "Identifier" || expression.property.name !== "currentTarget" && expression.property.name !== "target") {
+    return null;
+  }
+  const parameterName = expression.object.name;
+  const property = expression.property.name;
+  const owner = nearestEnclosingFunction2(node);
+  if (!owner?.params.some((parameter) => parameter.type === "Identifier" && parameter.name === parameterName)) {
+    return null;
+  }
+  return {
+    parameter: parameterName,
+    property
+  };
 }
-var noServiceConstructorImportsRule = defineRule17({
+var preferEventParameterTypeRule = defineRule18({
   meta: {
-    type: "problem",
+    type: "suggestion",
     docs: {
-      description: "Disallow project-local make<CapabilityName> imports outside test and spec files."
+      description: "Prefer typing event target properties in the handler parameter instead of asserting them at use sites."
     },
     messages: {
-      serviceConstructorImport: 'Do not import Effect service constructor "{{name}}" into runtime code. Import the owning Layer, yield the contextual service, and allow its requirements to propagate to the composition root.'
+      typeEventParameter: "Type `{{parameter}}.{{property}}` in the function signature instead of asserting it at the use site."
     }
   },
   create(context) {
-    const isTestFile = TEST_FILE.test(context.filename.replaceAll("\\", "/"));
+    const checkAssertion = (node) => {
+      const eventParameter = assertedEventParameter(node);
+      if (!eventParameter)
+        return;
+      context.report({
+        node,
+        messageId: "typeEventParameter",
+        data: eventParameter
+      });
+    };
     return {
-      ImportDeclaration(node) {
-        if (isTestFile || !isProjectLocalImport(node.source.value))
-          return;
-        for (const specifier of node.specifiers) {
-          if (specifier.type !== "ImportSpecifier")
-            continue;
-          const importedName2 = getImportedName(specifier);
-          if (!SERVICE_CONSTRUCTOR_NAME.test(importedName2))
-            continue;
-          context.report({
-            node: specifier,
-            messageId: "serviceConstructorImport",
-            data: { name: importedName2 }
-          });
-        }
-      }
+      TSAsExpression: checkAssertion,
+      TSTypeAssertion: checkAssertion
     };
   }
 });
 
-// vendor/anti-slop/src/effect/index.ts
-var antiSlopEffectPlugin = eslintCompatPlugin3({
-  meta: { name: "anti-slop-effect" },
+// src/generic/index.ts
+var timmoPlugin = eslintCompatPlugin4({
+  meta: { name: "timmo" },
   rules: {
-    "no-service-constructor-imports": noServiceConstructorImportsRule
+    "prefer-event-parameter-type": preferEventParameterTypeRule
   }
 });
-var effect_default2 = antiSlopEffectPlugin;
-// src/cli.ts
-import { resolve as resolve2 } from "node:path";
+var generic_default = timmoPlugin;
+
+// node_modules/oxlint/dist/index.js
+function defineConfig(config) {
+  return config;
+}
 
 // src/configs/enable-plugin-rules.ts
 function enablePluginRules(namespace, plugin) {
   return Object.fromEntries(Object.keys(plugin.rules).sort().map((rule) => [`${namespace}/${rule}`, "error"]));
 }
 
+// src/configs/recommended.ts
+var recommended = defineConfig({
+  jsPlugins: [
+    {
+      name: "anti-slop",
+      specifier: "@timmo001/oxlint-rules/upstream/anti-slop"
+    },
+    { name: "timmo", specifier: "@timmo001/oxlint-rules/generic" }
+  ],
+  rules: {
+    ...enablePluginRules("anti-slop", src_default),
+    ...enablePluginRules("timmo", generic_default)
+  }
+});
+var recommended_default = recommended;
+
+// src/configs/effect.ts
+var effect = defineConfig({
+  extends: [recommended_default],
+  jsPlugins: [
+    {
+      name: "anti-slop-effect",
+      specifier: "@timmo001/oxlint-rules/upstream/effect"
+    },
+    { name: "timmo-effect", specifier: "@timmo001/oxlint-rules/effect" }
+  ],
+  rules: {
+    ...enablePluginRules("anti-slop-effect", effect_default2),
+    ...enablePluginRules("timmo-effect", effect_default)
+  }
+});
+var effect_default3 = effect;
+
+// src/cli.ts
+import { resolve as resolve2 } from "node:path";
+
 // src/install/copy.ts
 import { cp, mkdir, readdir, rm } from "node:fs/promises";
 import { dirname, join, relative, resolve, sep } from "node:path";
@@ -2039,11 +2145,14 @@ async function copyRules(destination, options = {}) {
   await cp(join(root, "vendor/anti-slop/LICENSE"), join(target, "upstream/effect/LICENSE"));
   await copyTree(join(root, "src/effect"), join(target, "effect"));
   await cp(join(root, "LICENSE"), join(target, "effect/LICENSE"));
+  await copyTree(join(root, "src/generic"), join(target, "generic"));
+  await cp(join(root, "LICENSE"), join(target, "generic/LICENSE"));
   const displayRoot = relative(process.cwd(), target) || ".";
   const entryPoint = (path) => `./${path.split(sep).join("/")}`;
   return {
     antiSlop: entryPoint(join(displayRoot, "upstream/anti-slop/index.ts")),
     antiSlopEffect: entryPoint(join(displayRoot, "upstream/effect/index.ts")),
+    timmo: entryPoint(join(displayRoot, "generic/index.ts")),
     timmoEffect: entryPoint(join(displayRoot, "effect/index.ts"))
   };
 }
@@ -2077,12 +2186,10 @@ if (command === "--help" || command === "-h") {
       console.log("Copied Oxlint plugins:");
       console.log(`  anti-slop: ${entries.antiSlop}`);
       console.log(`  anti-slop-effect: ${entries.antiSlopEffect}`);
+      console.log(`  timmo: ${entries.timmo}`);
       console.log(`  timmo-effect: ${entries.timmoEffect}`);
-      printRuleSettings("General rule settings:", enablePluginRules("anti-slop", src_default));
-      printRuleSettings("Effect rule settings (opt-in):", {
-        ...enablePluginRules("anti-slop-effect", effect_default2),
-        ...enablePluginRules("timmo-effect", effect_default)
-      });
+      printRuleSettings("General rule settings:", recommended_default.rules ?? {});
+      printRuleSettings("Effect rule settings (opt-in):", effect_default3.rules ?? {});
     } catch (error) {
       console.error(error instanceof Error ? error.message : String(error));
       process.exitCode = 1;