@react-native-harness/metro 1.1.0 → 1.2.0-rc.1

package/.claude/settings.local.json

@@ -0,0 +1,9 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npm run typecheck:*)",
+      "Bash(npm run:*)",
+      "Bash(npx tsc:*)"
+    ]
+  }
+}

package/dist/__tests__/paths.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=paths.test.d.ts.map

package/dist/__tests__/paths.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/paths.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/paths.test.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
+const node_os_1 = tslib_1.__importDefault(require("node:os"));
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const vitest_1 = require("vitest");
+const paths_js_1 = require("../paths.js");
+const tempDirs = [];
+const createTempProjectRoot = () => {
+    const tempDir = node_fs_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), 'rn-harness-metro-'));
+    tempDirs.push(tempDir);
+    return tempDir;
+};
+(0, vitest_1.afterEach)(() => {
+    for (const tempDir of tempDirs.splice(0)) {
+        node_fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+    }
+});
+(0, vitest_1.describe)('metro paths', () => {
+    (0, vitest_1.it)('resolves the harness root under the project root', () => {
+        const projectRoot = createTempProjectRoot();
+        (0, vitest_1.expect)((0, paths_js_1.getHarnessRootPath)(projectRoot)).toBe(node_path_1.default.join(projectRoot, '.harness'));
+        (0, vitest_1.expect)((0, paths_js_1.getHarnessManifestPath)(projectRoot)).toBe(node_path_1.default.join(projectRoot, '.harness', 'manifest.js'));
+        (0, vitest_1.expect)((0, paths_js_1.getHarnessMetroCachePath)(projectRoot)).toBe(node_path_1.default.join(projectRoot, '.harness', 'metro-cache'));
+    });
+    (0, vitest_1.it)('returns false when the metro cache directory is missing', () => {
+        const projectRoot = createTempProjectRoot();
+        (0, vitest_1.expect)((0, paths_js_1.isMetroCacheReusable)(projectRoot)).toBe(false);
+    });
+    (0, vitest_1.it)('returns false when the metro cache directory is empty', () => {
+        const projectRoot = createTempProjectRoot();
+        node_fs_1.default.mkdirSync((0, paths_js_1.getHarnessMetroCachePath)(projectRoot), { recursive: true });
+        (0, vitest_1.expect)((0, paths_js_1.isMetroCacheReusable)(projectRoot)).toBe(false);
+    });
+    (0, vitest_1.it)('returns true when the metro cache directory contains entries', () => {
+        const projectRoot = createTempProjectRoot();
+        const metroCachePath = (0, paths_js_1.getHarnessMetroCachePath)(projectRoot);
+        node_fs_1.default.mkdirSync(metroCachePath, { recursive: true });
+        node_fs_1.default.writeFileSync(node_path_1.default.join(metroCachePath, 'entry'), 'cached');
+        (0, vitest_1.expect)((0, paths_js_1.isMetroCacheReusable)(projectRoot)).toBe(true);
+    });
+});

package/dist/babel-transformer.d.ts

@@ -0,0 +1,6 @@
+import type { BabelTransformer } from 'metro-babel-transformer';
+import { MetroConfig } from '@react-native/metro-config';
+export declare const getHarnessBabelTransformerPath: (metroConfig: MetroConfig) => string;
+declare const transform: BabelTransformer['transform'];
+export { transform };
+//# sourceMappingURL=babel-transformer.d.ts.map

package/dist/babel-transformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"babel-transformer.d.ts","sourceRoot":"","sources":["../src/babel-transformer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAEzD,eAAO,MAAM,8BAA8B,GACzC,aAAa,WAAW,KACvB,MASF,CAAC;AAEF,QAAA,MAAM,SAAS,EAAE,gBAAgB,CAAC,WAAW,CAoB5C,CAAC;AAEF,OAAO,EAAE,SAAS,EAAE,CAAC"}

