FilesExpand file tree

master

/

esm-loader.mjs

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

152 lines (129 loc) · 4.08 KB

master

/

esm-loader.mjs

Copy path

Top

File metadata and controls

• Code
• Blame

152 lines (129 loc) · 4.08 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

// ESM loader for module-alias

// Provides resolve hooks for ES modules

import { readFileSync, existsSync, statSync } from 'node:fs'

import { join, resolve as pathResolve, dirname } from 'node:path'

import { fileURLToPath, pathToFileURL } from 'node:url'

let aliases = {}

let moduleDirectories = []

let base = process.cwd()

let initialized = false

export function init (options = {}) {

if (initialized) return

const thisDir = dirname(fileURLToPath(import.meta.url))

const candidatePaths = options.base

? [pathResolve(options.base)]

: [join(thisDir, '../..'), process.cwd()]

let pkg

for (const candidate of candidatePaths) {

try {

pkg = JSON.parse(readFileSync(join(candidate, 'package.json'), 'utf8'))

base = candidate

break

} catch (e) {

// Continue to next candidate

}

}

if (!pkg) {

console.warn('[module-alias] Unable to find package.json in:', candidatePaths.join(', '))

initialized = true

return

}

// Load _moduleAliases

const pkgAliases = pkg._moduleAliases || {}

for (const alias in pkgAliases) {

const target = pkgAliases[alias]

aliases[alias] = target.startsWith('/') ? target : join(base, target)

}

// Load _moduleDirectories

if (Array.isArray(pkg._moduleDirectories)) {

moduleDirectories = pkg._moduleDirectories

.filter(d => d !== 'node_modules')

.map(d => join(base, d))

}

initialized = true

}

export function isPathMatchesAlias (path, alias) {

// Matching /^alias(\/|$)/

if (path.indexOf(alias) === 0) {

if (path.length === alias.length) return true

if (path[alias.length] === '/') return true

}

return false

}

export function resolveAlias (specifier, parentURL) {

init() // Ensure initialized

// Sort aliases by length (longest first) for correct matching

const sortedAliases = Object.keys(aliases).sort((a, b) => b.length - a.length)

for (const alias of sortedAliases) {

if (isPathMatchesAlias(specifier, alias)) {

const target = aliases[alias]

// Function-based resolver

if (typeof target === 'function') {

const parentPath = parentURL ? fileURLToPath(parentURL) : process.cwd()

const result = target(parentPath, specifier, alias)

if (!result || typeof result !== 'string') {

throw new Error('[module-alias] Custom handler must return path')

}

return result

}

// String path - join target with remainder of specifier

return join(target, specifier.slice(alias.length))

}

}

// Check moduleDirectories

for (const dir of moduleDirectories) {

const modulePath = join(dir, specifier)

// Check for directory with index.mjs/index.js

if (existsSync(join(modulePath, 'index.mjs'))) {

return join(modulePath, 'index.mjs')

}

if (existsSync(join(modulePath, 'index.js'))) {

return join(modulePath, 'index.js')

}

// Check for file with extension

if (existsSync(modulePath + '.mjs')) {

return modulePath + '.mjs'

}

if (existsSync(modulePath + '.js')) {

return modulePath + '.js'

}

// Check for exact file

if (existsSync(modulePath) && !statSync(modulePath).isDirectory()) {

return modulePath

}

}

return null

}

export function addAlias (alias, target) {

aliases[alias] = target

}

export function addAliases (aliasMap) {

for (const alias in aliasMap) {

addAlias(alias, aliasMap[alias])

}

}

export function addPath (path) {

moduleDirectories.push(path)

}

export function reset () {

aliases = {}

moduleDirectories = []

base = process.cwd()

initialized = false

}

// For Node 18-21: async loader hooks

export async function resolve (specifier, context, nextResolve) {

const resolved = resolveAlias(specifier, context.parentURL)

if (resolved) {

// If absolute path, convert to file URL

if (resolved.startsWith('/')) {

return { url: pathToFileURL(resolved).href, shortCircuit: true }

}

// Otherwise let Node resolve it (could be npm package)

return nextResolve(resolved, context)

}

return nextResolve(specifier, context)

}

export async function initialize (data) {

init(data || {})

}