@hanzogui/static 8.3.1 → 8.3.2

package/src/exports.ts

@@ -1,17 +1,17 @@
-export * from './checkDeps'
-export * from './types'
-export { createExtractor } from './extractor/createExtractor'
-export { literalToAst } from './extractor/literalToAst'
-export * from './constants'
-export * from './extractor/extractablePath'
-export * from './extractor/extractToClassNames'
-export * from './extractor/concatClassName'
-export * from './extractor/extractToNative'
-export * from './extractor/extractHelpers'
-export * from './extractor/loadGui'
-export * from './extractor/watchGuiConfig'
-export * from './extractor/createLogger'
-export * from './registerRequire'
-export { detectModuleFormat, clearFormatCache } from './extractor/detectModuleFormat'
-export { esbundleGuiConfig } from './extractor/bundle'
-export * from './getPragmaOptions'
+export * from './checkDeps.ts'
+export * from './types.ts'
+export { createExtractor } from './extractor/createExtractor.ts'
+export { literalToAst } from './extractor/literalToAst.ts'
+export * from './constants.ts'
+export * from './extractor/extractablePath.ts'
+export * from './extractor/extractToClassNames.ts'
+export * from './extractor/concatClassName.ts'
+export * from './extractor/extractToNative.ts'
+export * from './extractor/extractHelpers.ts'
+export * from './extractor/loadGui.ts'
+export * from './extractor/watchGuiConfig.ts'
+export * from './extractor/createLogger.ts'
+export * from './registerRequire.ts'
+export { detectModuleFormat, clearFormatCache } from './extractor/detectModuleFormat.ts'
+export { esbundleGuiConfig } from './extractor/bundle.ts'
+export * from './getPragmaOptions.ts'

package/src/extractor/babelParse.ts