package/dist/babel-transformer.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transform = exports.getHarnessBabelTransformerPath = void 0;
+const babel_preset_1 = require("@react-native-harness/babel-preset");
+const getHarnessBabelTransformerPath = (metroConfig) => {
+    const upstreamTransformerPath = metroConfig.transformer?.babelTransformerPath;
+    if (!upstreamTransformerPath || typeof upstreamTransformerPath !== 'string') {
+        throw new Error('Upstream transformer path is not a string');
+    }
+    process.env.RN_HARNESS_UPSTREAM_TRANSFORMER_PATH = upstreamTransformerPath;
+    return require.resolve('./babel-transformer.js');
+};
+exports.getHarnessBabelTransformerPath = getHarnessBabelTransformerPath;
+const transform = (args) => {
+    const { plugins } = args;
+    const upstreamTransformerPath = process.env.RN_HARNESS_UPSTREAM_TRANSFORMER_PATH;
+    if (!upstreamTransformerPath || typeof upstreamTransformerPath !== 'string') {
+        throw new Error('Upstream transformer path is not a string');
+    }
+    const upstreamTransformer = require(upstreamTransformerPath);
+    const pluginsWithHarness = [
+        // Checked against @babel/core's type definitions - plugins are an array of PluginItem
+        ...(plugins ?? []),
+        ...babel_preset_1.rnHarnessPlugins,
+    ];
+    return upstreamTransformer.transform({
+        ...args,
+        plugins: pluginsWithHarness,
+    });
+};
+exports.transform = transform;

package/dist/errors.d.ts

@@ -0,0 +1,4 @@
+export declare class CouldNotPatchModuleSystemError extends Error {
+    constructor();
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,8BAA+B,SAAQ,KAAK;;CAKxD"}

package/dist/errors.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CouldNotPatchModuleSystemError = void 0;
+class CouldNotPatchModuleSystemError extends Error {
+    constructor() {
+        super('Could not patch module system');
+        this.name = 'CouldNotPatchModuleSystemError';
+    }
+}
+exports.CouldNotPatchModuleSystemError = CouldNotPatchModuleSystemError;

package/dist/getHarnessSerializer.d.ts

@@ -0,0 +1,4 @@
+import type { MetroConfig } from 'metro-config';
+export type Serializer = NonNullable<NonNullable<MetroConfig['serializer']>['customSerializer']>;
+export declare const getHarnessSerializer: () => Serializer;
+//# sourceMappingURL=getHarnessSerializer.d.ts.map

package/dist/getHarnessSerializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getHarnessSerializer.d.ts","sourceRoot":"","sources":["../src/getHarnessSerializer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD,MAAM,MAAM,UAAU,GAAG,WAAW,CAClC,WAAW,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAC3D,CAAC;AAYF,eAAO,MAAM,oBAAoB,QAAO,UA6BvC,CAAC"}

package/dist/getHarnessSerializer.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHarnessSerializer = void 0;
+const getBaseSerializer = () => {
+    const baseJSBundle = require('metro/private/DeltaBundler/Serializers/baseJSBundle');
+    const bundleToString = require('metro/private/lib/bundleToString');
+    return (entryPoint, prepend, graph, bundleOptions) => bundleToString(baseJSBundle(entryPoint, prepend, graph, bundleOptions));
+};
+const getAllFiles = require('metro/private/DeltaBundler/Serializers/getAllFiles');
+const getHarnessSerializer = () => {
+    const baseSerializer = getBaseSerializer();
+    let mainEntryPointModules = new Set();
+    return async (entryPoint, preModules, graph, options) => {
+        if (options.modulesOnly) {
+            // This is most likely a test file
+            return baseSerializer(entryPoint, preModules, graph, {
+                ...options,
+                processModuleFilter: (mod) => {
+                    if (options.processModuleFilter &&
+                        !options.processModuleFilter(mod)) {
+                        // If the module is not allowed by the processModuleFilter, skip it
+                        return false;
+                    }
+                    // If the module is in the main entry point, skip it
+                    return !mainEntryPointModules.has(mod.path);
+                },
+            });
+        }
+        mainEntryPointModules = new Set(await getAllFiles(preModules, graph, options));
+        return baseSerializer(entryPoint, preModules, graph, options);
+    };
+};
+exports.getHarnessSerializer = getHarnessSerializer;

package/dist/jest-globals-mock.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=jest-globals-mock.d.ts.map

package/dist/jest-globals-mock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jest-globals-mock.d.ts","sourceRoot":"","sources":["../src/jest-globals-mock.ts"],"names":[],"mappings":""}

package/dist/jest-globals-mock.js

@@ -0,0 +1,5 @@
+"use strict";
+// Mock module for @jest/globals imports
+// This module throws immediately when imported to warn users about using Jest APIs
+Object.defineProperty(exports, "__esModule", { value: true });
+throw new Error("Importing '@jest/globals' is not supported in Harness tests. Import from 'react-native-harness' instead.");

package/dist/json-reporter.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=json-reporter.d.ts.map

package/dist/json-reporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-reporter.d.ts","sourceRoot":"","sources":["../src/json-reporter.ts"],"names":[],"mappings":""}

package/dist/json-reporter.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const JsonReporter = require('metro/private/lib/JsonReporter');
+class CustomReporter extends JsonReporter {
+    constructor() {
+        super(process.stdout);
+    }
+}
+module.exports = CustomReporter;

package/dist/manifest.d.ts

@@ -0,0 +1,3 @@
+import { Config as HarnessConfig } from '@react-native-harness/config';
+export declare const getHarnessManifest: (harnessConfig: HarnessConfig) => string;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../src/manifest.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAWvE,eAAO,MAAM,kBAAkB,GAAI,eAAe,aAAa,KAAG,MAQjE,CAAC"}

package/dist/manifest.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHarnessManifest = void 0;
+const tslib_1 = require("tslib");
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
+const paths_1 = require("./paths");
+const getManifestContent = (harnessConfig) => {
+    return `global.RN_HARNESS = { 
+    appRegistryComponentName: '${harnessConfig.appRegistryComponentName}',
+    webSocketPort: ${harnessConfig.webSocketPort},
+    disableViewFlattening: ${harnessConfig.disableViewFlattening},
+  };`;
+};
+const getHarnessManifest = (harnessConfig) => {
+    const manifestContent = getManifestContent(harnessConfig);
+    const manifestPath = (0, paths_1.getHarnessManifestPath)();
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(manifestPath), { recursive: true });
+    node_fs_1.default.writeFileSync(manifestPath, manifestContent);
+    return manifestPath;
+};
+exports.getHarnessManifest = getHarnessManifest;

