react-native-update-cli 2.8.4 → 2.9.0

package/lib/api.d.ts

@@ -0,0 +1,18 @@
+import type { Package, Session } from './types';
+export declare const getSession: () => Session | undefined;
+export declare const getApiToken: () => string | undefined;
+export declare const setApiToken: (token: string) => void;
+export declare const replaceSession: (newSession: {
+    token: string;
+}) => void;
+export declare const loadSession: () => Promise<void>;
+export declare const saveSession: () => void;
+export declare const closeSession: () => void;
+export declare const get: (api: string) => Promise<any>;
+export declare const post: (api: string, body?: Record<string, any>) => Promise<any>;
+export declare const put: (api: string, body?: Record<string, any>) => Promise<any>;
+export declare const doDelete: (api: string, body?: Record<string, any>) => Promise<any>;
+export declare function uploadFile(fn: string, key?: string): Promise<{
+    hash: any;
+}>;
+export declare const getAllPackages: (appId: string) => Promise<Package[] | null | undefined>;

package/lib/app.d.ts

@@ -0,0 +1,38 @@
+import type { Platform } from './types';
+interface AppSummary {
+    id: number;
+    name: string;
+    platform: Platform;
+}
+export declare function getPlatform(platform?: string): Promise<Platform>;
+export declare function assertPlatform(platform: string): Platform;
+export declare function getSelectedApp(platform: Platform): any;
+export declare function listApp(platform?: Platform | ''): Promise<AppSummary[]>;
+export declare function chooseApp(platform: Platform): Promise<AppSummary>;
+export declare const appCommands: {
+    createApp: ({ options, }: {
+        options: {
+            name: string;
+            downloadUrl: string;
+            platform?: Platform | "";
+        };
+    }) => Promise<void>;
+    deleteApp: ({ args, options, }: {
+        args: string[];
+        options: {
+            platform: Platform;
+        };
+    }) => Promise<void>;
+    apps: ({ options }: {
+        options: {
+            platform?: Platform | "";
+        };
+    }) => Promise<void>;
+    selectApp: ({ args, options, }: {
+        args: string[];
+        options: {
+            platform?: Platform | "";
+        };
+    }) => Promise<void>;
+};
+export {};

package/lib/app.js

