feat(plugin): add resolve method of loader

Author: ije

server/app.ts

@@ -558,89 +558,23 @@ export class Application implements ServerApplication {
     ]
   }
 
-  /** fetch module content */
-  async fetchModule(url: string): Promise<{ content: Uint8Array, contentType: string | null }> {
-    if (!util.isLikelyHttpURL(url)) {
-      const filepath = path.join(this.srcDir, util.trimPrefix(url, 'file://'))
-      const content = await Deno.readFile(filepath)
-      return { content, contentType: null }
-    }
-
-    const u = new URL(url)
-    if (url.startsWith('https://esm.sh/')) {
-      if (this.isDev && !u.searchParams.has('dev')) {
-        u.searchParams.set('dev', '')
-        u.search = u.search.replace('dev=', 'dev')
-      }
-    }
-
-    const { protocol, hostname, port, pathname, search } = u
-    const versioned = reFullVersion.test(pathname)
-    const reload = this.#reloading || !versioned
-    const isLocalhost = url.startsWith('http://localhost:')
-    const cacheDir = path.join(
-      await getDenoDir(),
-      'deps',
-      util.trimSuffix(protocol, ':'),
-      hostname + (port ? '_PORT' + port : '')
-    )
-    const hash = createHash('sha256').update(pathname + search).toString()
-    const contentFile = path.join(cacheDir, hash)
-    const metaFile = path.join(cacheDir, hash + '.metadata.json')
-
-    if (!reload && !isLocalhost && existsFileSync(contentFile) && existsFileSync(metaFile)) {
-      const [content, meta] = await Promise.all([
-        Deno.readFile(contentFile),
-        Deno.readTextFile(metaFile),
-      ])
-      try {
-        const { headers } = JSON.parse(meta)
-        return {
-          content,
-          contentType: headers['content-type'] || null
-        }
-      } catch (e) { }
+  async resolveModule(url: string) {
+    const { content, contentType } = await this.fetchModule(url)
+    const source = await this.precompile(url, content, contentType)
+    if (source === null) {
+      throw new Error(`Unsupported module '${url}'`)
     }
+    return source
+  }
 
-    // download dep when deno cache failed
-    let err = new Error('Unknown')
-    for (let i = 0; i < 15; i++) {
-      if (i === 0) {
-        if (!isLocalhost) {
-          log.info('Download', url)
-        }
-      } else {
-        log.debug('Download error:', err)
-        log.warn(`Download ${url} failed, retrying...`)
-      }
-      try {
-        const resp = await fetch(u.toString())
-        if (resp.status >= 400) {
-          return Promise.reject(new Error(resp.statusText))
-        }
-        const buffer = await resp.arrayBuffer()
-        const content = await Deno.readAll(new Deno.Buffer(buffer))
-        if (!isLocalhost) {
-          await ensureDir(cacheDir)
-          Deno.writeFile(contentFile, content)
-          Deno.writeTextFile(metaFile, JSON.stringify({
-            headers: Array.from(resp.headers.entries()).reduce((m, [k, v]) => {
-              m[k] = v
-              return m
-            }, {} as Record<string, string>),
-            url
-          }, undefined, 2))
-        }
-        return {
-          content,
-          contentType: resp.headers.get('content-type')
-        }
-      } catch (e) {
-        err = e
-      }
+  /** default compiler options */
+  private get defaultCompileOptions(): TransformOptions {
+    return {
+      importMap: this.importMap,
+      alephPkgUri: getAlephPkgUri(),
+      reactVersion: defaultReactVersion,
+      isDev: this.isDev,
     }
-
-    return Promise.reject(err)
   }
 
   /** build the application to a static site(SSG) */
@@ -731,17 +665,107 @@ export class Application implements ServerApplication {
     return { code, map }
   }
 
-  /** default compiler options */
-  private get defaultCompileOptions(): TransformOptions {
-    return {
-      importMap: this.importMap,
-      alephPkgUri: getAlephPkgUri(),
-      reactVersion: defaultReactVersion,
-      isDev: this.isDev,
+  /** fetch module content */
+  private async fetchModule(url: string): Promise<{ content: Uint8Array, contentType: string | null }> {
+    for (const plugin of this.config.plugins) {
+      if (plugin.type === 'loader' && plugin.test.test(url) && plugin.resolve !== undefined) {
+        const ret = plugin.resolve(url)
+        let content: Uint8Array
+        if (ret instanceof Promise) {
+          content = (await ret).content
+        } else {
+          content = ret.content
+        }
+        if (content instanceof Uint8Array) {
+          return { content, contentType: null }
+        }
+      }
+    }
+
+    if (!util.isLikelyHttpURL(url)) {
+      const filepath = path.join(this.srcDir, util.trimPrefix(url, 'file://'))
+      const content = await Deno.readFile(filepath)
+      return { content, contentType: null }
+    }
+
+    const u = new URL(url)
+    if (url.startsWith('https://esm.sh/')) {
+      if (this.isDev && !u.searchParams.has('dev')) {
+        u.searchParams.set('dev', '')
+        u.search = u.search.replace('dev=', 'dev')
+      }
     }
+
+    const { protocol, hostname, port, pathname, search } = u
+    const versioned = reFullVersion.test(pathname)
+    const reload = this.#reloading || !versioned
+    const isLocalhost = url.startsWith('http://localhost:')
+    const cacheDir = path.join(
+      await getDenoDir(),
+      'deps',
+      util.trimSuffix(protocol, ':'),
+      hostname + (port ? '_PORT' + port : '')
+    )
+    const hash = createHash('sha256').update(pathname + search).toString()
+    const contentFile = path.join(cacheDir, hash)
+    const metaFile = path.join(cacheDir, hash + '.metadata.json')
+
+    if (!reload && !isLocalhost && existsFileSync(contentFile) && existsFileSync(metaFile)) {
+      const [content, meta] = await Promise.all([
+        Deno.readFile(contentFile),
+        Deno.readTextFile(metaFile),
+      ])
+      try {
+        const { headers } = JSON.parse(meta)
+        return {
+          content,
+          contentType: headers['content-type'] || null
+        }
+      } catch (e) { }
+    }
+
+    // download dep when deno cache failed
+    let err = new Error('Unknown')
+    for (let i = 0; i < 15; i++) {
+      if (i === 0) {
+        if (!isLocalhost) {
+          log.info('Download', url)
+        }
+      } else {
+        log.debug('Download error:', err)
+        log.warn(`Download ${url} failed, retrying...`)
+      }
+      try {
+        const resp = await fetch(u.toString())
+        if (resp.status >= 400) {
+          return Promise.reject(new Error(resp.statusText))
+        }
+        const buffer = await resp.arrayBuffer()
+        const content = await Deno.readAll(new Deno.Buffer(buffer))
+        if (!isLocalhost) {
+          await ensureDir(cacheDir)
+          Deno.writeFile(contentFile, content)
+          Deno.writeTextFile(metaFile, JSON.stringify({
+            headers: Array.from(resp.headers.entries()).reduce((m, [k, v]) => {
+              m[k] = v
+              return m
+            }, {} as Record<string, string>),
+            url
+          }, undefined, 2))
+        }
+        return {
+          content,
+          contentType: resp.headers.get('content-type')
+        }
+      } catch (e) {
+        err = e
+      }
+    }
+
+    return Promise.reject(err)
   }
 
-  async precompile(
+  private async precompile(
     url: string,
     sourceContent: Uint8Array,
     contentType: string | null
@@ -1009,16 +1033,6 @@ export class Application implements ServerApplication {
     }
   }
 
-  private replaceDepHash(jsContent: string, dep: DependencyDescriptor) {
-    const s = `.js#${dep.url}@`
-    return jsContent.split(s).map((p, i) => {
-      if (i > 0 && p.charAt(6) === '"') {
-        return dep.hash.slice(0, 6) + p.slice(6)
-      }
-      return p
-    }).join(s)
-  }
-
   /** create bundle chunks for production. */
   private async bundle() {
     const sharedEntryMods = new Set<string>()
@@ -1176,6 +1190,16 @@ export class Application implements ServerApplication {
     return ssr
   }
 
+  private replaceDepHash(jsContent: string, dep: DependencyDescriptor) {
+    const s = `.js#${dep.url}@`
+    return jsContent.split(s).map((p, i) => {
+      if (i > 0 && p.charAt(6) === '"') {
+        return dep.hash.slice(0, 6) + p.slice(6)
+      }
+      return p
+    }).join(s)
+  }
+
   /** lookup deps recurively. */
   private lookupDeps(
     url: string,

server/bundler.ts

@@ -1,5 +1,5 @@
 import { ECMA, minify as terser } from 'https://esm.sh/[email protected]'
-import { transform } from '../compiler/mod.ts'
+import { transform, parseExportNames } from '../compiler/mod.ts'
 import { colors, ensureDir, path } from '../deps.ts'
 import { trimModuleExt } from '../framework/core/module.ts'
 import { defaultReactVersion } from '../shared/constants.ts'
@@ -130,14 +130,13 @@ export class Bundler {
       return bundlingFile
     }
 
-    const { content, contentType } = await this.#app.fetchModule(mod.url)
-    const source = await this.#app.precompile(mod.url, content, contentType)
+    const source = await this.#app.resolveModule(mod.url)
     if (source === null) {
       throw new Error(`Unsupported module '${mod.url}'`)
     }
 
     const [sourceCode, sourceType] = source
-    let { code } = await transform(
+    let { code, bundleStarExports } = await transform(
       mod.url,
       sourceCode,
       {
@@ -154,6 +153,15 @@ export class Bundler {
       }
     )
 
+    if (bundleStarExports && bundleStarExports.length > 0) {
+      for (let index = 0; index < bundleStarExports.length; index++) {
+        const url = bundleStarExports[index]
+        const [sourceCode, sourceType] = await this.#app.resolveModule(url)
+        const names = await parseExportNames(url, sourceCode, { sourceType })
+        code = code.replace(`export const $$star_${index}`, `export const {${names.filter(name => name !== 'default').join(',')}}`)
+      }
+    }
+
     // compile deps
     for (const dep of mod.deps) {
       if (!dep.url.startsWith('#') && !external.includes(dep.url)) {

types.ts

@@ -14,6 +14,8 @@ export type LoaderPlugin = {
   acceptHMR?: boolean
   /** `asPage` allows the loaded module as a page. */
   asPage?: boolean
+  /** `resolve` resolves the module content. */
+  resolve?(url: string): { content: Uint8Array } | Promise<{ content: Uint8Array }>
   /** `transform` transforms the source content. */
   transform(source: { url: string, content: Uint8Array, map?: Uint8Array }): LoaderTransformResult | Promise<LoaderTransformResult>
 }