package/dist/metro-cache.d.ts

@@ -0,0 +1,4 @@
+import { MetroCache } from 'metro-cache';
+import type { CacheStoresConfigT } from 'metro-config';
+export declare const getHarnessCacheStores: () => ((metroCache: MetroCache) => CacheStoresConfigT);
+//# sourceMappingURL=metro-cache.d.ts.map

package/dist/metro-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metro-cache.d.ts","sourceRoot":"","sources":["../src/metro-cache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,UAAU,EAAE,MAAM,aAAa,CAAC;AAGrD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAGvD,eAAO,MAAM,qBAAqB,QAAO,CAAC,CACxC,UAAU,EAAE,UAAU,KACnB,kBAAkB,CAYtB,CAAC"}

package/dist/metro-cache.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHarnessCacheStores = void 0;
+const tslib_1 = require("tslib");
+const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
+const paths_1 = require("./paths");
+const getHarnessCacheStores = () => {
+    return ({ FileStore }) => {
+        const cacheRoot = (0, paths_1.getHarnessMetroCachePath)();
+        node_fs_1.default.mkdirSync(cacheRoot, { recursive: true });
+        return [
+            new FileStore({ root: cacheRoot }),
+        ];
+    };
+};
+exports.getHarnessCacheStores = getHarnessCacheStores;

package/dist/moduleSystem.d.ts

@@ -0,0 +1,2 @@
+export declare const patchModuleSystem: () => void;
+//# sourceMappingURL=moduleSystem.d.ts.map

