update vite-monorepo-alias

packages/vite-monorepo-alias/src/__tests__/get-typescript-alias.spec.ts

@@ -10,28 +10,37 @@ describe('get-typescript-alias', () => {
     vi.mocked(parseWorkspacePath).mockRestore()
   })
   const setup = () => {
-    vi.mocked(parseWorkspacePath).mockImplementation((_, path) => path)
+    vi.mocked(parseWorkspacePath).mockImplementation((_, path) => path as any)
 
     return {}
   }
   it('should get typescript alias', async () => {
     setup()
-    const alias = await getTypescriptAlias([
-      join(__dirname, 'packages/*'),
-      join(__dirname, 'apps/*'),
-    ])
+    const alias = await getTypescriptAlias(
+      [join(__dirname, 'packages/*'), join(__dirname, 'apps/*')],
+      {'@/*': ['src/*']},
+    )
 
     expect(alias).toEqual([
       {
-        alias: [['src/*', 'src/']],
+        alias: [
+          ['@/*', 'src/'],
+          ['src/*', 'src/'],
+        ],
         path: join(__dirname, 'apps', 'john'),
       },
       {
-        alias: [['components/*', 'components/']],
+        alias: [
+          ['@/*', 'src/'],
+          ['components/*', 'components/'],
+        ],
         path: join(__dirname, 'packages', 'foo'),
       },
       {
-        alias: [['components/*', 'components/']],
+        alias: [
+          ['@/*', 'src/'],
+          ['components/*', 'components/'],
+        ],
         path: join(__dirname, 'packages', 'bar'),
       },
     ])

packages/vite-monorepo-alias/src/get-typescript-alias.ts

@@ -1,25 +1,30 @@
 import {glob} from 'glob'
-import {readFileSync} from 'node:fs'
 import {join} from 'node:path'
-import {WorkspaceInfo} from 'src/types'
-import {readConfigFile} from 'typescript'
+import {Paths, WorkspaceInfo} from './types'
+import {parseConfigFileTextToJson, sys} from 'typescript'
 import {parseWorkspacePath} from './parse-workspace-path'
+
 const WildCard = /\/\*$/u
 
 /**
  * todo finding exact alias is yet
  * @param workspacePath
+ * @param paths
  */
-export const getTypescriptAlias = async (workspacePath: string[]): Promise<WorkspaceInfo[]> => {
-  const paths = await glob(workspacePath)
-  return paths.map((path) => {
-    const {config} = readConfigFile(join(path, 'tsconfig.json'), (path) =>
-      readFileSync(path).toString(),
-    )
+export const getTypescriptAlias = async (
+  workspacePath: string[],
+  paths?: Paths,
+): Promise<WorkspaceInfo[]> => {
+  const eachPaths = await glob(workspacePath)
+  return eachPaths.map((path) => {
+    const configPath = join(path, 'tsconfig.json')
+    const file = sys.readFile(join(path, 'tsconfig.json')) ?? '{}'
+    const {config} = parseConfigFileTextToJson(configPath, file)
     const configPaths: Record<string, string[]> = config.compilerOptions?.paths ?? {}
+    const mergedPaths = {...paths, ...configPaths}
 
     return {
-      alias: Object.entries(configPaths).map(([key, value]) => {
+      alias: Object.entries(mergedPaths).map(([key, value]) => {
         return [parseWorkspacePath('', key), value[0].replace(WildCard, '/')]
       }),
       path: parseWorkspacePath('', path),

packages/vite-monorepo-alias/src/index.ts

@@ -1,2 +1,3 @@
 export * from './alias'
 export * from './workspace-info'
+export * from './plugin'

packages/vite-monorepo-alias/src/normalize-workspace-info-options.ts

@@ -1,6 +1,8 @@
 import {join} from 'node:path'
+import {Paths} from './types'
 
 export interface CreateWorkspaceInfoOptions {
+  defaultPaths?: Paths
   root?: string
   workspaces: string[]
 }

packages/vite-monorepo-alias/src/plugin.ts

@@ -0,0 +1,20 @@
+import type {Plugin} from 'vite'
+import {createAlias} from './alias'
+import {CreateWorkspaceInfoOptions} from './normalize-workspace-info-options'
+import {createWorkspaceInfo} from './workspace-info'
+
+export type ViteMonorepoAliasPluginOptions = CreateWorkspaceInfoOptions
+export const viteMonorepoAlias = (options: CreateWorkspaceInfoOptions): Plugin => {
+  return {
+    async config() {
+      const workspaceInfo = await createWorkspaceInfo(options)
+      return {
+        resolve: {
+          alias: [createAlias(workspaceInfo)],
+        },
+      }
+    },
+    enforce: 'pre',
+    name: 'vite-monorepo-alias',
+  }
+}

packages/vite-monorepo-alias/src/types.ts

@@ -2,3 +2,7 @@ export interface WorkspaceInfo {
   alias: [RegExp, string][]
   path: RegExp
 }
+
+export interface Paths {
+  [key: string]: string[]
+}

packages/vite-monorepo-alias/src/workspace-info.ts

@@ -10,5 +10,5 @@ export const createWorkspaceInfo = (
 ): Promise<WorkspaceInfo[]> => {
   const normalizedOptions = normalizeWorkspaceInfoOptions(options)
 
-  return getTypescriptAlias(normalizedOptions.workspaces)
+  return getTypescriptAlias(normalizedOptions.workspaces, options.defaultPaths)
 }

vite.config.ts

@@ -1,23 +1,22 @@
 /// <reference types="vitest" />
 /// <reference types="histoire" />
 
+import {viteMonorepoAlias} from '@byte-abc/vite-monorepo-alias'
 import vue from '@vitejs/plugin-vue'
 import {defineConfig} from 'vite'
-import {createAlias, createWorkspaceInfo} from '@byte-abc/vite-monorepo-alias'
 
 export default defineConfig(async () => {
-  const workspaceInfo = await createWorkspaceInfo({
-    workspaces: ['packages/*', 'apps/*'],
-  })
   return {
     histoire: {
       // Alternative way of specifying histoire config
       setupFile: '/histoire.setup.ts',
     },
-    plugins: [vue()],
-    resolve: {
-      alias: [createAlias(workspaceInfo)],
-    },
+    plugins: [
+      vue(),
+      viteMonorepoAlias({
+        workspaces: ['packages/*', 'apps/*'],
+      }),
+    ],
     test: {
       // ...
     },