babel-preset-expo 13.1.5 → 13.1.6

package/build/common.d.ts

@@ -1,3 +1,5 @@
+import { type NodePath } from '@babel/core';
+import * as t from '@babel/types';
 export declare function hasModule(name: string): boolean;
 /** Determine which bundler is being used. */
 export declare function getBundler(caller?: any): "metro" | "webpack" | null;
@@ -15,3 +17,4 @@ export declare function getIsServer(caller?: any): boolean;
 export declare function getExpoRouterAbsoluteAppRoot(caller?: any): string;
 export declare function getInlineEnvVarsEnabled(caller?: any): boolean;
 export declare function getAsyncRoutes(caller?: any): boolean;
+export declare function createAddNamedImportOnce(t: typeof import('@babel/types')): (path: NodePath<t.Node>, name: string, source: string) => any;

package/build/common.js

@@ -18,6 +18,9 @@ exports.getIsServer = getIsServer;
 exports.getExpoRouterAbsoluteAppRoot = getExpoRouterAbsoluteAppRoot;
 exports.getInlineEnvVarsEnabled = getInlineEnvVarsEnabled;
 exports.getAsyncRoutes = getAsyncRoutes;
+exports.createAddNamedImportOnce = createAddNamedImportOnce;
+// @ts-expect-error: missing types
+const helper_module_imports_1 = require("@babel/helper-module-imports");
 const node_path_1 = __importDefault(require("node:path"));
 function hasModule(name) {
     try {
@@ -122,13 +125,12 @@ function getExpoRouterAbsoluteAppRoot(caller) {
 function getInlineEnvVarsEnabled(caller) {
     assertExpoBabelCaller(caller);
     const isWebpack = getBundler(caller) === 'webpack';
-    const isDev = getIsDev(caller);
     const isServer = getIsServer(caller);
     const isNodeModule = getIsNodeModule(caller);
     const preserveEnvVars = caller?.preserveEnvVars;
-    // Development env vars are added in the serializer to avoid caching issues in development.
+    // Development env vars are added using references to enable HMR in development.
     // Servers have env vars left as-is to read from the environment.
-    return !isNodeModule && !isWebpack && !isDev && !isServer && !preserveEnvVars;
+    return !isNodeModule && !isWebpack && !isServer && !preserveEnvVars;
 }
 function getAsyncRoutes(caller) {
     assertExpoBabelCaller(caller);
@@ -143,3 +145,22 @@ function getAsyncRoutes(caller) {
     }
     return caller?.asyncRoutes ?? false;
 }
+const getOrCreateInMap = (map, key, create) => {
+    if (!map.has(key)) {
+        const result = create();
+        map.set(key, result);
+        return [result, true];
+    }
+    return [map.get(key), false];
+};
+function createAddNamedImportOnce(t) {
+    const addedImportsCache = new Map();
+    return function addNamedImportOnce(path, name, source) {
+        const [sourceCache] = getOrCreateInMap(addedImportsCache, source, () => new Map());
+        const [identifier, didCreate] = getOrCreateInMap(sourceCache, name, () => (0, helper_module_imports_1.addNamed)(path, name, source));
+        // for cached imports, we need to clone the resulting identifier, because otherwise
+        // '@babel/plugin-transform-modules-commonjs' won't replace the references to the import for some reason.
+        // this is a helper for that.
+        return didCreate ? identifier : t.cloneNode(identifier);
+    };
+}

package/build/inline-env-vars.d.ts

@@ -1,4 +1,4 @@
-import { ConfigAPI, PluginObj, types } from '@babel/core';
+import { ConfigAPI, PluginObj, types as t } from '@babel/core';
 export declare function expoInlineEnvVars(api: ConfigAPI & {
-    types: typeof types;
+    types: typeof t;
 }): PluginObj;

package/build/inline-env-vars.js

@@ -1,28 +1,54 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.expoInlineEnvVars = expoInlineEnvVars;
+const core_1 = require("@babel/core");
+const common_1 = require("./common");
 const debug = require('debug')('expo:babel:env-vars');
 function expoInlineEnvVars(api) {
-    const { types: t } = api;
+    const isProduction = api.caller(common_1.getIsProd);
     function isFirstInAssign(path) {
-        return t.isAssignmentExpression(path.parent) && path.parent.left === path.node;
+        return core_1.types.isAssignmentExpression(path.parent) && path.parent.left === path.node;
     }
+    let addEnvImport;
+    const publicEnvVars = new Set();
     return {
-        name: 'expo-inline-production-environment-variables',
+        name: 'expo-inline-or-reference-env-vars',
+        pre(file) {
+            const addNamedImportOnce = (0, common_1.createAddNamedImportOnce)(core_1.types);
+            addEnvImport = () => {
+                return addNamedImportOnce(file.path, 'env', 'expo/virtual/env');
+            };
+        },
         visitor: {
             MemberExpression(path, state) {
                 const filename = state.filename;
                 if (path.get('object').matchesPattern('process.env')) {
-                    // @ts-expect-error: missing types
+                    // @ts-expect-error
                     const key = path.toComputedKey();
-                    if (t.isStringLiteral(key) &&
+                    if (core_1.types.isStringLiteral(key) &&
                         !isFirstInAssign(path) &&
                         key.value.startsWith('EXPO_PUBLIC_')) {
-                        debug('Inlining environment variable in %s: %s', filename, key.value);
-                        path.replaceWith(t.valueToNode(process.env[key.value]));
+                        const envVar = key.value;
+                        debug(`${isProduction ? 'Inlining' : 'Referencing'} environment variable in %s: %s`, filename, envVar);
+                        publicEnvVars.add(envVar);
+                        if (isProduction) {
+                            path.replaceWith(core_1.types.valueToNode(process.env[envVar]));
+                        }
+                        else {
+                            path.replaceWith(core_1.types.memberExpression(addEnvImport(), core_1.types.identifier(envVar)));
+                        }
                     }
                 }
             },
         },
+        post(file) {
+            assertExpoMetadata(file.metadata);
+            file.metadata.publicEnvVars = Array.from(publicEnvVars);
+        },
     };
 }
+function assertExpoMetadata(metadata) {
+    if (!metadata || typeof metadata !== 'object') {
+        throw new Error('Expected Babel state.file.metadata to be an object');
+    }
+}

package/build/server-actions-plugin.js

@@ -44,8 +44,6 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.reactServerActionsPlugin = reactServerActionsPlugin;
 const core_1 = require("@babel/core");
-// @ts-expect-error: missing types
-const helper_module_imports_1 = require("@babel/helper-module-imports");
 const t = __importStar(require("@babel/types"));
 const node_path_1 = require("node:path");
 const node_url_1 = __importStar(require("node:url"));
@@ -189,7 +187,7 @@ function reactServerActionsPlugin(api) {
             assertExpoMetadata(file.metadata);
             file.metadata.extractedActions = [];
             file.metadata.isModuleMarkedWithUseServerDirective = false;
-            const addNamedImportOnce = createAddNamedImportOnce(t);
+            const addNamedImportOnce = (0, common_1.createAddNamedImportOnce)(t);
             addReactImport = () => {
                 return addNamedImportOnce(file.path, 'registerServerReference', 'react-server-dom-webpack/server');
             };
@@ -634,26 +632,7 @@ function assertExpoMetadata(metadata) {
         throw new Error('Expected Babel state.file.metadata to be an object');
     }
 }
-const getOrCreateInMap = (map, key, create) => {
-    if (!map.has(key)) {
-        const result = create();
-        map.set(key, result);
-        return [result, true];
-    }
-    return [map.get(key), false];
-};
 function hasUseServerDirective(path) {
     const { body } = path.node;
     return t.isBlockStatement(body) && body.directives.some((d) => d.value.value === 'use server');
 }
-const createAddNamedImportOnce = (t) => {
-    const addedImportsCache = new Map();
-    return function addNamedImportOnce(path, name, source) {
-        const [sourceCache] = getOrCreateInMap(addedImportsCache, source, () => new Map());
-        const [identifier, didCreate] = getOrCreateInMap(sourceCache, name, () => (0, helper_module_imports_1.addNamed)(path, name, source));
-        // for cached imports, we need to clone the resulting identifier, because otherwise
-        // '@babel/plugin-transform-modules-commonjs' won't replace the references to the import for some reason.
-        // this is a helper for that.
-        return didCreate ? identifier : t.cloneNode(identifier);
-    };
-};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babel-preset-expo",
-  "version": "13.1.5",
+  "version": "13.1.6",
   "description": "The Babel preset for Expo projects",
   "main": "build/index.js",
   "files": [
@@ -76,8 +76,8 @@
     "@babel/traverse": "^7.9.0",
     "@babel/types": "^7.9.0",
     "babel-plugin-react-compiler": "^19.0.0-beta-e993439-20250405",
-    "expo-module-scripts": "^4.1.2",
+    "expo-module-scripts": "^4.1.4",
     "jest": "^29.2.1"
   },
-  "gitHead": "f1394f21ff2719a9a3037d7511db170704e5c492"
+  "gitHead": "dd4ea2ac865a2b0c1f4ea3fc5879d90679099862"
 }