@flareapp/react-native-sourcemaps 2.6.0

package/dist/bin.mjs

@@ -0,0 +1,252 @@
+#!/usr/bin/env node
+import { t as uploadSourcemaps } from "./uploadSourcemaps-C2EGBxe1.mjs";
+import { r as LOG_PREFIX, t as resolveAutoVersion } from "./version-DnFqflPl.mjs";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+//#region src/banner.ts
+const BORDER = "=".repeat(60);
+/**
+* Mask an API key for display in a build log, which CI commonly archives. A key
+* long enough to stay unguessable keeps a short head/tail so the user can still
+* recognise WHICH key it was; a short key is fully masked. Never returns the key
+* in full, so the secret cannot leak through the failure banner.
+*/
+function maskApiKey(apiKey) {
+	if (apiKey.length <= 12) return "*".repeat(apiKey.length);
+	return `${apiKey.slice(0, 4)}${"*".repeat(8)}${apiKey.slice(-4)}`;
+}
+/**
+* The deliberately large failure banner. A one-line "failed to upload" is too easy
+* to miss in a long native-build log, so this is a bordered block surrounded by
+* blank lines. Resolved values are interpolated into the re-run command so the
+* user can copy-paste it; unknown values show a labelled placeholder (in the
+* version-unset case `version` stays a placeholder — it is the value to supply).
+* The API key is the one exception: it is MASKED, never printed in full, because
+* this banner lands in the native build log.
+*/
+function formatFailureBanner(info) {
+	const sourcemap = info.sourcemap ?? "<path-to-map>";
+	const bundleFilename = info.bundleFilename ?? "<bundle-filename>";
+	const version = info.version && info.version.length > 0 ? info.version : "<flare-sourcemap-version>";
+	const hasApiKey = !!(info.apiKey && info.apiKey.length > 0);
+	const apiKey = hasApiKey ? maskApiKey(info.apiKey) : "<your-flare-api-key>";
+	const endpointFlag = info.apiEndpoint ? ` --api-endpoint ${info.apiEndpoint}` : "";
+	const lines = [
+		"",
+		BORDER,
+		"  FLARE SOURCEMAP UPLOAD FAILED",
+		`  Reason: ${info.reason}`,
+		"  Your release will report minified stack traces until the",
+		"  sourcemap is uploaded. Re-run manually:",
+		`    npx flare-rn-sourcemaps upload --sourcemap ${sourcemap} \\`,
+		`      --bundle-filename ${bundleFilename} --version ${version} --api-key ${apiKey}${endpointFlag}`
+	];
+	if (hasApiKey) lines.push("  (the --api-key above is masked; pass your full Flare key, or set FLARE_API_KEY, when re-running)");
+	lines.push(BORDER, "");
+	return lines.join("\n");
+}
+function printFailureBanner(info) {
+	console.error(formatFailureBanner(info));
+}
+
+//#endregion
+//#region src/config.ts
+/**
+* Read flare.json from an EXPLICIT path. The hooks run from android/ or ios/, so
+* resolving relative to process.cwd() would read the wrong file — callers always
+* pass --config. Missing or malformed file → empty config, so resolution falls
+* through to env, then to the no-key skip-with-banner. Any `version` key is
+* deliberately ignored: in the auto path the version flows only through
+* FLARE_SOURCEMAP_VERSION (see resolveAutoVersion / the design doc).
+*/
+function readFlareConfig(configPath) {
+	if (!configPath) return {};
+	try {
+		const raw = JSON.parse(readFileSync(configPath, "utf8"));
+		const config = {};
+		const apiKey = asString(raw.apiKey);
+		const apiEndpoint = asString(raw.apiEndpoint);
+		if (apiKey !== void 0) config.apiKey = apiKey;
+		if (apiEndpoint !== void 0) config.apiEndpoint = apiEndpoint;
+		return config;
+	} catch {
+		return {};
+	}
+}
+function asString(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+
+//#endregion
+//#region src/env.ts
+const ENV_FILES = [".env.local", ".env"];
+/**
+* Load FLARE_* variables from .env.local / .env in `rootDir` into process.env,
+* without overwriting anything already set.
+*
+* The native build hooks run in a fresh process whose environment often does NOT
+* carry the upload key: the app's .env files are loaded by Metro at JS runtime, not
+* at native build time, and a build launched from an IDE — or served by a reused
+* Gradle daemon with a stale environment — won't see a key you exported in your
+* shell. Reading the key from the FILE here makes "drop FLARE_API_KEY in .env.local"
+* work the way developers expect, on both platforms, without re-exporting it per
+* build.
+*
+* Only FLARE_-prefixed keys are read, so this never pulls unrelated secrets from the
+* file into the process. Minimal parser (no dependency): `KEY=value`, an optional
+* `export ` prefix, surrounding single/double quotes stripped, blank and `#` comment
+* lines ignored. Inline comments are NOT stripped (a `#` is treated as part of the
+* value), which is fine for the alphanumeric keys Flare issues.
+*/
+function loadEnvFiles(rootDir) {
+	for (const file of ENV_FILES) {
+		let raw;
+		try {
+			raw = readFileSync(join(rootDir, file), "utf8");
+		} catch {
+			continue;
+		}
+		for (const [key, value] of parseFlareEnv(raw)) if (process.env[key] === void 0) process.env[key] = value;
+	}
+}
+function parseFlareEnv(raw) {
+	const out = [];
+	for (const line of raw.split(/\r?\n/)) {
+		const trimmed = line.trim();
+		if (trimmed === "" || trimmed.startsWith("#")) continue;
+		const body = trimmed.startsWith("export ") ? trimmed.slice(7).trim() : trimmed;
+		const eq = body.indexOf("=");
+		if (eq === -1) continue;
+		const key = body.slice(0, eq).trim();
+		if (!key.startsWith("FLARE_")) continue;
+		let value = body.slice(eq + 1).trim();
+		if ((value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) && value.length >= 2) value = value.slice(1, -1);
+		out.push([key, value]);
+	}
+	return out;
+}
+
+//#endregion
+//#region src/cli.ts
+const USAGE = "Usage: flare-rn-sourcemaps upload --sourcemap <path> [--api-key <key>] [--bundle-filename <name>] [--version <v>] [--api-endpoint <url>] [--config <flare.json>] [--auto]";
+/** Minimal `--flag value` / `--flag` parser. No external dependency. */
+function parseArgs(argv) {
+	const [command, ...rest] = argv;
+	const flags = {};
+	for (let i = 0; i < rest.length; i++) {
+		const arg = rest[i];
+		if (!arg.startsWith("--")) continue;
+		const body = arg.slice(2);
+		const eq = body.indexOf("=");
+		if (eq !== -1) {
+			flags[body.slice(0, eq)] = body.slice(eq + 1);
+			continue;
+		}
+		const key = body;
+		const next = rest[i + 1];
+		if (next !== void 0 && !next.startsWith("--")) {
+			flags[key] = next;
+			i++;
+		} else flags[key] = "true";
+	}
+	return {
+		command,
+		flags
+	};
+}
+async function runCli(argv) {
+	const { command, flags } = parseArgs(argv);
+	if (command !== "upload") {
+		console.error(`${LOG_PREFIX}: Unknown command "${command ?? ""}".\n${USAGE}`);
+		process.exitCode = 1;
+		return;
+	}
+	const sourcemap = flags.sourcemap;
+	if (!sourcemap) {
+		console.error(`${LOG_PREFIX}: --sourcemap is required.\n${USAGE}`);
+		process.exitCode = 1;
+		return;
+	}
+	if (flags.auto === "true") loadEnvFiles(flags.config ? dirname(flags.config) : process.cwd());
+	const config = readFlareConfig(flags.config);
+	const apiKey = flags["api-key"] ?? process.env.FLARE_API_KEY ?? config.apiKey ?? "";
+	const apiEndpoint = flags["api-endpoint"] ?? process.env.FLARE_API_ENDPOINT ?? config.apiEndpoint;
+	const bundleFilename = flags["bundle-filename"];
+	if (flags.auto === "true") {
+		await runAutoUpload({
+			apiKey,
+			sourcemap,
+			bundleFilename,
+			apiEndpoint,
+			version: flags.version
+		});
+		return;
+	}
+	await uploadSourcemaps({
+		apiKey,
+		sourcemap,
+		bundleFilename,
+		version: flags.version,
+		apiEndpoint
+	});
+}
+/**
+* The build-hook upload path. It NEVER throws and NEVER sets a non-zero exit code
+* (a Gradle doLast / Xcode run-script phase would abort the build on a non-zero
+* child). Every failure mode — no key, unresolved version, upload error — prints the
+* loud banner and returns, leaving the build green. Only arg misuse (handled in
+* runCli before we get here) exits non-zero.
+*/
+async function runAutoUpload(options) {
+	const { apiKey, sourcemap, bundleFilename, apiEndpoint } = options;
+	if (!apiKey) {
+		printFailureBanner({
+			reason: "No Flare API key. Set FLARE_API_KEY (shell, .env.local, or .env) or add \"apiKey\" to flare.json.",
+			sourcemap,
+			bundleFilename,
+			apiKey,
+			apiEndpoint
+		});
+		return;
+	}
+	const version = resolveAutoVersion(options.version);
+	if (!version) {
+		printFailureBanner({
+			reason: "FLARE_SOURCEMAP_VERSION is not set (required for the automatic upload).",
+			sourcemap,
+			bundleFilename,
+			apiKey,
+			apiEndpoint
+		});
+		return;
+	}
+	try {
+		await uploadSourcemaps({
+			apiKey,
+			sourcemap,
+			bundleFilename,
+			version,
+			apiEndpoint
+		});
+	} catch (error) {
+		printFailureBanner({
+			reason: error instanceof Error ? error.message : String(error),
+			sourcemap,
+			bundleFilename,
+			version,
+			apiKey,
+			apiEndpoint
+		});
+	}
+}
+
+//#endregion
+//#region src/bin.ts
+runCli(process.argv.slice(2)).catch((error) => {
+	console.error(error);
+	process.exitCode = 1;
+});
+
+//#endregion
+export {  };

package/dist/expo.cjs

@@ -0,0 +1,254 @@
+//#region \0rolldown/runtime.js
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+//#endregion
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+let _expo_config_plugins = require("@expo/config-plugins");
+
+//#region src/expoTransforms.ts
+const FLARE_GRADLE_MARKER = "@flareapp/react-native-sourcemaps Expo config plugin";
+const SOURCEMAP_FILE_LINE = "export SOURCEMAP_FILE=\"$TARGET_TEMP_DIR/main.jsbundle.map\"";
+const GITIGNORE_ENTRY = "flare.json";
+/** Serialise the plugin props into the flare.json the native hooks read. Absent
+* props are omitted so the CLI applies its own defaults (endpoint) and env fallback
+* (FLARE_API_KEY). No `version` key — version flows only through FLARE_SOURCEMAP_VERSION. */
+function flareJsonContents(props) {
+	const config = {};
+	if (props.apiKey) config.apiKey = props.apiKey;
+	if (props.apiEndpoint) config.apiEndpoint = props.apiEndpoint;
+	return `${JSON.stringify(config, null, 4)}\n`;
+}
+/** Append `apply from: "<path>"` to android/app/build.gradle. Idempotent via a marker
+* comment, so a re-prebuild without --clean does not duplicate it. */
+function addFlareGradleApply(buildGradle, applyFromPath) {
+	if (buildGradle.includes(FLARE_GRADLE_MARKER)) return buildGradle;
+	return `${buildGradle.endsWith("\n") ? buildGradle : `${buildGradle}\n`}\n// ${FLARE_GRADLE_MARKER}\napply from: ${JSON.stringify(applyFromPath)}\n`;
+}
+/** Ensure ios/.xcode.env exports SOURCEMAP_FILE so the stock bundle phase emits the
+* composed map. Idempotent, and treats a missing file (empty string) as valid input.
+* The guard is line-based and ignores comments, so a commented-out `# SOURCEMAP_FILE=`
+* does not suppress injection while a real `export SOURCEMAP_FILE=`/`SOURCEMAP_FILE=`
+* (a user's custom map path) is left untouched. */
+function addSourcemapFileEnv(xcodeEnv) {
+	if (xcodeEnv.split("\n").some((line) => {
+		const trimmed = line.trim();
+		return !trimmed.startsWith("#") && /^(export\s+)?SOURCEMAP_FILE=/.test(trimmed);
+	})) return xcodeEnv;
+	return `${xcodeEnv.length === 0 || xcodeEnv.endsWith("\n") ? xcodeEnv : `${xcodeEnv}\n`}# Flare: emit the composed Hermes sourcemap so the upload phase can find it\n${SOURCEMAP_FILE_LINE}\n`;
+}
+/** Append `flare.json` to .gitignore once (the file is generated from app.json props). */
+function ensureGitignored(gitignore, entry = GITIGNORE_ENTRY) {
+	if (gitignore.split("\n").some((line) => line.trim() === entry)) return gitignore;
+	return `${gitignore.length === 0 || gitignore.endsWith("\n") ? gitignore : `${gitignore}\n`}${entry}\n`;
+}
+/** The shell body of the iOS "Upload Flare sourcemaps" phase: source RN's
+* with-environment.sh (so SOURCEMAP_FILE/FLARE_* are present), then run flare-xcode.sh. */
+function flareXcodeShellScript(withEnvironmentPath, flareXcodePath) {
+	return [
+		"set -e",
+		`WITH_ENVIRONMENT="${withEnvironmentPath}"`,
+		`FLARE_XCODE="${flareXcodePath}"`,
+		"/bin/sh \"$WITH_ENVIRONMENT\" \"$FLARE_XCODE\"",
+		""
+	].join("\n");
+}
+/** path.relative, normalised to forward slashes (Gradle/Xcode script paths are posix
+* even when prebuild runs on Windows). */
+function toPosixRelative(fromDir, target) {
+	return (0, node_path.relative)(fromDir, target).split(node_path.sep).join("/");
+}
+
+//#endregion
+//#region src/expoXcode.ts
+const FLARE_PHASE_NAME = "Upload Flare sourcemaps";
+const ALWAYS_OUT_OF_DATE = 1;
+/**
+* Append an "Upload Flare sourcemaps" shell-script phase to the app target. The phase
+* is APPENDED (so it always runs after the JS bundle phase, whatever that phase is
+* named or wherever it sits across Expo SDKs). Idempotency guard: skip if a phase with
+* our name already exists. Note this mutates `project` in place (the `xcode` lib's
+* contract) and returns the same instance for convenience.
+*/
+function addUploadBuildPhase(project, shellScript) {
+	const internal = project;
+	const phases = internal.hash.project.objects.PBXShellScriptBuildPhase ?? {};
+	if (Object.values(phases).some((phase) => typeof phase === "object" && phase !== null && typeof phase.name === "string" && phase.name.replace(/^"|"$/g, "") === FLARE_PHASE_NAME)) return project;
+	const { buildPhase } = internal.addBuildPhase([], "PBXShellScriptBuildPhase", FLARE_PHASE_NAME, null, {
+		shellPath: "/bin/sh",
+		shellScript
+	});
+	buildPhase.alwaysOutOfDate = ALWAYS_OUT_OF_DATE;
+	return project;
+}
+
+//#endregion
+//#region package.json
+var require_package = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		"name": "@flareapp/react-native-sourcemaps",
+		"version": "2.6.0",
+		"description": "Upload React Native (Metro) sourcemaps to Flare",
+		"homepage": "https://flareapp.io",
+		"bugs": "https://github.com/spatie/flare-client-js/issues",
+		"repository": {
+			"type": "git",
+			"url": "git+https://github.com/spatie/flare-client-js.git"
+		},
+		"license": "MIT",
+		"author": {
+			"name": "Spatie",
+			"email": "info@spatie.be"
+		},
+		"files": [
+			"dist",
+			"flare.gradle",
+			"scripts"
+		],
+		"main": "./dist/index.cjs",
+		"module": "./dist/index.mjs",
+		"types": "./dist/index.d.cts",
+		"bin": { "flare-rn-sourcemaps": "./dist/bin.cjs" },
+		"exports": {
+			".": {
+				"import": {
+					"types": "./dist/index.d.mts",
+					"default": "./dist/index.mjs"
+				},
+				"require": {
+					"types": "./dist/index.d.cts",
+					"default": "./dist/index.cjs"
+				}
+			},
+			"./babel": {
+				"import": {
+					"types": "./dist/babel.d.mts",
+					"default": "./dist/babel.mjs"
+				},
+				"require": {
+					"types": "./dist/babel.d.cts",
+					"default": "./dist/babel.cjs"
+				}
+			},
+			"./runtime": {
+				"import": {
+					"types": "./dist/runtime.d.mts",
+					"default": "./dist/runtime.mjs"
+				},
+				"require": {
+					"types": "./dist/runtime.d.cts",
+					"default": "./dist/runtime.cjs"
+				}
+			},
+			"./expo": {
+				"types": "./dist/expo.d.cts",
+				"require": "./dist/expo.cjs",
+				"default": "./dist/expo.cjs"
+			},
+			"./package.json": "./package.json"
+		},
+		"engines": { "node": ">=18" },
+		"scripts": {
+			"prepublishOnly": "npm run build",
+			"build": "tsdown",
+			"test": "vitest run",
+			"typescript": "tsc --noEmit",
+			"release": "release-it"
+		},
+		"devDependencies": {
+			"@babel/core": "^7.0.0",
+			"@expo/config-plugins": "^56.0.9",
+			"@flareapp/flare-api": "*",
+			"@types/babel__core": "^7.0.0",
+			"tsdown": "^0.20.3",
+			"typescript": "^5.7.0",
+			"vitest": "^4.0.0",
+			"xcode": "^3.0.1"
+		},
+		"peerDependencies": {
+			"@babel/core": ">=7.0.0",
+			"@expo/config-plugins": ">=7.0.0"
+		},
+		"peerDependenciesMeta": {
+			"@babel/core": { "optional": true },
+			"@expo/config-plugins": { "optional": true }
+		},
+		"publishConfig": { "access": "public" }
+	};
+}));
+
+//#endregion
+//#region src/expo.ts
+function packageDir() {
+	return (0, node_path.dirname)(require.resolve("@flareapp/react-native-sourcemaps/package.json"));
+}
+function flareGradlePath() {
+	return (0, node_path.join)(packageDir(), "flare.gradle");
+}
+function flareXcodeScriptPath() {
+	return (0, node_path.join)(packageDir(), "scripts", "flare-xcode.sh");
+}
+function withEnvironmentScriptPath() {
+	return (0, node_path.join)((0, node_path.dirname)(require.resolve("react-native/package.json")), "scripts", "xcode", "with-environment.sh");
+}
+async function writeFlareConfigFiles(projectRoot, props) {
+	await node_fs.promises.writeFile((0, node_path.join)(projectRoot, "flare.json"), flareJsonContents(props), "utf8");
+	const gitignorePath = (0, node_path.join)(projectRoot, ".gitignore");
+	let gitignore = "";
+	try {
+		gitignore = await node_fs.promises.readFile(gitignorePath, "utf8");
+	} catch {
+		gitignore = "";
+	}
+	await node_fs.promises.writeFile(gitignorePath, ensureGitignored(gitignore), "utf8");
+}
+const withFlareConfigFiles = (config, props) => {
+	for (const platform of ["ios", "android"]) config = (0, _expo_config_plugins.withDangerousMod)(config, [platform, async (cfg) => {
+		await writeFlareConfigFiles(cfg.modRequest.projectRoot, props);
+		return cfg;
+	}]);
+	return config;
+};
+const withFlareAndroidGradle = (config) => (0, _expo_config_plugins.withAppBuildGradle)(config, (cfg) => {
+	const appDir = (0, node_path.join)(cfg.modRequest.platformProjectRoot, "app");
+	cfg.modResults.contents = addFlareGradleApply(cfg.modResults.contents, toPosixRelative(appDir, flareGradlePath()));
+	return cfg;
+});
+const withFlareXcodeEnv = (config) => (0, _expo_config_plugins.withDangerousMod)(config, ["ios", async (cfg) => {
+	const xcodeEnvPath = (0, node_path.join)(cfg.modRequest.platformProjectRoot, ".xcode.env");
+	let contents = "";
+	try {
+		contents = await node_fs.promises.readFile(xcodeEnvPath, "utf8");
+	} catch {
+		contents = "";
+	}
+	await node_fs.promises.writeFile(xcodeEnvPath, addSourcemapFileEnv(contents), "utf8");
+	return cfg;
+}]);
+const withFlareIosBuildPhase = (config) => (0, _expo_config_plugins.withXcodeProject)(config, (cfg) => {
+	const iosRoot = cfg.modRequest.platformProjectRoot;
+	const shellScript = flareXcodeShellScript(toPosixRelative(iosRoot, withEnvironmentScriptPath()), toPosixRelative(iosRoot, flareXcodeScriptPath()));
+	cfg.modResults = addUploadBuildPhase(cfg.modResults, shellScript);
+	return cfg;
+});
+const withFlareSourcemaps = (config, props) => {
+	config = withFlareConfigFiles(config, props ?? {});
+	config = withFlareAndroidGradle(config);
+	config = withFlareXcodeEnv(config);
+	config = withFlareIosBuildPhase(config);
+	return config;
+};
+const pkg = (() => {
+	try {
+		return require_package();
+	} catch {
+		return {
+			name: "@flareapp/react-native-sourcemaps",
+			version: "0.0.0"
+		};
+	}
+})();
+var expo_default = (0, _expo_config_plugins.createRunOncePlugin)(withFlareSourcemaps, pkg.name, pkg.version);
+
+//#endregion
+module.exports = expo_default;

package/dist/expo.d.cts

@@ -0,0 +1,11 @@
+import { ConfigPlugin } from "@expo/config-plugins";
+
+//#region src/expoTransforms.d.ts
+type FlarePluginProps = {
+  apiKey?: string;
+  apiEndpoint?: string;
+};
+//#endregion
+//#region src/expo.d.ts
+declare const _default: ConfigPlugin<FlarePluginProps | undefined>;
+export = _default;