@timmo001/oxlint-rules 0.3.6 → 0.4.0

package/README.md

@@ -74,12 +74,20 @@ replace an existing destination unless `--force` is passed.
 ### `anti-slop` and `anti-slop-effect`
 
 See the upstream [rule documentation](https://github.com/dmmulroy/anti-slop#rules).
+The recommended configs disable
+`anti-slop/require-safety-comment-for-type-assertion` in favour of
+`timmo/prefer-types-over-assertions`. The upstream rule remains available for
+explicit use.
 
 ### `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.
+- `prefer-types-over-assertions`: reports non-`const` TypeScript assertions,
+  even when preceded by a `SAFETY:` comment. Type values where they enter the
+  code, for example in function parameters or a checked DOM lookup helper that
+  returns `null` when the element is missing or has the wrong type.
 
 ### `timmo-effect`
 
@@ -104,8 +112,9 @@ bunx jsr@0.14.3 publish --dry-run --allow-dirty
 
 `bun run lint` builds the local plugins before linting all maintained code,
 including tests, tooling, the root config and packaged skill scripts. The root
-config extends the local `recommended-effect` source config, enabling every
-registered rule in `anti-slop`, `timmo`, `anti-slop-effect` and `timmo-effect`.
+config extends the local `recommended-effect` source config, enabling registered
+rules in `anti-slop`, `timmo`, `anti-slop-effect` and `timmo-effect` except for
+the upstream safety-comment requirement described above.
 Plugin imports resolve through this package's exports to the fresh `dist` build.
 
 Lint disables nested configs so the vendored submodule's config cannot override

package/dist/cli.js

@@ -2604,11 +2604,38 @@ var preferEventParameterTypeRule = defineRule18({
   }
 });
 
+// src/generic/rules/prefer-types-over-assertions.ts
+import { defineRule as defineRule19 } from "@oxlint/plugins";
+var preferTypesOverAssertionsRule = defineRule19({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Prefer typing a value at its source over a TypeScript type assertion."
+    },
+    messages: {
+      avoidAssertion: "Type this value at its source, such as a function parameter or DOM lookup, instead of asserting it here. A SAFETY comment is not a fix."
+    }
+  },
+  create(context) {
+    const checkAssertion = (node) => {
+      if (node.typeAnnotation.type === "TSTypeReference" && node.typeAnnotation.typeName.type === "Identifier" && node.typeAnnotation.typeName.name === "const") {
+        return;
+      }
+      context.report({ node, messageId: "avoidAssertion" });
+    };
+    return {
+      TSAsExpression: checkAssertion,
+      TSTypeAssertion: checkAssertion
+    };
+  }
+});
+
 // src/generic/index.ts
 var timmoPlugin = eslintCompatPlugin2({
   meta: { name: "timmo" },
   rules: {
-    "prefer-event-parameter-type": preferEventParameterTypeRule
+    "prefer-event-parameter-type": preferEventParameterTypeRule,
+    "prefer-types-over-assertions": preferTypesOverAssertionsRule
   }
 });
 var generic_default = timmoPlugin;
@@ -2629,7 +2656,8 @@ var recommended = defineConfig({
   ],
   rules: {
     ...enablePluginRules("anti-slop", src_default),
-    ...enablePluginRules("timmo", generic_default)
+    ...enablePluginRules("timmo", generic_default),
+    "anti-slop/require-safety-comment-for-type-assertion": "off"
   }
 });
 var recommended_default = recommended;
@@ -2638,7 +2666,7 @@ var recommended_default = recommended;
 import { eslintCompatPlugin as eslintCompatPlugin3 } from "@oxlint/plugins";
 
 // src/effect/rules/no-try-catch-in-effect-generators.ts
