react-native-update-cli 1.44.3 → 1.44.6

package/lib/utils/latest-version/cli.js

@@ -0,0 +1,344 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _safe = require("@colors/colors/safe");
+const _fs = require("fs");
+const _path = require("path");
+const _ = /*#__PURE__*/ _interop_require_default(require("."));
+const _major = /*#__PURE__*/ _interop_require_default(require("semver/functions/major"));
+const _diff = /*#__PURE__*/ _interop_require_default(require("semver/functions/diff"));
+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 colorizeDiff = (from, to)=>{
+    const toParts = to.split('.');
+    const diffIndex = from.split('.').findIndex((part, i)=>part !== toParts[i]);
+    if (diffIndex !== -1) {
+        let color = _safe.magenta;
+        if (toParts[0] !== '0') {
+            color = diffIndex === 0 ? _safe.red : diffIndex === 1 ? _safe.cyan : _safe.green;
+        }
+        const start = toParts.slice(0, diffIndex).join('.');
+        const mid = diffIndex === 0 ? '' : '.';
+        const end = color(toParts.slice(diffIndex).join('.'));
+        return `${start}${mid}${end}`;
+    }
+    return to;
+};
+const columnCellRenderer = (column, row)=>{
+    let text = row[column.attrName];
+    const gap = text.length < column.maxLength ? ' '.repeat(column.maxLength - text.length) : '';
+    switch(column.attrName){
+        case 'name':
+            text = (0, _safe.yellow)(text);
+            break;
+        case 'installed':
+        case 'separator':
+            text = (0, _safe.blue)(text);
+            break;
+        case 'location':
+        case 'tagOrRange':
+            text = (0, _safe.gray)(text);
+            break;
+        case 'wanted':
+            text = colorizeDiff(row.installed, text);
+            break;
+        case 'latest':
+            if (text !== row.wanted) {
+                text = colorizeDiff(row.installed, text);
+            }
+            break;
+        default:
+            break;
+    }
+    return column.align === 'right' ? `${gap}${text}` : `${text}${gap}`;
+};
+const columnHeaderRenderer = (column)=>{
+    const text = column.label;
+    const gap = text.length < column.maxLength ? ' '.repeat(column.maxLength - text.length) : '';
+    return column.align === 'right' ? `${gap}${(0, _safe.underline)(text)}` : `${(0, _safe.underline)(text)}${gap}`;
+};
+const drawBox = (lines, color = _safe.yellow, horizontalPadding = 3)=>{
+    const maxLineWidth = lines.reduce((max, row)=>Math.max(max, (0, _safe.strip)(row).length), 0);
+    console.log(color(`┌${'─'.repeat(maxLineWidth + horizontalPadding * 2)}┐`));
+    lines.forEach((row)=>{
+        const padding = ' '.repeat(horizontalPadding);
+        const fullRow = `${row}${' '.repeat(maxLineWidth - (0, _safe.strip)(row).length)}`;
+        console.log(`${color('│')}${padding}${(0, _safe.reset)(fullRow)}${padding}${color('│')}`);
+    });
+    console.log(color(`└${'─'.repeat(maxLineWidth + horizontalPadding * 2)}┘`));
+};
+const getTableColumns = (rows)=>{
+    const columns = [
+        {
+            label: 'Package',
+            attrName: 'name',
+            align: 'left',
+            maxLength: 0,
+            items: []
+        },
+        {
+            label: 'Location',
+            attrName: 'location',
+            align: 'left',
+            maxLength: 0,
+            items: []
+        },
+        {
+            label: 'Installed',
+            attrName: 'installed',
+            align: 'right',
+            maxLength: 0,
+            items: []
+        },
+        {
+            label: '',
+            attrName: 'separator',
+            align: 'center',
+            maxLength: 0,
+            items: []
+        },
+        {
+            label: 'Range',
+            attrName: 'tagOrRange',
+            align: 'right',
+            maxLength: 0,
+            items: []
+        },
+        {
+            label: '',
+            attrName: 'separator',
+            align: 'center',
+            maxLength: 0,
+            items: []
+        },
+        {
+            label: 'Wanted',
+            attrName: 'wanted',
+            align: 'right',
+            maxLength: 0,
+            items: []
+        },
+        {
+            label: 'Latest',
+            attrName: 'latest',
+            align: 'right',
+            maxLength: 0,
+            items: []
+        }
+    ];
+    rows.forEach((row)=>{
+        columns.forEach((column)=>{
+            column.maxLength = Math.max(column.label.length, column.maxLength, row[column.attrName].length || 0);
+        });
+    });
+    return columns;
+};
+const getTableRows = (updates)=>{
+    return updates.reduce((all, pkg)=>{
+        const { name, latest, local, globalNpm, globalYarn, wantedTagOrRange, updatesAvailable } = pkg;
+        const getGroup = (a, b)=>{
+            if (b && (0, _major.default)(b) === 0) {
+                return 'majorVersionZero';
+            } else if (a && b) {
+                var _semverDiff;
+                const releaseType = (_semverDiff = (0, _diff.default)(a, b)) != null ? _semverDiff : '';
+                if ([
+                    'major',
+                    'premajor',
+                    'prerelease'
+                ].includes(releaseType)) {
+                    return 'major';
+                } else if ([
+                    'minor',
+                    'preminor'
+                ].includes(releaseType)) {
+                    return 'minor';
+                } else if ([
+                    'patch',
+                    'prepatch'
+                ].includes(releaseType)) {
+                    return 'patch';
+                }
+            }
+            return 'unknown';
+        };
+        const add = (group, location, installed, wanted)=>all.push({
+                name: ' ' + name,
+                location,
+                installed: installed != null ? installed : 'unknown',
+                latest: latest != null ? latest : 'unknown',
+                tagOrRange: wantedTagOrRange != null ? wantedTagOrRange : 'unknown',
+                separator: '→',
+                wanted: wanted != null ? wanted : 'unknown',
+                group
+            });
+        if (updatesAvailable) {
+            if (updatesAvailable.local) {
+                add(getGroup(local, updatesAvailable.local), 'local', local, updatesAvailable.local);
+            }
+            if (updatesAvailable.globalNpm) {
+                add(getGroup(globalNpm, updatesAvailable.globalNpm), 'NPM global', globalNpm, updatesAvailable.globalNpm);
+            }
+            if (updatesAvailable.globalYarn) {
+                add(getGroup(globalYarn, updatesAvailable.globalYarn), 'YARN global', globalYarn, updatesAvailable.globalYarn);
+            }
+        } else {
+            if (local && local !== latest) {
+                add(getGroup(local, latest), 'local', local, pkg.wanted);
+            }
+            if (globalNpm && globalNpm !== latest) {
+                add(getGroup(globalNpm, latest), 'NPM global', globalNpm, pkg.wanted);
+            }
+            if (globalYarn && globalYarn !== latest) {
+                add(getGroup(globalYarn, latest), 'YARN global', globalYarn, pkg.wanted);
+            }
+            if (!local && !globalNpm && !globalYarn) {
+                add('unknown', 'unknown', 'unknown', pkg.wanted);
+            }
+        }
+        return all;
+    }, []);
+};
+const displayTable = (latestVersionPackages)=>{
+    const updates = latestVersionPackages.filter((pkg)=>pkg.updatesAvailable);
+    if (updates.length) {
+        const rows = getTableRows(updates);
+        const hasUpdates = rows.some((row)=>row.installed !== 'unknown');
+        const columns = getTableColumns(rows);
+        const columnGap = 2;
+        const getGroupLines = (groupType, color, title, description)=>{
+            const items = rows.filter((row)=>row.group === groupType).sort((a, b)=>a.name > b.name ? 1 : -1);
+            return !items.length ? [] : [
+                '',
+                color(`${(0, _safe.bold)(title)} ${(0, _safe.italic)(`(${description})`)}`),
+                ...items.map((row)=>columns.map((column)=>columnCellRenderer(column, row)).join(' '.repeat(columnGap)))
+            ];
+        };
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+        drawBox([
+            '',
+            hasUpdates ? (0, _safe.yellow)('Important updates are available.') : undefined,
+            hasUpdates ? '' : undefined,
+            columns.map(columnHeaderRenderer).join(' '.repeat(columnGap)),
+            ...getGroupLines('patch', _safe.green, 'Patch', 'backwards-compatible bug fixes'),
+            ...getGroupLines('minor', _safe.cyan, 'Minor', 'backwards-compatible features'),
+            ...getGroupLines('major', _safe.red, 'Major', 'potentially breaking API changes'),
+            ...getGroupLines('majorVersionZero', _safe.magenta, 'Major version zero', 'not stable, anything may change'),
+            ...getGroupLines('unknown', _safe.blue, 'Missing', 'not installed'),
+            ''
+        ].filter((line)=>line !== undefined));
+    } else {
+        console.log((0, _safe.green)('🎉 Packages are up-to-date'));
+    }
+};
+const checkVersions = async (packages, skipMissing, options = {
+    useCache: true
+})=>{
+    const ora = (await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("ora")))).default;
+    const spinner = ora({
+        text: (0, _safe.cyan)('Checking versions...')
+    });
+    spinner.start();
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    let latestVersionPackages = await (0, _.default)(packages, options);
+    if (skipMissing) {
+        latestVersionPackages = latestVersionPackages.filter((pkg)=>{
+            var _pkg_local, _ref;
+            return (_ref = (_pkg_local = pkg.local) != null ? _pkg_local : pkg.globalNpm) != null ? _ref : pkg.globalYarn;
+        });
+    }
+    spinner.stop();
+    displayTable(latestVersionPackages);
+};
+void (async ()=>{
+    let args = process.argv.slice(2);
+    const skipMissing = args.includes('--skip-missing');
+    // Remove any options from the arguments
+    args = args.filter((arg)=>!arg.startsWith('-'));
+    // If argument is a package.json file
+    if (args.length === 1 && args[0].endsWith('package.json')) {
+        if ((0, _fs.existsSync)(args[0])) {
+            process.chdir((0, _path.dirname)(args[0]));
+            await checkVersions(JSON.parse((0, _fs.readFileSync)(args[0]).toString()), skipMissing);
+        } else {
+            console.log((0, _safe.cyan)('No package.json file were found'));
+        }
+    } else {
+        // Check if a local package.json file exists
+        let localPkgJson;
+        if ((0, _fs.existsSync)('package.json')) {
+            localPkgJson = JSON.parse((0, _fs.readFileSync)('package.json').toString());
+        }
+        // Check given arguments
+        if (args.length) {
+            // Map arguments with any range that could be found in local package.json
+            args = args.map((arg)=>{
+                var _localPkgJson_dependencies, _localPkgJson_devDependencies, _localPkgJson_peerDependencies;
+                if (localPkgJson == null ? void 0 : (_localPkgJson_dependencies = localPkgJson.dependencies) == null ? void 0 : _localPkgJson_dependencies[arg]) {
+                    var _localPkgJson_dependencies1;
+                    return `${arg}@${(_localPkgJson_dependencies1 = localPkgJson.dependencies) == null ? void 0 : _localPkgJson_dependencies1[arg]}`;
+                }
+                if (localPkgJson == null ? void 0 : (_localPkgJson_devDependencies = localPkgJson.devDependencies) == null ? void 0 : _localPkgJson_devDependencies[arg]) {
+                    var _localPkgJson_devDependencies1;
+                    return `${arg}@${(_localPkgJson_devDependencies1 = localPkgJson.devDependencies) == null ? void 0 : _localPkgJson_devDependencies1[arg]}`;
+                }
+                if (localPkgJson == null ? void 0 : (_localPkgJson_peerDependencies = localPkgJson.peerDependencies) == null ? void 0 : _localPkgJson_peerDependencies[arg]) {
+                    var _localPkgJson_peerDependencies1;
+                    return `${arg}@${(_localPkgJson_peerDependencies1 = localPkgJson.peerDependencies) == null ? void 0 : _localPkgJson_peerDependencies1[arg]}`;
+                }
+                return arg;
+            });
+            await checkVersions(args, skipMissing);
+        } else if (localPkgJson) {
+            await checkVersions(localPkgJson, skipMissing);
+        } else {
+            console.log((0, _safe.cyan)('No packages were found'));
+        }
+    }
+})();