@@ -2,19 +2,10 @@ import * as babelParser from '@babel/parser'
 import type * as t from '@babel/types'
 
 const plugins: babelParser.ParserPlugin[] = [
-  'asyncGenerators',
-  'classProperties',
-  'dynamicImport',
   'functionBind',
   'jsx',
-  'numericSeparator',
-  'objectRestSpread',
-  'optionalCatchBinding',
   'decorators-legacy',
   'typescript',
-  'optionalChaining',
-  'nullishCoalescingOperator',
-  'topLevelAwait',
 ]
 
 export const parserOptions: babelParser.ParserOptions = Object.freeze({
@@ -27,11 +18,11 @@ const parser = babelParser.parse.bind(babelParser)
 export function babelParse(code: string | Buffer, fileName?: string): t.File {
   const codeString = code.toString()
   try {
-    return parser(codeString, parserOptions) as any
+    return parser(codeString, parserOptions)
   } catch (err) {
     throw new Error(
       `Error parsing babel: ${err} in ${fileName}, code:\n${codeString}\n ${
-        (err as any).stack
+        err instanceof Error ? err.stack : ''
       }`
     )
   }

package/src/extractor/buildClassName.ts

@@ -1,6 +1,6 @@
 import * as t from '@babel/types'
 
-import type { ClassNameObject } from '../types'
+import type { ClassNameObject } from '../types.ts'
 
 type Builder = (
   objects: ClassNameObject[],

package/src/extractor/bundle.ts

@@ -1,12 +1,16 @@
 import { readFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
 import esbuild from 'esbuild'
-import * as FS from 'fs-extra'
-import type { GuiPlatform } from '../types'
-import { detectModuleFormat } from './detectModuleFormat'
-import { esbuildAliasPlugin } from './esbuildAliasPlugin'
-import { hasTopLevelAwait } from './hasTopLevelAwait'
-import { resolveWebOrNativeSpecificEntry } from './loadGui'
-import { TsconfigPathsPlugin } from './esbuildTsconfigPaths'
+import FS from 'fs-extra'
+import type { GuiPlatform } from '../types.ts'
+import { detectModuleFormat } from './detectModuleFormat.ts'
+import { esbuildAliasPlugin } from './esbuildAliasPlugin.ts'
+import { hasTopLevelAwait } from './hasTopLevelAwait.ts'
+import { resolveWebOrNativeSpecificEntry } from './loadGui.ts'
+import { TsconfigPathsPlugin } from './esbuildTsconfigPaths.ts'
+import { url } from '../here.ts'
+
+const need = createRequire(url)
 
 export const esbuildLoaderConfig = {
   '.js': 'jsx',
@@ -211,7 +215,7 @@ function getESBuildConfig(
       {
         name: 'external',
         setup(build) {
-          const proxyWormPath = require.resolve('@hanzogui/proxy-worm')
+          const proxyWormPath = need.resolve('@hanzogui/proxy-worm')
 
           // only externalize @hanzogui/core and @hanzogui/web - these are provided at runtime
           // other @hanzogui/* packages (like @hanzogui/config/v3) must be bundled in to avoid
@@ -278,7 +282,7 @@ function detectEntryFormat(entryPoint: string): esbuild.BuildOptions['format'] {
   }
   // bare module specifier - check package.json type field
   try {
-    const pkgJsonPath = require.resolve(entryPoint + '/package.json')
+    const pkgJsonPath = need.resolve(entryPoint + '/package.json')
     const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'))
     return pkg.type === 'module' ? 'esm' : 'cjs'
   } catch {

package/src/extractor/bundleConfig.ts

@@ -5,20 +5,24 @@ import { createHash } from 'node:crypto'
 import { existsSync, readFileSync, unlinkSync } from 'node:fs'
 import { basename, dirname, extname, join, relative, sep } from 'node:path'
 import { pathToFileURL } from 'node:url'
+import { createRequire } from 'node:module'
+import { load, url } from '../here.ts'
+
+const need = createRequire(url)
 // @ts-ignore why
 import { Color, colorLog } from '@hanzogui/cli-color'
 import { type StaticConfig, type GuiInternalConfig } from '@hanzogui/web'
 import esbuild from 'esbuild'
-import * as FS from 'fs-extra'
+import FS from 'fs-extra'
 import { readFile } from 'node:fs/promises'
-import { registerRequire, setRequireResult } from '../registerRequire'
-import type { GuiOptions } from '../types'
-import { babelParse } from './babelParse'
-import { esbuildLoaderConfig, esbundleGuiConfig } from './bundle'
-import { getGuiConfigPathFromOptionsConfig } from './getGuiConfigPathFromOptionsConfig'
-import { hasTopLevelAwait } from './hasTopLevelAwait'
-import { requireGuiCore } from '../helpers/requireGuiCore'
-import { detectModuleFormat } from './detectModuleFormat'
+import { registerRequire, setRequireResult } from '../registerRequire.ts'
+import type { GuiOptions } from '../types.ts'
+import { babelParse } from './babelParse.ts'
+import { esbuildLoaderConfig, esbundleGuiConfig } from './bundle.ts'
+import { getGuiConfigPathFromOptionsConfig } from './getGuiConfigPathFromOptionsConfig.ts'
+import { hasTopLevelAwait } from './hasTopLevelAwait.ts'
+import { requireGuiCore } from '../helpers/requireGuiCore.ts'
+import { detectModuleFormat } from './detectModuleFormat.ts'
 
 // track temp files for cleanup on exit
 const activeTempFiles = new Set<string>()
@@ -45,10 +49,10 @@ function getEsbuildStdinLoader(filePath: string): esbuild.Loader {
 
 function resolvePackageEntry(packageName: string, format: 'esm' | 'cjs') {
   if (format === 'cjs') {
-    return require.resolve(packageName)
+    return need.resolve(packageName)
   }
 
-  const packageJsonPath = require.resolve(`${packageName}/package.json`)
+  const packageJsonPath = need.resolve(`${packageName}/package.json`)
   const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'))
   const packageRoot = dirname(packageJsonPath)
   const exportEntry = packageJson.exports?.['.']
@@ -63,7 +67,7 @@ function resolvePackageEntry(packageName: string, format: 'esm' | 'cjs') {
     return join(packageRoot, esmEntry)
   }
 
-  return require.resolve(packageName)
+  return need.resolve(packageName)
 }
 
 function cleanupTempFiles() {
@@ -296,7 +300,7 @@ export async function bundleConfig(props: GuiOptions) {
     // detect format per component module
     const componentFormats: Array<'esm' | 'cjs'> = baseComponents.map((mod) => {
       try {
-        const pkgJson = require.resolve(mod + '/package.json')
+        const pkgJson = need.resolve(mod + '/package.json')
         const pkg = JSON.parse(readFileSync(pkgJson, 'utf-8'))
         return pkg.type === 'module' ? 'esm' : 'cjs'
       } catch {
@@ -410,13 +414,13 @@ export async function bundleConfig(props: GuiOptions) {
     // external requires like @hanzogui/config/v3 that are externalized in the bundled CJS
     if (hasBundledOnce) {
       try {
-        delete require.cache[require.resolve(configOutPath)]
+        delete need.cache[need.resolve(configOutPath)]
       } catch {
         // file may not exist yet
       }
       for (const p of componentOutPaths) {
         try {
-          delete require.cache[require.resolve(p)]
+          delete need.cache[need.resolve(p)]
         } catch {
           // file may not exist yet
         }
@@ -428,9 +432,9 @@ export async function bundleConfig(props: GuiOptions) {
     let out: any
     if (configFormat === 'esm') {
       // use file:// URL for proper ESM resolution
-      out = await import(pathToFileURL(configOutPath).href)
+      out = await load(configOutPath)
     } else {
-      out = require(configOutPath)
+      out = need(configOutPath)
     }
 
     // try and find .config, even if on .default
@@ -651,9 +655,9 @@ export async function loadComponentsInner(
         let moduleResult: any
         if (format === 'esm') {
           // use file:// URL for proper ESM resolution
-          moduleResult = await import(pathToFileURL(loadModule).href)
+          moduleResult = await load(loadModule)
         } else {
-          moduleResult = require(loadModule)
+          moduleResult = need(loadModule)
         }
 
         if (!forceExports) {
@@ -800,10 +804,10 @@ export function loadComponentsInnerSync(
         }
 
         if (process.env.DEBUG === 'hanzogui') {
-          console.info(`loadModule`, loadModule, require.resolve(loadModule))
+          console.info(`loadModule`, loadModule, need.resolve(loadModule))
         }
 
-        const moduleResult = require(loadModule)
+        const moduleResult = need(loadModule)
 
         if (!forceExports) {
           setRequireResult(name, moduleResult)

package/src/extractor/createEvaluator.ts

@@ -5,9 +5,9 @@ import type { NodePath } from '@babel/traverse'
 import * as t from '@babel/types'
 import esbuild from 'esbuild'
 
-import { FAILED_EVAL } from '../constants'
-import type { GuiOptionsWithFileInfo } from '../types'
-import { evaluateAstNode } from './evaluateAstNode'
+import { FAILED_EVAL } from '../constants.ts'
+import type { GuiOptionsWithFileInfo } from '../types.ts'
+import { evaluateAstNode } from './evaluateAstNode.ts'
 
 export function createEvaluator({
   props,

package/src/extractor/createExtractor.ts

@@ -1,4 +1,4 @@
-import type { NodePath, TraverseOptions } from '@babel/traverse'
+import type { NodePath, TraverseOptions, Visitor } from '@babel/traverse'
 import traverse from '@babel/traverse'
 import * as t from '@babel/types'
 import { Color, colorLog } from '@hanzogui/cli-color'
@@ -12,13 +12,13 @@ import {
   type StaticConfig,
   type GuiComponentState,
 } from '@hanzogui/web'
-import { existsSync, readFileSync } from 'node:fs'
+import { readFileSync } from 'node:fs'
 import { basename, dirname, resolve, relative } from 'node:path'
-import { nodeModuleNameResolver, sys } from 'typescript'
 import type { ViewStyle } from 'react-native'
 
-import { FAILED_EVAL } from '../constants'
-import { requireGuiCore } from '../helpers/requireGuiCore'
+import { FAILED_EVAL } from '../constants.ts'
+import { requireGuiCore } from '../helpers/requireGuiCore.ts'
+import { registerRequire } from '../registerRequire.ts'
 import type {
   ExtractedAttr,
   ExtractedAttrStyle,
@@ -27,11 +27,12 @@ import type {
   GuiOptions,
   GuiOptionsWithFileInfo,
   Ternary,
-} from '../types'
-import type { LoadedComponents, GuiProjectInfo } from './bundleConfig'
-import { createEvaluator, createSafeEvaluator } from './createEvaluator'
-import { installedPackageOf } from './extractablePath'
-import { evaluateAstNode } from './evaluateAstNode'
+  GuiPlatform,
+} from '../types.ts'
+import type { LoadedComponents, GuiProjectInfo } from './bundleConfig.ts'
+import { createEvaluator, createSafeEvaluator } from './createEvaluator.ts'
+import { installedPackageOf } from './extractablePath.ts'
+import { evaluateAstNode } from './evaluateAstNode.ts'
 import {
   attrStr,
   findComponentName,
@@ -41,18 +42,32 @@ import {
   isPresent,
   isValidImport,
   objToStr,
-} from './extractHelpers'
-import { findTopmostFunction } from './findTopmostFunction'
-import { cleanupBeforeExit, getStaticBindingsForScope } from './getStaticBindingsForScope'
-import { literalToAst } from './literalToAst'
-import { loadGui, loadGuiSync } from './loadGui'
-import { logLines } from './logLines'
-import { normalizeTernaries } from './normalizeTernaries'
-import { setPropsToFontFamily } from './propsToFontFamilyCache'
-import { timer } from './timer'
-import { validHTMLAttributes } from './validHTMLAttributes'
-import { BailOptimizationError } from './errors'
-import { loadCompilerOptionsFromTsconfig } from './esbuildTsconfigPaths'
+} from './extractHelpers.ts'
+import { findTopmostFunction } from './findTopmostFunction.ts'
+import {
+  cleanupBeforeExit,
+  getStaticBindingsForScope,
+} from './getStaticBindingsForScope.ts'
+import { literalToAst } from './literalToAst.ts'
+import { loadGui, loadGuiSync } from './loadGui.ts'
+import { logLines } from './logLines.ts'
+import { normalizeTernaries } from './normalizeTernaries.ts'
+import { setPropsToFontFamily } from './propsToFontFamilyCache.ts'
+import { timer } from './timer.ts'
+import { validHTMLAttributes } from './validHTMLAttributes.ts'
+import { BailOptimizationError } from './errors.ts'
+import { probe, resolveAlias } from './esbuildTsconfigPaths.ts'
+
+// The core of a platform, loaded with the extractor's own require in place so
+// the react-native its native emit asks for is the one this process can run.
+const loadGuiCore = (platform: GuiPlatform) => {
+  const { unregister } = registerRequire(platform)
+  try {
+    return requireGuiCore(platform)
+  } finally {
+    unregister()
+  }
+}
 
 const UNTOUCHED_PROPS = {
   key: true,
@@ -183,60 +198,14 @@ export function createExtractor(
   const dynamicComponentCache = new Map<string, LoadedComponents>()
   const dynamicLoadingInProgress = new Set<string>()
 
-  // lazily loaded tsconfig compiler options for path alias resolution
-  let _compilerOptions: any = null
-  function getCompilerOptions() {
-    if (!_compilerOptions) {
-      try {
-        _compilerOptions = loadCompilerOptionsFromTsconfig()
-      } catch {
-        _compilerOptions = {}
-      }
-    }
-    return _compilerOptions
-  }
-
   function resolveImportPath(fromFile: string, importPath: string): string | null {
+    const dir = dirname(fromFile)
     if (importPath.startsWith('.')) {
-      // relative path resolution
-      const dir = dirname(fromFile)
-      const base = resolve(dir, importPath)
-      const extensions = ['.tsx', '.ts', '.jsx', '.js']
-      for (const ext of extensions) {
-        const full = base + ext
-        if (existsSync(full)) return full
-      }
-      // try index files
-      for (const ext of extensions) {
-        const full = resolve(base, `index${ext}`)
-        if (existsSync(full)) return full
-      }
-      return null
+      return probe(resolve(dir, importPath))
     }
-
-    // tsconfig path alias resolution (e.g. ~/foo, @/bar)
-    const compilerOptions = getCompilerOptions()
-    if (compilerOptions.paths) {
-      try {
-        const { resolvedModule } = nodeModuleNameResolver(
-          importPath,
-          fromFile,
-          compilerOptions,
-          sys
-        )
-        if (
-          resolvedModule &&
-          !resolvedModule.resolvedFileName.endsWith('.d.ts') &&
-          !resolvedModule.isExternalLibraryImport
-        ) {
-          return resolvedModule.resolvedFileName
-        }
-      } catch {
-        // fallback - tsconfig resolution failed
-      }
-    }
-
-    return null
+    // tsconfig path alias (e.g. ~/foo, @/bar) into project source, never into node_modules
+    const file = resolveAlias(importPath, dir)
+    return file && !file.includes('node_modules') ? file : null
   }
 
   const styledCheckCache = new Map<string, boolean>()
@@ -338,7 +307,7 @@ export function createExtractor(
       proxyThemeVariables,
       getDefaultProps,
       pseudoDescriptors,
-    } = requireGuiCore(platform)
+    } = loadGuiCore(platform)
 
     let shouldPrintDebug = options.shouldPrintDebug || false
 
@@ -636,8 +605,7 @@ export function createExtractor(
     // only keeping a cache around per-file, reset it if it changes
     const bindingCache: Record<string, string | null> = {}
 
-    const callTraverse = (a: TraverseOptions<any>) => {
-      // @ts-ignore
+    const callTraverse = (a: TraverseOptions & Visitor) => {
       return fileOrPath.type === 'File' ? traverse(fileOrPath, a) : fileOrPath.traverse(a)
     }
 
@@ -661,7 +629,6 @@ export function createExtractor(
     const version = `${Math.random()}`
 
     callTraverse({
-      // @ts-ignore
       Program: {
         enter(path) {
           programPath = path
@@ -2009,6 +1976,21 @@ export function createExtractor(
             (staticConfig.neverFlatten === 'jsx' ? hasOnlyStringChildren : true)
           )
 
+          if (shouldPrintDebug === 'verbose') {
+            logger.info(
+              `  flatten? ${originalNodeName} -> ${flatNodeName} ${JSON.stringify({
+                shouldFlatten,
+                shouldDeopt,
+                canFlattenProps,
+                hasSpread,
+                isStyledHOC: staticConfig.isStyledHOC,
+                isHOC: staticConfig.isHOC,
+                isReactNative: staticConfig.isReactNative,
+                neverFlatten: staticConfig.neverFlatten,
+              })}`
+            )
+          }
+
           const usedThemeKeys = new Set<string>()
           // if it accesses any theme values during evaluation
           themeAccessListeners.add((key) => {

package/src/extractor/createLogger.ts

@@ -1,7 +1,7 @@
 import { basename } from 'node:path'
 
-import type { GuiOptions } from '../types'
-import { getPrefixLogs } from './getPrefixLogs'
+import type { GuiOptions } from '../types.ts'
+import { getPrefixLogs } from './getPrefixLogs.ts'
 
 export function createLogger(sourcePath: string, options: GuiOptions) {
   const shouldLogTiming = options.logTimings ?? true

package/src/extractor/esbuildTsconfigPaths.ts

@@ -1,134 +1,69 @@
 import type { Plugin } from 'esbuild'
-import fs from 'node:fs'
-import path from 'node:path'
-import * as ts from 'typescript'
-
-const name = 'tsconfig-paths'
-
-/**
- * This package does not own the `typescript` it reads — it borrows whatever the
- * app installed, and what that means changed. `typescript@7` ships the native
- * compiler, and its root export is `{ version, versionMajorMinor }`: `sys`,
- * `findConfigFile` and `nodeModuleNameResolver` are gone. Reading `sys.fileExists`
- * off it threw `Cannot read properties of undefined` while BUNDLING THE GUI
- * CONFIG, so on any app that took TS 7 the whole compiler plugin died before it
- * could write a single rule — measured on hanzoai/chat.
- *
- * The API is therefore probed, not assumed. Without it this plugin stops
- * rewriting `compilerOptions.paths` and esbuild resolves on its own, which costs
- * a gui config that imports through a TS path alias and costs everything else
- * nothing. Losing an alias beats losing the stylesheet.
- */
-const hasProgramApi = typeof (ts as any)?.sys?.fileExists === 'function'
-
-let warned = false
-function warnOnce() {
-  if (warned) return
-  warned = true
-  console.warn(
-    `  ➡ [hanzogui] typescript ${(ts as any)?.version ?? '(not found)'} has no program API ` +
-      `(7.x removed it from the root export), so tsconfig "paths" are not applied when ` +
-      `bundling the gui config. Imports resolve through node.`
-  )
-}
-
-interface Tsconfig {
-  compilerOptions?: {
-    baseUrl?: string
-    paths?: Record<string, string[]>
+import { statSync } from 'node:fs'
+import { join } from 'node:path'
+import {
+  createPathsMatcher,
+  getTsconfig,
+  type Cache,
+  type PathsMatcher,
+  type TsConfigResult,
+} from 'get-tsconfig'
+
+const extensions = ['.tsx', '.ts', '.jsx', '.js']
+
+const isFile = (path: string) => {
+  try {
+    return statSync(path).isFile()
+  } catch {
+    return false
   }
 }
 
-export function TsconfigPathsPlugin(): Plugin {
-  if (!hasProgramApi) {
-    warnOnce()
-    return { name, setup() {} }
+/** The source file an extensionless path names: the path itself, then each extension, then an index file. */
+export function probe(base: string): string | null {
+  for (const ext of ['', ...extensions]) {
+    if (isFile(base + ext)) return base + ext
   }
-
-  const compilerOptions = loadCompilerOptionsFromTsconfig()
-
-  return {
-    name,
-    setup({ onResolve }) {
-      onResolve({ filter: /.*/ }, (args) => {
-        // skip @hanzogui packages - they should be externalized, not resolved via tsconfig
-        if (args.path.startsWith('@hanzogui/')) {
-          return null
-        }
-
-        const paths = compilerOptions.paths || {}
-        const hasMatchingPath = Object.keys(paths).some((p) =>
-          new RegExp(p.replace('*', '\\w*')).test(args.path)
-        )
-
-        if (!hasMatchingPath) {
-          return null
-        }
-
-        const { resolvedModule } = ts.nodeModuleNameResolver(
-          args.path,
-          args.importer,
-          compilerOptions,
-          ts.sys
-        )
-
-        if (!resolvedModule) {
-          return null
-        }
-
-        const { resolvedFileName } = resolvedModule
-
-        if (!resolvedFileName || resolvedFileName.endsWith('.d.ts')) {
-          return null
-        }
-
-        return {
-          path: resolvedFileName,
-        }
-      })
-    },
+  for (const ext of extensions) {
+    const index = join(base, `index${ext}`)
+    if (isFile(index)) return index
   }
+  return null
 }
 
-export function loadCompilerOptionsFromTsconfig(tsconfig?: Tsconfig | string) {
-  if (!hasProgramApi) {
-    warnOnce()
-    return {}
+const configs: Cache<TsConfigResult | null> = new Map()
+const matchers = new Map<string, PathsMatcher | null>()
+
+/** Maps a specifier through `compilerOptions.paths` of the tsconfig (or jsconfig) nearest `dir` to a source file. */
+export function resolveAlias(specifier: string, dir: string): string | null {
+  if (!matchers.has(dir)) {
+    // A dependency's tsconfig may extend a preset it does not ship; that is
+    // no paths to map, not a reason to fail the bundle.
+    let tsconfig: TsConfigResult | null = null
+    try {
+      tsconfig =
+        getTsconfig(dir, 'tsconfig.json', configs) ??
+        getTsconfig(dir, 'jsconfig.json', configs)
+    } catch {}
+    matchers.set(dir, tsconfig && createPathsMatcher(tsconfig))
   }
-
-  if (!tsconfig) {
-    const configPath =
-      ts.findConfigFile(process.cwd(), ts.sys.fileExists, 'tsconfig.json') ||
-      ts.findConfigFile(process.cwd(), ts.sys.fileExists, 'jsconfig.json')
-
-    if (configPath) {
-      return parseTsconfig(configPath)
-    }
-    return {}
-  }
-
-  if (typeof tsconfig === 'string') {
-    if (fs.existsSync(tsconfig)) {
-      return parseTsconfig(tsconfig)
-    } else {
-      throw new Error(`Specified tsconfig file not found: ${tsconfig}`)
-    }
+  for (const candidate of matchers.get(dir)?.(specifier) ?? []) {
+    const file = probe(candidate)
+    if (file) return file
   }
-
-  const baseDir = process.cwd()
-  const parsed = ts.parseJsonConfigFileContent(tsconfig, ts.sys, baseDir)
-  return parsed.options
+  return null
 }
 
-function parseTsconfig(configFilePath: string) {
-  const configFile = ts.readConfigFile(configFilePath, ts.sys.readFile)
-  if (configFile.error) {
-    throw new Error(
-      `Error reading tsconfig file '${configFilePath}': ${configFile.error.messageText}`
-    )
+export function TsconfigPathsPlugin(): Plugin {
+  return {
+    name: 'tsconfig-paths',
+    setup({ onResolve }) {
+      onResolve({ filter: /.*/ }, ({ path, resolveDir }) => {
+        // @hanzogui packages are externalized, never resolved through tsconfig
+        if (path.startsWith('@hanzogui/')) return null
+        const file = resolveAlias(path, resolveDir || process.cwd())
+        return file ? { path: file } : null
+      })
+    },
   }
-
-  const baseDir = path.dirname(configFilePath)
-  const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, baseDir)
-  return parsed.options
 }