-import { defineRule as defineRule19 } from "@oxlint/plugins";
+import { defineRule as defineRule20 } from "@oxlint/plugins";
 function resolveVariable2(sourceCode, identifier) {
   let scope = sourceCode.getScope(identifier);
   while (scope) {
@@ -2704,7 +2732,7 @@ function isRecognisedEffectGenerator(sourceCode, owner) {
   const factoryCall = parent.callee;
   return factoryCall.type === "CallExpression" && isEffectMethod(sourceCode, factoryCall.callee, "fn");
 }
-var noTryCatchInEffectGeneratorsRule = defineRule19({
+var noTryCatchInEffectGeneratorsRule = defineRule20({
   meta: {
     type: "problem",
     docs: {
@@ -2742,7 +2770,7 @@ var effect_default = timmoEffectPlugin;
 import { eslintCompatPlugin as eslintCompatPlugin4 } from "@oxlint/plugins";
 
 // vendor/anti-slop/src/effect/rules/no-manual-effect-error-tag.ts
-import { defineRule as defineRule20 } from "@oxlint/plugins";
+import { defineRule as defineRule21 } from "@oxlint/plugins";
 
 // vendor/anti-slop/src/effect/shared/tagged-values.ts
 var equalityOperators = new Set(["==", "===", "!=", "!=="]);
@@ -2789,7 +2817,7 @@ var isMatchPatternObject = (node) => {
 };
 
 // vendor/anti-slop/src/effect/rules/no-manual-effect-error-tag.ts
-var noManualEffectErrorTagRule = defineRule20({
+var noManualEffectErrorTagRule = defineRule21({
   meta: {
     type: "problem",
     docs: {
@@ -2826,8 +2854,8 @@ var noManualEffectErrorTagRule = defineRule20({
 });
 
 // vendor/anti-slop/src/effect/rules/no-manual-tag-comparison.ts
-import { defineRule as defineRule21 } from "@oxlint/plugins";
-var noManualTagComparisonRule = defineRule21({
+import { defineRule as defineRule22 } from "@oxlint/plugins";
+var noManualTagComparisonRule = defineRule22({
   meta: {
     type: "problem",
     docs: {
@@ -2857,8 +2885,8 @@ var noManualTagComparisonRule = defineRule21({
 });
 
 // vendor/anti-slop/src/effect/rules/no-manual-tagged-construction.ts
-import { defineRule as defineRule22 } from "@oxlint/plugins";
-var noManualTaggedConstructionRule = defineRule22({
+import { defineRule as defineRule23 } from "@oxlint/plugins";
+var noManualTaggedConstructionRule = defineRule23({
   meta: {
     type: "problem",
     docs: {
@@ -2883,7 +2911,7 @@ var noManualTaggedConstructionRule = defineRule22({
 });
 
 // vendor/anti-slop/src/effect/rules/no-service-constructor-imports.ts
-import { defineRule as defineRule23 } from "@oxlint/plugins";
+import { defineRule as defineRule24 } from "@oxlint/plugins";
 var SERVICE_CONSTRUCTOR_NAME = /^make[A-Z]/u;
 var TEST_FILE = /\.(?:test|spec)\.[cm]?[jt]sx?$/u;
 function isProjectLocalImport(source) {
@@ -2894,7 +2922,7 @@ function getImportedName(specifier) {
     return specifier.imported.name;
   return specifier.imported.value;
 }
-var noServiceConstructorImportsRule = defineRule23({
+var noServiceConstructorImportsRule = defineRule24({
   meta: {
     type: "problem",
     docs: {
@@ -2928,9 +2956,9 @@ var noServiceConstructorImportsRule = defineRule23({
 });
 
 // vendor/anti-slop/src/effect/rules/prefer-effect-match.ts
-import { defineRule as defineRule24 } from "@oxlint/plugins";
+import { defineRule as defineRule25 } from "@oxlint/plugins";
 var equalityOperators2 = new Set(["==", "===", "!=", "!=="]);
-var preferEffectMatchRule = defineRule24({
+var preferEffectMatchRule = defineRule25({
   meta: {
     type: "problem",
     docs: {

package/dist/configs/recommended-effect.js

@@ -2957,11 +2957,38 @@ var preferEventParameterTypeRule = defineRule24({
   }
 });
 
+// src/generic/rules/prefer-types-over-assertions.ts
+import { defineRule as defineRule25 } from "@oxlint/plugins";
+var preferTypesOverAssertionsRule = defineRule25({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Prefer typing a value at its source over a TypeScript type assertion."
+    },
+    messages: {
+      avoidAssertion: "Type this value at its source, such as a function parameter or DOM lookup, instead of asserting it here. A SAFETY comment is not a fix."
+    }
+  },
+  create(context) {
+    const checkAssertion = (node) => {
+      if (node.typeAnnotation.type === "TSTypeReference" && node.typeAnnotation.typeName.type === "Identifier" && node.typeAnnotation.typeName.name === "const") {
+        return;
+      }
+      context.report({ node, messageId: "avoidAssertion" });
+    };
+    return {
+      TSAsExpression: checkAssertion,
+      TSTypeAssertion: checkAssertion
+    };
+  }
+});
+
 // src/generic/index.ts
 var timmoPlugin = eslintCompatPlugin4({
   meta: { name: "timmo" },
   rules: {
-    "prefer-event-parameter-type": preferEventParameterTypeRule
+    "prefer-event-parameter-type": preferEventParameterTypeRule,
+    "prefer-types-over-assertions": preferTypesOverAssertionsRule
   }
 });
 var generic_default = timmoPlugin;
@@ -2977,7 +3004,8 @@ var recommended = defineConfig({
   ],
   rules: {
     ...enablePluginRules("anti-slop", src_default),
-    ...enablePluginRules("timmo", generic_default)
+    ...enablePluginRules("timmo", generic_default),
+    "anti-slop/require-safety-comment-for-type-assertion": "off"
   }
 });
 var recommended_default = recommended;

package/dist/configs/recommended.js

@@ -2599,11 +2599,38 @@ var preferEventParameterTypeRule = defineRule18({
   }
 });
 
+// src/generic/rules/prefer-types-over-assertions.ts
+import { defineRule as defineRule19 } from "@oxlint/plugins";
+var preferTypesOverAssertionsRule = defineRule19({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Prefer typing a value at its source over a TypeScript type assertion."
+    },
+    messages: {
+      avoidAssertion: "Type this value at its source, such as a function parameter or DOM lookup, instead of asserting it here. A SAFETY comment is not a fix."
+    }
+  },
+  create(context) {
+    const checkAssertion = (node) => {
+      if (node.typeAnnotation.type === "TSTypeReference" && node.typeAnnotation.typeName.type === "Identifier" && node.typeAnnotation.typeName.name === "const") {
+        return;
+      }
+      context.report({ node, messageId: "avoidAssertion" });
+    };
+    return {
+      TSAsExpression: checkAssertion,
+      TSTypeAssertion: checkAssertion
+    };
+  }
+});
+
 // src/generic/index.ts
 var timmoPlugin = eslintCompatPlugin2({
   meta: { name: "timmo" },
   rules: {
-    "prefer-event-parameter-type": preferEventParameterTypeRule
+    "prefer-event-parameter-type": preferEventParameterTypeRule,
+    "prefer-types-over-assertions": preferTypesOverAssertionsRule
   }
 });
 var generic_default = timmoPlugin;
@@ -2624,7 +2651,8 @@ var recommended = defineConfig({
   ],
   rules: {
     ...enablePluginRules("anti-slop", src_default),
-    ...enablePluginRules("timmo", generic_default)
+    ...enablePluginRules("timmo", generic_default),
+    "anti-slop/require-safety-comment-for-type-assertion": "off"
   }
 });
 var recommended_default = recommended;

package/dist/generic/index.js

@@ -57,11 +57,38 @@ var preferEventParameterTypeRule = defineRule({
   }
 });
 
+// src/generic/rules/prefer-types-over-assertions.ts
+import { defineRule as defineRule2 } from "@oxlint/plugins";
+var preferTypesOverAssertionsRule = defineRule2({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Prefer typing a value at its source over a TypeScript type assertion."
+    },
+    messages: {
+      avoidAssertion: "Type this value at its source, such as a function parameter or DOM lookup, instead of asserting it here. A SAFETY comment is not a fix."
+    }
+  },
+  create(context) {
+    const checkAssertion = (node) => {
+      if (node.typeAnnotation.type === "TSTypeReference" && node.typeAnnotation.typeName.type === "Identifier" && node.typeAnnotation.typeName.name === "const") {
+        return;
+      }
+      context.report({ node, messageId: "avoidAssertion" });
+    };
+    return {
+      TSAsExpression: checkAssertion,
+      TSTypeAssertion: checkAssertion
+    };
+  }
+});
+
 // src/generic/index.ts
 var timmoPlugin = eslintCompatPlugin({
   meta: { name: "timmo" },
   rules: {
-    "prefer-event-parameter-type": preferEventParameterTypeRule
+    "prefer-event-parameter-type": preferEventParameterTypeRule,
+    "prefer-types-over-assertions": preferTypesOverAssertionsRule
   }
 });
 var generic_default = timmoPlugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timmo001/oxlint-rules",
-  "version": "0.3.6",
+  "version": "0.4.0",
   "description": "Shared Oxlint plugins and configs with optional Effect rules.",
   "type": "module",
   "license": "Apache-2.0",
@@ -46,14 +46,14 @@
     "typecheck": "tsc --noEmit"
   },
   "peerDependencies": {
-    "@oxlint/plugins": "1.85.0",
-    "oxlint": "1.85.0"
+    "@oxlint/plugins": "1.86.0",
+    "oxlint": "1.86.0"
   },
   "devDependencies": {
-    "@oxlint/plugins": "1.85.0",
+    "@oxlint/plugins": "1.86.0",
     "@types/bun": "^1.3.14",
-    "oxlint": "1.85.0",
-    "oxlint-tsgolint": "7.0.2002",
+    "oxlint": "1.86.0",
+    "oxlint-tsgolint": "7.0.2003",
     "prettier": "^3.9.5",
     "skills-ref": "0.1.5",
     "typescript": "^7.0.0"

package/src/generic/index.ts

@@ -1,11 +1,13 @@
 import { eslintCompatPlugin } from "@oxlint/plugins";
 
 import { preferEventParameterTypeRule } from "./rules/prefer-event-parameter-type.ts";
+import { preferTypesOverAssertionsRule } from "./rules/prefer-types-over-assertions.ts";
 
 const timmoPlugin = eslintCompatPlugin({
   meta: { name: "timmo" },
   rules: {
     "prefer-event-parameter-type": preferEventParameterTypeRule,
+    "prefer-types-over-assertions": preferTypesOverAssertionsRule,
   },
 });
 

package/src/generic/rules/prefer-types-over-assertions.ts

@@ -0,0 +1,38 @@
+import { defineRule } from "@oxlint/plugins";
+
+import type { ESTree } from "@oxlint/plugins";
+
+type TypeAssertion = ESTree.TSAsExpression | ESTree.TSTypeAssertion;
+
+/** Prefer typing values at their source over asserting them at use sites. */
+export const preferTypesOverAssertionsRule = defineRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Prefer typing a value at its source over a TypeScript type assertion.",
+    },
+    messages: {
+      avoidAssertion:
+        "Type this value at its source, such as a function parameter or DOM lookup, instead of asserting it here. A SAFETY comment is not a fix.",
+    },
+  },
+  create(context) {
+    const checkAssertion = (node: TypeAssertion) => {
+      if (
+        node.typeAnnotation.type === "TSTypeReference" &&
+        node.typeAnnotation.typeName.type === "Identifier" &&
+        node.typeAnnotation.typeName.name === "const"
+      ) {
+        return;
+      }
+
+      context.report({ node, messageId: "avoidAssertion" });
+    };
+
+    return {
+      TSAsExpression: checkAssertion,
+      TSTypeAssertion: checkAssertion,
+    };
+  },
+});