@trackunit/eslint-plugin-trackunit 0.6.50 → 0.6.52

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 0.6.52 (2026-07-01)
+
+### 🧱 Updated Dependencies
+
+- Updated shared-utils to 1.15.52
+
+## 0.6.51 (2026-07-01)
+
+### 🧱 Updated Dependencies
+
+- Updated shared-utils to 1.15.51
+
 ## 0.6.50 (2026-06-30)
 
 ### 🧱 Updated Dependencies

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trackunit/eslint-plugin-trackunit",
-  "version": "0.6.50",
+  "version": "0.6.52",
   "license": "SEE LICENSE IN LICENSE.txt",
   "repository": "https://github.com/Trackunit/manager",
   "engines": {

package/src/lib/config/fragments/typescript-rules.js

@@ -8,7 +8,7 @@ exports.typescriptRules = {
     "@typescript-eslint/no-unnecessary-condition": "error",
     "no-unused-vars": "off",
     "@typescript-eslint/no-unused-vars": [
-        "warn",
+        "error",
         {
             args: "all",
             argsIgnorePattern: "^_",

package/src/lib/rules/prefer-event-specific-callback-naming/utils.d.ts

@@ -4,19 +4,6 @@
  * used by both string-based and type-based detection strategies.
  */
 import { TSESLint, TSESTree } from "@typescript-eslint/utils";
-/**
- * Result of extracting callback information from an expression.
- * Does not include messageId - each strategy adds its own.
- */
-export type CallbackExtractionResult = {
-    callbackName: string;
-    suggestedName: string;
-    node: TSESTree.Node;
-    /** The identifier node for the callback - used for fix ranges */
-    identifierNode: TSESTree.Identifier;
-    /** Whether the callback is wrapped in an arrow function */
-    isWrapped: boolean;
-} | null;
 /**
  * Information about a locally defined variable, including its definition
  * and all references within the same file.
@@ -40,8 +27,7 @@ export type LocalDefinitionInfo = {
 export declare const findLocalDefinitionInfo: (identifier: TSESTree.Identifier, context: TSESLint.RuleContext<string, ReadonlyArray<unknown>>) => LocalDefinitionInfo | null;
 /**
  * Result of extracting a callback identifier from an expression.
- * Unlike CallbackExtractionResult, this doesn't include suggested names
- * since those depend on the specific event handler being used.
+ * Does not include suggested names since those depend on the specific event handler being used.
  */
 export type CallbackIdentifierResult = {
     callbackName: string;

package/src/lib/rules/prefer-event-specific-callback-naming/utils.js

@@ -105,87 +105,6 @@ const findLocalDefinitionInfo = (identifier, context) => {
     };
 };
 exports.findLocalDefinitionInfo = findLocalDefinitionInfo;
-/**
- * Checks if a callback name is problematic when used with click handlers.
- * A name is problematic if it starts with "on" but not "onClick".
- *
- * @example
- * isProblematicName("onClose") // true - should be onClickClose
- * isProblematicName("onClickClose") // false - already correct
- * isProblematicName("handleClose") // false - different convention
- * isProblematicName("close") // false - doesn't start with "on"
- */
-const isProblematicName = (name) => {
-    return name.startsWith("on") && !name.startsWith("onClick");
-};
-/**
- * Converts a problematic callback name to the suggested onClick* format.
- *
- * @example
- * getSuggestedName("onClose") // "onClickClose"
- * getSuggestedName("onCancel") // "onClickCancel"
- */
-const getSuggestedName = (name) => {
-    // Remove "on" prefix and add "onClick" prefix
-    return `onClick${name.slice(2)}`;
-};
-/**
- * Extracts callback info from a direct identifier pattern: onClick={onClose}
- */
-const extractFromDirectIdentifier = (expression) => {
-    if (expression.type !== utils_1.AST_NODE_TYPES.Identifier) {
-        return null;
-    }
-    const callbackName = expression.name;
-    if (!isProblematicName(callbackName)) {
-        return null;
-    }
-    return {
-        callbackName,
-        suggestedName: getSuggestedName(callbackName),
-        node: expression,
-        identifierNode: expression,
-        isWrapped: false,
-    };
-};
-/**
- * Extracts callback info from a single-call arrow function: onClick={() => onClose()}
- */
-const extractFromSingleCallArrow = (expression) => {
-    if (expression.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
-        return null;
-    }
-    const { body } = expression;
-    // Only check if body is a single call expression (not a block statement)
-    if (body.type !== utils_1.AST_NODE_TYPES.CallExpression) {
-        return null;
-    }
-    // Only check if the callee is a simple identifier
-    if (body.callee.type !== utils_1.AST_NODE_TYPES.Identifier) {
-        return null;
-    }
-    const callbackName = body.callee.name;
-    if (!isProblematicName(callbackName)) {
-        return null;
-    }
-    return {
-        callbackName,
-        suggestedName: getSuggestedName(callbackName),
-        node: body.callee,
-        identifierNode: body.callee,
-        isWrapped: true,
-    };
-};
-/**
- * Extracts callback information from an expression.
- * Handles both direct identifiers (onClick={onClose}) and
- * single-call arrow functions (onClick={() => onClose()}).
- *
- * @returns Callback extraction result without messageId, or null if no problematic callback found
- */
-const extractCallbackInfo = (expression) => {
-    return extractFromDirectIdentifier(expression) ?? extractFromSingleCallArrow(expression);
-};
 /**
  * Extracts the callback identifier from an expression without checking naming patterns.
  * Used by strict prop events check which has its own naming criteria.

package/src/lib/utils/ast-utils.js

@@ -12,7 +12,6 @@ const utils_1 = require("@typescript-eslint/utils");
  * - `isParameterExplicitlyDestructured()` - Check if parameter is explicitly destructured
  * - `isParameterInitialized()` - Check if parameter has a default value
  * - `isParameterUsedInFunction()` - Check if parameter is used in function body
- * - `getParameterRestUsage()` - Get info about parameter accessed via rest params
  * - `hasExistingBodyInitializations()` - Check for initialization patterns in function body
  *
  * ## Identifier Origin Analysis (Usage → Origin)
@@ -194,44 +193,6 @@ const isParameterUsedInFunction = (context, functionNode, paramName) => {
     return false;
 };
 exports.isParameterUsedInFunction = isParameterUsedInFunction;
-/**
- * Check if a parameter is accessed via rest parameters (e.g., rest.paramName)
- * and return information about the rest parameter usage
- */
-const getParameterRestUsage = (context, functionNode, paramName) => {
-    // Look for rest elements in both direct params and inside object patterns
-    const restParameters = [];
-    functionNode.params.forEach(param => {
-        if (param.type === utils_1.AST_NODE_TYPES.RestElement && param.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
-            // Direct rest parameter: (...rest: Params)
-            restParameters.push({ name: param.argument.name, param });
-        }
-        else if (param.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
-            // Look for rest elements inside object patterns: ({ param1, ...rest }: Params)
-            param.properties.forEach(property => {
-                if (property.type === utils_1.AST_NODE_TYPES.RestElement && property.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
-                    restParameters.push({ name: property.argument.name, param });
-                }
-            });
-        }
-    });
-    if (restParameters.length === 0) {
-        return { isUsedViaRest: false };
-    }
-    // Check if the function body contains rest.paramName patterns
-    const functionText = context.sourceCode.getText(functionNode);
-    for (const restParam of restParameters) {
-        const pattern = new RegExp(`\\b${restParam.name}\\.${paramName}\\b`);
-        if (pattern.test(functionText)) {
-            return {
-                isUsedViaRest: true,
-                restParamName: restParam.name,
-                restParam: restParam.param,
-            };
-        }
-    }
-    return { isUsedViaRest: false };
-};
 const jsxTagNameIsIntrinsic = (name) => name.type === utils_1.AST_NODE_TYPES.JSXIdentifier && /^[a-z]/.test(name.name);
 const nodeContainsJSX = (node) => {
     if (node.type === utils_1.AST_NODE_TYPES.JSXElement) {

package/src/lib/utils/classname-utils.js

@@ -337,49 +337,6 @@ const extractFromJsxAttribute = (node) => {
     return [];
 };
 // =============================================================================
-// Variable Declaration Extraction
-// =============================================================================
-/**
- * Extract classname locations from a variable declaration with a classname-like name.
- *
- * Example: const buttonClass = "flex items-center";
- */
-const extractFromVariableDeclarator = (node) => {
-    if (node.id.type !== utils_1.AST_NODE_TYPES.Identifier) {
-        return [];
-    }
-    const varName = node.id.name;
-    if (!(0, exports.isClassnameVariable)(varName)) {
-        return [];
-    }
-    if (!node.init) {
-        return [];
-    }
-    const context = {
-        type: "variable",
-        variableName: varName,
-    };
-    // Handle string literal
-    const extracted = extractStringValue(node.init);
-    if (extracted) {
-        return [
-            {
-                value: extracted.value,
-                reportNode: node.init,
-                fixNode: extracted.node,
-                context,
-            },
-        ];
-    }
-    // Handle array of strings
-    if (node.init.type === utils_1.AST_NODE_TYPES.ArrayExpression) {
-        return extractFromArray(node.init, context);
-    }
-    // Note: Function calls in variable initializers are handled separately
-    // by the CallExpression handler
-    return [];
-};
-// =============================================================================
 // Unified Entry Points
 // =============================================================================
 /**
@@ -426,27 +383,6 @@ const findClassnameStringsInAttribute = (node) => {
     return extractFromJsxAttribute(node);
 };
 exports.findClassnameStringsInAttribute = findClassnameStringsInAttribute;
-/**
- * Find all classname string locations in a VariableDeclarator node.
- *
- * Use this in your ESLint rule's VariableDeclarator handler to process
- * variables with classname-like names.
- *
- * @example
- * ```typescript
- * VariableDeclarator(node) {
- *   const locations = findClassnameStringsInVariable(node);
- *   for (const location of locations) {
- *     if (hasBannedPattern(location.value)) {
- *       context.report({ node: location.reportNode, ... });
- *     }
- *   }
- * }
- * ```
- */
-const findClassnameStringsInVariable = (node) => {
-    return extractFromVariableDeclarator(node);
-};
 // =============================================================================
 // Utility Helpers for Fixing
 // =============================================================================
@@ -473,20 +409,4 @@ const formatAsArray = (classes) => {
     return JSON.stringify(classes);
 };
 exports.formatAsArray = formatAsArray;
-/**
- * Get the quote character used in a string literal.
- */
-const getQuoteChar = (node) => {
-    if (typeof node.value === "string" && node.raw) {
-        return node.raw.charAt(0);
-    }
-    return '"';
-};
-/**
- * Create a quoted string with the same quote style as the original.
- */
-const quoteString = (value, originalNode) => {
-    const quote = getQuoteChar(originalNode);
-    return `${quote}${value}${quote}`;
-};
 //# sourceMappingURL=classname-utils.js.map

package/src/lib/utils/import-utils.js

@@ -12,11 +12,8 @@ const utils_1 = require("@typescript-eslint/utils");
  * ## Main Functions
  * - `addImportSpecifiers()` - Add new imports or merge with existing ones
  * - `replaceNamespaceWithDestructured()` - Replace namespace imports (e.g., `import React from "react"`)
- * - `addSingleImportSpecifier()` - Convenience for adding a single import
- *
  * ## Helper Functions
  * - `findImportDeclaration()` - Find existing import for a package
- * - `hasImportSpecifier()` - Check if specific import already exists
  * - `getImportSpecifiers()` - Extract specifiers from an import
  */
 /**
@@ -39,21 +36,6 @@ const findImportDeclaration = (sourceCode, packageName) => {
     return found;
 };
 exports.findImportDeclaration = findImportDeclaration;
-/**
- * Check if a specific specifier is already imported from a package.
- *
- * @example
- * // File has: import { useState, useEffect } from "react";
- * hasImportSpecifier(sourceCode, "react", "useState")  // → true
- * hasImportSpecifier(sourceCode, "react", "useRef")    // → false
- */
-const hasImportSpecifier = (sourceCode, packageName, specifierName) => {
-    return sourceCode.ast.body.some(node => node.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
-        node.source.value === packageName &&
-        node.specifiers.some(specifier => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
-            specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
-            specifier.imported.name === specifierName));
-};
 /**
  * Get existing import specifiers from an import declaration.
  *
@@ -119,24 +101,6 @@ const addImportSpecifiers = (options) => {
     return fixes;
 };
 exports.addImportSpecifiers = addImportSpecifiers;
-/**
- * Add a single import specifier - convenience wrapper around addImportSpecifiers.
- * Automatically finds and merges with existing imports from the same package.
- *
- * @example
- * // Before: import { useState } from "react";
- * // After:  import { useEffect, useState } from "react";
- * addSingleImportSpecifier({ sourceCode, fixer, packageName: "react", specifier: "useEffect" })
- */
-const addSingleImportSpecifier = (options) => {
-    const { sourceCode, packageName, specifier } = options;
-    const existingImport = (0, exports.findImportDeclaration)(sourceCode, packageName);
-    return (0, exports.addImportSpecifiers)({
-        ...options,
-        specifiers: [specifier],
-        existingImport,
-    });
-};
 /**
  * Replace a namespace/default import with destructured imports.
  * Automatically handles merging, semicolons, sorting, and formatting.