uilint-eslint 0.2.101 → 0.2.103

package/dist/index.d.ts

@@ -805,6 +805,16 @@ declare const rules: {
     } | undefined)?], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
         name: string;
     };
+    "no-unsafe-type-casts": _typescript_eslint_utils_ts_eslint.RuleModule<"noAsAny" | "noAsUnknown" | "noDoubleCast" | "noLegacyAsAny" | "noLegacyAsUnknown", [{
+        reportAsAny?: boolean;
+        reportAsUnknown?: boolean;
+        reportDoubleCast?: boolean;
+        allowInTestFiles?: boolean;
+        allowInCatchBlocks?: boolean;
+        allowedTypes?: string[];
+    }], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
+        name: string;
+    };
 };
 /**
  * Plugin metadata
@@ -948,6 +958,16 @@ declare const plugin: {
         } | undefined)?], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
             name: string;
         };
+        "no-unsafe-type-casts": _typescript_eslint_utils_ts_eslint.RuleModule<"noAsAny" | "noAsUnknown" | "noDoubleCast" | "noLegacyAsAny" | "noLegacyAsUnknown", [{
+            reportAsAny?: boolean;
+            reportAsUnknown?: boolean;
+            reportDoubleCast?: boolean;
+            allowInTestFiles?: boolean;
+            allowInCatchBlocks?: boolean;
+            allowedTypes?: string[];
+        }], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
+            name: string;
+        };
     };
 };
 /**

package/dist/index.js

@@ -3,8 +3,8 @@ import { ESLintUtils } from "@typescript-eslint/utils";
 var createRule = ESLintUtils.RuleCreator(
   (name) => `https://github.com/peter-suggate/uilint/blob/main/packages/uilint-eslint/docs/rules/${name}.md`
 );
-function defineRuleMeta(meta17) {
-  return meta17;
+function defineRuleMeta(meta18) {
+  return meta18;
 }
 
 // src/rules/consistent-dark-mode.ts
@@ -4197,8 +4197,8 @@ function loadIndex(projectRoot, indexPath) {
     log(`Loaded metadata.json: ${Object.keys(entries).length} entries`);
     const metadataStore = /* @__PURE__ */ new Map();
     const fileToChunks = /* @__PURE__ */ new Map();
