react-native-update-cli 2.7.0 → 2.7.2

package/lib/esm/utils/app-info-parser/xml-parser/manifest..mjs

@@ -0,0 +1,200 @@
+// From https://github.com/openstf/adbkit-apkreader
+import { BinaryXmlParser } from "./binary";
+const INTENT_MAIN = 'android.intent.action.MAIN';
+const CATEGORY_LAUNCHER = 'android.intent.category.LAUNCHER';
+export class ManifestParser {
+    collapseAttributes(element) {
+        const collapsed = Object.create(null);
+        for (const attr of Array.from(element.attributes)){
+            collapsed[attr.name] = attr.typedValue.value;
+        }
+        return collapsed;
+    }
+    parseIntents(element, target) {
+        target.intentFilters = [];
+        target.metaData = [];
+        for (const child of element.childNodes){
+            switch(child.nodeName){
+                case 'intent-filter':
+                    {
+                        const intentFilter = this.collapseAttributes(child);
+                        intentFilter.actions = [];
+                        intentFilter.categories = [];
+                        intentFilter.data = [];
+                        for (const item of child.childNodes){
+                            switch(item.nodeName){
+                                case 'action':
+                                    intentFilter.actions.push(this.collapseAttributes(item));
+                                    break;
+                                case 'category':
+                                    intentFilter.categories.push(this.collapseAttributes(item));
+                                    break;
+                                case 'data':
+                                    intentFilter.data.push(this.collapseAttributes(item));
+                                    break;
+                            }
+                        }
+                        target.intentFilters.push(intentFilter);
+                        break;
+                    }
+                case 'meta-data':
+                    target.metaData.push(this.collapseAttributes(child));
+                    break;
+            }
+        }
+    }
+    parseApplication(element) {
+        const app = this.collapseAttributes(element);
+        app.activities = [];
+        app.activityAliases = [];
+        app.launcherActivities = [];
+        app.services = [];
+        app.receivers = [];
+        app.providers = [];
+        app.usesLibraries = [];
+        app.metaData = [];
+        for (const child of element.childNodes){
+            switch(child.nodeName){
+                case 'activity':
+                    {
+                        const activity = this.collapseAttributes(child);
+                        this.parseIntents(child, activity);
+                        app.activities.push(activity);
+                        if (this.isLauncherActivity(activity)) {
+                            app.launcherActivities.push(activity);
+                        }
+                        break;
+                    }
+                case 'activity-alias':
+                    {
+                        const activityAlias = this.collapseAttributes(child);
+                        this.parseIntents(child, activityAlias);
+                        app.activityAliases.push(activityAlias);
+                        if (this.isLauncherActivity(activityAlias)) {
+                            app.launcherActivities.push(activityAlias);
+                        }
+                        break;
+                    }
+                case 'service':
+                    {
+                        const service = this.collapseAttributes(child);
+                        this.parseIntents(child, service);
+                        app.services.push(service);
+                        break;
+                    }
+                case 'receiver':
+                    {
+                        const receiver = this.collapseAttributes(child);
+                        this.parseIntents(child, receiver);
+                        app.receivers.push(receiver);
+                        break;
+                    }
+                case 'provider':
+                    {
+                        const provider = this.collapseAttributes(child);
+                        provider.grantUriPermissions = [];
+                        provider.metaData = [];
+                        provider.pathPermissions = [];
+                        for (const item of child.childNodes){
+                            switch(item.nodeName){
+                                case 'grant-uri-permission':
+                                    provider.grantUriPermissions.push(this.collapseAttributes(item));
+                                    break;
+                                case 'meta-data':
+                                    provider.metaData.push(this.collapseAttributes(item));
+                                    break;
+                                case 'path-permission':
+                                    provider.pathPermissions.push(this.collapseAttributes(item));
+                                    break;
+                            }
+                        }
+                        app.providers.push(provider);
+                        break;
+                    }
+                case 'uses-library':
+                    app.usesLibraries.push(this.collapseAttributes(child));
+                    break;
+                case 'meta-data':
+                    app.metaData.push(this.collapseAttributes(child));
+                    break;
+            }
+        }
+        return app;
+    }
+    isLauncherActivity(activity) {
+        return activity.intentFilters.some((filter)=>{
+            const hasMain = filter.actions.some((action)=>action.name === INTENT_MAIN);
+            if (!hasMain) {
+                return false;
+            }
+            return filter.categories.some((category)=>category.name === CATEGORY_LAUNCHER);
+        });
+    }
+    parse() {
+        const document = this.xmlParser.parse();
+        const manifest = this.collapseAttributes(document);
+        manifest.usesPermissions = [];
+        manifest.usesPermissionsSDK23 = [];
+        manifest.permissions = [];
+        manifest.permissionTrees = [];
+        manifest.permissionGroups = [];
+        manifest.instrumentation = null;
+        manifest.usesSdk = null;
+        manifest.usesConfiguration = null;
+        manifest.usesFeatures = [];
+        manifest.supportsScreens = null;
+        manifest.compatibleScreens = [];
+        manifest.supportsGlTextures = [];
+        manifest.application = Object.create(null);
+        for (const element of document.childNodes){
+            switch(element.nodeName){
+                case 'uses-permission':
+                    manifest.usesPermissions.push(this.collapseAttributes(element));
+                    break;
+                case 'uses-permission-sdk-23':
+                    manifest.usesPermissionsSDK23.push(this.collapseAttributes(element));
+                    break;
+                case 'permission':
+                    manifest.permissions.push(this.collapseAttributes(element));
+                    break;
+                case 'permission-tree':
+                    manifest.permissionTrees.push(this.collapseAttributes(element));
+                    break;
+                case 'permission-group':
+                    manifest.permissionGroups.push(this.collapseAttributes(element));
+                    break;
+                case 'instrumentation':
+                    manifest.instrumentation = this.collapseAttributes(element);
+                    break;
+                case 'uses-sdk':
+                    manifest.usesSdk = this.collapseAttributes(element);
+                    break;
+                case 'uses-configuration':
+                    manifest.usesConfiguration = this.collapseAttributes(element);
+                    break;
+                case 'uses-feature':
+                    manifest.usesFeatures.push(this.collapseAttributes(element));
+                    break;
+                case 'supports-screens':
+                    manifest.supportsScreens = this.collapseAttributes(element);
+                    break;
+                case 'compatible-screens':
+                    for (const screen of element.childNodes){
+                        manifest.compatibleScreens.push(this.collapseAttributes(screen));
+                    }
+                    break;
+                case 'supports-gl-texture':
+                    manifest.supportsGlTextures.push(this.collapseAttributes(element));
+                    break;
+                case 'application':
+                    manifest.application = this.parseApplication(element);
+                    break;
+            }
+        }
+        return manifest;
+    }
+    constructor(buffer, options = {}){
+        this.buffer = buffer;
+        this.xmlParser = new BinaryXmlParser(this.buffer, options);
+    }
+}

