one/dist/esm/cli/updatesPublish.native.js

One is a React framework for web, iOS, and Android apps.

import { execFileSync } from "child_process";
import { createHash, randomUUID } from "crypto";
import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, rmSync, writeFileSync } from "fs";
import { createRequire } from "module";
import { tmpdir } from "os";
import { join, relative, resolve, sep } from "path";
import { validateNativeApp } from "../native/appManifest.native.js";
import { loadUserOneOptions } from "../vite/loadConfig.native.js";

function lastValue(value) {
	return Array.isArray(value) ? value[value.length - 1] : value;
}
function allValues(value) {
	if (value === void 0) return [];
	return Array.isArray(value) ? value : [value];
}
function base64Url(bytes) {
	return bytes.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
}
function sha256Base64Url(path) {
	return base64Url(createHash("sha256").update(readFileSync(path)).digest());
}
function parseMetadata(entries) {
	var metadata = {};
	var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
	try {
		for (var _iterator = entries[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
			var entry = _step.value;
			var equals = entry.indexOf("=");
			if (equals <= 0) {
				throw new Error(`[one] --metadata must look like key=value, got "${entry}"`);
			}
			var key = entry.slice(0, equals);
			var raw = entry.slice(equals + 1);
			var value = raw;
			try {
				var parsed = JSON.parse(raw);
				if (typeof parsed === "string" || typeof parsed === "number" || typeof parsed === "boolean") {
					value = parsed;
				}
			} catch (unused) {}
			metadata[key] = value;
		}
	} catch (err) {
		_didIteratorError = true;
		_iteratorError = err;
	} finally {
		try {
			if (!_iteratorNormalCompletion && _iterator.return != null) {
				_iterator.return();
			}
		} finally {
			if (_didIteratorError) {
				throw _iteratorError;
			}
		}
	}
	return metadata;
}
function collectFiles(root) {
	var files = [];
	var visit = function visit1(dir) {
		var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
		try {
			for (var _iterator = readdirSync(dir, { withFileTypes: true })[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
				var entry = _step.value;
				var path = join(dir, entry.name);
				if (entry.isDirectory()) visit(path);
				else if (entry.isFile()) files.push(path);
			}
		} catch (err) {
			_didIteratorError = true;
			_iteratorError = err;
		} finally {
			try {
				if (!_iteratorNormalCompletion && _iterator.return != null) {
					_iterator.return();
				}
			} finally {
				if (_didIteratorError) {
					throw _iteratorError;
				}
			}
		}
	};
	if (existsSync(root)) visit(root);
	return files.sort();
}
function resolveCliJs(root) {
	var require2 = createRequire(join(root, "package.json"));
	var packageJson = require2.resolve("react-native/package.json");
	return join(packageJson.slice(0, -"package.json".length), "cli.js");
}
function resolveNpmHermesc(root) {
	var require2 = createRequire(join(root, "package.json"));
	var reactNativeJson = require2.resolve("react-native/package.json");
	var nested = createRequire(reactNativeJson);
	var compilerJson = nested.resolve("hermes-compiler/package.json");
	var dir = compilerJson.slice(0, -"package.json".length);
	var bin = process.platform === "darwin" ? "osx-bin" : process.platform === "win32" ? "win64-bin" : "linux64-bin";
	return join(dir, "hermesc", bin, process.platform === "win32" ? "hermesc.exe" : "hermesc");
}
function resolveHermesc(root, platform) {
	if (platform === "ios") {
		var pod = join(root, "ios", "Pods", "hermes-engine", "destroot", "bin", "hermesc");
		if (existsSync(pod)) return pod;
	}
	var npm = resolveNpmHermesc(root);
	if (!existsSync(npm)) {
		throw new Error(`[one] hermesc not found at ${npm}: install dependencies${platform === "ios" ? " and run one prebuild with pod install" : ""} first`);
	}
	return npm;
}
async function resolveRuntimeVersion(platform, flag) {
	var _app_updates;
	var { oneOptions } = await loadUserOneOptions("build", true);
	var native = oneOptions === null || oneOptions === void 0 ? void 0 : oneOptions.native;
	var app = typeof native === "object" ? native.app : void 0;
	if (!app) {
		if (!flag) {
			throw new Error("[one] one updates publish needs native.app.updates.runtimeVersion, or --runtime-version for an app built with expo prebuild: the binary only takes updates published for its own runtime version");
		}
		return flag;
	}
	validateNativeApp(app, platform);
	var runtimeVersion = (_app_updates = app.updates) === null || _app_updates === void 0 ? void 0 : _app_updates.runtimeVersion;
	if (!runtimeVersion) {
		throw new Error("[one] one updates publish needs native.app.updates.runtimeVersion: the binary only takes updates published for its own runtime version");
	}
	if (flag !== void 0 && flag !== runtimeVersion) {
		throw new Error(`[one] --runtime-version ${flag} differs from native.app.updates.runtimeVersion ${runtimeVersion}`);
	}
	return runtimeVersion;
}
async function runUpdatesPublish(args) {
	var platform = lastValue(args.platform);
	if (platform !== "ios" && platform !== "android") {
		throw new Error("[one] one updates publish needs --platform ios|android");
	}
	var out = lastValue(args.out);
	if (!out) {
		throw new Error("[one] one updates publish needs --out <dir>");
	}
	var intermediatesOut = lastValue(args.intermediatesOut);
	if (intermediatesOut) {
		var published = resolve(out);
		var debug = resolve(intermediatesOut);
		if (published === debug || published.startsWith(`${debug}${sep}`) || debug.startsWith(`${published}${sep}`)) {
			throw new Error("[one] --intermediates-out must be separate from --out");
		}
		if (existsSync(debug) && readdirSync(debug).length > 0) {
			throw new Error(`[one] refusing to write intermediates into non-empty ${debug}`);
		}
	}
	var root = process.cwd();
	var runtimeVersion = await resolveRuntimeVersion(platform, lastValue(args.runtimeVersion));
	if (existsSync(out) && readdirSync(out).length > 0) {
		throw new Error(`[one] refusing to publish into non-empty ${out}: every publish writes a fresh directory`);
	}
	mkdirSync(out, { recursive: true });
	if (intermediatesOut) {
		mkdirSync(intermediatesOut, { recursive: true });
		var published1 = realpathSync(out);
		var debug1 = realpathSync(intermediatesOut);
		if (published1 === debug1 || published1.startsWith(`${debug1}${sep}`) || debug1.startsWith(`${published1}${sep}`)) {
			throw new Error("[one] --intermediates-out must be separate from --out");
		}
	}
	var assetsOut = join(out, "assets");
	mkdirSync(assetsOut, { recursive: true });
	var metadata = parseMetadata(allValues(args.metadata));
	var work = mkdtempSync(join(tmpdir(), "one-updates-publish-"));
	var bundleJs = join(work, "bundle.js");
	var packagerMap = join(work, "bundle.js.map");
	var assetsDir = join(work, "assets");
	var bytecode = join(work, "main.jsbundle");
	var composedMap = join(work, "main.jsbundle.map");
	try {
		execFileSync(process.execPath, [
			resolveCliJs(root),
			"bundle",
			"--entry-file",
			"index.js",
			"--platform",
			platform,
			"--dev",
			"false",
			"--reset-cache",
			"--bundle-output",
			bundleJs,
			...intermediatesOut ? ["--sourcemap-output", packagerMap] : [],
			"--assets-dest",
			assetsDir,
			"--minify",
			platform === "ios" ? "true" : "false"
		], {
			cwd: root,
			stdio: "inherit"
		});
		var hermesc = resolveHermesc(root, platform);
		var hermescArgs = ["-emit-binary", "-max-diagnostic-width=80"];
		if (platform === "android") hermescArgs.push("-w");
		hermescArgs.push("-O");
		if (intermediatesOut) hermescArgs.push("-output-source-map");
		hermescArgs.push("-out", bytecode, bundleJs);
		try {
			execFileSync(hermesc, hermescArgs, {
				cwd: root,
				stdio: "inherit"
			});
		} catch (error) {
			throw new Error(`[one] hermesc failed to compile the ${platform} update bundle${error instanceof Error ? `: ${error.message}` : ""}`);
		}
		if (intermediatesOut) {
			var require2 = createRequire(join(root, "package.json"));
			var reactNativeJson = require2.resolve("react-native/package.json");
			var composeSourceMaps = join(reactNativeJson.slice(0, -"package.json".length), "scripts", "compose-source-maps.js");
			execFileSync(process.execPath, [
				composeSourceMaps,
				packagerMap,
				`${bytecode}.map`,
				"-o",
				composedMap
			], {
				cwd: root,
				stdio: "inherit"
			});
			writeFileSync(join(intermediatesOut, "bundle.js"), readFileSync(bundleJs));
			writeFileSync(join(intermediatesOut, "main.jsbundle.map"), readFileSync(composedMap));
		}
		var bundleHash = sha256Base64Url(bytecode);
		writeFileSync(join(assetsOut, bundleHash), readFileSync(bytecode));
		var assets = [];
		var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
		try {
			for (var _iterator = collectFiles(assetsDir)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
				var file = _step.value;
				var hash = sha256Base64Url(file);
				var target = join(assetsOut, hash);
				if (!existsSync(target)) writeFileSync(target, readFileSync(file));
				assets.push({
					hash,
					url: `assets/${hash}`,
					path: relative(assetsDir, file).split(sep).join("/")
				});
			}
		} catch (err) {
			_didIteratorError = true;
			_iteratorError = err;
		} finally {
			try {
				if (!_iteratorNormalCompletion && _iterator.return != null) {
					_iterator.return();
				}
			} finally {
				if (_didIteratorError) {
					throw _iteratorError;
				}
			}
		}
		assets.sort(function(a, b) {
			return a.path < b.path ? -1 : a.path > b.path ? 1 : 0;
		});
		var manifest = {
			id: randomUUID(),
			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
			runtimeVersion,
			launchAsset: {
				hash: bundleHash,
				url: `assets/${bundleHash}`,
				path: "main.jsbundle"
			},
			assets,
			metadata
		};
		writeFileSync(join(out, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
`);
		console.info(`[one] published ${platform} update ${manifest.id} (${assets.length} assets) to ${out}`);
	} finally {
		rmSync(work, {
			recursive: true,
			force: true
		});
	}
}

export { runUpdatesPublish };
//# sourceMappingURL=updatesPublish.native.js.map