babel-preset-expo 54.1.0-canary-20260105-6b962e6 → 54.1.0-canary-20260119-70f7c28

package/build/common.d.ts

@@ -13,6 +13,7 @@ export declare function getIsNodeModule(caller?: any): boolean;
 export declare function getBaseUrl(caller?: any): string;
 export declare function getReactCompiler(caller?: any): boolean;
 export declare function getIsServer(caller?: any): boolean;
+export declare function getIsLoaderBundle(caller?: any): boolean;
 export declare function getMetroSourceType(caller?: any): "script" | "module" | "asset" | undefined;
 export declare function getBabelRuntimeVersion(caller?: any): string;
 export declare function getExpoRouterAbsoluteAppRoot(caller?: any): string;

package/build/common.js

@@ -15,6 +15,7 @@ exports.getIsNodeModule = getIsNodeModule;
 exports.getBaseUrl = getBaseUrl;
 exports.getReactCompiler = getReactCompiler;
 exports.getIsServer = getIsServer;
+exports.getIsLoaderBundle = getIsLoaderBundle;
 exports.getMetroSourceType = getMetroSourceType;
 exports.getBabelRuntimeVersion = getBabelRuntimeVersion;
 exports.getExpoRouterAbsoluteAppRoot = getExpoRouterAbsoluteAppRoot;
@@ -118,6 +119,10 @@ function getIsServer(caller) {
     assertExpoBabelCaller(caller);
     return caller?.isServer ?? false;
 }