package/lib/esm/utils/app-info-parser/zip..mjs

@@ -0,0 +1,65 @@
+const Unzip = require('isomorphic-unzip');
+import { decodeNullUnicode, isBrowser } from "./utils";
+let bundleZipUtils;
+export class Zip {
+    /**
+   * get entries by regexps, the return format is: { <filename>: <Buffer|Blob> }
+   * @param {Array} regexps // regexps for matching files
+   * @param {String} type // return type, can be buffer or blob, default buffer
+   */ getEntries(regexps, type = 'buffer') {
+        const decoded = regexps.map((regex)=>decodeNullUnicode(regex));
+        return new Promise((resolve, reject)=>{
+            this.unzip.getBuffer(decoded, {
+                type
+            }, (err, buffers)=>{
+                err ? reject(err) : resolve(buffers);
+            });
+        });
+    }
+    /**
+   * get entry by regex, return an instance of Buffer or Blob
+   * @param {Regex} regex // regex for matching file
+   * @param {String} type // return type, can be buffer or blob, default buffer
+   */ getEntry(regex, type = 'buffer') {
+        const decoded = decodeNullUnicode(regex);
+        return new Promise((resolve, reject)=>{
+            this.unzip.getBuffer([
+                decoded
+            ], {
+                type
+            }, (err, buffers)=>{
+                err ? reject(err) : resolve(buffers[decoded]);
+            });
+        });
+    }
+    async getEntryFromHarmonyApp(regex) {
+        try {
+            const { enumZipEntries, readEntry } = bundleZipUtils != null ? bundleZipUtils : bundleZipUtils = require('../../bundle');
+            let originSource;
+            await enumZipEntries(this.file, (entry, zipFile)=>{
+                if (regex.test(entry.fileName)) {
+                    return readEntry(entry, zipFile).then((value)=>{
+                        originSource = value;
+                    });
+                }
+            });
+            return originSource;
+        } catch (error) {
+            console.error('Error in getEntryFromHarmonyApp:', error);
+        }
+    }
+    constructor(file){
+        if (isBrowser()) {
+            if (!(file instanceof window.Blob || typeof file.size !== 'undefined')) {
+                throw new Error('Param error: [file] must be an instance of Blob or File in browser.');
+            }
+            this.file = file;
+        } else {
+            if (typeof file !== 'string') {
+                throw new Error('Param error: [file] must be file path in Node.');
+            }
+            this.file = require('path').resolve(file);
+        }
+        this.unzip = new Unzip(this.file);
+    }
+}