package/dist/moduleSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"moduleSystem.d.ts","sourceRoot":"","sources":["../src/moduleSystem.ts"],"names":[],"mappings":"AAqCA,eAAO,MAAM,iBAAiB,QAAO,IAOpC,CAAC"}

package/dist/moduleSystem.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchModuleSystem = void 0;
+const errors_1 = require("./errors");
+const optionalResolve = (path, from) => {
+    try {
+        return require.resolve(path, { paths: [from] });
+    }
+    catch {
+        return null;
+    }
+};
+const getMetroDefaultsPath = () => {
+    const reactNativeMetroConfigPath = require.resolve('@react-native/metro-config', { paths: [process.cwd()] });
+    const preExportsDefaults = optionalResolve('metro-config/src/defaults/defaults', reactNativeMetroConfigPath);
+    if (preExportsDefaults) {
+        return preExportsDefaults;
+    }
+    const privateDefaults = optionalResolve('metro-config/private/defaults/defaults', reactNativeMetroConfigPath);
+    if (privateDefaults) {
+        return privateDefaults;
+    }
+    throw new errors_1.CouldNotPatchModuleSystemError();
+};
+const patchModuleSystem = () => {
+    const metroConfigPath = getMetroDefaultsPath();
+    const metroConfig = require(metroConfigPath);
+    metroConfig.moduleSystem = require.resolve('@react-native-harness/runtime/moduleSystem');
+};
+exports.patchModuleSystem = patchModuleSystem;

package/dist/node_modules/.cache/rn-harness/manifest.js

@@ -0,0 +1 @@
+global.RN_HARNESS = { appRegistryComponentName: 'Playground' };

package/dist/paths.d.ts

@@ -0,0 +1,5 @@
+export declare const getHarnessRootPath: (projectRoot?: string) => string;
+export declare const getHarnessManifestPath: (projectRoot?: string) => string;
+export declare const getHarnessMetroCachePath: (projectRoot?: string) => string;
+export declare const isMetroCacheReusable: (projectRoot?: string) => boolean;
+//# sourceMappingURL=paths.d.ts.map

package/dist/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../src/paths.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,kBAAkB,GAAI,oBAA2B,KAAG,MACrB,CAAC;AAE7C,eAAO,MAAM,sBAAsB,GAAI,oBAA2B,KAAG,MACN,CAAC;AAEhE,eAAO,MAAM,wBAAwB,GACnC,oBAA2B,KAC1B,MAAyE,CAAC;AAE7E,eAAO,MAAM,oBAAoB,GAAI,oBAA2B,KAAG,OAclE,CAAC"}

package/dist/paths.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMetroCacheReusable = exports.getHarnessMetroCachePath = exports.getHarnessManifestPath = exports.getHarnessRootPath = void 0;
+const tslib_1 = require("tslib");
+const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const HARNESS_DIRNAME = '.harness';
+const MANIFEST_FILENAME = 'manifest.js';
+const METRO_CACHE_DIRNAME = 'metro-cache';
+const getHarnessRootPath = (projectRoot = process.cwd()) => node_path_1.default.resolve(projectRoot, HARNESS_DIRNAME);
+exports.getHarnessRootPath = getHarnessRootPath;
+const getHarnessManifestPath = (projectRoot = process.cwd()) => node_path_1.default.join((0, exports.getHarnessRootPath)(projectRoot), MANIFEST_FILENAME);
+exports.getHarnessManifestPath = getHarnessManifestPath;
+const getHarnessMetroCachePath = (projectRoot = process.cwd()) => node_path_1.default.join((0, exports.getHarnessRootPath)(projectRoot), METRO_CACHE_DIRNAME);
+exports.getHarnessMetroCachePath = getHarnessMetroCachePath;
+const isMetroCacheReusable = (projectRoot = process.cwd()) => {
+    const metroCachePath = (0, exports.getHarnessMetroCachePath)(projectRoot);
+    try {
+        const stat = node_fs_1.default.statSync(metroCachePath);
+        if (!stat.isDirectory()) {
+            return false;
+        }
+        return node_fs_1.default.readdirSync(metroCachePath).length > 0;
+    }
+    catch {
+        return false;
+    }
+};
+exports.isMetroCacheReusable = isMetroCacheReusable;

