react-native-update-cli 2.8.4 → 2.9.0

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

@@ -13,47 +13,6 @@ function _interop_require_default(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]);
@@ -105,11 +64,11 @@ const columnHeaderRenderer = (column)=>{
 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)=>{
+    for (const row of lines){
         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)=>{
@@ -171,11 +130,11 @@ const getTableColumns = (rows)=>{
             items: []
         }
     ];
-    rows.forEach((row)=>{
-        columns.forEach((column)=>{
+    for (const row of rows){
+        for (const column of columns){
             column.maxLength = Math.max(column.label.length, column.maxLength, row[column.attrName].length || 0);
-        });
-    });
+        }
+    }
     return columns;
 };
 const getTableRows = (updates)=>{
@@ -184,7 +143,8 @@ const getTableRows = (updates)=>{
         const getGroup = (a, b)=>{
             if (b && (0, _major.default)(b) === 0) {
                 return 'majorVersionZero';
-            } else if (a && b) {
+            }
+            if (a && b) {
                 var _semverDiff;
                 const releaseType = (_semverDiff = (0, _diff.default)(a, b)) != null ? _semverDiff : '';
                 if ([
@@ -193,12 +153,14 @@ const getTableRows = (updates)=>{
                     'prerelease'
                 ].includes(releaseType)) {
                     return 'major';
-                } else if ([
+                }
+                if ([
                     'minor',
                     'preminor'
                 ].includes(releaseType)) {
                     return 'minor';
-                } else if ([
+                }
+                if ([
                     'patch',
                     'prepatch'
                 ].includes(releaseType)) {
@@ -208,7 +170,7 @@ const getTableRows = (updates)=>{
             return 'unknown';
         };
         const add = (group, location, installed, wanted)=>all.push({
-                name: ' ' + name,
+                name: ` ${name}`,
                 location,
                 installed: installed != null ? installed : 'unknown',
                 latest: latest != null ? latest : 'unknown',
@@ -279,21 +241,23 @@ const displayTable = (latestVersionPackages)=>{
 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);
+    console.log((0, _safe.cyan)('Checking versions...'));
+    let latestVersionPackages;
+    if (typeof packages === 'string') {
+        latestVersionPackages = [
+            await (0, _.default)(packages, options)
+        ];
+    } else if (Array.isArray(packages)) {
+        latestVersionPackages = await (0, _.default)(packages, options);
+    } else {
+        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 ()=>{

package/lib/utils/latest-version/index.d.ts

@@ -0,0 +1,146 @@
+import type { Agent } from 'http';
+interface RegistryVersions {
+    /**
+     * The latest version of the package found on the registry (if found).
+     */
+    latest?: string;
+    /**
+     * The next version of the package found on the registry (if found).
+     */
+    next?: string;
+    /**
+     * The latest version of the package found on the registry and satisfied by the wanted tag or version range.
+     */
+    wanted?: string;
+}
+interface InstalledVersions {
+    /**
+     * The current local installed version of the package (if installed).
+     */
+    local?: string;
+    /**
+     * The current npm global installed version of the package (if installed).
+     */
+    globalNpm?: string;
+    /**
+     * The current yarn global installed version of the package (if installed).
+     */
+    globalYarn?: string;
+}
+interface LatestVersionPackage extends InstalledVersions, RegistryVersions {
+    /**
+     * The name of the package.
+     */
+    name: string;
+    /**
+     * The tag or version range that was provided (if provided).
+     * @default "latest"
+     */
+    wantedTagOrRange?: string;
+    /**
+     * Whether the local or global installed versions (if any) could be upgraded or not, based on the wanted version.
+     */
+    updatesAvailable: {
+        local: string | false;
+        globalNpm: string | false;
+        globalYarn: string | false;
+    } | false;
+    /**
+     * Any error that might have occurred during the process.
+     */
+    error?: Error;
+}
+interface RequestOptions {
+    readonly ca?: string | Buffer | Array<string | Buffer>;
+    readonly rejectUnauthorized?: boolean;
+    readonly agent?: Agent | boolean;
+    readonly timeout?: number;
+}
+interface LatestVersionOptions {
+    /**
+     * Awaiting the api to return might take time, depending on the network, and might impact your package loading performance.
+     * You can use the cache mechanism to improve load performance and reduce unnecessary network requests.
+     * If `useCache` is not supplied, the api will always check for updates and wait for every requests to return before returning itself.
+     * If `useCache` is used, the api will always returned immediately, with either (for each provided packages):
+     * 1) a latest/next version available if a cache was found
+     * 2) no latest/next version available if no cache was found - in such case updates will be fetched in the background and a cache will
+     * be created for each provided packages and made available for the next call to the api.
+     * @default false
+     */
+    readonly useCache?: boolean;
+    /**
+     * How long the cache for the provided packages should be used before being refreshed (in milliseconds).
+     * If `useCache` is not supplied, this option has no effect.
+     * If `0` is used, this will force the cache to refresh immediately:
+     * 1) The api will returned immediately (without any latest nor next version available for the provided packages)
+     * 2) New updates will be fetched in the background
+     * 3) The cache for each provided packages will be refreshed and made available for the next call to the api
+     * @default ONE_DAY
+     */
+    readonly cacheMaxAge?: number;
+    /**
+     * A JavaScript package registry url that implements the CommonJS Package Registry specification.
+     * @default "Looks at any registry urls in the .npmrc file or fallback to the default npm registry instead"
+     * @example <caption>.npmrc</caption>
+     * registry = 'https://custom-registry.com/'
+     * @pkgscope:registry = 'https://custom-registry.com/'
+     */
+    readonly registryUrl?: string;
+    /**
+     * Set of options to be passed down to Node.js http/https request.
+     * @example <caption>Behind a proxy with self-signed certificate</caption>
+     * { ca: [ fs.readFileSync('proxy-cert.pem') ] }
+     * @example <caption>Bypassing certificate validation</caption>
+     * { rejectUnauthorized: false }
+     */
+    readonly requestOptions?: RequestOptions;
+}
+interface LatestVersion {
+    /**
+     * Get latest versions of packages from of a package json like object.
+     * @param {PackageJson} item - A package json like object (with dependencies, devDependencies and peerDependencies attributes).
+     * @example { dependencies: { 'npm': 'latest' }, devDependencies: { 'npm': '1.3.2' }, peerDependencies: { '@scope/name': '^5.0.2' } }
+     * @param {LatestVersionOptions} [options] - An object optionally specifying the use of the cache, the max age of the cache, the registry url and the http or https options.
+     * If `useCache` is not supplied, the default of `false` is used.
+     * If `cacheMaxAge` is not supplied, the default of `one day` is used.
+     * If `registryUrl` is not supplied, the default from `.npmrc` is used or a fallback to the `npm registry url` instead.
+     * @returns {Promise<LatestVersionPackage[]>}
+     */
+    (item: PackageJson, options?: LatestVersionOptions): Promise<LatestVersionPackage[]>;
+    /**
+     * Get latest version of a single package.
+     * @param {Package} item - A single package object (represented by a string that should match the following format: `${'@' | ''}${string}@${string}`)
+     * @example 'npm', 'npm@1.3.2', '@scope/name@^5.0.2'
+     * @param {LatestVersionOptions} [options] - An object optionally specifying the use of the cache, the max age of the cache, the registry url and the http or https options.
+     * If `useCache` is not supplied, the default of `false` is used.
+     * If `cacheMaxAge` is not supplied, the default of `one day` is used.
+     * If `registryUrl` is not supplied, the default from `.npmrc` is used or a fallback to the npm registry url instead.
+     * @returns {Promise<LatestVersionPackage>}
+     */
+    (item: Package, options?: LatestVersionOptions): Promise<LatestVersionPackage>;
+    /**
+     * Get latest versions of a collection of packages.
+     * @param {Package[]} items - A collection of package object (represented by a string that should match the following format: `${'@' | ''}${string}@${string}`)
+     * @example ['npm', 'npm@1.3.2', '@scope/name@^5.0.2']
+     * @param {LatestVersionOptions} [options] - An object optionally specifying the use of the cache, the max age of the cache, the registry url and the http or https options.
+     * If `useCache` is not supplied, the default of `false` is used.
+     * If `cacheMaxAge` is not supplied, the default of `one day` is used.
+     * If `registryUrl` is not supplied, the default from `.npmrc` is used or a fallback to the npm registry url instead.
+     * @returns {Promise<LatestVersionPackage[]>}
+     */
+    (items: Package[], options?: LatestVersionOptions): Promise<LatestVersionPackage[]>;
+}
+type PackageRange = `${'@' | ''}${string}@${string}`;
+type Package = PackageRange | string;
+type PackageJsonDependencies = Record<string, string>;
+type PackageJson = Record<string, any> & ({
+    dependencies: PackageJsonDependencies;
+} | {
+    devDependencies: PackageJsonDependencies;
+} | {
+    peerDependencies: PackageJsonDependencies;
+});
+export declare const ONE_DAY: number;
+declare const latestVersion: LatestVersion;
+export type { LatestVersion, Package, PackageRange, PackageJson, PackageJsonDependencies, RegistryVersions, LatestVersionPackage, RequestOptions, LatestVersionOptions, };
+export default latestVersion;

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

@@ -173,7 +173,8 @@ const getInstalledVersion = (pkgName, location = 'local')=>{
         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') {
+        }
+        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'));
@@ -181,27 +182,26 @@ const getInstalledVersion = (pkgName, location = 'local')=>{
                 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;
-                }
+        }
+        /**
+     * 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;

package/lib/utils/options.d.ts

@@ -0,0 +1,4 @@
+export declare function getBooleanOption(options: Record<string, unknown>, key: string, fallback?: boolean): boolean;
+export declare function getStringOption(options: Record<string, unknown>, key: string, fallback?: string): string;
+export declare function getOptionalStringOption(options: Record<string, unknown>, key: string): string | undefined;
+export declare function toObjectState<T extends Record<string, unknown>>(value: unknown, fallback: T): T;

package/lib/utils/options.js

@@ -0,0 +1,63 @@
+"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, {
+    getBooleanOption: function() {
+        return getBooleanOption;
+    },
+    getOptionalStringOption: function() {
+        return getOptionalStringOption;
+    },
+    getStringOption: function() {
+        return getStringOption;
+    },
+    toObjectState: function() {
+        return toObjectState;
+    }
+});
+function getBooleanOption(options, key, fallback = false) {
+    const value = options[key];
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return value.toLowerCase() === 'true';
+    }
+    if (typeof value === 'number') {
+        return value !== 0;
+    }
+    return fallback;
+}
+function getStringOption(options, key, fallback = '') {
+    const value = options[key];
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    return fallback;
+}
+function getOptionalStringOption(options, key) {
+    const value = options[key];
+    if (typeof value === 'string') {
+        return value || undefined;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    return undefined;
+}
+function toObjectState(value, fallback) {
+    if (value && typeof value === 'object') {
+        return value;
+    }
+    return fallback;
+}

package/lib/utils/plugin-config.d.ts

@@ -0,0 +1,9 @@
+interface PluginConfig {
+    name: string;
+    bundleParams?: {
+        [key: string]: any;
+    };
+    detect: () => Promise<boolean>;
+}
+export declare const plugins: PluginConfig[];
+export {};

package/lib/utils/zip-entries.d.ts

@@ -0,0 +1,3 @@
+import { type Entry, type ZipFile as YauzlZipFile } from 'yauzl';
+export declare function readEntry(entry: Entry, zipFile: YauzlZipFile): Promise<Buffer>;
+export declare function enumZipEntries(zipFn: string, callback: (entry: Entry, zipFile: YauzlZipFile, nestedPath?: string) => Promise<any> | undefined, nestedPath?: string): Promise<unknown>;

package/lib/versions.d.ts

@@ -0,0 +1,43 @@
+import type { Package, Platform } from './types';
+interface VersionCommandOptions {
+    appId?: string;
+    name?: string;
+    description?: string;
+    metaInfo?: string;
+    platform?: Platform;
+    versionId?: string;
+    packageId?: string;
+    packageVersion?: string;
+    minPackageVersion?: string;
+    maxPackageVersion?: string;
+    packageVersionRange?: string;
+    rollout?: string;
+    dryRun?: boolean;
+    versionDeps?: Record<string, string>;
+}
+export declare const bindVersionToPackages: ({ appId, versionId, pkgs, rollout, dryRun, }: {
+    appId: string;
+    versionId: string;
+    pkgs: Package[];
+    rollout?: number;
+    dryRun?: boolean;
+}) => Promise<void>;
+export declare const versionCommands: {
+    publish: ({ args, options, }: {
+        args: string[];
+        options: VersionCommandOptions;
+    }) => Promise<string>;
+    versions: ({ options }: {
+        options: VersionCommandOptions;
+    }) => Promise<void>;
+    update: ({ options }: {
+        options: VersionCommandOptions;
+    }) => Promise<void>;
+    updateVersionInfo: ({ options, }: {
+        options: VersionCommandOptions;
+    }) => Promise<void>;
+    deleteVersion: ({ options, }: {
+        options: VersionCommandOptions;
+    }) => Promise<void>;
+};
+export {};