package/lib/esm/utils/check-lockfile..mjs

@@ -0,0 +1,78 @@
+import fs from "fs";
+import path from "path";
+import { t } from "./i18n";
+const lockFiles = [
+    'package-lock.json',
+    'yarn.lock',
+    'pnpm-lock.yaml',
+    'bun.lockb',
+    'bun.lock'
+];
+// Function to check if a package.json has a workspaces field
+function hasWorkspaces(dir) {
+    const pkgPath = path.join(dir, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+            return !!pkg.workspaces;
+        } catch (e) {
+        // Ignore parsing errors
+        }
+    }
+    return false;
+}
+// Helper function to find lock files in a specific directory
+function findLockFilesInDir(directory) {
+    const found = [];
+    for (const file of lockFiles){
+        const filePath = path.join(directory, file);
+        if (fs.existsSync(filePath)) {
+            found.push(filePath);
+        }
+    }
+    return found;
+}
+export function checkLockFiles() {
+    const cwd = process.cwd();
+    let searchDir = cwd;
+    let foundLockFiles = findLockFilesInDir(searchDir);
+    // If no lock file in cwd, try to find monorepo root and check there
+    if (foundLockFiles.length === 0) {
+        // Search upwards for package.json with workspaces
+        let currentDir = path.dirname(cwd); // Start searching from parent
+        let projectRootDir = null;
+        while(true){
+            if (hasWorkspaces(currentDir)) {
+                projectRootDir = currentDir;
+                break;
+            }
+            const parentDir = path.dirname(currentDir);
+            if (parentDir === currentDir) {
+                break;
+            }
+            currentDir = parentDir;
+        }
+        // If a potential root was found, switch search directory and re-check
+        if (projectRootDir) {
+            searchDir = projectRootDir;
+            foundLockFiles = findLockFilesInDir(searchDir);
+        }
+    // If no projectRootDir found, foundLockFiles remains empty and searchDir remains cwd
+    }
+    // Handle results based on findings in the final searchDir
+    if (foundLockFiles.length === 1) {
+        // Successfully found one lock file in the determined searchDir
+        return;
+    }
+    if (foundLockFiles.length > 1) {
+        // Found multiple lock files in the determined searchDir
+        console.warn(t('lockBestPractice'));
+        throw new Error(t('multipleLocksFound', {
+            lockFiles: foundLockFiles.join(', ')
+        }));
+    }
+    // If we reach here, foundLockFiles.length === 0
+    console.warn(t('lockBestPractice'));
+    // Warn instead of throwing an error if no lock file is found
+    console.warn(t('lockNotFound'));
+}

