v0.3.0-beta.10

Author: ije

bundler/mod.ts

@@ -8,7 +8,8 @@ import type { DependencyGraph } from '../server/analyzer.ts'
 import type { Aleph } from '../server/aleph.ts'
 import { clearBuildCache, computeHash, getAlephPkgUri } from '../server/helper.ts'
 import { ensureTextFile, existsFile, lazyRemove } from '../shared/fs.ts'
-import type { BrowserName, Module } from '../types.d.ts'
+import util from '../shared/util.ts'
+import type { BrowserName, Module, DependencyDescriptor } from '../types.d.ts'
 import { VERSION } from '../version.ts'
 import { esbuild, stopEsbuild, esmLoader } from './esbuild.ts'
 
@@ -136,7 +137,7 @@ export class Bundler {
       return jsFile
     }
 
-    let source = await this.#aleph.resolveModuleSource(mod.specifier)
+    let source = 'source' in mod ? (mod as any).source : await this.#aleph.resolveModuleSource(mod.specifier)
     if (source === null) {
       this.#compiled.delete(mod.specifier)
       throw new Error(`Unsupported module '${mod.specifier}'`)
@@ -175,8 +176,22 @@ export class Bundler {
         }
       }
 
+      let extraDeps: DependencyDescriptor[] = []
+      for (const { test, transform } of this.#aleph.transformListeners) {
+        if (test instanceof RegExp && test.test(mod.specifier)) {
+          const { jsBuffer, ready, ...rest } = mod
+          const ret = await transform({ module: { ...structuredClone(rest) }, code, bundleMode: true })
+          if (util.isFilledString(ret?.code)) {
+            code = ret!.code
+          }
+          if (Array.isArray(ret?.extraDeps)) {
+            extraDeps.push(...ret!.extraDeps)
+          }
+        }
+      }
+
       // compile deps