package/dist/resolver.d.ts

@@ -0,0 +1,6 @@
+import type { MetroConfig } from '@react-native/metro-config';
+import type { Config as HarnessConfig } from '@react-native-harness/config';
+type CustomResolver = NonNullable<NonNullable<MetroConfig['resolver']>['resolveRequest']>;
+export declare const getHarnessResolver: (metroConfig: MetroConfig, harnessConfig: HarnessConfig) => CustomResolver;
+export {};
+//# sourceMappingURL=resolver.d.ts.map

package/dist/resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../src/resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,KAAK,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAE5E,KAAK,cAAc,GAAG,WAAW,CAC/B,WAAW,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC,gBAAgB,CAAC,CACvD,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAC7B,aAAa,WAAW,EACxB,eAAe,aAAa,KAC3B,cAgCF,CAAC"}

package/dist/resolver.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHarnessResolver = void 0;
+const getHarnessResolver = (metroConfig, harnessConfig) => {
+    // Can be relative to the project root or absolute, need to normalize it
+    const resolvedEntryPointPath = require.resolve(harnessConfig.entryPoint, {
+        paths: [process.cwd()],
+    });
+    return (context, moduleName, platform) => {
+        const existingResolver = metroConfig.resolver?.resolveRequest ?? context.resolveRequest;
+        const resolvedModule = existingResolver(context, moduleName, platform);
+        // Replace the entry point with Harness
+        if (resolvedModule.type === 'sourceFile' &&
+            resolvedModule.filePath === resolvedEntryPointPath) {
+            return {
+                type: 'sourceFile',
+                filePath: require.resolve('@react-native-harness/runtime/entry-point'),
+            };
+        }
+        // Intercept @jest/globals imports and redirect to mock module
+        if (moduleName === '@jest/globals') {
+            return {
+                type: 'sourceFile',
+                filePath: require.resolve('./jest-globals-mock'),
+            };
+        }
+        return resolvedModule;
+    };
+};
+exports.getHarnessResolver = getHarnessResolver;

package/dist/resolvers/composite-resolver.d.ts

@@ -0,0 +1,3 @@
+import type { HarnessResolver, MetroResolver } from './types';
+export declare const createHarnessResolver: (resolvers: HarnessResolver[]) => MetroResolver;
+//# sourceMappingURL=composite-resolver.d.ts.map

package/dist/resolvers/composite-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composite-resolver.d.ts","sourceRoot":"","sources":["../../src/resolvers/composite-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE9D,eAAO,MAAM,qBAAqB,GAChC,WAAW,eAAe,EAAE,KAC3B,aAWF,CAAC"}

package/dist/resolvers/composite-resolver.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHarnessResolver = void 0;
+const createHarnessResolver = (resolvers) => {
+    return (context, moduleName, platform) => {
+        for (const resolver of resolvers) {
+            const result = resolver(context, moduleName, platform);
+            if (result != null) {
+                return result;
+            }
+        }
+        return context.resolveRequest(context, moduleName, platform);
+    };
+};
+exports.createHarnessResolver = createHarnessResolver;

package/dist/resolvers/resolver.d.ts

@@ -0,0 +1,8 @@
+import type { MetroConfig } from '@react-native/metro-config';
+import type { Config as HarnessConfig } from '@react-native-harness/config';
+import type { HarnessResolver, MetroResolver } from './types';
+export declare const createHarnessEntryPointResolver: (harnessConfig: HarnessConfig) => HarnessResolver;
+export declare const createJestGlobalsResolver: () => HarnessResolver;
+export declare const createJsxRuntimeResolver: () => HarnessResolver;
+export declare const getHarnessResolver: (metroConfig: MetroConfig, harnessConfig: HarnessConfig) => MetroResolver;
+//# sourceMappingURL=resolver.d.ts.map