@@ -71,7 +71,8 @@ function getSelectedApp(platform) {
 }
 async function listApp(platform = '') {
     const { data } = await (0, _api.get)('/app/list');
-    const list = platform ? data.filter((v)=>v.platform === platform) : data;
+    const allApps = data;
+    const list = platform ? allApps.filter((app)=>app.platform === platform) : allApps;
     const header = [
         {
             value: (0, _i18n.t)('appId')
@@ -102,7 +103,7 @@ async function chooseApp(platform) {
     const list = await listApp(platform);
     while(true){
         const id = await (0, _utils.question)((0, _i18n.t)('enterAppIdQuestion'));
-        const app = list.find((v)=>v.id === Number(id));
+        const app = list.find((item)=>item.id === Number(id));
         if (app) {
             return app;
         }
@@ -140,8 +141,8 @@ const appCommands = {
         console.log((0, _i18n.t)('operationSuccess'));
     },
     apps: async ({ options })=>{
-        const { platform } = options;
-        listApp(platform);
+        const { platform = '' } = options;
+        await listApp(platform);
     },
     selectApp: async ({ args, options })=>{
         const platform = await getPlatform(options.platform);

package/lib/bundle-pack.d.ts

@@ -0,0 +1 @@
+export declare function packBundle(dir: string, output: string): Promise<void>;

package/lib/bundle-pack.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "packBundle", {
+    enumerable: true,
+    get: function() {
+        return packBundle;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
+const _yazl = require("yazl");
+const _i18n = require("./utils/i18n");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const ignorePackingFileNames = [
+    '.',
+    '..',
+    'index.bundlejs.map',
+    'bundle.harmony.js.map'
+];
+const ignorePackingExtensions = [
+    'DS_Store',
+    'txt.map'
+];
+async function packBundle(dir, output) {
+    console.log((0, _i18n.t)('packing'));
+    _fsextra.ensureDirSync(_path.default.dirname(output));
+    await new Promise((resolve, reject)=>{
+        const zipfile = new _yazl.ZipFile();
+        function addDirectory(root, rel) {
+            if (rel) {
+                zipfile.addEmptyDirectory(rel);
+            }
+            const children = _fsextra.readdirSync(root);
+            for (const name of children){
+                if (ignorePackingFileNames.includes(name) || ignorePackingExtensions.some((ext)=>name.endsWith(`.${ext}`))) {
+                    continue;
+                }
+                const fullPath = _path.default.join(root, name);
+                const stat = _fsextra.statSync(fullPath);
+                if (stat.isFile()) {
+                    zipfile.addFile(fullPath, rel + name);
+                } else if (stat.isDirectory()) {
+                    addDirectory(fullPath, `${rel}${name}/`);
+                }
+            }
+        }
+        addDirectory(dir, '');
+        zipfile.outputStream.on('error', (err)=>reject(err));
+        zipfile.outputStream.pipe(_fsextra.createWriteStream(output)).on('close', ()=>{
+            resolve();
+        });
+        zipfile.end();
+    });
+    console.log((0, _i18n.t)('fileGenerated', {
+        file: output
+    }));
+}

package/lib/bundle-runner.d.ts

@@ -0,0 +1,20 @@
+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;
+    cli: BundleCliOptions;
+    isSentry: boolean;
+}
+export declare function runReactNativeBundleCommand({ bundleName, dev, entryFile, outputFolder, platform, sourcemapOutput, config, forceHermes, cli, isSentry, }: RunBundleCommandOptions): Promise<void>;
+export declare function copyDebugidForSentry(bundleName: string, outputFolder: string, sourcemapOutput: string): Promise<void>;
+export declare function uploadSourcemapForSentry(bundleName: string, outputFolder: string, sourcemapOutput: string, version: string): Promise<void>;

package/lib/bundle-runner.js

@@ -0,0 +1,404 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    copyDebugidForSentry: function() {
+        return copyDebugidForSentry;
+    },
+    runReactNativeBundleCommand: function() {
+        return runReactNativeBundleCommand;
+    },
+    uploadSourcemapForSentry: function() {
+        return uploadSourcemapForSentry;
+    }
+});
+const _child_process = require("child_process");
+const _os = /*#__PURE__*/ _interop_require_default(require("os"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _compareversions = require("compare-versions");
+const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
+const _i18n = require("./utils/i18n");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const g2js = require('gradle-to-js/lib/parser');
+const properties = require('properties');
+async function runReactNativeBundleCommand({ bundleName, dev, entryFile, outputFolder, platform, sourcemapOutput, config, forceHermes, cli, isSentry }) {
+    let gradleConfig = {};
+    if (platform === 'android') {
+        gradleConfig = await checkGradleConfig();
+        if (gradleConfig.crunchPngs !== false) {
+            console.warn((0, _i18n.t)('androidCrunchPngsWarning'));
+        }
+    }
+    const reactNativeBundleArgs = [];
+    const envArgs = process.env.PUSHY_ENV_ARGS;
+    if (envArgs) {
+        reactNativeBundleArgs.push(...envArgs.trim().split(/\s+/));
+    }
+    _fsextra.emptyDirSync(outputFolder);
+    let cliPath = '';
+    let usingExpo = false;
+    const getExpoCli = ()=>{
+        try {
+            const searchPaths = [
+                process.cwd()
+            ];
+            try {
+                const expoPath = require.resolve('expo/package.json', {
+                    paths: [
+                        process.cwd()
+                    ]
+                });
+                const expoDir = expoPath.replace(/\/package\.json$/, '');
+                searchPaths.push(expoDir);
+            } catch (e) {
+            // expo 包不存在，忽略
+            }
+            cliPath = require.resolve('@expo/cli', {
+                paths: searchPaths
+            });
+            const expoCliVersion = JSON.parse(_fsextra.readFileSync(require.resolve('@expo/cli/package.json', {
+                paths: searchPaths
+            })).toString()).version;
+            if ((0, _compareversions.satisfies)(expoCliVersion, '>= 0.10.17')) {
+                usingExpo = true;
+            } else {
+                cliPath = '';
+            }
+        } catch (e) {
+        // fallback 到 RN CLI
+        }
+    };
+    const getRnCli = ()=>{
+        try {
+            cliPath = require.resolve('react-native/local-cli/cli.js', {
+                paths: [
+                    process.cwd()
+                ]
+            });
+        } catch (e) {
+            cliPath = require.resolve('@react-native-community/cli/build/bin.js', {
+                paths: [
+                    process.cwd()
+                ]
+            });
+        }
+    };
+    const getTaroCli = ()=>{
+        try {
+            cliPath = require.resolve('@tarojs/cli/bin/taro', {
+                paths: [
+                    process.cwd()
+                ]
+            });
+        } catch (e) {
+        // fallback 到 RN CLI
+        }
+    };
+    if (cli.expo) {
+        getExpoCli();
+    } else if (cli.taro) {
+        getTaroCli();
+    } else if (cli.rncli) {
+        getRnCli();
+    }
+    if (!cliPath) {
+        getExpoCli();
+        if (!usingExpo) {
+            getRnCli();
+        }
+    }
+    if (isSentry) {
+        if (platform === 'ios') {
+            process.env.SENTRY_PROPERTIES = 'ios/sentry.properties';
+        } else if (platform === 'android') {
+            process.env.SENTRY_PROPERTIES = 'android/sentry.properties';
+        }
+    }
+    let bundleCommand = 'bundle';
+    if (usingExpo) {
+        bundleCommand = 'export:embed';
+    } else if (platform === 'harmony') {
+        bundleCommand = 'bundle-harmony';
+    } else if (cli.taro) {
+        bundleCommand = 'build';
+    }
+    if (platform === 'harmony') {
+        bundleName = 'bundle.harmony.js';
+        if (forceHermes === undefined) {
+            forceHermes = true;
+        }
+    }
+    reactNativeBundleArgs.push(cliPath, bundleCommand, '--assets-dest', outputFolder, '--bundle-output', _path.default.join(outputFolder, bundleName));
+    if (platform !== 'harmony') {
+        reactNativeBundleArgs.push('--platform', platform, '--reset-cache');
+    }
+    if (cli.taro) {
+        reactNativeBundleArgs.push('--type', 'rn');
+    } else {
+        reactNativeBundleArgs.push('--dev', dev, '--entry-file', entryFile);
+    }
+    if (sourcemapOutput) {
+        reactNativeBundleArgs.push('--sourcemap-output', sourcemapOutput);
+    }
+    if (config) {
+        reactNativeBundleArgs.push('--config', config);
+    }
+    const reactNativeBundleProcess = (0, _child_process.spawn)('node', reactNativeBundleArgs);
+    console.log(`Running bundle command: node ${reactNativeBundleArgs.join(' ')}`);
+    await new Promise((resolve, reject)=>{
+        reactNativeBundleProcess.stdout.on('data', (data)=>{
+            console.log(data.toString().trim());
+        });
+        reactNativeBundleProcess.stderr.on('data', (data)=>{
+            console.error(data.toString().trim());
+        });
+        reactNativeBundleProcess.on('close', async (exitCode)=>{
+            if (exitCode) {
+                reject(new Error((0, _i18n.t)('bundleCommandError', {
+                    code: exitCode
+                })));
+                return;
+            }
+            let hermesEnabled = false;
+            if (forceHermes) {
+                hermesEnabled = true;
+                console.log((0, _i18n.t)('forceHermes'));
+            } else if (platform === 'android') {
+                const gradleProperties = await new Promise((resolve)=>{
+                    properties.parse('./android/gradle.properties', {
+                        path: true
+                    }, (error, props = {})=>{
+                        if (error) {
+                            console.error(error);
+                            resolve({});
+                            return;
+                        }
+                        resolve(props);
+                    });
+                });
+                hermesEnabled = gradleProperties.hermesEnabled;
+                if (typeof hermesEnabled !== 'boolean') {
+                    hermesEnabled = gradleConfig.enableHermes;
+                }
+            } else if (platform === 'ios' && _fsextra.existsSync('ios/Pods/hermes-engine')) {
+                hermesEnabled = true;
+            }
+            if (hermesEnabled) {
+                await compileHermesByteCode(bundleName, outputFolder, sourcemapOutput, !isSentry);
+            }
+            if (platform === 'harmony') {
+                const harmonyRawAssetsPath = 'harmony/entry/src/main/resources/rawfile/assets';
+                _fsextra.ensureDirSync(harmonyRawAssetsPath);
+                _fsextra.copySync(outputFolder, harmonyRawAssetsPath, {
+                    overwrite: true
+                });
+                _fsextra.moveSync(`${harmonyRawAssetsPath}/bundle.harmony.js`, `${harmonyRawAssetsPath}/../bundle.harmony.js`, {
+                    overwrite: true
+                });
+            }
+            resolve();
+        });
+    });
+}
+function getHermesOSBin() {
+    if (_os.default.platform() === 'win32') return 'win64-bin';
+    if (_os.default.platform() === 'darwin') return 'osx-bin';
+    if (_os.default.platform() === 'linux') return 'linux64-bin';
+}
+async function checkGradleConfig() {
+    let enableHermes = false;
+    let crunchPngs;
+    try {
+        const gradleConfig = await g2js.parseFile('android/app/build.gradle');
+        crunchPngs = gradleConfig.android.buildTypes.release.crunchPngs;
+        const projectConfig = gradleConfig['project.ext.react'];
+        if (projectConfig) {
+            for (const packagerConfig of projectConfig){
+                if (packagerConfig.includes('enableHermes') && packagerConfig.includes('true')) {
+                    enableHermes = true;
+                    break;
+                }
+            }
+        }
+    } catch (e) {
+    // ignore parsing failures
+    }
+    return {
+        enableHermes,
+        crunchPngs
+    };
+}
+async function compileHermesByteCode(bundleName, outputFolder, sourcemapOutput, shouldCleanSourcemap) {
+    console.log((0, _i18n.t)('hermesEnabledCompiling'));
+    const rnDir = _path.default.dirname(require.resolve('react-native', {
+        paths: [
+            process.cwd()
+        ]
+    }));
+    let hermesPath = _path.default.join(rnDir, `/sdks/hermesc/${getHermesOSBin()}`);
+    if (!_fsextra.existsSync(hermesPath)) {
+        hermesPath = `node_modules/hermes-engine/${getHermesOSBin()}`;
+    }
+    const hermesCommand = `${hermesPath}/hermesc`;
+    const args = [
+        '-emit-binary',
+        '-out',
+        _path.default.join(outputFolder, bundleName),
+        _path.default.join(outputFolder, bundleName),
+        '-O'
+    ];
+    if (sourcemapOutput) {
+        _fsextra.copyFileSync(sourcemapOutput, _path.default.join(outputFolder, `${bundleName}.txt.map`));
+        args.push('-output-source-map');
+    }
+    console.log((0, _i18n.t)('runningHermesc', {
+        command: hermesCommand,
+        args: args.join(' ')
+    }));
+    (0, _child_process.spawnSync)(hermesCommand, args, {
+        stdio: 'ignore'
+    });
+    if (sourcemapOutput) {
+        const composerPath = 'node_modules/react-native/scripts/compose-source-maps.js';
+        if (!_fsextra.existsSync(composerPath)) {
+            return;
+        }
+        console.log((0, _i18n.t)('composingSourceMap'));
+        (0, _child_process.spawnSync)('node', [
+            composerPath,
+            _path.default.join(outputFolder, `${bundleName}.txt.map`),
+            _path.default.join(outputFolder, `${bundleName}.map`),
+            '-o',
+            sourcemapOutput
+        ], {
+            stdio: 'ignore'
+        });
+    }
+    if (shouldCleanSourcemap) {
+        _fsextra.removeSync(_path.default.join(outputFolder, `${bundleName}.txt.map`));
+    }
+}
+async function copyDebugidForSentry(bundleName, outputFolder, sourcemapOutput) {
+    if (sourcemapOutput) {
+        let copyDebugidPath;
+        try {
+            copyDebugidPath = require.resolve('@sentry/react-native/scripts/copy-debugid.js', {
+                paths: [
+                    process.cwd()
+                ]
+            });
+        } catch (e) {
+            console.error((0, _i18n.t)('sentryCliNotFound'));
+            return;
+        }
+        if (!_fsextra.existsSync(copyDebugidPath)) {
+            return;
+        }
+        console.log((0, _i18n.t)('copyingDebugId'));
+        (0, _child_process.spawnSync)('node', [
+            copyDebugidPath,
+            _path.default.join(outputFolder, `${bundleName}.txt.map`),
+            _path.default.join(outputFolder, `${bundleName}.map`)
+        ], {
+            stdio: 'ignore'
+        });
+    }
+    _fsextra.removeSync(_path.default.join(outputFolder, `${bundleName}.txt.map`));
+}
+async function uploadSourcemapForSentry(bundleName, outputFolder, sourcemapOutput, version) {
+    if (!sourcemapOutput) {
+        return;
+    }
+    let sentryCliPath;
+    try {
+        sentryCliPath = require.resolve('@sentry/cli/bin/sentry-cli', {
+            paths: [
+                process.cwd()
+            ]
+        });
+    } catch (e) {
+        console.error((0, _i18n.t)('sentryCliNotFound'));
+        return;
+    }
+    if (!_fsextra.existsSync(sentryCliPath)) {
+        return;
+    }
+    (0, _child_process.spawnSync)('node', [
+        sentryCliPath,
+        'releases',
+        'set-commits',
+        version,
+        '--auto'
+    ], {
+        stdio: 'inherit'
+    });
+    console.log((0, _i18n.t)('sentryReleaseCreated', {
+        version
+    }));
+    console.log((0, _i18n.t)('uploadingSourcemap'));
+    (0, _child_process.spawnSync)('node', [
+        sentryCliPath,
+        'releases',
+        'files',
+        version,
+        'upload-sourcemaps',
+        '--strip-prefix',
+        _path.default.join(process.cwd(), outputFolder),
+        _path.default.join(outputFolder, bundleName),
+        _path.default.join(outputFolder, `${bundleName}.map`)
+    ], {
+        stdio: 'inherit'
+    });
+}

package/lib/bundle.d.ts

@@ -0,0 +1,6 @@
+export declare const bundleCommands: {
+    bundle: ({ options, }: {
+        args?: string[];
+        options: Record<string, unknown>;
+    }) => Promise<void>;
+};