-    for (const [id, meta17] of Object.entries(entries)) {
-      const m = meta17;
+    for (const [id, meta18] of Object.entries(entries)) {
+      const m = meta18;
       metadataStore.set(id, {
         filePath: m.filePath,
         startLine: m.startLine,
@@ -4302,9 +4302,9 @@ function findSimilarChunks(index, chunkId, threshold) {
   const sortedAll = allScores.sort((a, b) => b.score - a.score).slice(0, 10);
   log(`  Top 10 similarity scores (threshold=${threshold}):`);
   for (const { id, score } of sortedAll) {
-    const meta17 = index.metadataStore.get(id);
+    const meta18 = index.metadataStore.get(id);
     const meetsThreshold = score >= threshold ? "\u2713" : "\u2717";
-    log(`    ${meetsThreshold} ${(score * 100).toFixed(1)}% - ${id} (${meta17?.name || "anonymous"} in ${meta17?.filePath})`);
+    log(`    ${meetsThreshold} ${(score * 100).toFixed(1)}% - ${id} (${meta18?.name || "anonymous"} in ${meta18?.filePath})`);
   }
   log(`  Found ${results.length} chunks above threshold`);
   return results.sort((a, b) => b.score - a.score);
@@ -4395,20 +4395,20 @@ var no_semantic_duplicates_default = createRule({
           log(`  Chunk ${chunkId} already reported, skipping`);
           continue;
         }
-        const meta17 = index.metadataStore.get(chunkId);
-        if (!meta17) {
+        const meta18 = index.metadataStore.get(chunkId);
+        if (!meta18) {
           log(`  No metadata for chunk ${chunkId}`);
           continue;
         }
-        log(`  Checking chunk ${chunkId}: lines ${meta17.startLine}-${meta17.endLine} (node at line ${nodeLine})`);
-        if (nodeLine >= meta17.startLine && nodeLine <= meta17.endLine) {
+        log(`  Checking chunk ${chunkId}: lines ${meta18.startLine}-${meta18.endLine} (node at line ${nodeLine})`);
+        if (nodeLine >= meta18.startLine && nodeLine <= meta18.endLine) {
           log(`  Node is within chunk range, searching for similar chunks...`);
           const similar = findSimilarChunks(index, chunkId, threshold);
           if (similar.length > 0) {
             const best = similar[0];
             const bestMeta = index.metadataStore.get(best.id);
             if (bestMeta) {
-              const chunkLines = meta17.endLine - meta17.startLine + 1;
+              const chunkLines = meta18.endLine - meta18.startLine + 1;
               if (chunkLines < minLines) {
                 log(`  Skipping: chunk has ${chunkLines} lines, below minLines=${minLines}`);
                 continue;
@@ -4418,8 +4418,8 @@ var no_semantic_duplicates_default = createRule({
               const similarity = Math.round(best.score * 100);
               const sourceCode = extractCodeFromFile(
                 filename,
-                meta17.startLine,
-                meta17.endLine
+                meta18.startLine,
+                meta18.endLine
               );
               const targetAbsolutePath = join6(projectRoot, bestMeta.filePath);
               const targetCode = extractCodeFromFile(
@@ -4427,17 +4427,17 @@ var no_semantic_duplicates_default = createRule({
                 bestMeta.startLine,
                 bestMeta.endLine
               );
-              log(`  REPORTING: ${meta17.kind} '${name || meta17.name}' is ${similarity}% similar to '${bestMeta.name}' at ${relPath}:${bestMeta.startLine}`);
+              log(`  REPORTING: ${meta18.kind} '${name || meta18.name}' is ${similarity}% similar to '${bestMeta.name}' at ${relPath}:${bestMeta.startLine}`);
               context.report({
                 node,
                 loc: {
-                  start: { line: meta17.startLine, column: meta17.startColumn },
-                  end: { line: meta17.endLine, column: meta17.endColumn }
+                  start: { line: meta18.startLine, column: meta18.startColumn },
+                  end: { line: meta18.endLine, column: meta18.endColumn }
                 },
                 messageId: "semanticDuplicate",
                 data: {
-                  kind: meta17.kind,
-                  name: name || meta17.name || "(anonymous)",
+                  kind: meta18.kind,
+                  name: name || meta18.name || "(anonymous)",
                   similarity: String(similarity),
                   otherName: bestMeta.name || "(anonymous)",
                   otherLocation: `${relPath}:${bestMeta.startLine}`,
@@ -4446,10 +4446,10 @@ var no_semantic_duplicates_default = createRule({
                   targetCode: targetCode || "",
                   sourceLocation: JSON.stringify({
                     filePath: relativeFilename,
-                    startLine: meta17.startLine,
-                    endLine: meta17.endLine,
-                    startColumn: meta17.startColumn,
-                    endColumn: meta17.endColumn
+                    startLine: meta18.startLine,
+                    endLine: meta18.endLine,
+                    startColumn: meta18.startColumn,
+                    endColumn: meta18.endColumn
                   }),
                   targetLocation: JSON.stringify({
                     filePath: bestMeta.filePath,
@@ -4459,7 +4459,7 @@ var no_semantic_duplicates_default = createRule({
                     startColumn: bestMeta.startColumn,
                     endColumn: bestMeta.endColumn
                   }),
-                  sourceName: name || meta17.name || "(anonymous)",
+                  sourceName: name || meta18.name || "(anonymous)",
                   targetName: bestMeta.name || "(anonymous)",
                   similarityScore: String(best.score)
                 }
@@ -4469,7 +4469,7 @@ var no_semantic_duplicates_default = createRule({
             log(`  No similar chunks found above threshold`);
           }
         } else {
-          log(`  Node line ${nodeLine} not in chunk range ${meta17.startLine}-${meta17.endLine}`);
+          log(`  Node line ${nodeLine} not in chunk range ${meta18.startLine}-${meta18.endLine}`);
         }
       }
     }
@@ -6830,6 +6830,379 @@ var prefer_tailwind_default = createRule({
   }
 });
 
+// src/rules/no-unsafe-type-casts.ts
+var meta16 = defineRuleMeta({
+  id: "no-unsafe-type-casts",
+  version: "1.0.0",
+  name: "No Unsafe Type Casts",
+  description: "Disallow unsafe type casting patterns that bypass TypeScript's type system",
+  defaultSeverity: "error",
+  category: "static",
+  icon: "\u{1F6E1}\uFE0F",
+  hint: "Prevents type system circumvention via casts",
+  defaultEnabled: true,
+  defaultOptions: [
+    {
+      reportAsAny: true,
+      reportAsUnknown: false,
+      reportDoubleCast: true,
+      allowInTestFiles: true,
+      allowInCatchBlocks: true,
+      allowedTypes: []
+    }
+  ],
+  optionSchema: {
+    fields: [
+      {
+        key: "reportAsAny",
+        label: "Report 'as any' casts",
+        type: "boolean",
+        defaultValue: true,
+        description: "Flag expressions like `value as any`"
+      },
+      {
+        key: "reportAsUnknown",
+        label: "Report 'as unknown' casts",
+        type: "boolean",
+        defaultValue: false,
+        description: "Flag expressions like `value as unknown`"
+      },
+      {
+        key: "reportDoubleCast",
+        label: "Report double-cast patterns",
+        type: "boolean",
+        defaultValue: true,
+        description: "Flag expressions like `value as unknown as Type`"
+      },
+      {
+        key: "allowInTestFiles",
+        label: "Allow in test files",
+        type: "boolean",
+        defaultValue: true,
+        description: "Skip reporting in *.test.ts, *.spec.ts, and __tests__/* files"
+      },
+      {
+        key: "allowInCatchBlocks",
+        label: "Allow in catch blocks",
+        type: "boolean",
+        defaultValue: true,
+        description: "Allow type casts inside catch blocks for error handling"
+      },
+      {
+        key: "allowedTypes",
+        label: "Allowed target types",
+        type: "text",
+        defaultValue: "",
+        placeholder: "HTMLElement, Error, Event",
+        description: "Comma-separated list of type names that are allowed as cast targets"
+      }
+    ]
+  },
+  docs: `
+## What it does
+
+Detects and prevents unsafe type casting patterns in TypeScript that bypass
+the type system. These patterns can introduce runtime errors by lying to the
+compiler about types.
+
+### Detected Patterns
+
+| Pattern | Risk | Description |
+|---------|------|-------------|
+| \`x as any\` | High | Completely disables type checking |
+| \`x as unknown as T\` | High | Forces incompatible type conversion |
+| \`x as unknown\` | Medium | Casts to unknown without narrowing |
+| \`<any>x\` | High | Legacy syntax equivalent to \`as any\` |
+
+## Why it's useful
+
+- **Type Safety**: Catches type system circumvention that leads to runtime errors
+- **Code Quality**: Encourages proper type guards and runtime validation
+- **Maintainability**: Makes type assumptions explicit and verifiable
+- **Refactoring**: Prevents hidden type mismatches that break during refactors
+
+## Examples
+
+### \u274C Incorrect
+
+\`\`\`typescript
+// Casting to any - bypasses all type checking
+const data = response.data as any;
+data.nonExistentMethod(); // No error, but crashes at runtime
+
+// Double-cast pattern - forces incompatible types
+const user = jsonData as unknown as User;
+console.log(user.email); // Might be undefined!
+
+// Legacy angle-bracket syntax
+const element = <any>document.getElementById("app");
+\`\`\`
+
+### \u2705 Correct
+
+\`\`\`typescript
+// Use runtime validation (Zod, io-ts, etc.)
+const user = UserSchema.parse(jsonData);
+console.log(user.email); // Type-safe!
+
+// Use type guards
+function isUser(data: unknown): data is User {
+  return typeof data === "object" && data !== null && "email" in data;
+}
+
+if (isUser(jsonData)) {
+  console.log(jsonData.email); // Narrowed to User
+}
+
+// Proper DOM type assertions (allowed by default)
+const input = document.getElementById("email") as HTMLInputElement;
+
+// Safe cast with validation
+const error = err instanceof Error ? err : new Error(String(err));
+\`\`\`
+
+## Configuration
+
+\`\`\`js
+// eslint.config.js
+"uilint/no-unsafe-type-casts": ["error", {
+  reportAsAny: true,           // Flag 'as any' casts
+  reportAsUnknown: false,      // Don't flag 'as unknown' alone
+  reportDoubleCast: true,      // Flag 'as unknown as T' patterns
+  allowInTestFiles: true,      // Allow in test files
+  allowInCatchBlocks: true,    // Allow error handling casts
+  allowedTypes: [              // Types that are safe to cast to
+    "HTMLElement",
+    "HTMLInputElement",
+    "HTMLButtonElement",
+    "Error",
+    "Event"
+  ]
+}]
+\`\`\`
+
+## Allowed Type Exceptions
+
+You can configure specific types that are allowed as cast targets. This is useful for:
+
+- **DOM elements**: \`HTMLElement\`, \`HTMLInputElement\`, etc.
+- **Error handling**: \`Error\`, \`TypeError\`, etc.
+- **Event handling**: \`Event\`, \`MouseEvent\`, \`KeyboardEvent\`, etc.
+- **Third-party types**: Types from libraries that require casting
+
+## When to Disable
+
+Consider disabling this rule when:
+
+- Working with legacy code that requires extensive type casting
+- Integrating with untyped JavaScript libraries
+- Writing type-level tests or type utilities
+
+Use inline comments for specific exceptions:
+
+\`\`\`typescript
+// eslint-disable-next-line uilint/no-unsafe-type-casts
+const data = legacyApiResponse as any;
+\`\`\`
+`
+});
+function isTestFile2(filename) {
+  return filename.includes(".test.") || filename.includes(".spec.") || filename.includes("__tests__") || filename.includes("__mocks__");
+}
+function isInsideCatchBlock(node) {
+  let current = node.parent;
+  while (current) {
+    if (current.type === "CatchClause") {
+      return true;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+function getTypeName(typeAnnotation) {
+  switch (typeAnnotation.type) {
+    case "TSTypeReference":
+      if (typeAnnotation.typeName.type === "Identifier") {
+        return typeAnnotation.typeName.name;
+      }
+      if (typeAnnotation.typeName.type === "TSQualifiedName") {
+        return `${getQualifiedName(typeAnnotation.typeName)}`;
+      }
+      return null;
+    case "TSAnyKeyword":
+      return "any";
+    case "TSUnknownKeyword":
+      return "unknown";
+    default:
+      return null;
+  }
+}
+function getQualifiedName(node) {
+  const left = node.left.type === "Identifier" ? node.left.name : getQualifiedName(node.left);
+  return `${left}.${node.right.name}`;
+}
+function isAllowedType(typeAnnotation, allowedTypes) {
+  const typeName = getTypeName(typeAnnotation);
+  if (!typeName) return false;
+  return allowedTypes.includes(typeName);
+}
+function isDoubleCastPattern(node) {
+  if (node.expression.type !== "TSAsExpression") {
+    return false;
+  }
+  const innerCast = node.expression;
+  const innerType = innerCast.typeAnnotation;
+  return innerType.type === "TSUnknownKeyword" || innerType.type === "TSAnyKeyword";
+}
+function isLegacyDoubleCastPattern(node) {
+  if (node.expression.type !== "TSTypeAssertion") {
+    return false;
+  }
+  const innerCast = node.expression;
+  const innerType = innerCast.typeAnnotation;
+  return innerType.type === "TSUnknownKeyword" || innerType.type === "TSAnyKeyword";
+}
+var no_unsafe_type_casts_default = createRule({
+  name: "no-unsafe-type-casts",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow unsafe type casting patterns that bypass TypeScript's type system"
+    },
+    messages: {
+      noAsAny: "Avoid using 'as any'. This completely bypasses type checking. Use proper typing, type guards, or runtime validation instead.",
+      noAsUnknown: "Casting to 'unknown' without subsequent type narrowing bypasses type safety. Use type guards or validation.",
+      noDoubleCast: "Double-cast pattern ('as unknown as {{targetType}}') bypasses type checking. Use runtime validation or type guards instead.",
+      noLegacyAsAny: "Avoid using '<any>' type assertion. This completely bypasses type checking. Use proper typing or type guards instead.",
+      noLegacyAsUnknown: "Casting to '<unknown>' without subsequent type narrowing bypasses type safety. Use type guards or validation."
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          reportAsAny: {
+            type: "boolean",
+            description: "Report 'as any' casts"
+          },
+          reportAsUnknown: {
+            type: "boolean",
+            description: "Report 'as unknown' casts"
+          },
+          reportDoubleCast: {
+            type: "boolean",
+            description: "Report double-cast patterns like 'as unknown as T'"
+          },
+          allowInTestFiles: {
+            type: "boolean",
+            description: "Allow casts in test files"
+          },
+          allowInCatchBlocks: {
+            type: "boolean",
+            description: "Allow casts in catch blocks for error handling"
+          },
+          allowedTypes: {
+            type: "array",
+            items: { type: "string" },
+            description: "Type names that are allowed as cast targets"
+          }
+        },
+        additionalProperties: false
+      }
+    ]
+  },
+  defaultOptions: [
+    {
+      reportAsAny: true,
+      reportAsUnknown: false,
+      reportDoubleCast: true,
+      allowInTestFiles: true,
+      allowInCatchBlocks: true,
+      allowedTypes: []
+    }
+  ],
+  create(context) {
+    const options = context.options[0] || {};
+    const reportAsAny = options.reportAsAny ?? true;
+    const reportAsUnknown = options.reportAsUnknown ?? false;
+    const reportDoubleCast = options.reportDoubleCast ?? true;
+    const allowInTestFiles = options.allowInTestFiles ?? true;
+    const allowInCatchBlocks = options.allowInCatchBlocks ?? true;
+    const allowedTypes = options.allowedTypes ?? [];
+    const filename = context.filename || context.getFilename();
+    if (allowInTestFiles && isTestFile2(filename)) {
+      return {};
+    }
+    function checkAsExpression(node) {
+      const targetType = node.typeAnnotation;
+      if (allowInCatchBlocks && isInsideCatchBlock(node)) {
+        return;
+      }
+      if (reportDoubleCast && isDoubleCastPattern(node)) {
+        const targetTypeName = getTypeName(targetType) || "Type";
+        context.report({
+          node,
+          messageId: "noDoubleCast",
+          data: { targetType: targetTypeName }
+        });
+        return;
+      }
+      if (isAllowedType(targetType, allowedTypes)) {
+        return;
+      }
+      if (reportAsAny && targetType.type === "TSAnyKeyword") {
+        context.report({
+          node,
+          messageId: "noAsAny"
+        });
+        return;
+      }
+      if (reportAsUnknown && targetType.type === "TSUnknownKeyword") {
+        context.report({
+          node,
+          messageId: "noAsUnknown"
+        });
+        return;
+      }
+    }
+    function checkTypeAssertion(node) {
+      const targetType = node.typeAnnotation;
+      if (allowInCatchBlocks && isInsideCatchBlock(node)) {
+        return;
+      }
+      if (reportDoubleCast && isLegacyDoubleCastPattern(node)) {
+        const targetTypeName = getTypeName(targetType) || "Type";
+        context.report({
+          node,
+          messageId: "noDoubleCast",
+          data: { targetType: targetTypeName }
+        });
+        return;
+      }
+      if (isAllowedType(targetType, allowedTypes)) {
+        return;
+      }
+      if (reportAsAny && targetType.type === "TSAnyKeyword") {
+        context.report({
+          node,
+          messageId: "noLegacyAsAny"
+        });
+        return;
+      }
+      if (reportAsUnknown && targetType.type === "TSUnknownKeyword") {
+        context.report({
+          node,
+          messageId: "noLegacyAsUnknown"
+        });
+        return;
+      }
+    }
+    return {
+      TSAsExpression: checkAsExpression,
+      TSTypeAssertion: checkTypeAssertion
+    };
+  }
+});
+
 // src/category-registry.ts
 var categoryRegistry = [
   {
@@ -6873,7 +7246,9 @@ var ruleRegistry = [
   // Test coverage enforcement
   meta14,
   // Style preferences
-  meta15
+  meta15,
+  // Type safety
+  meta16
 ];
 function getRuleMetadata(id) {
   return ruleRegistry.find((rule) => rule.id === id);
@@ -6906,15 +7281,16 @@ var rules = {
   "require-input-validation": require_input_validation_default,
   "no-semantic-duplicates": no_semantic_duplicates_default,
   "require-test-coverage": require_test_coverage_default,
-  "prefer-tailwind": prefer_tailwind_default
+  "prefer-tailwind": prefer_tailwind_default,
+  "no-unsafe-type-casts": no_unsafe_type_casts_default
 };
 var version = "0.1.0";
-var meta16 = {
+var meta17 = {
   name: "uilint",
   version
 };
 var plugin = {
-  meta: meta16,
+  meta: meta17,
   rules
 };
 var jsxLanguageOptions = {
@@ -7049,6 +7425,16 @@ var recommendedConfig = {
         "preferSemanticColors": true,
         "allowedHardCodedColors": []
       }
+    ]],
+    "uilint/no-unsafe-type-casts": ["error", ...[
+      {
+        "reportAsAny": true,
+        "reportAsUnknown": false,
+        "reportDoubleCast": true,
+        "allowInTestFiles": true,
+        "allowInCatchBlocks": true,
+        "allowedTypes": []
+      }
     ]]
   }
 };
@@ -7196,6 +7582,16 @@ var strictConfig = {
         "preferSemanticColors": true,
         "allowedHardCodedColors": []
       }
+    ]],
+    "uilint/no-unsafe-type-casts": ["error", ...[
+      {
+        "reportAsAny": true,
+        "reportAsUnknown": false,
+        "reportDoubleCast": true,
+        "allowInTestFiles": true,
+        "allowInCatchBlocks": true,
+        "allowedTypes": []
+      }
     ]]
   }
 };
@@ -7204,7 +7600,7 @@ var configs = {
   strict: strictConfig
 };
 var uilintEslint = {
-  meta: meta16,
+  meta: meta17,
   plugin,
   rules,
   configs
@@ -7242,7 +7638,7 @@ export {
   isEventHandlerAttribute,
   loadCache,
   loadStyleguide,
-  meta16 as meta,
+  meta17 as meta,
   plugin,
   ruleRegistry,
   rules,