package/dist/resolvers/resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../src/resolvers/resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,KAAK,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAI5E,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAS9D,eAAO,MAAM,+BAA+B,GAAI,eAAe,aAAa,KAAG,eA4B9E,CAAC;AAEF,eAAO,MAAM,yBAAyB,QAAO,eAY5C,CAAC;AAEF,eAAO,MAAM,wBAAwB,QAAO,eAyB3C,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAC7B,aAAa,WAAW,EACxB,eAAe,aAAa,KAC3B,aAWF,CAAC"}

package/dist/resolvers/resolver.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHarnessResolver = exports.createJsxRuntimeResolver = exports.createJestGlobalsResolver = exports.createHarnessEntryPointResolver = void 0;
+const tslib_1 = require("tslib");
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const composite_resolver_1 = require("./composite-resolver");
+const tsconfig_resolver_1 = require("./tsconfig-resolver");
+// Safely resolves a path and strips its extension
+const getExtensionlessAbsolutePath = (basePath, relativePath = '') => {
+    const fullPath = node_path_1.default.resolve(basePath, relativePath);
+    const parsed = node_path_1.default.parse(fullPath);
+    return node_path_1.default.join(parsed.dir, parsed.name);
+};
+const createHarnessEntryPointResolver = (harnessConfig) => {
+    const rootPath = node_path_1.default.resolve(process.cwd());
+    const expectedEntryPoint = getExtensionlessAbsolutePath(rootPath, harnessConfig.entryPoint);
+    const resolvedHarnessPath = require.resolve('@react-native-harness/runtime/entry-point');
+    return (context, moduleName, _platform) => {
+        // 1. Resolve the origin path of the file making the import
+        const currentOrigin = node_path_1.default.resolve(context.originModulePath);
+        // Fast Fail: If the import isn't happening from the root directory, skip it immediately
+        if (currentOrigin !== rootPath) {
+            return null;
+        }
+        // 2. Resolve the module being imported and strip its extension
+        // This safely normalizes './index', './index.js', 'index.js', etc.
+        const requestedModule = getExtensionlessAbsolutePath(currentOrigin, moduleName);
+        // 3. String comparison
+        if (requestedModule === expectedEntryPoint) {
+            return {
+                type: 'sourceFile',
+                filePath: resolvedHarnessPath,
+            };
+        }
+        return null;
+    };
+};
+exports.createHarnessEntryPointResolver = createHarnessEntryPointResolver;
+const createJestGlobalsResolver = () => {
+    return (_context, moduleName, _platform) => {
+        // Intercept @jest/globals imports and redirect to mock module
+        if (moduleName === '@jest/globals') {
+            return {
+                type: 'sourceFile',
+                filePath: require.resolve('../jest-globals-mock'),
+            };
+        }
+        return null;
+    };
+};
+exports.createJestGlobalsResolver = createJestGlobalsResolver;
+const createJsxRuntimeResolver = () => {
+    const resolvedJsxRuntimePath = require.resolve('@react-native-harness/runtime/jsx-runtime');
+    const resolvedJsxDevRuntimePath = require.resolve('@react-native-harness/runtime/jsx-dev-runtime');
+    return (_context, moduleName, _platform) => {
+        if (moduleName === '@react-native-harness/runtime/jsx-runtime') {
+            return {
+                type: 'sourceFile',
+                filePath: resolvedJsxRuntimePath,
+            };
+        }
+        if (moduleName === '@react-native-harness/runtime/jsx-dev-runtime') {
+            return {
+                type: 'sourceFile',
+                filePath: resolvedJsxDevRuntimePath,
+            };
+        }
+        return null;
+    };
+};
+exports.createJsxRuntimeResolver = createJsxRuntimeResolver;
+const getHarnessResolver = (metroConfig, harnessConfig) => {
+    const userResolver = metroConfig.resolver?.resolveRequest;
+    const resolvers = [
+        (0, exports.createHarnessEntryPointResolver)(harnessConfig),
+        (0, exports.createJestGlobalsResolver)(),
+        (0, exports.createJsxRuntimeResolver)(),
+        (0, tsconfig_resolver_1.createTsConfigResolver)(process.cwd()),
+        userResolver,
+    ].filter((resolver) => !!resolver);
+    return (0, composite_resolver_1.createHarnessResolver)(resolvers);
+};
+exports.getHarnessResolver = getHarnessResolver;