package/lib/utils/latest-version/index.js

@@ -0,0 +1,261 @@
+"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, {
+    ONE_DAY: function() {
+        return ONE_DAY;
+    },
+    default: function() {
+        return _default;
+    }
+});
+const _fs = require("fs");
+const _path = require("path");
+const _globaldirs = require("global-dirs");
+const _os = require("os");
+const _url = require("url");
+const _registryurl = /*#__PURE__*/ _interop_require_default(require("registry-auth-token/registry-url"));
+const _registryauthtoken = /*#__PURE__*/ _interop_require_default(require("registry-auth-token"));
+const _maxsatisfying = /*#__PURE__*/ _interop_require_default(require("semver/ranges/max-satisfying"));
+const _gt = /*#__PURE__*/ _interop_require_default(require("semver/functions/gt"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const ONE_DAY = 1000 * 60 * 60 * 24; // eslint-disable-line @typescript-eslint/naming-convention
+const isPackageJson = (obj)=>{
+    return obj.dependencies !== undefined || obj.devDependencies !== undefined || obj.peerDependencies !== undefined;
+};
+const downloadMetadata = (pkgName, options)=>{
+    return new Promise((resolve, reject)=>{
+        const i = pkgName.indexOf('/');
+        const pkgScope = i !== -1 ? pkgName.slice(0, i) : '';
+        var _options_registryUrl;
+        const registryUrl = (_options_registryUrl = options == null ? void 0 : options.registryUrl) != null ? _options_registryUrl : (0, _registryurl.default)(pkgScope);
+        const pkgUrl = new _url.URL(encodeURIComponent(pkgName).replace(/^%40/, '@'), registryUrl);
+        let requestOptions = {
+            headers: {
+                accept: 'application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*'
+            },
+            host: pkgUrl.hostname,
+            path: pkgUrl.pathname,
+            port: pkgUrl.port
+        };
+        const authInfo = (0, _registryauthtoken.default)(pkgUrl.toString(), {
+            recursive: true
+        });
+        if (authInfo && requestOptions.headers) {
+            requestOptions.headers.authorization = `${authInfo.type} ${authInfo.token}`;
+        }
+        if (options == null ? void 0 : options.requestOptions) {
+            requestOptions = {
+                ...requestOptions,
+                ...options.requestOptions
+            };
+        }
+        const { get } = require(pkgUrl.protocol === 'https:' ? 'https' : 'http');
+        const request = get(requestOptions, (res)=>{
+            if (res.statusCode === 200) {
+                let rawData = '';
+                res.setEncoding('utf8');
+                res.on('data', (chunk)=>rawData += chunk);
+                res.once('error', (err)=>{
+                    res.removeAllListeners();
+                    reject(`Request error (${err.message}): ${pkgUrl}`);
+                });
+                res.once('end', ()=>{
+                    res.removeAllListeners();
+                    try {
+                        const pkgMetadata = JSON.parse(rawData);
+                        resolve({
+                            name: pkgName,
+                            lastUpdateDate: Date.now(),
+                            versions: Object.keys(pkgMetadata.versions),
+                            distTags: pkgMetadata['dist-tags']
+                        });
+                        return;
+                    } catch (err) {
+                        reject(err);
+                        return;
+                    }
+                });
+            } else {
+                res.removeAllListeners();
+                res.resume(); // consume response data to free up memory
+                reject(`Request error (${res.statusCode}): ${pkgUrl}`);
+                return;
+            }
+        });
+        const abort = (error)=>{
+            request.destroy();
+            reject(error);
+        };
+        request.once('timeout', ()=>{
+            abort(`Request timed out: ${pkgUrl}`);
+        });
+        request.once('error', (err)=>{
+            abort(err);
+        });
+        request.on('close', ()=>{
+            request.removeAllListeners();
+        });
+    });
+};
+const getCacheDir = (name = '@badisi/latest-version')=>{
+    const homeDir = (0, _os.homedir)();
+    switch(process.platform){
+        case 'darwin':
+            return (0, _path.join)(homeDir, 'Library', 'Caches', name);
+        case 'win32':
+            var _process_env_LOCALAPPDATA;
+            return (0, _path.join)((_process_env_LOCALAPPDATA = process.env.LOCALAPPDATA) != null ? _process_env_LOCALAPPDATA : (0, _path.join)(homeDir, 'AppData', 'Local'), name, 'Cache');
+        default:
+            var _process_env_XDG_CACHE_HOME;
+            return (0, _path.join)((_process_env_XDG_CACHE_HOME = process.env.XDG_CACHE_HOME) != null ? _process_env_XDG_CACHE_HOME : (0, _path.join)(homeDir, '.cache'), name);
+    }
+};
+const saveMetadataToCache = (pkg)=>{
+    const filePath = (0, _path.join)(getCacheDir(), `${pkg.name}.json`);
+    if (!(0, _fs.existsSync)((0, _path.dirname)(filePath))) {
+        (0, _fs.mkdirSync)((0, _path.dirname)(filePath), {
+            recursive: true
+        });
+    }
+    (0, _fs.writeFileSync)(filePath, JSON.stringify(pkg));
+};
+const getMetadataFromCache = (pkgName, options)=>{
+    var _options_cacheMaxAge;
+    const maxAge = (_options_cacheMaxAge = options == null ? void 0 : options.cacheMaxAge) != null ? _options_cacheMaxAge : ONE_DAY;
+    if (maxAge !== 0) {
+        const pkgCacheFilePath = (0, _path.join)(getCacheDir(), `${pkgName}.json`);
+        if ((0, _fs.existsSync)(pkgCacheFilePath)) {
+            const pkg = JSON.parse((0, _fs.readFileSync)(pkgCacheFilePath).toString());
+            if (Date.now() - pkg.lastUpdateDate < maxAge) {
+                return pkg;
+            }
+        }
+    }
+    return undefined; // invalidates cache
+};
+const getRegistryVersions = async (pkgName, tagOrRange, options)=>{
+    let pkgMetadata;
+    if (pkgName.length && (options == null ? void 0 : options.useCache)) {
+        pkgMetadata = getMetadataFromCache(pkgName, options);
+        if (!pkgMetadata) {
+            pkgMetadata = await downloadMetadata(pkgName, options);
+            saveMetadataToCache(pkgMetadata);
+        }
+    } else if (pkgName.length) {
+        pkgMetadata = await downloadMetadata(pkgName, options);
+    }
+    const versions = {
+        latest: pkgMetadata == null ? void 0 : pkgMetadata.distTags.latest,
+        next: pkgMetadata == null ? void 0 : pkgMetadata.distTags.next
+    };
+    if (tagOrRange && (pkgMetadata == null ? void 0 : pkgMetadata.distTags[tagOrRange])) {
+        versions.wanted = pkgMetadata.distTags[tagOrRange];
+    } else if (tagOrRange && (pkgMetadata == null ? void 0 : pkgMetadata.versions.length)) {
+        var _maxSatisfying;
+        versions.wanted = (_maxSatisfying = (0, _maxsatisfying.default)(pkgMetadata.versions, tagOrRange)) != null ? _maxSatisfying : undefined;
+    }
+    return versions;
+};
+const getInstalledVersion = (pkgName, location = 'local')=>{
+    try {
+        if (location === 'globalNpm') {
+            var _require;
+            return (_require = require((0, _path.join)(_globaldirs.npm.packages, pkgName, 'package.json'))) == null ? void 0 : _require.version;
+        } else if (location === 'globalYarn') {
+            var _yarnGlobalPkg_dependencies, _require1;
+            // Make sure package is globally installed by Yarn
+            const yarnGlobalPkg = require((0, _path.resolve)(_globaldirs.yarn.packages, '..', 'package.json'));
+            if (!(yarnGlobalPkg == null ? void 0 : (_yarnGlobalPkg_dependencies = yarnGlobalPkg.dependencies) == null ? void 0 : _yarnGlobalPkg_dependencies[pkgName])) {
+                return undefined;
+            }
+            return (_require1 = require((0, _path.join)(_globaldirs.yarn.packages, pkgName, 'package.json'))) == null ? void 0 : _require1.version;
+        } else {
+            /**
+       * Compute the local paths manually as require.resolve() and require.resolve.paths()
+       * cannot be trusted anymore.
+       * @see https://github.com/nodejs/node/issues/33460
+       * @see https://github.com/nodejs/loaders/issues/26
+       */ const { root } = (0, _path.parse)(process.cwd());
+            let path = process.cwd();
+            const localPaths = [
+                (0, _path.join)(path, 'node_modules')
+            ];
+            while(path !== root){
+                path = (0, _path.dirname)(path);
+                localPaths.push((0, _path.join)(path, 'node_modules'));
+            }
+            for (const localPath of localPaths){
+                const pkgPath = (0, _path.join)(localPath, pkgName, 'package.json');
+                if ((0, _fs.existsSync)(pkgPath)) {
+                    var _require2;
+                    return (_require2 = require(pkgPath)) == null ? void 0 : _require2.version;
+                }
+            }
+        }
+        return undefined;
+    } catch (e) {
+        return undefined;
+    }
+};
+const getInfo = async (pkg, options)=>{
+    const i = pkg.lastIndexOf('@');
+    let pkgInfo = {
+        name: i > 1 ? pkg.slice(0, i) : pkg,
+        wantedTagOrRange: i > 1 ? pkg.slice(i + 1) : 'latest',
+        updatesAvailable: false
+    };
+    try {
+        pkgInfo = {
+            ...pkgInfo,
+            local: getInstalledVersion(pkgInfo.name, 'local'),
+            globalNpm: getInstalledVersion(pkgInfo.name, 'globalNpm'),
+            globalYarn: getInstalledVersion(pkgInfo.name, 'globalYarn'),
+            ...await getRegistryVersions(pkgInfo.name, pkgInfo.wantedTagOrRange, options)
+        };
+        const local = pkgInfo.local && pkgInfo.wanted ? (0, _gt.default)(pkgInfo.wanted, pkgInfo.local) ? pkgInfo.wanted : false : false;
+        const globalNpm = pkgInfo.globalNpm && pkgInfo.wanted ? (0, _gt.default)(pkgInfo.wanted, pkgInfo.globalNpm) ? pkgInfo.wanted : false : false;
+        const globalYarn = pkgInfo.globalYarn && pkgInfo.wanted ? (0, _gt.default)(pkgInfo.wanted, pkgInfo.globalYarn) ? pkgInfo.wanted : false : false;
+        pkgInfo.updatesAvailable = local || globalNpm || globalYarn ? {
+            local,
+            globalNpm,
+            globalYarn
+        } : false;
+    } catch (err) {
+        var _err_message;
+        pkgInfo.error = (_err_message = err == null ? void 0 : err.message) != null ? _err_message : err;
+    }
+    return pkgInfo;
+};
+const latestVersion = async (arg, options)=>{
+    const pkgs = [];
+    if (typeof arg === 'string') {
+        pkgs.push(arg);
+    } else if (Array.isArray(arg)) {
+        pkgs.push(...arg);
+    } else if (isPackageJson(arg)) {
+        const addDeps = (deps)=>{
+            if (deps) {
+                pkgs.push(...Object.keys(deps).map((key)=>`${key}@${deps[key]}`));
+            }
+        };
+        addDeps(arg.dependencies);
+        addDeps(arg.devDependencies);
+        addDeps(arg.peerDependencies);
+    }
+    const jobs = await Promise.allSettled(pkgs.map((pkg)=>getInfo(pkg, options)));
+    const results = jobs.map((jobResult)=>jobResult.value);
+    return typeof arg === 'string' ? results[0] : results;
+};
+const _default = latestVersion;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-update-cli",
-  "version": "1.44.3",
+  "version": "1.44.6",
   "description": "command line tool for react-native-update (remote updates for react native)",
   "main": "index.js",
   "bin": {
@@ -35,7 +35,7 @@
   },
   "homepage": "https://github.com/reactnativecn/react-native-pushy/tree/master/react-native-pushy-cli",
   "dependencies": {
-    "@badisi/latest-version": "^7.0.14",
+    "@colors/colors": "^1.6.0",
     "bplist-parser": "^0.3.2",
     "bytebuffer": "^5.0.1",
     "cgbi-to-png": "^1.0.7",
@@ -46,6 +46,7 @@
     "filesize-parser": "^1.5.1",
     "form-data": "^4.0.2",
     "fs-extra": "8",
+    "global-dirs": "^4.0.0",
     "gradle-to-js": "^2.0.1",
     "i18next": "^24.2.3",
     "isomorphic-git": "^1.30.1",
@@ -55,6 +56,7 @@
     "progress": "^2.0.3",
     "properties": "^1.2.1",
     "read": "^4.1.0",
+    "registry-auth-token": "^5.1.0",
     "semver": "^7.7.1",
     "tcp-ping": "^0.1.1",
     "tty-table": "4.2",
@@ -82,8 +84,5 @@
   "trustedDependencies": [
     "@biomejs/biome",
     "@swc/core"
-  ],
-  "patchedDependencies": {
-    "@badisi/latest-version@7.0.14": "patches/@badisi%2Flatest-version@7.0.14.patch"
-  }
+  ]
 }

package/src/api.ts

@@ -1,7 +1,7 @@
 import fetch from 'node-fetch';
-import fs from 'node:fs';
-import util from 'node:util';
-import path from 'node:path';
+import fs from 'fs';
+import util from 'util';
+import path from 'path';
 import ProgressBar from 'progress';
 import packageJson from '../package.json';
 import tcpp from 'tcp-ping';