Rename fetchModule to fetchModuleSource

Author: ije

bundler/mod.ts

@@ -134,7 +134,7 @@ export class Bundler {
       return jsFile
     }
 
-    const source = await this.#aleph.loadModuleSource(mod.specifier)
+    const source = await this.#aleph.resolveModuleSource(mod.specifier)
     if (source === null) {
       this.#compiled.delete(mod.specifier)
       throw new Error(`Unsupported module '${mod.specifier}'`)

plugins/css.ts

@@ -76,7 +76,7 @@ export const cssLoader = async ({ specifier, data }: LoadInput, aleph: Aleph): P
   } else if (util.isFilledString(data)) {
     sourceCode = data
   } else {
-    const { content } = await aleph.fetchModule(specifier)
+    const { content } = await aleph.fetchModuleSource(specifier)
     sourceCode = (new TextDecoder).decode(content)
   }
 

plugins/markdown.ts

@@ -19,7 +19,7 @@ export const markdownResovler = (specifier: string): ResolveResult => {
 
 export const markdownLoader = async ({ specifier }: LoadInput, aleph: Aleph): Promise<LoadOutput> => {
   const { framework } = aleph.config
-  const { content } = await aleph.fetchModule(specifier)
+  const { content } = await aleph.fetchModuleSource(specifier)
   const { __content, ...meta } = safeLoadFront((new TextDecoder).decode(content))
   const html = marked.parse(__content)
   const props = {

server/aleph.ts

@@ -733,7 +733,7 @@ export class Aleph implements IAleph {
 
   /** parse the export names of the module. */
   async parseModuleExportNames(specifier: string): Promise<string[]> {
-    const { content, contentType } = await this.fetchModule(specifier)
+    const { content, contentType } = await this.fetchModuleSource(specifier)
     const sourceType = getSourceType(specifier, contentType || undefined)
     if (sourceType === SourceType.Unknown || sourceType === SourceType.CSS) {
       return []
@@ -873,34 +873,6 @@ export class Aleph implements IAleph {
     return [routePath, specifier, isIndex]
   }
 
-  /** fetch module content by the specifier. */
-  async fetchModule(specifier: string): Promise<{ content: Uint8Array, contentType: string | null }> {
-    if (!util.isLikelyHttpURL(specifier)) {
-      const filepath = join(this.workingDir, this.config.srcDir, util.trimPrefix(specifier, 'file://'))
-      if (await existsFile(filepath)) {
-        const content = await Deno.readFile(filepath)
-        return { content, contentType: getContentType(filepath) }
-      } else {
-        return Promise.reject(new Error(`No such file: ${util.trimPrefix(filepath, this.workingDir + '/')}`))
-      }
-    }
-
-    // append `dev` query for development mode
-    if (this.isDev && specifier.startsWith('https://esm.sh/')) {
-      const u = new URL(specifier)
-      if (!u.searchParams.has('dev')) {
-        u.searchParams.set('dev', '')
-        u.search = u.search.replace('dev=', 'dev')
-        specifier = u.toString()
-      }
-    }
-
-    return await cache(specifier, {
-      forceRefresh: this.#reloading,
-      retryTimes: 10
-    })
-  }
-
   async importModule<T = any>({ jsFile, hash, sourceHash }: Module): Promise<T> {
     return await import(`file://${join(this.buildDir, jsFile)}#${(hash || sourceHash).slice(0, 6)}`)
   }
@@ -952,7 +924,35 @@ export class Aleph implements IAleph {
     ].join('\n'))
   }
 
-  async loadModuleSource(specifier: string, data?: any): Promise<ModuleSource> {
+  /** fetch module source by the specifier. */
+  async fetchModuleSource(specifier: string): Promise<{ content: Uint8Array, contentType: string | null }> {
+    if (!util.isLikelyHttpURL(specifier)) {
+      const filepath = join(this.workingDir, this.config.srcDir, util.trimPrefix(specifier, 'file://'))
+      if (await existsFile(filepath)) {
+        const content = await Deno.readFile(filepath)
+        return { content, contentType: getContentType(filepath) }
+      } else {
+        return Promise.reject(new Error(`No such file: ${util.trimPrefix(filepath, this.workingDir + '/')}`))
+      }
+    }
+
+    // append `dev` query for development mode
+    if (this.isDev && specifier.startsWith('https://esm.sh/')) {
+      const u = new URL(specifier)
+      if (!u.searchParams.has('dev')) {
+        u.searchParams.set('dev', '')
+        u.search = u.search.replace('dev=', 'dev')
+        specifier = u.toString()
+      }
+    }
+
+    return await cache(specifier, {
+      forceRefresh: this.#reloading,
+      retryTimes: 10
+    })
+  }
+
+  async resolveModuleSource(specifier: string, data?: any): Promise<ModuleSource> {
     let sourceCode: string = ''
     let sourceType: SourceType = SourceType.Unknown
     let sourceMap: string | null = null
@@ -981,7 +981,7 @@ export class Aleph implements IAleph {
       sourceCode = code
       sourceMap = map || null
     } else {
-      const source = await this.fetchModule(specifier)
+      const source = await this.fetchModuleSource(specifier)
       sourceType = getSourceType(specifier, source.contentType || undefined)
       if (sourceType !== SourceType.Unknown) {
         sourceCode = (new TextDecoder).decode(source.content)
@@ -1104,7 +1104,7 @@ export class Aleph implements IAleph {
     )
     if (shouldLoad) {
       try {
-        const src = customSource || await this.loadModuleSource(specifier, data)
+        const src = customSource || await this.resolveModuleSource(specifier, data)
         const sourceHash = computeHash(src.code)
         if (mod.sourceHash === '' || mod.sourceHash !== sourceHash) {
           mod.sourceHash = sourceHash

types.ts

@@ -5,9 +5,9 @@ export interface Aleph {
   readonly mode: 'development' | 'production'
   readonly workingDir: string
   readonly config: RequiredConfig
-  addModule(specifier: string, sourceCode?: string): Promise<void>
   addDist(path: string, content: Uint8Array): Promise<void>
-  fetchModule(specifier: string): Promise<{ content: Uint8Array, contentType: string | null }>
+  addModule(specifier: string, sourceCode?: string): Promise<void>
+  fetchModuleSource(specifier: string): Promise<{ content: Uint8Array, contentType: string | null }>
   onResolve(test: RegExp, resolve: (specifier: string) => ResolveResult): void
   onLoad(test: RegExp, load: (input: LoadInput) => LoadOutput | Promise<LoadOutput>): void
   onTransform(test: 'hmr' | 'mainscript' | RegExp, transform: (input: TransformInput) => TransformOutput): void