package/dist/resolvers/tsconfig-resolver.d.ts

@@ -0,0 +1,18 @@
+import type { Resolution, CustomResolutionContext } from 'metro-resolver';
+import type { HarnessResolver } from './types';
+export type TsConfigPaths = {
+    paths: Record<string, string[]>;
+    baseUrl: string;
+    hasBaseUrl: boolean;
+};
+/**
+ * Load tsconfig.json or jsconfig.json and extract path mappings
+ */
+export declare const loadTsConfigPaths: (projectRoot: string) => TsConfigPaths | null;
+/**
+ * Resolve module using tsconfig path mappings
+ * Use this directly in your custom resolver
+ */
+export declare const resolveWithTsConfigPaths: (tsConfig: TsConfigPaths, context: CustomResolutionContext, moduleName: string, platform: string | null) => Resolution | null;
+export declare const createTsConfigResolver: (projectRoot: string) => HarnessResolver;
+//# sourceMappingURL=tsconfig-resolver.d.ts.map

package/dist/resolvers/tsconfig-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsconfig-resolver.d.ts","sourceRoot":"","sources":["../../src/resolvers/tsconfig-resolver.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AAC1E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAO/C,MAAM,MAAM,aAAa,GAAG;IAC3B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,OAAO,CAAC;CACpB,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,iBAAiB,GAC7B,aAAa,MAAM,KACjB,aAAa,GAAG,IA+BlB,CAAC;AAsFF;;;GAGG;AACH,eAAO,MAAM,wBAAwB,GACpC,UAAU,aAAa,EACvB,SAAS,uBAAuB,EAChC,YAAY,MAAM,EAClB,UAAU,MAAM,GAAG,IAAI,KACrB,UAAU,GAAG,IAqCf,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAClC,aAAa,MAAM,KACjB,eAqBF,CAAC"}

