Merge pull request #32 from domharries/inherited-aliases

feat: inherited import aliases in tsconfig

Author: antonk52

src/spec/resolveAliasedFilepath.spec.ts

@@ -2,6 +2,7 @@ import {existsSync} from 'fs';
 import {lilconfigSync} from 'lilconfig';
 import {type Mock, describe, expect, it, vi} from 'vitest';
 import {resolveAliasedImport} from '../utils/resolveAliasedImport';
+import {resolveJson5File} from '../utils/resolveJson5File';
 
 vi.mock('lilconfig', async () => {
     const actual: typeof import('lilconfig') =
@@ -12,6 +13,12 @@ vi.mock('lilconfig', async () => {
     };
 });
 
+vi.mock('../utils/resolveJson5File', async () => {
+    return {
+        resolveJson5File: vi.fn(),
+    };
+});
+
 vi.mock('fs', async () => {
     const actual: typeof import('fs') = await vi.importActual('fs');
     const existsSync = vi.fn();
@@ -175,4 +182,62 @@ describe('utils: resolveAliasedFilepath', () => {
 
         expect(result).toEqual(expected);
     });
+
+    it('searches for paths in parent configs when extends is set', () => {
+        (lilconfigSync as Mock).mockReturnValueOnce({
+            search: () => ({
+                config: {
+                    compilerOptions: {},
+                    extends: '../tsconfig.base.json',
+                },
+                filepath: '/root/module/tsconfig.json',
+            }),
+        });
+        (existsSync as Mock).mockReturnValue(true);
+        (resolveJson5File as Mock).mockReturnValueOnce({
+            config: {
+                compilerOptions: {
+                    baseUrl: './',
+                    paths: {
+                        '@other/*': ['./other/*'],
+                    },
+                },
+            },
+            filepath: '/root/tsconfig.base.json',
+        });
+        const result = resolveAliasedImport({
+            location: '',
+            importFilepath: '@other/file.css',
+        });
+        const expected = '/root/other/file.css';
+
+        expect(result).toEqual(expected);
+    });
+
+    it('handles infinite extends loops', () => {
+        (lilconfigSync as Mock).mockReturnValueOnce({
+            search: () => ({
+                config: {
+                    compilerOptions: {},
+                    extends: '../tsconfig.base.json',
+                },
+                filepath: '/root/module/tsconfig.json',
+            }),
+        });
+        (existsSync as Mock).mockReturnValue(true);
+        (resolveJson5File as Mock).mockReturnValue({
+            config: {
+                compilerOptions: {},
+                extends: './tsconfig.base.json',
+            },
+            filepath: '/root/tsconfig.base.json',
+        });
+        const result = resolveAliasedImport({
+            location: '',
+            importFilepath: '@bar/file.css',
+        });
+        const expected = null;
+
+        expect(result).toEqual(expected);
+    });
 });

src/utils/resolveAliasedImport.ts

@@ -3,6 +3,7 @@ import path from 'path';
 import JSON5 from 'json5';
 
 import {lilconfigSync} from 'lilconfig';
+import {resolveJson5File} from './resolveJson5File';
 
 const validate = {
     string: (x: unknown): x is string => typeof x === 'string',
@@ -54,22 +55,46 @@ export const resolveAliasedImport = ({
             '.json': (_, content) => JSON5.parse(content),
         },
     });
-    const config = searcher.search(location);
+    let config = searcher.search(location);
 
     if (config == null) {
         return null;
     }
 
-    const paths: unknown = config.config?.compilerOptions?.paths;
+    let configLocation = path.dirname(config.filepath);
 
-    const potentialBaseUrl: unknown = config.config?.compilerOptions?.baseUrl;
+    let paths: unknown = config.config?.compilerOptions?.paths;
+    let pathsBase = configLocation;
 
-    const configLocation = path.dirname(config.filepath);
+    let potentialBaseUrl: unknown = config.config?.compilerOptions?.baseUrl;
+    let baseUrl = validate.string(potentialBaseUrl)
+        ? path.resolve(configLocation, potentialBaseUrl)
+        : null;
+
+    let depth = 0;
+    while ((!paths || !baseUrl) && config.config?.extends && depth++ < 10) {
+        config = resolveJson5File({
+            path: config.config.extends,
+            base: configLocation,
+        });
+        if (config == null) {
+            return null;
+        }
+        configLocation = path.dirname(config.filepath);
+        if (!paths && config.config?.compilerOptions?.paths) {
+            paths = config.config.compilerOptions.paths;
+            pathsBase = configLocation;
+        }
+        if (!baseUrl && config.config?.compilerOptions?.baseUrl) {
+            potentialBaseUrl = config.config.compilerOptions.baseUrl;
+            baseUrl = validate.string(potentialBaseUrl)
+                ? path.resolve(configLocation, potentialBaseUrl)
+                : null;
+        }
+    }
 
     if (validate.tsconfigPaths(paths)) {
-        const baseUrl = validate.string(potentialBaseUrl)
-            ? potentialBaseUrl
-            : '.';
+        baseUrl = baseUrl || pathsBase;
 
         for (const alias in paths) {
             const aliasRe = new RegExp(alias.replace('*', '(.+)'), '');
@@ -80,7 +105,6 @@ export const resolveAliasedImport = ({
 
             for (const potentialAliasLocation of paths[alias]) {
                 const resolvedFileLocation = path.resolve(
-                    configLocation,
                     baseUrl,
                     potentialAliasLocation
                         // "./utils/*" -> "./utils/style.module.css"
@@ -100,12 +124,8 @@ export const resolveAliasedImport = ({
     // 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 (baseUrl) {
+        const resolvedFileLocation = path.resolve(baseUrl, importFilepath);
 
         if (fs.existsSync(resolvedFileLocation)) {
             return resolvedFileLocation;

src/utils/resolveJson5File.ts

@@ -0,0 +1,36 @@
+import fs from 'fs';
+import JSON5 from 'json5';
+
+import type {LilconfigResult} from 'lilconfig';
+
+/**
+ * Attempts to resolve the path to a json5 file using node.js resolution rules
+ *
+ * returns null if file could not be resolved, or if JSON5 parsing fails
+ * @see https://www.typescriptlang.org/tsconfig/#extends
+ */
+export const resolveJson5File = ({
+    path,
+    base,
+}: {
+    /**
+     * path to the json5 file
+     * @example "../tsconfig.json"
+     */
+    path: string;
+    /**
+     * directory where the file with import is located
+     * @example "/Users/foo/project/components"
+     */
+    base: string;
+}): LilconfigResult => {
+    try {
+        const filepath = require.resolve(path, {paths: [base]});
+        const content = fs.readFileSync(filepath, 'utf8');
+        const isEmpty = content.trim() === '';
+        const config = isEmpty ? {} : JSON5.parse(content);
+        return {filepath, isEmpty, config};
+    } catch (e) {
+        return null;
+    }
+};