@crossbind/plugin-metro 2.0.0-beta.50

package/CHANGELOG.md

@@ -0,0 +1,34 @@
+# @crossbind/plugin-metro
+
+## 2.0.0-beta.50
+
+### Patch Changes
+
+- Aligned on the 2.0.0-beta.50 baseline. No source change; the version exists so every package in
+  the workspace names the same release.
+
+## 1.0.2
+
+### Patch Changes
+
+- Updated dependencies
+  - crossbind@1.0.4
+
+## 1.0.0
+
+### Major Changes
+
+- 🚀 first stable release
+
+### Patch Changes
+
+- Updated dependencies
+  - crossbind@1.0.0
+
+## 1.0.0-beta.38
+
+### Patch Changes
+
+- chore: add initial version of CHANGELOGS files
+- Updated dependencies
+  - crossbind@1.0.0-beta.33

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Buğra Sarı and crossbind contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,75 @@
+# @crossbind/plugin-metro
+**crossbind Metro plugin**  
+A tool for seamless C++ integration with the Metro bundler.
+
+<a href="https://www.npmjs.com/package/@crossbind/plugin-metro">
+    <img alt="NPM version" src="https://img.shields.io/npm/v/@crossbind/plugin-metro?style=for-the-badge" />
+</a>
+<a href="https://github.com/crossbind/crossbind/blob/main/LICENSE">
+    <img alt="License" src="https://img.shields.io/github/license/crossbind/crossbind?style=for-the-badge" />
+</a>
+<a href="https://crossbind.dev/docs/guide/integrate-into-existing-project/react-native">
+    <img alt="Docs - React Native" src="https://img.shields.io/badge/Docs_-_React%20Native-20B2AA?style=for-the-badge" />
+</a>
+<a href="https://crossbind.dev/docs/guide/integrate-into-existing-project/expo">
+    <img alt="Docs - Expo" src="https://img.shields.io/badge/Docs_-_Expo-20B2AA?style=for-the-badge" />
+</a>
+
+## Integration
+To integrate crossbind into your project using Metro as a bundler, you can utilize the @crossbind/plugin-metro plugin. Start by installing these package with the following command:
+
+NPM
+```sh
+npm install @crossbind/plugin-metro --save-dev
+```
+or YARN
+```sh
+yarn add @crossbind/plugin-metro --dev
+```
+or PNPM
+```sh
+pnpm add @crossbind/plugin-metro --save-dev
+```
+or BUN
+```sh
+bun add @crossbind/plugin-metro --dev
+```
+
+To enable the plugin, modify the metro.config.js file as shown below.
+
+**React Native**
+```diff
+const {getDefaultConfig, mergeConfig} = require('@react-native/metro-config');
++const CrossbindMetroPlugin = require('@crossbind/plugin-metro');
+
+/**
+ * Metro configuration
+ * https://reactnative.dev/docs/metro
+ *
+ * @type {import('metro-config').MetroConfig}
+ */
+-const config = {};
++const config = {
++    ...CrossbindMetroPlugin(getDefaultConfig(__dirname)),
++};
+
+module.exports = mergeConfig(getDefaultConfig(__dirname), config);
+```
+
+**Expo**
+```diff
+// Learn more https://docs.expo.io/guides/customizing-metro
+const { getDefaultConfig } = require('expo/metro-config');
++const { mergeConfig } = require('metro-config');
++const CrossbindMetroPlugin = require('@crossbind/plugin-metro');
+
+/** @type {import('expo/metro-config').MetroConfig} */
+const config = getDefaultConfig(__dirname);
+
++const newConfig = {
++    ...CrossbindMetroPlugin(config),
++};
+
+-module.exports = config;
++module.exports = mergeConfig(config, newConfig);
+```

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@crossbind/plugin-metro",
+  "version": "2.0.0-beta.50",
+  "description": "crossbind Metro plugin: A tool for seamless C++ integration with the Metro bundler.",
+  "homepage": "https://github.com/crossbind/crossbind/tree/main/plugins/metro#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/crossbind/crossbind.git"
+  },
+  "license": "MIT",
+  "main": "src/metro-plugin.cjs",
+  "peerDependencies": {
+    "metro": "*",
+    "@babel/core": "^7.0.0"
+  },
+  "dependencies": {
+    "crossbind": "^2.0.0-beta.50",
+    "@babel/runtime": "^7.29.7",
+    "@react-native/metro-babel-transformer": "^0.85.3",
+    "upath": "^3.0.8"
+  },
+  "keywords": [
+    "crossbind-plugin",
+    "metro",
+    "react-native",
+    "expo",
+    "bind",
+    "c++",
+    "android",
+    "ios",
+    "mobile"
+  ]
+}