package/dist/resolvers/tsconfig-resolver.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTsConfigResolver = exports.resolveWithTsConfigPaths = exports.loadTsConfigPaths = void 0;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+/**
+ * Load tsconfig.json or jsconfig.json and extract path mappings
+ */
+const loadTsConfigPaths = (projectRoot) => {
+    const configFiles = ['tsconfig.json', 'jsconfig.json'];
+    for (const configFile of configFiles) {
+        const configPath = path_1.default.join(projectRoot, configFile);
+        if (!fs_1.default.existsSync(configPath))
+            continue;
+        try {
+            const content = fs_1.default.readFileSync(configPath, 'utf8');
+            // Strip comments without touching string literals
+            const jsonContent = stripJsonComments(content);
+            const config = JSON.parse(jsonContent);
+            const compilerOptions = config.compilerOptions || {};
+            const paths = compilerOptions.paths || {};
+            const baseUrl = compilerOptions.baseUrl;
+            if (Object.keys(paths).length > 0 || baseUrl) {
+                return {
+                    paths,
+                    baseUrl: baseUrl ? path_1.default.resolve(projectRoot, baseUrl) : projectRoot,
+                    hasBaseUrl: !!baseUrl,
+                };
+            }
+        }
+        catch (error) {
+            console.warn(`Failed to parse ${configFile}:`, error);
+        }
+    }
+    return null;
+};
+exports.loadTsConfigPaths = loadTsConfigPaths;
+const stripJsonComments = (input) => {
+    let result = '';
+    let inString = false;
+    let stringChar = '';
+    let isEscaped = false;
+    let inLineComment = false;
+    let inBlockComment = false;
+    for (let i = 0; i < input.length; i += 1) {
+        const char = input[i];
+        const nextChar = input[i + 1];
+        if (inLineComment) {
+            if (char === '\n') {
+                inLineComment = false;
+                result += char;
+            }
+            continue;
+        }
+        if (inBlockComment) {
+            if (char === '*' && nextChar === '/') {
+                inBlockComment = false;
+                i += 1;
+            }
+            continue;
+        }
+        if (inString) {
+            result += char;
+            if (!isEscaped && char === stringChar) {
+                inString = false;
+                stringChar = '';
+            }
+            isEscaped = !isEscaped && char === '\\';
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            inString = true;
+            stringChar = char;
+            result += char;
+            isEscaped = false;
+            continue;
+        }
+        if (char === '/' && nextChar === '/') {
+            inLineComment = true;
+            i += 1;
+            continue;
+        }
+        if (char === '/' && nextChar === '*') {
+            inBlockComment = true;
+            i += 1;
+            continue;
+        }
+        result += char;
+    }
+    return result;
+};
+/**
+ * Match module name against tsconfig path pattern (supports wildcards)
+ */
+const matchPattern = (pattern, moduleName) => {
+    const escapedPattern = pattern
+        .replace(/[.+?^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*/g, '(.*)');
+    const regex = new RegExp(`^${escapedPattern}$`);
+    const match = moduleName.match(regex);
+    return {
+        matched: !!match,
+        captured: match?.[1] || '',
+    };
+};
+/**
+ * Resolve module using tsconfig path mappings
+ * Use this directly in your custom resolver
+ */
+const resolveWithTsConfigPaths = (tsConfig, context, moduleName, platform) => {
+    const { paths, baseUrl, hasBaseUrl } = tsConfig;
+    const resolveRequest = context.resolveRequest;
+    if (!resolveRequest) {
+        return null;
+    }
+    // Try path mappings first
+    for (const [pattern, targets] of Object.entries(paths)) {
+        const { matched, captured } = matchPattern(pattern, moduleName);
+        if (!matched)
+            continue;
+        // Try each target
+        for (const target of targets) {
+            const resolvedTarget = target.replace('*', captured);
+            const absolutePath = path_1.default.resolve(baseUrl, resolvedTarget);
+            try {
+                return resolveRequest(context, absolutePath, platform);
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    // Try baseUrl for non-relative imports
+    if (hasBaseUrl && !moduleName.startsWith('.') && !moduleName.startsWith('/')) {
+        const absolutePath = path_1.default.resolve(baseUrl, moduleName);
+        try {
+            return resolveRequest(context, absolutePath, platform);
+        }
+        catch {
+            // Fall through
+        }
+    }
+    return null;
+};
+exports.resolveWithTsConfigPaths = resolveWithTsConfigPaths;
+const createTsConfigResolver = (projectRoot) => {
+    const tsConfig = (0, exports.loadTsConfigPaths)(projectRoot);
+    return (context, moduleName, platform) => {
+        if (!tsConfig) {
+            return null;
+        }
+        if (!context.resolveRequest) {
+            return null;
+        }
+        const resolved = (0, exports.resolveWithTsConfigPaths)(tsConfig, context, moduleName, platform);
+        return resolved ?? null;
+    };
+};
+exports.createTsConfigResolver = createTsConfigResolver;

package/dist/resolvers/types.d.ts

@@ -0,0 +1,4 @@
+import type { CustomResolutionContext, Resolution } from 'metro-resolver';
+export type HarnessResolver = (context: CustomResolutionContext, moduleName: string, platform: string | null) => Resolution | null;
+export type MetroResolver = (context: CustomResolutionContext, moduleName: string, platform: string | null) => Resolution;
+//# sourceMappingURL=types.d.ts.map

package/dist/resolvers/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/resolvers/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAE1E,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,EAAE,uBAAuB,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,KAAK,UAAU,GAAG,IAAI,CAAC;AACnI,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,EAAE,uBAAuB,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,KAAK,UAAU,CAAC"}

package/dist/resolvers/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils.d.ts

@@ -0,0 +1,4 @@
+export type NotReadOnly<T> = {
+    -readonly [K in keyof T]: T[K];
+};
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI;IAC3B,CAAC,UAAU,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAC/B,CAAC"}

package/dist/utils.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native-harness/metro",
-  "version": "1.1.0",
+  "version": "1.2.0-rc.1",
   "type": "commonjs",
   "main": "./dist/index.js",
   "module": "./dist/index.js",