Merge pull request #16 from quentin-fox/main

allow resolving in tsconfig even when no paths

Author: antonk52

src/spec/resolveAliasedFilepath.spec.ts

@@ -45,7 +45,7 @@ describe('utils: resolveAliaedFilepath', () => {
         expect(result).toEqual(expected);
     });
 
-    it('returns null when "paths" is not set in the config', () => {
+    it('returns null when "paths" is not set in the config and path does not match', () => {
         (lilconfigSync as jest.Mock).mockReturnValueOnce({
             search: () => ({
                 config: {
@@ -57,6 +57,7 @@ describe('utils: resolveAliaedFilepath', () => {
                 filepath: '/path/to/config',
             }),
         });
+        (existsSync as jest.Mock).mockReturnValue(false);
         const result = resolveAliasedImport({
             location: '',
             importFilepath: '',
@@ -66,7 +67,29 @@ describe('utils: resolveAliaedFilepath', () => {
         expect(result).toEqual(expected);
     });
 
-    it('returns null when no alias matched import path', () => {
+    it('returns resolved filepath when "paths" is not set in the config, and file exists', () => {
+        (lilconfigSync as jest.Mock).mockReturnValueOnce({
+            search: () => ({
+                config: {
+                    compilerOptions: {
+                        baseUrl: './',
+                        // missing "paths"
+                    },
+                },
+                filepath: '/path/to/tsconfig.json',
+            }),
+        });
+        (existsSync as jest.Mock).mockReturnValue(true);
+        const result = resolveAliasedImport({
+            location: '',
+            importFilepath: 'src/styles/file.css',
+        });
+        const expected = '/path/to/src/styles/file.css';
+
+        expect(result).toEqual(expected);
+    });
+
+    it('returns baseUrl-mapped path when no alias matched import path', () => {
         (lilconfigSync as jest.Mock).mockReturnValueOnce({
             search: () => ({
                 config: {
@@ -84,7 +107,7 @@ describe('utils: resolveAliaedFilepath', () => {
             location: '',
             importFilepath: '@foo',
         });
-        const expected = null;
+        const expected = '/path/to/@foo';
 
         expect(result).toEqual(expected);
     });

src/utils/resolveAliasedImport.ts

@@ -10,20 +10,17 @@ const validate = {
             return false;
         }
 
-        for (const key in x) {
-            const value =
-                // @ts-expect-error: here "key" can be used to index object
-                x[key];
-            if (
-                !Array.isArray(value) &&
+        const paths = x as Record<string, unknown>;
+
+        const isValid = Object.values(paths).every(value => {
+            return (
+                Array.isArray(value) &&
                 value.length > 0 &&
-                !value.every(validate.string)
-            ) {
-                return false;
-            }
-        }
+                value.every(validate.string)
+            );
+        });
 
-        return true;
+        return isValid;
     },
 };
 
@@ -59,35 +56,54 @@ export const resolveAliasedImport = ({
         return null;
     }
 
-    const paths = config.config?.compilerOptions?.paths as void | TsconfigPaths;
-    const baseUrl = config.config?.compilerOptions?.baseUrl as void | string;
+    const paths: unknown = config.config?.compilerOptions?.paths;
+
+    const potentialBaseUrl: unknown = config.config?.compilerOptions?.baseUrl;
+
     const configLocation = path.dirname(config.filepath);
 
-    if (!validate.string(baseUrl)) {
-        return null;
-    }
-    if (!validate.tsconfigPaths(paths)) {
-        return null;
-    }
+    if (validate.tsconfigPaths(paths)) {
+        const baseUrl = validate.string(potentialBaseUrl)
+            ? potentialBaseUrl
+            : '.';
 
-    for (const alias in paths) {
-        const aliasRe = new RegExp(alias.replace('*', '(.+)'), '');
+        for (const alias in paths) {
+            const aliasRe = new RegExp(alias.replace('*', '(.+)'), '');
 
-        const aliasMatch = importFilepath.match(aliasRe);
+            const aliasMatch = importFilepath.match(aliasRe);
 
-        if (aliasMatch == null) continue;
+            if (aliasMatch == null) continue;
 
-        for (const potentialAliasLocation of paths[alias]) {
-            const resolvedFileLocation = path.resolve(
-                configLocation,
-                baseUrl,
-                potentialAliasLocation
-                    // "./utils/*" -> "./utils/style.module.css"
-                    .replace('*', aliasMatch[1]),
-            );
+            for (const potentialAliasLocation of paths[alias]) {
+                const resolvedFileLocation = path.resolve(
+                    configLocation,
+                    baseUrl,
+                    potentialAliasLocation
+                        // "./utils/*" -> "./utils/style.module.css"
+                        .replace('*', aliasMatch[1]),
+                );
+
+                if (!fs.existsSync(resolvedFileLocation)) continue;
 
-            if (!fs.existsSync(resolvedFileLocation)) continue;
+                return resolvedFileLocation;
+            }
+        }
+    }
 
+    // if paths is defined, but no paths match
+    // then baseUrl will not fallback to "."
+    // if not using paths to find an alias, baseUrl must be defined
+    // so here we only try and resolve the file if baseUrl is explcitly set and valid
+    // i.e. if no baseUrl is provided
+    // then no imports relative to baseUrl on its own are allowed, only relative to paths
+    if (validate.string(potentialBaseUrl)) {
+        const resolvedFileLocation = path.resolve(
+            configLocation,
+            potentialBaseUrl,
+            importFilepath,
+        );
+
+        if (fs.existsSync(resolvedFileLocation)) {
             return resolvedFileLocation;
         }
     }