package/lib/esm/utils/check-plugin..mjs

@@ -0,0 +1,25 @@
+import { t } from "./i18n";
+import { plugins } from "./plugin-config";
+export async function checkPlugins() {
+    const params = {
+        sentry: false,
+        sourcemap: false
+    };
+    for (const plugin of plugins){
+        try {
+            const isEnabled = await plugin.detect();
+            if (isEnabled && plugin.bundleParams) {
+                Object.assign(params, plugin.bundleParams);
+                console.log(t('pluginDetected', {
+                    name: plugin.name
+                }));
+            }
+        } catch (err) {
+            console.warn(t('pluginDetectionError', {
+                name: plugin.name,
+                error: err
+            }));
+        }
+    }
+    return params;
+}

package/lib/esm/utils/constants..mjs

@@ -0,0 +1,19 @@
+import path from "path";
+export const scriptName = path.basename(process.argv[1]);
+export const IS_CRESC = scriptName === 'cresc';
+export const ppkBundleFileNames = [
+    'index.bundlejs',
+    'bundle.harmony.js'
+];
+export const isPPKBundleFileName = (fileName)=>ppkBundleFileNames.includes(fileName);
+export const credentialFile = IS_CRESC ? '.cresc.token' : '.update';
+export const updateJson = IS_CRESC ? 'cresc.config.json' : 'update.json';
+export const tempDir = IS_CRESC ? '.cresc.temp' : '.pushy';
+export const pricingPageUrl = IS_CRESC ? 'https://cresc.dev/pricing' : 'https://pushy.reactnative.cn/pricing.html';
+export const defaultEndpoints = IS_CRESC ? [
+    'https://api.cresc.dev',
+    'https://api.cresc.app'
+] : [
+    'https://update.reactnative.cn/api',
+    'https://update.react-native.cn/api'
+];

package/lib/esm/utils/dep-versions..mjs

@@ -0,0 +1,33 @@
+let currentPackage = null;
+try {
+    currentPackage = require(`${process.cwd()}/package.json`);
+} catch (e) {
+// console.warn('No package.json file were found');
+}
+const _depVersions = {};
+if (currentPackage) {
+    const depKeys = currentPackage.dependencies ? Object.keys(currentPackage.dependencies) : [];
+    const devDepKeys = currentPackage.devDependencies ? Object.keys(currentPackage.devDependencies) : [];
+    const dedupedDeps = [
+        ...new Set([
+            ...depKeys,
+            ...devDepKeys
+        ])
+    ];
+    for (const dep of dedupedDeps){
+        try {
+            const packageJsonPath = require.resolve(`${dep}/package.json`, {
+                paths: [
+                    process.cwd()
+                ]
+            });
+            const version = require(packageJsonPath).version;
+            _depVersions[dep] = version;
+        } catch (e) {}
+    }
+}
+export const depVersions = Object.keys(_depVersions).sort() // Sort the keys alphabetically
+.reduce((obj, key)=>{
+    obj[key] = _depVersions[key]; // Rebuild the object with sorted keys
+    return obj;
+}, {}); // console.log({ depVersions });

package/lib/esm/utils/git..mjs