-      await Promise.all(mod.deps.map(async dep => {
+      await Promise.all(mod.deps.concat(extraDeps).map(async dep => {
         if (!dep.specifier.startsWith('#') && !externals.includes(dep.specifier)) {
           const depMod = this.#aleph.getModule(dep.specifier)
           if (depMod !== null) {

server/aleph.ts

@@ -471,6 +471,10 @@ export class Aleph implements IAleph {
     return this.#ready
   }
 
+  get transformListeners() {
+    return this.#transformListeners
+  }
+
   /** get the module by given specifier. */
   getModule(specifier: string): Module | null {
     if (specifier === 'app') {
@@ -532,21 +536,23 @@ export class Aleph implements IAleph {
     if (sourceType === SourceType.Unknown) {
       throw new Error("addModule: unknown souce type")
     }
+    const source = {
+      code: sourceCode,
+      type: sourceType,
+    }
     const module = await this.compile(specifier, {
-      source: {
-        code: sourceCode,
-        type: sourceType,
-      },
+      source,
       forceRefresh,
     })
     if (specifier.startsWith('pages/') || specifier.startsWith('api/')) {
       specifier = '/' + specifier
     }
-    if (specifier.startsWith('/pages/')) {
+    if (specifier.startsWith('/pages/') && this.isPageModule(specifier)) {
       this.#pageRouting.update(...this.createRouteUpdate(specifier))
     } else if (specifier.startsWith('/api/') && !specifier.startsWith('/api/_middlewares.')) {
       this.#apiRouting.update(...this.createRouteUpdate(specifier))
     }
+    Object.assign(module, { source })
     return module
   }
 
@@ -1025,6 +1031,21 @@ export class Aleph implements IAleph {
     })
   }
 
+  resolveImport({ jsFile, sourceHash }: Module, importer: string, bundleMode?: boolean, timeStamp?: boolean): string {
+    const relPath = toRelativePath(
+      dirname(toLocalPath(importer)),
+      jsFile
+    )
+    if (bundleMode) {
+      return util.trimSuffix(relPath, '.js') + '.bundling.js'
+    }
+    let hash = '#' + sourceHash.slice(0, 8)
+    if (timeStamp) {
+      hash += '-' + Date.now()
+    }
+    return relPath + hash
+  }
+
   async resolveModuleSource(specifier: string, data?: any): Promise<ModuleSource> {
     let sourceCode: string = ''
     let sourceType: SourceType = SourceType.Unknown
@@ -1152,14 +1173,9 @@ export class Aleph implements IAleph {
 
     if (!forceRefresh && await existsFile(metaFp)) {
       try {
-        const { specifier: _specifier, sourceHash, deps, isStyle, ssrPropsFn, ssgPathsFn, denoHooks } = JSON.parse(await Deno.readTextFile(metaFp))
-        if (_specifier === specifier && util.isFilledString(sourceHash) && util.isArray(deps)) {
-          mod.sourceHash = sourceHash
-          mod.deps = deps
-          mod.isStyle = Boolean(isStyle) || undefined
-          mod.ssrPropsFn = util.isFilledString(ssrPropsFn) ? ssrPropsFn : undefined
-          mod.ssgPathsFn = Boolean(ssgPathsFn) || undefined
-          mod.denoHooks = util.isFilledArray(denoHooks) ? denoHooks : undefined
+        const meta = JSON.parse(await Deno.readTextFile(metaFp))
+        if (meta.specifier === specifier && util.isFilledString(meta.sourceHash) && util.isArray(meta.deps)) {
+          Object.assign(mod, meta)
         } else {
           log.warn(`removing invalid metadata '${name}.meta.json'`)
           Deno.remove(metaFp)
@@ -1413,22 +1429,14 @@ export class Aleph implements IAleph {
   }
 
   private async cacheModule(module: Module, sourceMap?: string) {
-    const { specifier, jsBuffer, jsFile } = module
+    const { jsBuffer, jsFile, ready, ...rest } = module
     if (jsBuffer) {
       const cacheFp = join(this.#buildDir, jsFile)
       const metaFp = cacheFp.slice(0, -3) + '.meta.json'
       await ensureDir(dirname(cacheFp))
       await Promise.all([
         Deno.writeFile(cacheFp, jsBuffer),
-        Deno.writeTextFile(metaFp, JSON.stringify({
-          specifier,
-          sourceHash: module.sourceHash,
-          isStyle: module.isStyle,
-          ssrPropsFn: module.ssrPropsFn,
-          ssgPathsFn: module.ssgPathsFn,
-          denoHooks: module.denoHooks,
-          deps: module.deps,
-        }, undefined, 2)),
+        Deno.writeTextFile(metaFp, JSON.stringify({ ...rest }, undefined, 2)),
         sourceMap ? Deno.writeTextFile(`${cacheFp}.map`, sourceMap) : Promise.resolve(),
         lazyRemove(cacheFp.slice(0, -3) + '.bundling.js'),
       ])

types.d.ts

@@ -8,6 +8,7 @@ export interface Aleph {
   addDist(path: string, content: Uint8Array): Promise<void>
   addModule(specifier: string, sourceCode: string, forceRefresh?: boolean): Promise<Module>
   fetchModule(specifier: string): Promise<{ content: Uint8Array, contentType: string | null }>
+  resolveImport(module: Module, importer: string, bundleMode?: boolean, timeStamp?: boolean): string
   onResolve(test: RegExp, resolve: (specifier: string) => ResolveResult): void
   onLoad(test: RegExp, load: (input: LoadInput) => LoadOutput | Promise<LoadOutput>): void
   onTransform(test: 'hmr' | 'main' | RegExp, transform: (input: TransformInput) => TransformOutput | void | Promise<TransformOutput | void>): void
@@ -91,6 +92,7 @@ export type LoadOutput = {
 export type TransformInput = {
   module: Omit<Module, 'jsBuffer' | 'ready'>
   code: string
+  bundleMode?: boolean
   map?: string
 }
 

version.ts

@@ -1,5 +1,5 @@
 /** `VERSION` managed by https://deno.land/x/publish */
-export const VERSION = '0.3.0-beta.9'
+export const VERSION = '0.3.0-beta.10'
 
 /** `prepublish` will be invoked before publish */
 export async function prepublish(version: string): Promise<boolean> {