+function getIsLoaderBundle(caller) {
+    assertExpoBabelCaller(caller);
+    return caller?.isLoaderBundle ?? false;
+}
 function getMetroSourceType(caller) {
     assertExpoBabelCaller(caller);
     return caller?.metroSourceType;

package/build/define-plugin.d.ts

@@ -5,6 +5,8 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import type { ConfigAPI, PluginObj } from '@babel/core';
-declare function definePlugin({ types: t }: ConfigAPI & typeof import('@babel/core')): PluginObj;
+import type { ConfigAPI, PluginObj, PluginPass } from '@babel/core';
+declare function definePlugin({ types: t, }: ConfigAPI & typeof import('@babel/core')): PluginObj<PluginPass & {
+    opts: Record<string, null | boolean | string>;
+}>;
 export default definePlugin;

package/build/define-plugin.js

@@ -7,30 +7,8 @@
  * LICENSE file in the root directory of this source tree.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Checks if the given identifier is an ES module import
- * @param  {babelNode} identifierNodePath The node to check
- * @return {boolean} Indicates if the provided node is an import specifier or references one
- */
-const isImportIdentifier = (identifierNodePath) => {
-    if (identifierNodePath.container &&
-        !Array.isArray(identifierNodePath.container) &&
-        'type' in identifierNodePath.container) {
-        return (identifierNodePath.container.type === 'ImportDefaultSpecifier' ||
-            identifierNodePath.container.type === 'ImportSpecifier');
-    }
-    return false;
-};
-const memberExpressionComparator = (nodePath, value) => nodePath.matchesPattern(value);
-const identifierComparator = (nodePath, value) => 'name' in nodePath.node && nodePath.node.name === value;
-const unaryExpressionComparator = (nodePath, value) => {
-    if ('argument' in nodePath.node && nodePath.node.argument && 'name' in nodePath.node?.argument) {
-        return nodePath.node.argument.name === value;
-    }
-    return false;
-};
 const TYPEOF_PREFIX = 'typeof ';
-function definePlugin({ types: t }) {
+function definePlugin({ types: t, }) {
     /**
      * Replace a node with a given value. If the replacement results in a BinaryExpression, it will be
      * evaluated. For example, if the result of the replacement is `var x = "production" === "production"`
@@ -38,79 +16,120 @@ function definePlugin({ types: t }) {
      */
     function replaceAndEvaluateNode(nodePath, replacement) {
         nodePath.replaceWith(t.valueToNode(replacement));
-        if (nodePath.parentPath && nodePath.parentPath.isBinaryExpression()) {
+        if (nodePath.parentPath?.isBinaryExpression()) {
             const result = nodePath.parentPath.evaluate();
             if (result.confident) {
                 nodePath.parentPath.replaceWith(t.valueToNode(result.value));
             }
         }
     }
-    const isLeftHandSideOfAssignmentExpression = (node, parent) => t.isAssignmentExpression(parent) && parent.left === node;
-    const processNode = (replacements, nodePath, comparator) => {
-        const replacementKey = Object.keys(replacements).find((value) => comparator(nodePath, value));
-        if (typeof replacementKey === 'string' &&
-            replacements != null &&
-            replacementKey in replacements) {
-            replaceAndEvaluateNode(nodePath, replacements[replacementKey]);
+    /** Get the root identifier name from a member expression (e.g., "process" from "process.env.NODE_ENV") */
+    function getMemberExpressionRoot(node) {
+        let current = node;
+        while (t.isMemberExpression(current)) {
+            current = current.object;
         }
-    };
+        return t.isIdentifier(current) ? current.name : null;
+    }
     return {
         name: 'expo-define-globals',
+        pre() {
+            // Pre-process replacements once per file
+            const identifiers = new Map();
+            const memberPatterns = [];
+            const typeofValues = new Map();
+            const memberRoots = new Set();
+            for (const key of Object.keys(this.opts)) {
+                const value = this.opts[key];
+                if (key.startsWith(TYPEOF_PREFIX)) {
+                    // "typeof window" -> typeofValues["window"]
+                    typeofValues.set(key.slice(TYPEOF_PREFIX.length), value);
+                }
+                else if (key.includes('.')) {
+                    // "process.env.NODE_ENV" -> memberPatterns, extract "process" as root
+                    memberPatterns.push([key, value]);
+                    const root = key.split('.')[0];
+                    memberRoots.add(root);
+                }
+                else {
+                    // "__DEV__" -> identifiers
+                    identifiers.set(key, value);
+                }
+            }
+            this.processed = {
+                identifiers,
+                memberPatterns,
+                typeofValues,
+                memberRoots,
+            };
+        },
         visitor: {
             // process.env.NODE_ENV;
             MemberExpression(nodePath, state) {
-                if (
                 // Prevent rewriting if the member expression is on the left-hand side of an assignment
-                isLeftHandSideOfAssignmentExpression(nodePath.node, nodePath.parent)) {
+                if (t.isAssignmentExpression(nodePath.parent) && nodePath.parent.left === nodePath.node) {
                     return;
                 }
-                const replacements = state.opts;
-                assertOptions(replacements);
-                processNode(replacements, nodePath, memberExpressionComparator);
+                const { memberPatterns, memberRoots } = state.processed;
+                if (memberPatterns.length === 0)
+                    return;
+                // Quick filter: check if root matches any known pattern root
+                const root = getMemberExpressionRoot(nodePath.node);
+                if (!root || !memberRoots.has(root))
+                    return;
+                // Check against patterns
+                for (const [pattern, replacement] of memberPatterns) {
+                    if (nodePath.matchesPattern(pattern)) {
+                        replaceAndEvaluateNode(nodePath, replacement);
+                        return;
+                    }
+                }
             },
             // const x = { version: VERSION };
             ReferencedIdentifier(nodePath, state) {
-                const binding = nodePath.scope?.getBinding(nodePath.node.name);
-                if (binding ||
-                    // Don't transform import identifiers. This is meant to mimic webpack's
-                    // DefinePlugin behavior.
-                    isImportIdentifier(nodePath) ||
-                    // Do not transform Object keys / properties unless they are computed like {[key]: value}
-                    (nodePath.key === 'key' &&
-                        nodePath.parent &&
-                        'computed' in nodePath.parent &&
-                        nodePath.parent.computed === false) ||
-                    (nodePath.key === 'property' &&
-                        nodePath.parent &&
-                        'computed' in nodePath.parent &&
-                        nodePath.parent.computed === false)) {
+                const { identifiers } = state.processed;
+                if (identifiers.size === 0)
+                    return;
+                const name = nodePath.node.name;
+                // Quick check: is this identifier in our replacements?
+                if (!identifiers.has(name))
+                    return;
+                // Check for binding (locally defined variable shadows replacement)
+                if (nodePath.scope?.getBinding(name))
+                    return;
+                // Don't transform import identifiers (mimics webpack's DefinePlugin behavior)
+                const container = nodePath.container;
+                if (container &&
+                    !Array.isArray(container) &&
+                    'type' in container &&
+                    (container.type === 'ImportDefaultSpecifier' || container.type === 'ImportSpecifier')) {
+                    return;
+                }
+                // Do not transform Object keys / properties unless they are computed like {[key]: value}
+                if ((nodePath.key === 'key' || nodePath.key === 'property') &&
+                    nodePath.parent &&
+                    'computed' in nodePath.parent &&
+                    nodePath.parent.computed === false) {
                     return;
                 }
-                const replacements = state.opts;
-                assertOptions(replacements);
-                processNode(replacements, nodePath, identifierComparator);
+                replaceAndEvaluateNode(nodePath, identifiers.get(name));
             },
             // typeof window
             UnaryExpression(nodePath, state) {
-                if (nodePath.node.operator !== 'typeof') {
+                if (nodePath.node.operator !== 'typeof')
+                    return;
+                const { typeofValues } = state.processed;
+                if (typeofValues.size === 0)
+                    return;
+                const argument = nodePath.node.argument;
+                if (!t.isIdentifier(argument))
                     return;
+                const replacement = typeofValues.get(argument.name);
+                if (replacement !== undefined) {
+                    replaceAndEvaluateNode(nodePath, replacement);
                 }
-                const replacements = state.opts;
-                assertOptions(replacements);
-                const typeofValues = {};
-                Object.keys(replacements).forEach((key) => {
-                    if (key.substring(0, TYPEOF_PREFIX.length) === TYPEOF_PREFIX) {
-                        typeofValues[key.substring(TYPEOF_PREFIX.length)] = replacements[key];
-                    }
-                });
-                processNode(typeofValues, nodePath, unaryExpressionComparator);
             },
         },
     };
 }
-function assertOptions(opts) {
-    if (opts == null || typeof opts !== 'object') {
-        throw new Error('define plugin expects an object as options');
-    }
-}
 exports.default = definePlugin;

package/build/expo-inline-manifest-plugin.d.ts

@@ -1,2 +1,6 @@
-import type { ConfigAPI, PluginObj } from '@babel/core';
-export declare function expoInlineManifestPlugin(api: ConfigAPI & typeof import('@babel/core')): PluginObj;
+import type { ConfigAPI, PluginObj, PluginPass } from '@babel/core';
+interface InlineManifestState extends PluginPass {
+    projectRoot: string;
+}
+export declare function expoInlineManifestPlugin(api: ConfigAPI & typeof import('@babel/core')): PluginObj<InlineManifestState>;
+export {};

package/build/expo-inline-manifest-plugin.js

@@ -4,7 +4,7 @@ exports.expoInlineManifestPlugin = expoInlineManifestPlugin;
 const common_1 = require("./common");
 const debug = require('debug')('expo:babel:inline-manifest');
 // Convert expo value to PWA value
-function ensurePWAorientation(orientation) {
+function ensurePWAOrientation(orientation) {
     if (orientation) {
         const webOrientation = orientation.toLowerCase();
         if (webOrientation !== 'default') {
@@ -52,7 +52,7 @@ function applyWebDefaults({ config, appName, webName }) {
     const startUrl = webManifest.startUrl;
     const { scope, crossorigin } = webManifest;
     const barStyle = webManifest.barStyle;
-    const orientation = ensurePWAorientation(webManifest.orientation || appJSON.orientation);
+    const orientation = ensurePWAOrientation(webManifest.orientation || appJSON.orientation);
     /**
      * **Splash screen background color**
      * `https://developers.google.com/web/fundamentals/web-app-manifest/#splash-screen`
@@ -144,34 +144,46 @@ function expoInlineManifestPlugin(api) {
     const platform = api.caller(common_1.getPlatform);
     const possibleProjectRoot = api.caller(common_1.getPossibleProjectRoot);
     const shouldInline = platform === 'web' || isReactServer;
+    // Early exit: return a no-op plugin if we're not going to inline anything
+    if (!shouldInline) {
+        return {
+            name: 'expo-inline-manifest-plugin',
+            visitor: {},
+        };
+    }
     return {
         name: 'expo-inline-manifest-plugin',
+        pre() {
+            this.projectRoot = possibleProjectRoot || this.file.opts.root || '';
+        },
         visitor: {
             MemberExpression(path, state) {
-                // Web-only/React Server-only feature: the native manifest is provided dynamically by the client.
-                if (!shouldInline) {
+                // We're looking for: process.env.APP_MANIFEST
+                // This visitor is called on every MemberExpression, so we need fast checks
+                // Quick check: the property we're looking for is 'APP_MANIFEST'
+                // The parent must be a MemberExpression with property 'APP_MANIFEST'
+                const parent = path.parentPath;
+                if (!parent?.isMemberExpression())
                     return;
-                }
-                if (!t.isIdentifier(path.node.object, { name: 'process' }) ||
-                    !t.isIdentifier(path.node.property, { name: 'env' })) {
+                // Check if parent's property is APP_MANIFEST (most selective check first)
+                const parentProp = parent.node.property;
+                if (!t.isIdentifier(parentProp) || parentProp.name !== 'APP_MANIFEST')
                     return;
-                }
-                const parent = path.parentPath;
-                if (!t.isMemberExpression(parent.node)) {
+                // Now verify this is process.env
+                const obj = path.node.object;
+                const prop = path.node.property;
+                if (!t.isIdentifier(obj) || obj.name !== 'process')
+                    return;
+                if (!t.isIdentifier(prop) || prop.name !== 'env')
+                    return;
+                // Skip if this is an assignment target
+                if (parent.parentPath?.isAssignmentExpression())
                     return;
-                }
-                const projectRoot = possibleProjectRoot || state.file.opts.root || '';
-                if (
                 // Surfaces the `app.json` (config) as an environment variable which is then parsed by
                 // `expo-constants` https://docs.expo.dev/versions/latest/sdk/constants/
-                t.isIdentifier(parent.node.property, {
-                    name: 'APP_MANIFEST',
-                }) &&
-                    !parent.parentPath.isAssignmentExpression()) {
-                    const manifest = getExpoAppManifest(projectRoot);
-                    if (manifest !== null) {
-                        parent.replaceWith(t.stringLiteral(manifest));
-                    }
+                const manifest = getExpoAppManifest(state.projectRoot);
+                if (manifest !== null) {
+                    parent.replaceWith(t.stringLiteral(manifest));
                 }
             },
         },

package/build/expo-router-plugin.js

@@ -8,11 +8,19 @@ const node_path_1 = __importDefault(require("node:path"));
 const resolve_from_1 = __importDefault(require("resolve-from"));
 const common_1 = require("./common");
 const debug = require('debug')('expo:babel:router');
+// Cache for getExpoRouterAppRoot results (projectRoot -> appRoot)
+const appRootCache = new Map();
 function getExpoRouterAppRoot(projectRoot, appFolder) {
+    const cacheKey = `${projectRoot}:${appFolder}`;
+    const cached = appRootCache.get(cacheKey);
+    if (cached !== undefined) {
+        return cached;
+    }
     // TODO: We should have cache invalidation if the expo-router/entry file location changes.
     const routerEntry = (0, resolve_from_1.default)(projectRoot, 'expo-router/entry');
     const appRoot = node_path_1.default.relative(node_path_1.default.dirname(routerEntry), appFolder);
     debug('routerEntry', routerEntry, appFolder, appRoot);
+    appRootCache.set(cacheKey, appRoot);
     return appRoot;
 }
 /**
@@ -28,36 +36,55 @@ function expoRouterBabelPlugin(api) {
     const possibleProjectRoot = api.caller(common_1.getPossibleProjectRoot);
     const asyncRoutes = api.caller(common_1.getAsyncRoutes);
     const routerAbsoluteRoot = api.caller(common_1.getExpoRouterAbsoluteAppRoot);
-    function isFirstInAssign(path) {
-        return t.isAssignmentExpression(path.parent) && path.parent.left === path.node;
-    }
+    const importMode = asyncRoutes ? 'lazy' : 'sync';
     return {
         name: 'expo-router',
+        pre() {
+            const state = this;
+            state.projectRoot = possibleProjectRoot || this.file.opts.root || '';
+            // Check test env at transform time, not module load time
+            state.isTestEnv = process.env.NODE_ENV === 'test';
+        },
         visitor: {
             MemberExpression(path, state) {
-                const projectRoot = possibleProjectRoot || state.file.opts.root || '';
-                if (path.get('object').matchesPattern('process.env')) {
-                    const key = path.toComputedKey();
-                    if (t.isStringLiteral(key) && !isFirstInAssign(path)) {
-                        // Used for log box on web.
-                        if (key.value.startsWith('EXPO_PROJECT_ROOT')) {
-                            path.replaceWith(t.stringLiteral(projectRoot));
-                        }
-                        else if (key.value.startsWith('EXPO_ROUTER_IMPORT_MODE')) {
-                            path.replaceWith(t.stringLiteral(asyncRoutes ? 'lazy' : 'sync'));
-                        }
-                        if (
-                        // Skip loading the app root in tests.
-                        // This is handled by the testing-library utils
-                        process.env.NODE_ENV !== 'test') {
-                            if (key.value.startsWith('EXPO_ROUTER_ABS_APP_ROOT')) {
-                                path.replaceWith(t.stringLiteral(routerAbsoluteRoot));
-                            }
-                            else if (key.value.startsWith('EXPO_ROUTER_APP_ROOT')) {
-                                path.replaceWith(t.stringLiteral(getExpoRouterAppRoot(projectRoot, routerAbsoluteRoot)));
-                            }
-                        }
-                    }
+                // Quick check: skip if not accessing something on an object named 'process'
+                const object = path.node.object;
+                if (!t.isMemberExpression(object))
+                    return;
+                const objectOfObject = object.object;
+                if (!t.isIdentifier(objectOfObject) || objectOfObject.name !== 'process')
+                    return;
+                // Now check if it's process.env
+                if (!t.isIdentifier(object.property) || object.property.name !== 'env')
+                    return;
+                // Skip if this is an assignment target
+                if (t.isAssignmentExpression(path.parent) && path.parent.left === path.node)
+                    return;
+                // Get the property key
+                const key = path.toComputedKey();
+                if (!t.isStringLiteral(key))
+                    return;
+                const keyValue = key.value;
+                // Check each possible env var
+                switch (keyValue) {
+                    case 'EXPO_PROJECT_ROOT':
+                        path.replaceWith(t.stringLiteral(state.projectRoot));
+                        return;
+                    case 'EXPO_ROUTER_IMPORT_MODE':
+                        path.replaceWith(t.stringLiteral(importMode));
+                        return;
+                    default:
+                        break;
+                }
+                // Skip app root transforms in tests (handled by testing-library utils)
+                if (state.isTestEnv)
+                    return;
+                switch (keyValue) {
+                    case 'EXPO_ROUTER_ABS_APP_ROOT':
+                        path.replaceWith(t.stringLiteral(routerAbsoluteRoot));
+                        return;
+                    case 'EXPO_ROUTER_APP_ROOT':
+                        path.replaceWith(t.stringLiteral(getExpoRouterAppRoot(state.projectRoot, routerAbsoluteRoot)));
                 }
             },
         },

package/build/index.js

@@ -163,8 +163,11 @@ function babelPresetExpo(api, options = {}) {
     }
     if ((0, common_1.hasModule)('expo-router')) {
         extraPlugins.push(expo_router_plugin_1.expoRouterBabelPlugin);
-        // Strip loader() functions from client bundles
-        if (!isServerEnv) {
+        // Process `loader()` functions for client, loader and server bundles (excluding RSC)
+        // - Client bundles: Remove loader exports, they run on server only
+        // - Server bundles: Keep loader exports (needed for SSG)
+        // - Loader-only bundles: Keep only loader exports, remove everything else
+        if (!isReactServer) {
             extraPlugins.push(server_data_loaders_plugin_1.serverDataLoadersPlugin);
         }
     }

package/build/server-data-loaders-plugin.js

@@ -8,11 +8,27 @@ function serverDataLoadersPlugin(api) {
     const { types: t } = api;
     const routerAbsoluteRoot = api.caller(common_1.getExpoRouterAbsoluteAppRoot);
     const isServer = api.caller(common_1.getIsServer);
+    const isLoaderBundle = api.caller(common_1.getIsLoaderBundle);
     return {
         name: 'expo-server-data-loaders',
         visitor: {
+            ExportDefaultDeclaration(path, state) {
+                // Early exit if file is not within the `app/` directory
+                if (!isInAppDirectory(state.file.opts.filename ?? '', routerAbsoluteRoot)) {
+                    return;
+                }
+                // Only remove default exports in loader-only bundles
+                if (!isLoaderBundle) {
+                    return;
+                }
+                debug('Loader bundle: removing default export from', state.file.opts.filename);
+                markForConstantFolding(state);
+                path.remove();
+            },
             ExportNamedDeclaration(path, state) {
-                if (isServer) {
+                // NOTE(@hassankhan): Server bundles currently preserve loaders for SSG, a followup is
+                // required to remove them.
+                if (isServer && !isLoaderBundle) {
                     return;
                 }
                 // Early exit if file is not within the `app/` directory
@@ -20,38 +36,73 @@ function serverDataLoadersPlugin(api) {
                     debug('Skipping file outside app directory:', state.file.opts.filename);
                     return;
                 }
-                debug(isServer ? 'Processing server bundle:' : 'Processing client bundle:', state.file.opts.filename);
+                debug(`Processing ${isLoaderBundle ? 'loader' : 'client'} bundle:`, state.file.opts.filename);
                 const { declaration, specifiers } = path.node;
                 // Is this a type export like `export type Foo`?
                 const isTypeExport = path.node.exportKind === 'type';
-                // Does this export with `export { loader }`?
                 // NOTE(@hassankhan): We should add proper handling for specifiers too
                 const hasSpecifiers = specifiers.length > 0;
                 if (isTypeExport || hasSpecifiers) {
                     return;
                 }
-                // Handles `export function loader() {}`
+                // Handles `export function loader() { ... }`
                 if (t.isFunctionDeclaration(declaration)) {
                     const name = declaration.id?.name;
                     if (name && isLoaderIdentifier(name)) {
-                        debug('Found and removed loader function declaration');
+                        // Mark the file as having a loader (for all bundle types)
+                        markWithLoaderReference(state);
+                        if (!isLoaderBundle) {
+                            // Client bundles: remove loader
+                            debug('Found and removed loader function declaration');
+                            markForConstantFolding(state);
+                            path.remove();
+                        }
+                        // Loader bundle: keep the loader
+                    }
+                    else if (name && isLoaderBundle) {
+                        // Loader bundle: remove non-loader function declarations
+                        debug('Loader bundle: removing non-loader function declaration:', name);
                         markForConstantFolding(state);
                         path.remove();
                     }
                 }
                 // Handles `export const loader = ...`
                 if (t.isVariableDeclaration(declaration)) {
-                    let hasRemovedLoader = false;
-                    declaration.declarations = declaration.declarations.filter((declarator) => {
+                    let hasModified = false;
+                    // Check if any declaration is a loader
+                    const hasLoaderDeclaration = declaration.declarations.some((declarator) => {
                         const name = t.isIdentifier(declarator.id) ? declarator.id.name : null;
-                        if (name && isLoaderIdentifier(name)) {
-                            debug('Found and removed loader variable declaration');
-                            hasRemovedLoader = true;
-                            return false;
-                        }
-                        return true;
+                        return name && isLoaderIdentifier(name);
                     });
-                    if (hasRemovedLoader) {
+                    // Mark the file as having a loader (for all bundle types)
+                    if (hasLoaderDeclaration) {
+                        markWithLoaderReference(state);
+                    }
+                    if (isLoaderBundle) {
+                        // Loader bundle: keep only loader declarations, remove others
+                        declaration.declarations = declaration.declarations.filter((declarator) => {
+                            const name = t.isIdentifier(declarator.id) ? declarator.id.name : null;
+                            if (name && !isLoaderIdentifier(name)) {
+                                debug('Loader bundle: removing non-loader variable declaration:', name);
+                                hasModified = true;
+                                return false;
+                            }
+                            return true;
+                        });
+                    }
+                    else {
+                        // Client bundles: remove loader declarations
+                        declaration.declarations = declaration.declarations.filter((declarator) => {
+                            const name = t.isIdentifier(declarator.id) ? declarator.id.name : null;
+                            if (name && isLoaderIdentifier(name)) {
+                                debug('Found and removed loader variable declaration');
+                                hasModified = true;
+                                return false;
+                            }
+                            return true;
+                        });
+                    }
+                    if (hasModified) {
                         markForConstantFolding(state);
                         // If all declarations were removed, remove the export
                         if (declaration.declarations.length === 0) {
@@ -92,3 +143,11 @@ function markForConstantFolding(state) {
     assertExpoMetadata(state.file.metadata);
     state.file.metadata.performConstantFolding = true;
 }
+/**
+ * Sets the `loaderReference` metadata to the file path. This is used to collect all modules with
+ * loaders in the Metro serializer.
+ */
+function markWithLoaderReference(state) {
+    assertExpoMetadata(state.file.metadata);
+    state.file.metadata.loaderReference = state.file.opts.filename ?? undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babel-preset-expo",
-  "version": "54.1.0-canary-20260105-6b962e6",
+  "version": "54.1.0-canary-20260119-70f7c28",
   "description": "The Babel preset for Expo projects",
   "main": "build/index.js",
   "files": [
@@ -43,7 +43,7 @@
   "peerDependencies": {
     "@babel/runtime": "^7.20.0",
     "react-refresh": ">=0.14.0 <1.0.0",
-    "expo": "55.0.0-canary-20260105-6b962e6"
+    "expo": "55.0.0-canary-20260119-70f7c28"
   },
   "peerDependenciesMeta": {
     "@babel/runtime": {
@@ -81,7 +81,7 @@
     "@babel/core": "^7.26.0",
     "@types/babel__core": "^7.20.5",
     "@expo/metro": "~54.2.0",
-    "expo-module-scripts": "5.1.0-canary-20260105-6b962e6",
+    "expo-module-scripts": "5.1.0-canary-20260119-70f7c28",
     "jest": "^29.2.1",
     "react-refresh": "^0.14.2"
   }