|
|
@@ -0,0 +1,180 @@
|
|
|
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
|
|
|
+import type { ResolveFnOutput, ResolveHookContext } from 'node:module'
|
|
|
+import { tmpdir } from 'node:os'
|
|
|
+import { dirname, join } from 'node:path'
|
|
|
+import { pathToFileURL } from 'node:url'
|
|
|
+import { afterEach, describe, expect, it, vi } from 'vitest'
|
|
|
+import { initialize, resolveHook, TsconfigPathsResolver } from '../src/tsconfig-paths-loader.ts'
|
|
|
+
|
|
|
+class ResolverFixture {
|
|
|
+ readonly root = mkdtempSync(join(tmpdir(), 'dsh-tsconfig-paths-'))
|
|
|
+
|
|
|
+ path(relativePath: string): string {
|
|
|
+ return join(this.root, relativePath)
|
|
|
+ }
|
|
|
+
|
|
|
+ write(relativePath: string, content = 'export {}\n'): string {
|
|
|
+ const path = this.path(relativePath)
|
|
|
+ mkdirSync(dirname(path), { recursive: true })
|
|
|
+ writeFileSync(path, content)
|
|
|
+ return path
|
|
|
+ }
|
|
|
+
|
|
|
+ writeJson(relativePath: string, value: unknown): string {
|
|
|
+ return this.write(relativePath, `${JSON.stringify(value)}\n`)
|
|
|
+ }
|
|
|
+
|
|
|
+ createResolver(paths: Record<string, string[]>): TsconfigPathsResolver {
|
|
|
+ const tsconfigPath = this.writeJson('tsconfig.json', { compilerOptions: { paths } })
|
|
|
+ return TsconfigPathsResolver.create(tsconfigPath)
|
|
|
+ }
|
|
|
+
|
|
|
+ parentURL(relativePath = 'consumer/src/nested/index.ts'): string {
|
|
|
+ return pathToFileURL(this.path(relativePath)).href
|
|
|
+ }
|
|
|
+
|
|
|
+ dispose(): void {
|
|
|
+ rmSync(this.root, { recursive: true, force: true })
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+const fixtures: ResolverFixture[] = []
|
|
|
+
|
|
|
+function fixture(): ResolverFixture {
|
|
|
+ const value = new ResolverFixture()
|
|
|
+ fixtures.push(value)
|
|
|
+ return value
|
|
|
+}
|
|
|
+
|
|
|
+afterEach(() => {
|
|
|
+ for (const value of fixtures.splice(0)) value.dispose()
|
|
|
+})
|
|
|
+
|
|
|
+describe('TsconfigPathsResolver', () => {
|
|
|
+ it('orders exact, longer-prefix, and longer-suffix path rules', async () => {
|
|
|
+ const files = fixture()
|
|
|
+ files.writeJson('consumer/package.json', {
|
|
|
+ dependencies: {
|
|
|
+ '@scope/feature-name': '*',
|
|
|
+ '@scope/feature-other': '*',
|
|
|
+ '@scope/plain-suffix': '*',
|
|
|
+ },
|
|
|
+ })
|
|
|
+ files.write('targets/exact.ts')
|
|
|
+ files.write('targets/prefix/other.ts')
|
|
|
+ files.write('targets/generic/feature-other.ts')
|
|
|
+ files.write('targets/suffix/plain.ts')
|
|
|
+ files.write('targets/generic/plain-suffix.ts')
|
|
|
+ const resolver = files.createResolver({
|
|
|
+ '@scope/*': ['./targets/generic/*'],
|
|
|
+ '@scope/*-suffix': ['./targets/suffix/*'],
|
|
|
+ '@scope/feature-*': ['./targets/prefix/*'],
|
|
|
+ '@scope/feature-name': ['./targets/exact.ts'],
|
|
|
+ })
|
|
|
+
|
|
|
+ await expect(resolver.resolve('@scope/feature-name', files.parentURL()))
|
|
|
+ .resolves.toBe(pathToFileURL(files.path('targets/exact.ts')).href)
|
|
|
+ await expect(resolver.resolve('@scope/feature-other', files.parentURL()))
|
|
|
+ .resolves.toBe(pathToFileURL(files.path('targets/prefix/other.ts')).href)
|
|
|
+ await expect(resolver.resolve('@scope/plain-suffix', files.parentURL()))
|
|
|
+ .resolves.toBe(pathToFileURL(files.path('targets/suffix/plain.ts')).href)
|
|
|
+ })
|
|
|
+
|
|
|
+ it('resolves only self-references and runtime dependencies from the nearest ancestor manifest', async () => {
|
|
|
+ const files = fixture()
|
|
|
+ files.writeJson('consumer/package.json', {
|
|
|
+ name: 'self-package',
|
|
|
+ dependencies: { dependency: '*' },
|
|
|
+ optionalDependencies: { optional: '*' },
|
|
|
+ peerDependencies: { peer: '*' },
|
|
|
+ })
|
|
|
+ for (const name of ['self-package', 'dependency', 'optional', 'peer', 'undeclared']) {
|
|
|
+ files.write(`targets/${name}.ts`)
|
|
|
+ }
|
|
|
+ const resolver = files.createResolver(Object.fromEntries(
|
|
|
+ ['self-package', 'dependency', 'optional', 'peer', 'undeclared']
|
|
|
+ .map(name => [name, [`./targets/${name}`]]),
|
|
|
+ ))
|
|
|
+
|
|
|
+ for (const name of ['self-package', 'dependency', 'optional', 'peer']) {
|
|
|
+ await expect(resolver.resolve(name, files.parentURL()))
|
|
|
+ .resolves.toBe(pathToFileURL(files.path(`targets/${name}.ts`)).href)
|
|
|
+ }
|
|
|
+ await expect(resolver.resolve('undeclared', files.parentURL())).resolves.toBeUndefined()
|
|
|
+ })
|
|
|
+
|
|
|
+ it('probes native TypeScript extensions and index files but excludes TSX and missing targets', async () => {
|
|
|
+ const files = fixture()
|
|
|
+ const names = ['plain-ts', 'module-mts', 'common-cts', 'directory', 'tsx-implicit', 'tsx-explicit', 'missing']
|
|
|
+ files.writeJson('consumer/package.json', {
|
|
|
+ dependencies: Object.fromEntries(names.map(name => [name, '*'])),
|
|
|
+ })
|
|
|
+ files.write('targets/plain.ts')
|
|
|
+ files.write('targets/module.mts')
|
|
|
+ files.write('targets/common.cts')
|
|
|
+ files.write('targets/directory/index.ts')
|
|
|
+ files.write('targets/component.tsx')
|
|
|
+ const resolver = files.createResolver({
|
|
|
+ 'plain-ts': ['./targets/plain'],
|
|
|
+ 'module-mts': ['./targets/module'],
|
|
|
+ 'common-cts': ['./targets/common'],
|
|
|
+ 'directory': ['./targets/directory'],
|
|
|
+ 'tsx-implicit': ['./targets/component'],
|
|
|
+ 'tsx-explicit': ['./targets/component.tsx'],
|
|
|
+ 'missing': ['./targets/missing'],
|
|
|
+ })
|
|
|
+
|
|
|
+ for (const [name, target] of [
|
|
|
+ ['plain-ts', 'targets/plain.ts'],
|
|
|
+ ['module-mts', 'targets/module.mts'],
|
|
|
+ ['common-cts', 'targets/common.cts'],
|
|
|
+ ['directory', 'targets/directory/index.ts'],
|
|
|
+ ] as const) {
|
|
|
+ await expect(resolver.resolve(name, files.parentURL()))
|
|
|
+ .resolves.toBe(pathToFileURL(files.path(target)).href)
|
|
|
+ }
|
|
|
+ await expect(resolver.resolve('tsx-implicit', files.parentURL())).resolves.toBeUndefined()
|
|
|
+ await expect(resolver.resolve('tsx-explicit', files.parentURL())).resolves.toBeUndefined()
|
|
|
+ await expect(resolver.resolve('missing', files.parentURL())).resolves.toBeUndefined()
|
|
|
+ })
|
|
|
+
|
|
|
+ it('anchors inherited paths at the config that declared them', async () => {
|
|
|
+ const files = fixture()
|
|
|
+ files.writeJson('consumer/package.json', { dependencies: { custom: '*' } })
|
|
|
+ files.write('targets/custom.ts')
|
|
|
+ files.writeJson('base.json', { compilerOptions: { paths: { custom: ['./targets/custom'] } } })
|
|
|
+ const customTsconfig = files.writeJson('configs/custom.json', { extends: '../base.json' })
|
|
|
+ const resolver = TsconfigPathsResolver.create(customTsconfig)
|
|
|
+
|
|
|
+ await expect(resolver.resolve('custom', files.parentURL()))
|
|
|
+ .resolves.toBe(pathToFileURL(files.path('targets/custom.ts')).href)
|
|
|
+ })
|
|
|
+
|
|
|
+ it('short-circuits matched aliases and delegates unsupported schemes or unmatched requests', async () => {
|
|
|
+ const files = fixture()
|
|
|
+ files.writeJson('consumer/package.json', { dependencies: { matched: '*' } })
|
|
|
+ const target = files.write('targets/matched.ts')
|
|
|
+ const tsconfigPath = files.writeJson('tsconfig.json', {
|
|
|
+ compilerOptions: { paths: { matched: ['./targets/matched'] } },
|
|
|
+ })
|
|
|
+ initialize({ tsconfigPath })
|
|
|
+ const context: ResolveHookContext = {
|
|
|
+ conditions: [],
|
|
|
+ importAttributes: {},
|
|
|
+ parentURL: files.parentURL(),
|
|
|
+ }
|
|
|
+ const nextResolve = vi.fn(async (
|
|
|
+ specifier: string,
|
|
|
+ _context: ResolveHookContext,
|
|
|
+ ): Promise<ResolveFnOutput> => ({ url: `next:${specifier}` }))
|
|
|
+
|
|
|
+ await expect(resolveHook('matched', context, nextResolve))
|
|
|
+ .resolves.toEqual({ url: pathToFileURL(target).href, shortCircuit: true })
|
|
|
+ expect(nextResolve).not.toHaveBeenCalled()
|
|
|
+
|
|
|
+ for (const specifier of ['unmatched', 'node:fs', 'data:text/javascript,export default 1', 'https://example.test/mod.ts']) {
|
|
|
+ await expect(resolveHook(specifier, context, nextResolve)).resolves.toEqual({ url: `next:${specifier}` })
|
|
|
+ expect(nextResolve).toHaveBeenLastCalledWith(specifier, context)
|
|
|
+ }
|
|
|
+ })
|
|
|
+})
|
imccyu