fix(file-extension-in-import): handle files with dots in basename

When importing "./utils.client" where the actual file is "utils.client.ts",
path.extname() treats ".client" as an extension. The resolver falls back to
the raw path, causing the rule to think currentExt === actualExt (both ".client")
and report no error.

Fix: when resolved filePath doesn't exist as a file, search for files matching
the full import basename and use the found file's actual extension. Also handle
directory imports where the directory name contains dots (e.g., "my-things.client/index.ts").

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: patricktree

lib/rules/file-extension-in-import.js

@@ -13,12 +13,15 @@ const visitImport = require("../util/visit-import")
 /**
  * Get all file extensions of the files which have the same basename.
  * @param {string} filePath The path to the original file to check.
+ * @param {string} [basename] Optional basename to use instead of deriving from filePath.
  * @returns {string[]} File extensions.
  */
-function getExistingExtensions(filePath) {
+function getExistingExtensions(filePath, basename) {
     const directory = path.dirname(filePath)
-    const extension = path.extname(filePath)
-    const basename = path.basename(filePath, extension)
+    if (basename == null) {
+        const extension = path.extname(filePath)
+        basename = path.basename(filePath, extension)
+    }
 
     try {
         return fs
@@ -115,17 +118,63 @@ module.exports = {
 
             // Get extension.
             const currentExt = path.extname(name)
-            const actualExt = path.extname(filePath)
+            let actualExt = path.extname(filePath)
+            let actualFilePath = filePath
+
+            // If the file doesn't exist (or is a directory), the resolver may have returned
+            // a fallback path. In this case, path.extname may return a "fake" extension
+            // (e.g., ".client" for "utils.client" when the actual file is "utils.client.ts").
+            // We need to search for the actual file using the full basename from the import.
+            const fileExists =
+                fs.existsSync(filePath) && fs.statSync(filePath).isFile()
+            if (actualExt !== "" && !fileExists) {
+                // Use the full basename (e.g., "utils.client") since what path.extname
+                // thinks is an extension (e.g., ".client") may not be a real file extension
+                const importBasename = path.basename(name)
+                const extensions = getExistingExtensions(
+                    filePath,
+                    importBasename
+                )
+                // Find the preferred extension based on tryExtensions order
+                const preferred = tryExtensions.find(ext =>
+                    extensions.includes(ext)
+                )
+                const foundExt = preferred ?? extensions[0]
+                if (foundExt) {
+                    actualExt = foundExt
+                    actualFilePath = path.join(
+                        path.dirname(filePath),
+                        `${importBasename}${actualExt}`
+                    )
+                }
+            }
+
+            let isDirectoryImport = false
+
+            // Check for directory imports. This handles both:
+            // 1. Normal case: "./my-folder" -> "./my-folder/index.js"
+            // 2. Dot-in-name case: "./my-things.client" -> "./my-things.client/index.js"
+            //    where path.extname incorrectly sees ".client" as an extension
+            const isDirectory =
+                fs.existsSync(filePath) && fs.statSync(filePath).isDirectory()
+            if (isDirectory) {
+                const indexExt = getIndexExtension(filePath, tryExtensions)
+                if (indexExt) {
+                    isDirectoryImport = true
+                    actualExt = indexExt
+                    actualFilePath = path.join(filePath, `index${indexExt}`)
+                }
+            }
+
             const style = overrideStyle[actualExt] || defaultStyle
 
             let expectedExt = convertTsExtensionToJs(
                 context,
-                filePath,
+                actualFilePath,
                 actualExt
             )
-            let isDirectoryImport = false
 
-            if (currentExt === "" && actualExt === "") {
+            if (currentExt === "" && actualExt === "" && !isDirectoryImport) {
                 const indexExt = getIndexExtension(filePath, tryExtensions)
                 if (indexExt) {
                     isDirectoryImport = true

tests/fixtures/file-extension-in-import/my-things.client/index.ts

@@ -0,0 +1,2 @@
+// Fixture: directory with dot in name (my-things.client/index.ts)
+export const bar = "baz"

tests/fixtures/file-extension-in-import/utils.client.ts

@@ -0,0 +1,2 @@
+// Fixture file with dot in basename (utils.client.ts)
+export const foo = "bar"

tests/lib/rules/file-extension-in-import.js

@@ -354,6 +354,23 @@ new RuleTester({
             errors: [{ messageId: "forbidExt", data: { ext: ".json" } }],
         },
 
+        // Files with dots in basename (e.g. utils.client.ts)
+        // The specifier "utils.client" looks like it has an extension but doesn't
+        // Rule should require the actual extension ".js" (mapped from .ts)
+        {
+            filename: fixture("test.ts"),
+            code: "import './utils.client'",
+            output: "import './utils.client.js'",
+            errors: [{ messageId: "requireExt", data: { ext: ".js" } }],
+        },
+        // Directories with dots in name (e.g. my-things.client/index.ts)
+        {
+            filename: fixture("test.ts"),
+            code: "import './my-things.client'",
+            output: "import './my-things.client/index.js'",
+            errors: [{ messageId: "requireExt", data: { ext: ".js" } }],
+        },
+
         // import()
         ...(DynamicImportSupported
             ? [