@@ -0,0 +1,43 @@
+import fs from "fs";
+import path from "path";
+import git from "isomorphic-git";
+function findGitRoot(dir = process.cwd()) {
+    const gitRoot = fs.readdirSync(dir).find((dir)=>dir === '.git');
+    if (gitRoot) {
+        // console.log({ gitRoot });
+        return path.join(dir, gitRoot);
+    }
+    const parentDir = path.dirname(dir);
+    if (parentDir === dir) {
+        return null;
+    }
+    return findGitRoot(parentDir);
+}
+const gitRoot = findGitRoot();
+export async function getCommitInfo() {
+    if (!gitRoot) {
+        return;
+    }
+    try {
+        const remotes = await git.listRemotes({
+            fs,
+            gitdir: gitRoot
+        });
+        const origin = remotes.find((remote)=>remote.remote === 'origin') || remotes[0];
+        const { commit, oid } = (await git.log({
+            fs,
+            gitdir: gitRoot,
+            depth: 1
+        }))[0];
+        return {
+            hash: oid,
+            message: commit.message,
+            author: commit.author.name || commit.committer.name,
+            timestamp: String(commit.committer.timestamp),
+            origin: origin == null ? void 0 : origin.url
+        };
+    } catch (error) {
+        console.error(error);
+        return;
+    }
+}

package/lib/esm/utils/http-helper..mjs

@@ -0,0 +1,70 @@
+import fetch from "node-fetch";
+import { defaultEndpoints } from "./constants";
+// const baseUrl = `http://localhost:9000`;
+// let baseUrl = SERVER.main[0];
+// const baseUrl = `https://p.reactnative.cn/api`;
+export function promiseAny(promises) {
+    return new Promise((resolve, reject)=>{
+        let count = 0;
+        for (const promise of promises){
+            Promise.resolve(promise).then(resolve).catch(()=>{
+                count++;
+                if (count === promises.length) {
+                    reject(new Error('All promises were rejected'));
+                }
+            });
+        }
+    });
+}
+export const ping = async (url)=>{
+    let pingFinished = false;
+    return Promise.race([
+        fetch(url, {
+            method: 'HEAD'
+        }).then(({ status, statusText })=>{
+            pingFinished = true;
+            if (status === 200) {
+                // console.log('ping success', url);
+                return url;
+            }
+            // console.log('ping failed', url, status, statusText);
+            throw new Error('ping failed');
+        }).catch((e)=>{
+            pingFinished = true;
+            // console.log('ping error', url, e);
+            throw new Error('ping error');
+        }),
+        new Promise((_, reject)=>setTimeout(()=>{
+                reject(new Error('ping timeout'));
+                if (!pingFinished) {
+                // console.log('ping timeout', url);
+                }
+            }, 2000))
+    ]);
+};
+export const testUrls = async (urls)=>{
+    if (!(urls == null ? void 0 : urls.length)) {
+        return null;
+    }
+    const ret = await promiseAny(urls.map(ping));
+    if (ret) {
+        return ret;
+    }
+    // console.log('all ping failed, use first url:', urls[0]);
+    return urls[0];
+};
+export const getBaseUrl = (async ()=>{
+    const testEndpoint = process.env.PUSHY_REGISTRY || process.env.RNU_API;
+    if (testEndpoint) {
+        return testEndpoint;
+    }
+    return testUrls(defaultEndpoints.map((url)=>`${url}/status`)).then((ret)=>{
+        let baseUrl = defaultEndpoints[0];
+        if (ret) {
+            // remove /status
+            baseUrl = ret.replace('/status', '');
+        }
+        // console.log('baseUrl', baseUrl);
+        return baseUrl;
+    });
+})();

package/lib/esm/utils/i18n..mjs

@@ -0,0 +1,23 @@
+import i18next from "i18next";
+import en from "../locales/en";
+import zh from "../locales/zh";
+import { IS_CRESC } from "./constants";
+i18next.init({
+    lng: IS_CRESC ? 'en' : 'zh',
+    // debug: process.env.NODE_ENV !== 'production',
+    // debug: true,
+    resources: {
+        en: {
+            translation: en
+        },
+        zh: {
+            translation: zh
+        }
+    },
+    interpolation: {
+        escapeValue: false
+    }
+});
+export function t(key, options) {
+    return i18next.t(key, options);
+}