rn-update-cli 1.0.0

package/lib/bundle-pack.js

@@ -0,0 +1,91 @@
+"use strict";
+/**
+ * [INPUT]: 依赖文件系统、路径、yazl ZIP 写入器、本地化文案与 ZIP 条目压缩策略
+ * [OUTPUT]: 对外提供 packBundle，将 bundle 目录打包为 CLI 发布制品
+ * [POS]: CLI PPK 制品打包器，只决定条目边界和压缩方式，不负责 bundle 生成与上传
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packBundle = packBundle;
+const fs = __importStar(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const yazl_1 = require("yazl");
+const i18n_1 = require("./utils/i18n");
+const zip_options_1 = require("./utils/zip-options");
+const ignorePackingExtensions = ['DS_Store', 'txt.map'];
+async function packBundle(dir, output, bundleName) {
+    const ignorePackingFileNames = [
+        'index.bundlejs.map',
+        'bundle.harmony.js.map',
+    ];
+    if (bundleName) {
+        ignorePackingFileNames.push(`${bundleName}.map`);
+    }
+    console.log((0, i18n_1.t)('packing'));
+    fs.ensureDirSync(path_1.default.dirname(output));
+    await new Promise((resolve, reject) => {
+        const zipfile = new yazl_1.ZipFile();
+        function addDirectory(root, rel) {
+            if (rel) {
+                zipfile.addEmptyDirectory(rel);
+            }
+            const children = fs.readdirSync(root);
+            for (const name of children) {
+                if (ignorePackingFileNames.includes(name) ||
+                    ignorePackingExtensions.some((ext) => name.endsWith(`.${ext}`))) {
+                    continue;
+                }
+                const fullPath = path_1.default.join(root, name);
+                const stat = fs.statSync(fullPath);
+                if (stat.isFile()) {
+                    zipfile.addFile(fullPath, rel + name, (0, zip_options_1.zipOptionsForPayloadFile)(fullPath, rel + name));
+                }
+                else if (stat.isDirectory()) {
+                    addDirectory(fullPath, `${rel}${name}/`);
+                }
+            }
+        }
+        addDirectory(dir, '');
+        zipfile.outputStream.on('error', (err) => reject(err));
+        zipfile.outputStream.pipe(fs.createWriteStream(output)).on('close', () => {
+            resolve();
+        });
+        zipfile.end();
+    });
+    console.log((0, i18n_1.t)('fileGenerated', { file: output }));
+}

package/lib/bundle-runner.d.ts

@@ -0,0 +1,168 @@
+import { type HermesBaseOption, type HermesBaseOutcome, type HermesBaseSelection } from './utils/hermes-base';
+export interface BundleCliOptions {
+    taro?: boolean;
+    expo?: boolean;
+    rncli?: boolean;
+}
+export interface RunBundleCommandOptions {
+    bundleName: string;
+    dev: string;
+    entryFile: string;
+    outputFolder: string;
+    platform: string;
+    sourcemapOutput: string;
+    config?: string;
+    forceHermes?: boolean;
+    /** Hermes -base-bytecode settings; omitted → compile without a base */
+    hermesBase?: HermesBaseRequest;
+    /** pass --reset-cache to Metro (default true); false reuses its transform cache */
+    resetCache?: boolean;
+    cli: BundleCliOptions;
+    isSentry: boolean;
+}
+export interface HermesBaseRequest {
+    option: HermesBaseOption;
+    appId?: string;
+    verify: boolean;
+    cacheMaxMb?: number;
+}
+export interface HermesCompileResult {
+    bytecodeVersion: number | null;
+    base: HermesBaseSelection | null;
+    /** true when --verifyHermesBase ran and passed; false when it failed (base dropped) */
+    verified?: boolean;
+    /**
+     * What became of the base, for version/create. Kept apart from `base`
+     * (null whenever nothing shipped with a base) so a rejected base and "no
+     * base found" stay distinguishable on the server.
+     */
+    outcome: HermesBaseOutcome;
+    /** first difference / failure reason behind `outcome`, when there is one */
+    outcomeDetail?: string;
+}
+/** Outcome of picking a base: what to compile with, plus the log lines. */
+export interface HermesBaseSelectionResult {
+    base: HermesBaseSelection | null;
+    bytecodeVersion: number | null;
+    /** messages to print when the compile phase starts (kept out of Metro's output) */
+    logs: string[];
+    /** the hermesc the selection was made with (the compile reuses it) */
+    hermesCommand?: string;
+    /** hermesc could not be resolved; the compile phase will report it */
+    commandUnavailable?: boolean;
+}
+interface GradleConfig {
+    crunchPngs?: boolean;
+    enableHermes?: boolean;
+}
+type ResolvedExpoCli = {
+    cliPath: string;
+    usingExpo: boolean;
+};
+type SentryUploadArtifacts = {
+    bundlePath: string;
+    sourcemapPath: string;
+};
+type BuildSentrySourcemapsUploadArgsOptions = {
+    sentryCliPath: string;
+    bundlePath: string;
+    sourcemapPath: string;
+    release?: string;
+    dist?: string;
+    stripPrefix?: string;
+    debugIdReference?: boolean;
+    useStandaloneSourcemapsCommand?: boolean;
+};
+export interface SentryUploadOptions {
+    sentryRelease?: string;
+    sentryDist?: string;
+}
+type SentryUploadMode = {
+    type: 'debug-id';
+    debugId: string;
+} | {
+    type: 'release';
+    release: string;
+    dist?: string;
+};
+export declare function hasProjectDependency(dependencyName: string, projectRoot?: string): boolean;
+export declare function resolveExpoCli(projectRoot?: string): ResolvedExpoCli;
+export declare function runReactNativeBundleCommand({ bundleName, dev, entryFile, outputFolder, platform, sourcemapOutput, config, forceHermes, hermesBase, resetCache, cli, isSentry, }: RunBundleCommandOptions): Promise<HermesCompileResult | null>;
+/**
+ * Validate the intermediate directory before it is emptied and return the
+ * canonical path that was validated. The caller must use this returned path:
+ * validating one spelling and deleting through another re-opens symlink
+ * redirection.
+ */
+export declare function assertSafeToEmpty(dir: string, cwd?: string): string;
+/**
+ * Whether the app runs Hermes, i.e. whether the bundle must be compiled to
+ * bytecode. A JS bundle shipped to a Hermes app still runs, but starts slower
+ * and cannot use the Hermes base delta, so false negatives are what this
+ * guards against.
+ *
+ * Android: `hermesEnabled` in gradle.properties wins; then the legacy
+ * `project.ext.react.enableHermes` of build.gradle; with neither, the React
+ * Native gradle plugin (0.71+) defaults to Hermes and older versions to JSC.
+ * iOS: an installed `Pods/hermes-engine`; when `pod install` has not run on
+ * this machine (CI), Expo's `Podfile.properties.json` or the pod listed in
+ * `Podfile.lock` tell the same.
+ */
+export declare function detectHermesEnabled(platform: string, forceHermes: boolean | undefined, gradleConfig: GradleConfig, projectRoot?: string): Promise<boolean>;
+/** Hermes on iOS: explicit configuration first, installed artifacts second. */
+export declare function detectIosHermes(projectRoot: string): boolean;
+export declare function resolveHermesCommand(projectRoot?: string): string;
+/**
+ * hermesc argument policy. `-output-source-map` is always passed: hermesc then
+ * strips the debug info section from the bytecode (like React Native's own
+ * release builds, 15-40% smaller bytecode and smaller hot-update patches) and
+ * writes its own `<bundle>.map` next to the output. When the user asked for a
+ * sourcemap that file is composed with the packager map as before; otherwise it
+ * simply stays in the intermediate directory (never packed into the ppk) so
+ * `address at` stack frames can still be symbolicated later.
+ */
+/**
+ * hermesc echoes every diagnostic as three lines (header, the offending source
+ * line, a caret line). Minified bundles put a whole module on one line, so a
+ * single warning can be 100k+ characters and blindly keeping the tail of stderr
+ * buries the actual error under warning noise. Keep the diagnostic headers,
+ * prefer errors over warnings, and cap the length of whatever survives.
+ */
+export declare function summarizeHermescStderr(stderr: string): string;
+/** hermesc arguments writing `bundlePath` from `input` (in place by default) */
+export declare function buildHermescArgs(bundlePath: string, input?: string): string[];
+export interface CompileHermesOptions {
+    bundleName: string;
+    outputFolder: string;
+    sourcemapOutput: string;
+    shouldCleanSourcemap: boolean;
+    baseRequest?: HermesBaseRequest;
+    /** base selection started alongside Metro (see startHermesBaseSelection) */
+    pendingBase?: Promise<HermesBaseSelectionResult>;
+    /** defaults to the hermesc the selection used, else the project's */
+    hermesCommand?: string;
+}
+export declare function compileHermesByteCode({ bundleName, outputFolder, sourcemapOutput, shouldCleanSourcemap, baseRequest, pendingBase, hermesCommand, }: CompileHermesOptions): Promise<HermesCompileResult>;
+/** where a failed base attempt's full hermesc output goes (never packed) */
+export declare function hermesBaseErrorLogPath(outputFolder: string): string;
+/**
+ * With PAKTA_HERMES_BASE_DEBUG set, both disassemblies of the equivalence
+ * check are kept next to the intermediate directory (never packed) so a
+ * rejected base can be reported with the exact difference.
+ */
+export declare function hermesBaseDumpPaths(outputFolder: string, env?: NodeJS.ProcessEnv): {
+    withBase: string;
+    plain: string;
+} | undefined;
+/**
+ * Begin resolving the base right away (before Metro); the compile phase awaits
+ * the result. Never rejects: any failure is reported there instead.
+ */
+export declare function startHermesBaseSelection(request: HermesBaseRequest): Promise<HermesBaseSelectionResult>;
+export declare function copyDebugidForSentry(bundleName: string, outputFolder: string, sourcemapOutput: string): Promise<void>;
+export declare function prepareSentryUploadArtifacts(bundleName: string, outputFolder: string, platform: string): Promise<SentryUploadArtifacts>;
+export declare function readSourcemapDebugId(sourcemapPath: string): Promise<string | undefined>;
+export declare function resolveSentryUploadMode(sourcemapPath: string, options?: SentryUploadOptions): Promise<SentryUploadMode>;
+export declare function buildSentrySourcemapsUploadArgs({ sentryCliPath, bundlePath, sourcemapPath, release, dist, stripPrefix, debugIdReference, useStandaloneSourcemapsCommand, }: BuildSentrySourcemapsUploadArgsOptions): string[];
+export declare function uploadSourcemapForSentry(bundleName: string, outputFolder: string, sourcemapOutput: string, platform?: string, sentryOptions?: SentryUploadOptions): Promise<void>;
+export {};