feat: enhance stack trace for import

Author: shigma

packages/core/src/registry.ts

@@ -189,7 +189,7 @@ class Registry<out C extends Context = Context> {
     return this.plugin({ inject, apply: callback, name: callback.name })
   }
 
-  plugin(plugin: Plugin<C>, config?: any, getOuterStack: () => Iterable<string> = buildOuterStack()) {
+  plugin(plugin: Plugin<C>, config?: any, getOuterStack = buildOuterStack()) {
     // check if it's a valid plugin
     const callback = this.resolve(plugin)
     if (!callback) throw new Error('invalid plugin, expect function or object with an "apply" method, received ' + typeof plugin)

packages/core/src/scope.ts

@@ -62,7 +62,7 @@ export class EffectScope<out C extends Context = Context> {
     config: any,
     public inject: Dict<Inject.Meta>,
     public runtime: Plugin.Runtime | null,
-    private getOuterStack: () => Iterable<string>,
+    private getOuterStack: () => string[],
   ) {
     if (parent.scope) {
       this.uid = parent.registry.counter
@@ -193,6 +193,7 @@ export class EffectScope<out C extends Context = Context> {
   private async _reload() {
     try {
       await composeError(async (info) => {
+        info.offset += 1
         let result: any
         if (isConstructor(this.runtime!.callback)) {
           // eslint-disable-next-line new-cap
@@ -217,7 +218,7 @@ export class EffectScope<out C extends Context = Context> {
             this.disposables.push(dispose)
           }
         }
-      }, 2, this.getOuterStack)
+      }, this.getOuterStack)
     } catch (reason) {
       // the registry impl guarantees that the error is non-null
       this.context.emit(this.ctx, 'internal/error', reason)
@@ -232,7 +233,7 @@ export class EffectScope<out C extends Context = Context> {
   private async _unload() {
     await Promise.all(this.disposables.clear().map(async (dispose) => {
       try {
-        await composeError(dispose, 1, this.getOuterStack)
+        await composeError(dispose, this.getOuterStack)
       } catch (reason) {
         this.context.emit(this.ctx, 'internal/error', reason)
       }

packages/core/src/utils.ts

@@ -229,10 +229,10 @@ interface StackInfo {
   offset: number
 }
 
-export async function composeError<T>(callback: (info: StackInfo) => Promise<T>, offset: number, getOuterStack: () => Iterable<string>) {
+export async function composeError<T>(callback: (info: StackInfo) => Promise<T>, getOuterStack = buildOuterStack()) {
   // force async stack trace
   await Promise.resolve()
-  const info: StackInfo = { offset }
+  const info: StackInfo = { offset: 1 }
 
   try {
     return await callback(info)

packages/hmr/src/index.ts

@@ -134,6 +134,11 @@ class HMR extends Service {
     })
   }
 
+  // hide stack trace from HMR
+  getOuterStack = (): string[] => [
+    // '    at HMR.partialReload (<anonymous>)',
+  ]
+
   async getLinked(filename: string) {
     // The second parameter `type` should always be `javascript`.
     const job = this.internal.loadCache.get(pathToFileURL(filename).toString())
@@ -271,26 +276,25 @@ class HMR extends Service {
     const attempts: Dict = {}
     try {
       for (const [, { filename }] of reloads) {
-        attempts[filename] = this.ctx.loader.unwrapExports(await import(filename))
+        attempts[filename] = this.ctx.loader.unwrapExports(await this.ctx.loader.import(filename, this.getOuterStack))
       }
     } catch (e) {
       handleError(this.ctx, e)
       return rollback()
     }
 
-    const reload = (plugin: any, runtime?: Plugin.Runtime) => {
+    const reload = (plugin: any, runtime: Plugin.Runtime) => {
       if (!runtime) return
       for (const oldFiber of runtime.scopes) {
-        const scope = oldFiber.parent.registry.plugin(plugin, oldFiber.config, () => [
-          '    at HMR.partialReload (<anonymous>)',
-        ])
+        const scope = oldFiber.parent.registry.plugin(plugin, oldFiber.config, this.getOuterStack)
         scope.entry = oldFiber.entry
         if (scope.entry) scope.entry.scope = scope
       }
     }
 
     try {
       for (const [plugin, { filename, runtime }] of reloads) {
+        if (!runtime) continue
         const path = this.relative(fileURLToPath(filename))
 
         try {
@@ -313,6 +317,7 @@ class HMR extends Service {
       // rollback cache and plugin states
       rollback()
       for (const [plugin, { filename, runtime }] of reloads) {
+        if (!runtime) continue
         try {
           this.ctx.registry.delete(attempts[filename])
           reload(plugin, runtime)

packages/loader/src/config/entry.ts

@@ -1,4 +1,4 @@
-import { composeError, Context, EffectScope } from '@cordisjs/core'
+import { Context, EffectScope } from '@cordisjs/core'
 import { isNullable } from 'cosmokit'
 import { Loader } from '../loader.ts'
 import { EntryGroup } from './group.ts'
@@ -157,9 +157,7 @@ export class Entry<C extends Context = Context> {
   private async _init() {
     let exports: any
     try {
-      exports = await composeError(async () => {
-        return this.parent.tree.import(this.options.name)
-      }, 2, this.getOuterStack)
+      exports = await this.parent.tree.import(this.options.name, this.getOuterStack, true)
     } catch (error) {
       this.context.emit(this.ctx, 'internal/error', error)
       return

packages/loader/src/config/tree.ts

@@ -1,4 +1,4 @@
-import { Context } from '@cordisjs/core'
+import { composeError, Context } from '@cordisjs/core'
 import { Dict } from 'cosmokit'
 import { Entry, EntryOptions } from './entry.ts'
 import { EntryGroup } from './group.ts'
@@ -95,12 +95,18 @@ export abstract class EntryTree<C extends Context = Context> {
     return entry.update(options)
   }
 
-  async import(name: string) {
-    if (this.ctx.loader.internal) {
-      return await this.ctx.loader.internal.import(name, this.url, {})
-    } else {
-      return await import(name)
-    }
+  import(name: string, getOuterStack?: () => string[], useInternal = false) {
+    return composeError(async (info) => {
+      // ModuleJob.run
+      // onImport.tracePromise.__proto__
+      // internal.import
+      info.offset += 3
+      if (useInternal && this.ctx.loader.internal) {
+        return await this.ctx.loader.internal.import(name, this.url, {})
+      } else {
+        return await import(name)
+      }
+    }, getOuterStack)
   }
 
   abstract write(): void