metro 0.75.1 → 0.76.0

package/src/ModuleGraph/worker/collectDependencies.js.flow

@@ -22,19 +22,16 @@ const generate = require('@babel/generator').default;
 const template = require('@babel/template').default;
 const traverse = require('@babel/traverse').default;
 const types = require('@babel/types');
-const invariant = require('invariant');
 const nullthrows = require('nullthrows');
 
 const {isImport} = types;
 
 type ImportDependencyOptions = $ReadOnly<{
   asyncType: AsyncDependencyType,
-  jsResource?: boolean,
-  splitCondition?: NodePath<>,
 }>;
 
-export type Dependency<TSplitCondition> = $ReadOnly<{
-  data: DependencyData<TSplitCondition>,
+export type Dependency = $ReadOnly<{
+  data: DependencyData,
   name: string,
 }>;
 
@@ -52,35 +49,31 @@ export type RequireContextParams = $ReadOnly<{
   mode: ContextMode,
 }>;
 
-type DependencyData<TSplitCondition> = $ReadOnly<{
+type DependencyData = $ReadOnly<{
   // A locally unique key for this dependency within the current module.
   key: string,
   // If null, then the dependency is synchronous.
   // (ex. `require('foo')`)
   asyncType: AsyncDependencyType | null,
   isOptional?: boolean,
-  // If left unspecified, then the dependency is unconditionally split.
-  splitCondition?: TSplitCondition,
   locs: Array<BabelSourceLocation>,
   /** Context for requiring a collection of modules. */
   contextParams?: RequireContextParams,
 }>;
 
-export type MutableInternalDependency<TSplitCondition> = {
-  ...DependencyData<TSplitCondition>,
+export type MutableInternalDependency = {
+  ...DependencyData,
   index: number,
   name: string,
 };
 
-export type InternalDependency<TSplitCondition> = $ReadOnly<
-  MutableInternalDependency<TSplitCondition>,
->;
+export type InternalDependency = $ReadOnly<MutableInternalDependency>;
 
-export type State<TSplitCondition> = {
+export type State = {
   asyncRequireModulePathStringLiteral: ?StringLiteral,
   dependencyCalls: Set<string>,
-  dependencyRegistry: ModuleDependencyRegistry<TSplitCondition>,
-  dependencyTransformer: DependencyTransformer<TSplitCondition>,
+  dependencyRegistry: ModuleDependencyRegistry,
+  dependencyTransformer: DependencyTransformer,
   dynamicRequires: DynamicRequiresBehavior,
   dependencyMapIdentifier: ?Identifier,
   keepRequireNames: boolean,
@@ -89,61 +82,51 @@ export type State<TSplitCondition> = {
   unstable_allowRequireContext: boolean,
 };
 
-export type Options<TSplitCondition = void> = $ReadOnly<{
+export type Options = $ReadOnly<{
   asyncRequireModulePath: string,
   dependencyMapName: ?string,
   dynamicRequires: DynamicRequiresBehavior,
   inlineableCalls: $ReadOnlyArray<string>,
   keepRequireNames: boolean,
   allowOptionalDependencies: AllowOptionalDependencies,
-  dependencyRegistry?: ModuleDependencyRegistry<TSplitCondition>,
-  dependencyTransformer?: DependencyTransformer<TSplitCondition>,
+  dependencyRegistry?: ModuleDependencyRegistry,
+  dependencyTransformer?: DependencyTransformer,
   /** Enable `require.context` statements which can be used to import multiple files in a directory. */
   unstable_allowRequireContext: boolean,
 }>;
 
-export type CollectedDependencies<+TSplitCondition> = $ReadOnly<{
+export type CollectedDependencies = $ReadOnly<{
   ast: BabelNodeFile,
   dependencyMapName: string,
-  dependencies: $ReadOnlyArray<Dependency<TSplitCondition>>,
+  dependencies: $ReadOnlyArray<Dependency>,
 }>;
 
 // Registry for the dependency of a module.
 // Defines when dependencies should be collapsed.
 // E.g. should a module that's once required optionally and once not
 // be treated as the same or different dependencies.
-export interface ModuleDependencyRegistry<+TSplitCondition> {
-  registerDependency(
-    qualifier: ImportQualifier,
-  ): InternalDependency<TSplitCondition>;
-  getDependencies(): Array<InternalDependency<TSplitCondition>>;
+export interface ModuleDependencyRegistry {
+  registerDependency(qualifier: ImportQualifier): InternalDependency;
+  getDependencies(): Array<InternalDependency>;
 }
 
-export interface DependencyTransformer<-TSplitCondition> {
+export interface DependencyTransformer {
   transformSyncRequire(
     path: NodePath<CallExpression>,
-    dependency: InternalDependency<TSplitCondition>,
-    state: State<TSplitCondition>,
+    dependency: InternalDependency,
+    state: State,
   ): void;
   transformImportCall(
     path: NodePath<>,
-    dependency: InternalDependency<TSplitCondition>,
-    state: State<TSplitCondition>,
-  ): void;
-  transformJSResource(
-    path: NodePath<>,
-    dependency: InternalDependency<TSplitCondition>,
-    state: State<TSplitCondition>,
+    dependency: InternalDependency,
+    state: State,
   ): void;
   transformPrefetch(
     path: NodePath<>,
-    dependency: InternalDependency<TSplitCondition>,
-    state: State<TSplitCondition>,
-  ): void;
-  transformIllegalDynamicRequire(
-    path: NodePath<>,
-    state: State<TSplitCondition>,
+    dependency: InternalDependency,
+    state: State,
   ): void;
+  transformIllegalDynamicRequire(path: NodePath<>, state: State): void;
 }
 
 export type DynamicRequiresBehavior = 'throwAtRuntime' | 'reject';
@@ -157,13 +140,13 @@ export type DynamicRequiresBehavior = 'throwAtRuntime' | 'reject';
  *
  * The second argument is only provided for debugging purposes.
  */
-function collectDependencies<TSplitCondition = void>(
+function collectDependencies(
   ast: BabelNodeFile,
-  options: Options<TSplitCondition>,
-): CollectedDependencies<TSplitCondition> {
+  options: Options,
+): CollectedDependencies {
   const visited = new WeakSet<BabelNodeCallExpression>();
 
-  const state: State<TSplitCondition> = {
+  const state: State = {
     asyncRequireModulePathStringLiteral: null,
     dependencyCalls: new Set(),
     dependencyRegistry:
@@ -180,7 +163,7 @@ function collectDependencies<TSplitCondition = void>(
   const visitor = {
     CallExpression(
       path: NodePath<BabelNodeCallExpression>,
-      state: State<TSplitCondition>,
+      state: State,
     ): void {
       if (visited.has(path.node)) {
         return;
@@ -203,29 +186,6 @@ function collectDependencies<TSplitCondition = void>(
         return;
       }
 
-      if (name === '__jsResource' && !path.scope.getBinding(name)) {
-        processImportCall(path, state, {
-          asyncType: 'async',
-          jsResource: true,
-        });
-        return;
-      }
-
-      if (
-        name === '__conditionallySplitJSResource' &&
-        !path.scope.getBinding(name)
-      ) {
-        const args = path.get('arguments');
-        invariant(Array.isArray(args), 'Expected arguments to be an array');
-
-        processImportCall(path, state, {
-          asyncType: 'async',
-          jsResource: true,
-          splitCondition: args[1],
-        });
-        return;
-      }
-
       // Match `require.context`
       if (
         // Feature gate, defaults to `false`.
@@ -246,6 +206,24 @@ function collectDependencies<TSplitCondition = void>(
         return;
       }
 
+      // Match `require.resolveWeak`
+      if (
+        callee.type === 'MemberExpression' &&
+        // `require`
+        callee.object.type === 'Identifier' &&
+        callee.object.name === 'require' &&
+        // `resolveWeak`
+        callee.property.type === 'Identifier' &&
+        callee.property.name === 'resolveWeak' &&
+        !callee.computed &&
+        // Ensure `require` refers to the global and not something else.
+        !path.scope.getBinding('require')
+      ) {
+        processResolveWeakCall(path, state);
+        visited.add(path.node);
+        return;
+      }
+
       if (
         name != null &&
         state.dependencyCalls.has(name) &&
@@ -260,7 +238,7 @@ function collectDependencies<TSplitCondition = void>(
     ExportNamedDeclaration: collectImports,
     ExportAllDeclaration: collectImports,
 
-    Program(path: NodePath<BabelNodeProgram>, state: State<TSplitCondition>) {
+    Program(path: NodePath<BabelNodeProgram>, state: State) {
       state.asyncRequireModulePathStringLiteral = types.stringLiteral(
         options.asyncRequireModulePath,
       );
@@ -282,9 +260,7 @@ function collectDependencies<TSplitCondition = void>(
 
   const collectedDependencies = state.dependencyRegistry.getDependencies();
   // Compute the list of dependencies.
-  const dependencies = new Array<Dependency<TSplitCondition>>(
-    collectedDependencies.length,
-  );
+  const dependencies = new Array<Dependency>(collectedDependencies.length);
 
   for (const {index, name, ...dependencyData} of collectedDependencies) {
     dependencies[index] = {
@@ -402,9 +378,9 @@ function getContextMode(path: NodePath<>, mode: string): ContextMode {
   );
 }
 
-function processRequireContextCall<TSplitCondition>(
+function processRequireContextCall(
   path: NodePath<CallExpression>,
-  state: State<TSplitCondition>,
+  state: State,
 ): void {
   const [directory, contextParams] = getRequireContextArgs(path);
   const transformer = state.dependencyTransformer;
@@ -426,10 +402,34 @@ function processRequireContextCall<TSplitCondition>(
   transformer.transformSyncRequire(path, dep, state);
 }
 
-function collectImports<TSplitCondition>(
-  path: NodePath<>,
-  state: State<TSplitCondition>,
+function processResolveWeakCall(
+  path: NodePath<CallExpression>,
+  state: State,
 ): void {
+  const name = getModuleNameFromCallArgs(path);
+
+  if (name == null) {
+    throw new InvalidRequireCallError(path);
+  }
+
+  const dependency = registerDependency(
+    state,
+    {
+      name,
+      asyncType: 'weak',
+      optional: isOptionalDependency(name, path, state),
+    },
+    path,
+  );
+
+  path.replaceWith(
+    makeResolveWeakTemplate({
+      MODULE_ID: createModuleIDExpression(dependency, state),
+    }),
+  );
+}
+
+function collectImports(path: NodePath<>, state: State): void {
   if (path.node.source) {
     registerDependency(
       state,
@@ -443,9 +443,9 @@ function collectImports<TSplitCondition>(
   }
 }
 
-function processImportCall<TSplitCondition>(
+function processImportCall(
   path: NodePath<CallExpression>,
-  state: State<TSplitCondition>,
+  state: State,
   options: ImportDependencyOptions,
 ): void {
   const name = getModuleNameFromCallArgs(path);
@@ -459,7 +459,6 @@ function processImportCall<TSplitCondition>(
     {
       name,
       asyncType: options.asyncType,
-      splitCondition: options.splitCondition,
       optional: isOptionalDependency(name, path, state),
     },
     path,
@@ -467,18 +466,16 @@ function processImportCall<TSplitCondition>(
 
   const transformer = state.dependencyTransformer;
 
-  if (options.jsResource) {
-    transformer.transformJSResource(path, dep, state);
-  } else if (options.asyncType === 'async') {
+  if (options.asyncType === 'async') {
     transformer.transformImportCall(path, dep, state);
   } else {
     transformer.transformPrefetch(path, dep, state);
   }
 }
 
-function processRequireCall<TSplitCondition>(
+function processRequireCall(
   path: NodePath<CallExpression>,
-  state: State<TSplitCondition>,
+  state: State,
 ): void {
   const name = getModuleNameFromCallArgs(path);
 
@@ -517,16 +514,15 @@ function getNearestLocFromPath(path: NodePath<>): ?BabelSourceLocation {
 export type ImportQualifier = $ReadOnly<{
   name: string,
   asyncType: AsyncDependencyType | null,
-  splitCondition?: NodePath<>,
   optional: boolean,
   contextParams?: RequireContextParams,
 }>;
 
-function registerDependency<TSplitCondition>(
-  state: State<TSplitCondition>,
+function registerDependency(
+  state: State,
   qualifier: ImportQualifier,
   path: NodePath<>,
-): InternalDependency<TSplitCondition> {
+): InternalDependency {
   const dependency = state.dependencyRegistry.registerDependency(qualifier);
   const loc = getNearestLocFromPath(path);
   if (loc != null) {
@@ -536,10 +532,10 @@ function registerDependency<TSplitCondition>(
   return dependency;
 }
 
-function isOptionalDependency<TSplitCondition>(
+function isOptionalDependency(
   name: string,
   path: NodePath<>,
-  state: State<TSplitCondition>,
+  state: State,
 ): boolean {
   const {allowOptionalDependencies} = state;
 
@@ -579,10 +575,8 @@ function isOptionalDependency<TSplitCondition>(
 }
 
 function getModuleNameFromCallArgs(path: NodePath<CallExpression>): ?string {
-  const expectedCount =
-    path.node.callee.name === '__conditionallySplitJSResource' ? 2 : 1;
   const args = path.get('arguments');
-  if (!Array.isArray(args) || args.length !== expectedCount) {
+  if (!Array.isArray(args) || args.length !== 1) {
     throw new InvalidRequireCallError(path);
   }
 
@@ -619,7 +613,7 @@ collectDependencies.InvalidRequireCallError = InvalidRequireCallError;
  * is reached. This makes dynamic require errors catchable by libraries that
  * want to use them.
  */
-const dynamicRequireErrorTemplate = template.statement(`
+const dynamicRequireErrorTemplate = template.expression(`
   (function(line) {
     throw new Error(
       'Dynamic require defined at line ' + line + '; not supported by Metro',
@@ -631,23 +625,23 @@ const dynamicRequireErrorTemplate = template.statement(`
  * Produces a Babel template that transforms an "import(...)" call into a
  * "require(...)" call to the asyncRequire specified.
  */
-const makeAsyncRequireTemplate = template.statement(`
+const makeAsyncRequireTemplate = template.expression(`
   require(ASYNC_REQUIRE_MODULE_PATH)(MODULE_ID, MODULE_NAME, DEPENDENCY_MAP.paths)
 `);
 
-const makeAsyncPrefetchTemplate = template.statement(`
+const makeAsyncPrefetchTemplate = template.expression(`
   require(ASYNC_REQUIRE_MODULE_PATH).prefetch(MODULE_ID, MODULE_NAME, DEPENDENCY_MAP.paths)
 `);
 
-const makeJSResourceTemplate = template.statement(`
-  require(ASYNC_REQUIRE_MODULE_PATH).resource(MODULE_ID, MODULE_NAME, DEPENDENCY_MAP.paths)
+const makeResolveWeakTemplate = template.expression(`
+  MODULE_ID
 `);
 
-const DefaultDependencyTransformer: DependencyTransformer<mixed> = {
+const DefaultDependencyTransformer: DependencyTransformer = {
   transformSyncRequire(
     path: NodePath<CallExpression>,
-    dependency: InternalDependency<mixed>,
-    state: State<mixed>,
+    dependency: InternalDependency,
+    state: State,
   ): void {
     const moduleIDExpression = createModuleIDExpression(dependency, state);
     path.node.arguments = ([moduleIDExpression]: Array<
@@ -664,8 +658,8 @@ const DefaultDependencyTransformer: DependencyTransformer<mixed> = {
 
   transformImportCall(
     path: NodePath<>,
-    dependency: InternalDependency<mixed>,
-    state: State<mixed>,
+    dependency: InternalDependency,
+    state: State,
   ): void {
     path.replaceWith(
       makeAsyncRequireTemplate({
@@ -679,27 +673,10 @@ const DefaultDependencyTransformer: DependencyTransformer<mixed> = {
     );
   },
 
-  transformJSResource(
-    path: NodePath<>,
-    dependency: InternalDependency<mixed>,
-    state: State<mixed>,
-  ): void {
-    path.replaceWith(
-      makeJSResourceTemplate({
-        ASYNC_REQUIRE_MODULE_PATH: nullthrows(
-          state.asyncRequireModulePathStringLiteral,
-        ),
-        MODULE_ID: createModuleIDExpression(dependency, state),
-        MODULE_NAME: createModuleNameLiteral(dependency),
-        DEPENDENCY_MAP: nullthrows(state.dependencyMapIdentifier),
-      }),
-    );
-  },
-
   transformPrefetch(
     path: NodePath<>,
-    dependency: InternalDependency<mixed>,
-    state: State<mixed>,
+    dependency: InternalDependency,
+    state: State,
   ): void {
     path.replaceWith(
       makeAsyncPrefetchTemplate({
@@ -713,7 +690,7 @@ const DefaultDependencyTransformer: DependencyTransformer<mixed> = {
     );
   },
 
-  transformIllegalDynamicRequire(path: NodePath<>, state: State<mixed>): void {
+  transformIllegalDynamicRequire(path: NodePath<>, state: State): void {
     path.replaceWith(
       dynamicRequireErrorTemplate({
         LINE: types.numericLiteral(path.node.loc?.start.line ?? 0),
@@ -723,9 +700,9 @@ const DefaultDependencyTransformer: DependencyTransformer<mixed> = {
 };
 
 function createModuleIDExpression(
-  dependency: InternalDependency<mixed>,
-  state: State<mixed>,
-) {
+  dependency: InternalDependency,
+  state: State,
+): BabelNodeExpression {
   return types.memberExpression(
     nullthrows(state.dependencyMapIdentifier),
     types.numericLiteral(dependency.index),
@@ -733,7 +710,7 @@ function createModuleIDExpression(
   );
 }
 
-function createModuleNameLiteral(dependency: InternalDependency<mixed>) {
+function createModuleNameLiteral(dependency: InternalDependency) {
   return types.stringLiteral(dependency.name);
 }
 
@@ -781,20 +758,15 @@ function getKeyForDependency(qualifier: ImportQualifier): string {
   return key;
 }
 
-class DefaultModuleDependencyRegistry<TSplitCondition = void>
-  implements ModuleDependencyRegistry<TSplitCondition>
-{
-  _dependencies: Map<string, InternalDependency<TSplitCondition>> = new Map();
+class DefaultModuleDependencyRegistry implements ModuleDependencyRegistry {
+  _dependencies: Map<string, InternalDependency> = new Map();
 
-  registerDependency(
-    qualifier: ImportQualifier,
-  ): InternalDependency<TSplitCondition> {
+  registerDependency(qualifier: ImportQualifier): InternalDependency {
     const key = getKeyForDependency(qualifier);
-    let dependency: ?InternalDependency<TSplitCondition> =
-      this._dependencies.get(key);
+    let dependency: ?InternalDependency = this._dependencies.get(key);
 
     if (dependency == null) {
-      const newDependency: MutableInternalDependency<TSplitCondition> = {
+      const newDependency: MutableInternalDependency = {
         name: qualifier.name,
         asyncType: qualifier.asyncType,
         locs: [],
@@ -826,7 +798,7 @@ class DefaultModuleDependencyRegistry<TSplitCondition = void>
     return dependency;
   }
 
-  getDependencies(): Array<InternalDependency<TSplitCondition>> {
+  getDependencies(): Array<InternalDependency> {
     return Array.from(this._dependencies.values());
   }
 }

package/src/Server/symbolicate.js

@@ -106,7 +106,6 @@ async function symbolicate(stack, maps, config) {
     return null;
   }
   function symbolicateFrame(frame) {
-    var _findFunctionName;
     const module = findModule(frame);
     if (!module) {
       return frame;
@@ -121,10 +120,7 @@ async function symbolicate(stack, maps, config) {
       return frame;
     }
     const methodName =
-      (_findFunctionName = findFunctionName(originalPos, module)) !== null &&
-      _findFunctionName !== void 0
-        ? _findFunctionName
-        : frame.methodName;
+      findFunctionName(originalPos, module) ?? frame.methodName;
     return {
       ...frame,
       methodName,

package/src/Server.js

@@ -96,7 +96,6 @@ class Server {
     return this._createModuleId;
   }
   async build(options) {
-    var _this$_config$server$;
     const {
       entryFile,
       graphOptions,
@@ -140,10 +139,7 @@ class Server {
       sourceUrl: serializerOptions.sourceUrl,
       inlineSourceMap: serializerOptions.inlineSourceMap,
       serverRoot:
-        (_this$_config$server$ = this._config.server.unstable_serverRoot) !==
-          null && _this$_config$server$ !== void 0
-          ? _this$_config$server$
-          : this._config.projectRoot,
+        this._config.server.unstable_serverRoot ?? this._config.projectRoot,
     };
     let bundleCode = null;
     let bundleMap = null;
@@ -180,7 +176,6 @@ class Server {
     };
   }
   async getRamBundleInfo(options) {
-    var _this$_config$server$2;
     const {
       entryFile,
       graphOptions,
@@ -227,10 +222,7 @@ class Server {
       sourceUrl: serializerOptions.sourceUrl,
       inlineSourceMap: serializerOptions.inlineSourceMap,
       serverRoot:
-        (_this$_config$server$2 = this._config.server.unstable_serverRoot) !==
-          null && _this$_config$server$2 !== void 0
-          ? _this$_config$server$2
-          : this._config.projectRoot,
+        this._config.server.unstable_serverRoot ?? this._config.projectRoot,
     });
   }
   async getAssets(options) {
@@ -386,24 +378,12 @@ class Server {
           bundlePerfLogger: noopLogger,
         });
       } else {
-        var _this$_config$unstabl, _this$_config$unstabl2, _this$_config;
         await this._processBundleRequest(req, res, options, {
           buildNumber,
           bundlePerfLogger:
-            (_this$_config$unstabl =
-              (_this$_config$unstabl2 = (_this$_config = this._config)
-                .unstable_perfLoggerFactory) === null ||
-              _this$_config$unstabl2 === void 0
-                ? void 0
-                : _this$_config$unstabl2.call(
-                    _this$_config,
-                    "BUNDLING_REQUEST",
-                    {
-                      key: buildNumber,
-                    }
-                  )) !== null && _this$_config$unstabl !== void 0
-              ? _this$_config$unstabl
-              : noopLogger,
+            this._config.unstable_perfLoggerFactory?.("BUNDLING_REQUEST", {
+              key: buildNumber,
+            }) ?? noopLogger,
         });
       }
       if (this._serverOptions && this._serverOptions.onBundleBuilt) {
@@ -628,7 +608,6 @@ class Server {
   }
   _processBundleRequest = this._createRequestProcessor({
     createStartEntry(context) {
-      var _context$req$headers$;
       return {
         action_name: "Requesting bundle",
         bundle_url: context.req.url,
@@ -637,11 +616,7 @@ class Server {
         build_id: getBuildID(context.buildNumber),
         bundle_options: context.bundleOptions,
         bundle_hash: context.graphId,
-        user_agent:
-          (_context$req$headers$ = context.req.headers["user-agent"]) !==
-            null && _context$req$headers$ !== void 0
-            ? _context$req$headers$
-            : "unknown",
+        user_agent: context.req.headers["user-agent"] ?? "unknown",
       };
     },
     createEndEntry(context) {
@@ -659,7 +634,6 @@ class Server {
       transformOptions,
       bundlePerfLogger,
     }) => {
-      var _this$_config$server$3;
       bundlePerfLogger.start();
       bundlePerfLogger.annotate({
         string: {
@@ -721,11 +695,7 @@ class Server {
           sourceUrl: serializerOptions.sourceUrl,
           inlineSourceMap: serializerOptions.inlineSourceMap,
           serverRoot:
-            (_this$_config$server$3 =
-              this._config.server.unstable_serverRoot) !== null &&
-            _this$_config$server$3 !== void 0
-              ? _this$_config$server$3
-              : this._config.projectRoot,
+            this._config.server.unstable_serverRoot ?? this._config.projectRoot,
         }
       );
       bundlePerfLogger.point("serializingBundle_end");
@@ -798,7 +768,6 @@ class Server {
       serializerOptions,
       transformOptions,
     }) => {
-      var _this$_config$server$4;
       const revPromise = this._bundler.getRevisionByGraphId(graphId);
       const { delta, revision } = await (revPromise != null
         ? this._bundler.updateGraph(await revPromise, false)
@@ -838,11 +807,7 @@ class Server {
           sourceUrl: serializerOptions.sourceUrl,
           inlineSourceMap: serializerOptions.inlineSourceMap,
           serverRoot:
-            (_this$_config$server$4 =
-              this._config.server.unstable_serverRoot) !== null &&
-            _this$_config$server$4 !== void 0
-              ? _this$_config$server$4
-              : this._config.projectRoot,
+            this._config.server.unstable_serverRoot ?? this._config.projectRoot,
         })
       );
       return {
@@ -1003,10 +968,7 @@ class Server {
         ) {
           continue;
         }
-        const fileAbsolute = path.resolve(
-          this._config.projectRoot,
-          file !== null && file !== void 0 ? file : ""
-        );
+        const fileAbsolute = path.resolve(this._config.projectRoot, file ?? "");
         try {
           return {
             content: codeFrameColumns(
@@ -1199,12 +1161,7 @@ class Server {
     sourceUrl: null,
   };
   _getServerRootDir() {
-    var _this$_config$server$5;
-    return (_this$_config$server$5 =
-      this._config.server.unstable_serverRoot) !== null &&
-      _this$_config$server$5 !== void 0
-      ? _this$_config$server$5
-      : this._config.projectRoot;
+    return this._config.server.unstable_serverRoot ?? this._config.projectRoot;
   }
   _getEntryPointAbsolutePath(entryFile) {
     return path.resolve(this._getServerRootDir(), entryFile);