package/src/metro-plugin.cjs

@@ -0,0 +1,51 @@
+const path = require('node:path');
+
+let getDependFilePathFunc;
+let crossbindState;
+import('crossbind').then(({ getDependFilePath, state }) => {
+    getDependFilePathFunc = getDependFilePath;
+    crossbindState = state;
+});
+
+module.exports = function CrossbindMetroPlugin(defaultConfig) {
+    // Generated proxy modules (e.g. a cargo package's lib.rs) originate in package workspaces
+    // outside the app's node_modules chain, so their bare imports (react-native, @babel/runtime,
+    // @crossbind/core-embind-jsi, ...) must fall back to the app's resolution. extraNodeModules is
+    // consulted only when normal resolution fails, so everything else is untouched.
+    const projectRoot = defaultConfig.projectRoot || process.cwd();
+    const appNodeModules = new Proxy({}, {
+        get: (_, name) => {
+            try {
+                return path.dirname(require.resolve(`${String(name)}/package.json`, { paths: [projectRoot] }));
+            } catch (e) {
+                return path.join(projectRoot, 'node_modules', String(name));
+            }
+        },
+    });
+
+    return {
+        resetCache: true,
+        resolver: {
+            extraNodeModules: appNodeModules,
+            sourceExts: [...defaultConfig.resolver.sourceExts, ...['h', 'hpp', 'hxx', 'hh'], ...['i'], ...['rs']],
+            resolveRequest: (context, moduleName, platform) => {
+                // The `crossbind` import above resolves asynchronously; until it lands (and for
+                // platforms with no matching target) fall back to Metro's default resolution
+                // instead of dereferencing undefined state.
+                if (crossbindState && getDependFilePathFunc) {
+                    const target = crossbindState.targets.find((t) => t.platform === platform);
+                    const dependFilePath = target && getDependFilePathFunc(moduleName, target);
+                    if (dependFilePath) {
+                        return context.resolveRequest(context, dependFilePath, platform);
+                    }
+                }
+
+                return context.resolveRequest(context, moduleName, platform);
+            },
+        },
+        transformer: {
+            ...defaultConfig.transformer,
+            babelTransformerPath: require.resolve('./metro-transformer.cjs'),
+        },
+    };
+};

package/src/metro-transformer.cjs

@@ -0,0 +1,47 @@
+ 
+const upstreamTransformer = (() => {
+    try {
+        return require('@expo/metro-config/babel-transformer');
+    } catch (error) {
+        try {
+            return require('@react-native/metro-babel-transformer');
+        } catch (e) {
+            return require('metro-react-native-babel-transformer');
+        }
+    }
+})();
+
+let compilerClassPromise;
+const getCompilerClass = () => {
+    if (compilerClassPromise) return compilerClassPromise;
+    compilerClassPromise = new Promise((resolve, reject) => {
+        import('crossbind').then(({ state, getCrossbindScript, getRustJsScript, createBridgeFile }) => {
+            resolve({ state, getCrossbindScript, getRustJsScript, createBridgeFile });
+        }).catch((e) => reject(e));
+    });
+    return compilerClassPromise;
+};
+
+module.exports.transform = async ({ src, filename, ...rest }) => {
+    const { state, getCrossbindScript, getRustJsScript, createBridgeFile } = await getCompilerClass();
+    const headerRegex = new RegExp(`\\.(${state.config.ext.header.join('|')})$`);
+    const moduleRegex = new RegExp(`\\.(${state.config.ext.module.join('|')})$`);
+    if (headerRegex.test(filename) || moduleRegex.test(filename) || filename.endsWith('.rs')) {
+        let target;
+        if (rest.options.platform === 'ios') target = state.targets.find((t) => t.platform === 'ios');
+        else if (rest.options.platform === 'android') target = state.targets.find((t) => t.platform === 'android');
+        else target = state.targets.find((t) => t.platform === 'wasm');
+
+        // Rust surfaces need no bridge file here: the native bridge is the package's generated
+        // companion crate; this only emits the JS proxy module (same shape as the .h flow).
+        if (filename.endsWith('.rs')) {
+            return upstreamTransformer.transform({ src: getRustJsScript(target, filename), filename, ...rest });
+        }
+
+        const bridgeFile = createBridgeFile(filename, target);
+
+        return upstreamTransformer.transform({ src: getCrossbindScript(target, bridgeFile), filename, ...rest });
+    }
+
+    return upstreamTransformer.transform({ src, filename, ...rest });
+};