react-native-update-cli 1.44.2 → 1.44.5

package/src/utils/index.ts

@@ -5,7 +5,7 @@ import pkg from '../../package.json';
 import AppInfoParser from './app-info-parser';
 import semverSatisfies from 'semver/functions/satisfies';
 import chalk from 'chalk';
-import latestVersion from '@badisi/latest-version';
+import latestVersion from '../utils/latest-version';
 import { checkPlugins } from './check-plugin';
 
 import { read } from 'read';
@@ -98,7 +98,7 @@ export async function getAppInfo(fn: string) {
   const metaJsonFile = await appInfoParser.parser.getEntryFromHarmonyApp(
     /rawfile\/meta.json/,
   );
-  let metaData = {};
+  let metaData: Record<string, any> = {};
   if (metaJsonFile) {
     metaData = JSON.parse(metaJsonFile.toString());
   }
@@ -181,16 +181,13 @@ export async function printVersionCommand() {
         version: chalk.green(latestRnuCliVersion),
       })}`
     : '';
-  console.log(
-    `react-native-update-cli: ${pkg.version}${latestRnuCliVersion}`,
-  );
-  let rnuVersion = '';
-  rnuVersion = depVersions['react-native-update'];
-  latestRnuVersion = latestRnuVersion
-    ? ` ${t('latestVersionTag', { version: chalk.green(latestRnuVersion) })}`
-    : '';
-  console.log(`react-native-update: ${rnuVersion}${latestRnuVersion}`);
+  console.log(`react-native-update-cli: ${pkg.version}${latestRnuCliVersion}`);
+  const rnuVersion = depVersions['react-native-update'];
   if (rnuVersion) {
+    latestRnuVersion = latestRnuVersion
+      ? ` ${t('latestVersionTag', { version: chalk.green(latestRnuVersion) })}`
+      : '';
+    console.log(`react-native-update: ${rnuVersion}${latestRnuVersion}`);
     if (IS_CRESC) {
       if (semverSatisfies(rnuVersion, '<10.27.0')) {
         console.error(

package/src/utils/latest-version/cli.ts

@@ -0,0 +1,443 @@
+import {
+  blue,
+  bold,
+  cyan,
+  gray,
+  green,
+  italic,
+  magenta,
+  red,
+  reset,
+  strip,
+  underline,
+  yellow,
+} from '@colors/colors/safe';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import latestVersion, {
+  type Package,
+  type PackageJson,
+  type LatestVersionPackage,
+  type LatestVersionOptions,
+} from '.';
+import semverMajor from 'semver/functions/major';
+import semverDiff from 'semver/functions/diff';
+
+interface TableColumn {
+  label: string;
+  attrName: keyof TableRow;
+  align: 'left' | 'center' | 'right';
+  maxLength: number;
+  items: string[];
+}
+
+type TableRowGroup =
+  | 'patch'
+  | 'minor'
+  | 'major'
+  | 'majorVersionZero'
+  | 'unknown';
+
+interface TableRow {
+  name: string;
+  location: string;
+  installed: string;
+  tagOrRange: string;
+  separator: string;
+  wanted: string;
+  latest: string;
+  group: TableRowGroup;
+}
+
+const colorizeDiff = (from: string, to: string): string => {
+  const toParts = to.split('.');
+
+  const diffIndex = from.split('.').findIndex((part, i) => part !== toParts[i]);
+  if (diffIndex !== -1) {
+    let color = magenta;
+    if (toParts[0] !== '0') {
+      color = diffIndex === 0 ? red : diffIndex === 1 ? cyan : 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: TableColumn, row: TableRow): string => {
+  let text = row[column.attrName];
+  const gap =
+    text.length < column.maxLength
+      ? ' '.repeat(column.maxLength - text.length)
+      : '';
+
+  switch (column.attrName) {
+    case 'name':
+      text = yellow(text);
+      break;
+    case 'installed':
+    case 'separator':
+      text = blue(text);
+      break;
+    case 'location':
+    case 'tagOrRange':
+      text = 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: TableColumn): string => {
+  const text = column.label;
+  const gap =
+    text.length < column.maxLength
+      ? ' '.repeat(column.maxLength - text.length)
+      : '';
+  return column.align === 'right'
+    ? `${gap}${underline(text)}`
+    : `${underline(text)}${gap}`;
+};
+
+const drawBox = (
+  lines: string[],
+  color = yellow,
+  horizontalPadding = 3,
+): void => {
+  const maxLineWidth = lines.reduce(
+    (max, row) => Math.max(max, strip(row).length),
+    0,
+  );
+
+  console.log(color(`┌${'─'.repeat(maxLineWidth + horizontalPadding * 2)}┐`));
+  lines.forEach((row) => {
+    const padding = ' '.repeat(horizontalPadding);
+    const fullRow = `${row}${' '.repeat(maxLineWidth - strip(row).length)}`;
+    console.log(
+      `${color('│')}${padding}${reset(fullRow)}${padding}${color('│')}`,
+    );
+  });
+  console.log(color(`└${'─'.repeat(maxLineWidth + horizontalPadding * 2)}┘`));
+};
+
+const getTableColumns = (rows: TableRow[]): TableColumn[] => {
+  const columns: TableColumn[] = [
+    {
+      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: LatestVersionPackage[]): TableRow[] => {
+  return updates.reduce<TableRow[]>((all, pkg) => {
+    const {
+      name,
+      latest,
+      local,
+      globalNpm,
+      globalYarn,
+      wantedTagOrRange,
+      updatesAvailable,
+    } = pkg;
+    const getGroup = (a?: string, b?: string): TableRowGroup => {
+      if (b && semverMajor(b) === 0) {
+        return 'majorVersionZero';
+      } else if (a && b) {
+        const releaseType = semverDiff(a, b) ?? '';
+        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: TableRowGroup,
+      location: string,
+      installed?: string,
+      wanted?: string,
+    ) =>
+      all.push({
+        name: ' ' + name,
+        location,
+        installed: installed ?? 'unknown',
+        latest: latest ?? 'unknown',
+        tagOrRange: wantedTagOrRange ?? 'unknown',
+        separator: '→',
+        wanted: 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: LatestVersionPackage[]): void => {
+  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: TableRowGroup,
+      color: (str: string) => string,
+      title: string,
+      description?: string,
+    ): string[] => {
+      const items = rows
+        .filter((row) => row.group === groupType)
+        .sort((a, b) => (a.name > b.name ? 1 : -1));
+      return !items.length
+        ? []
+        : [
+            '',
+            color(`${bold(title)} ${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 ? yellow('Important updates are available.') : undefined,
+        hasUpdates ? '' : undefined,
+        columns.map(columnHeaderRenderer).join(' '.repeat(columnGap)),
+        ...getGroupLines(
+          'patch',
+          green,
+          'Patch',
+          'backwards-compatible bug fixes',
+        ),
+        ...getGroupLines(
+          'minor',
+          cyan,
+          'Minor',
+          'backwards-compatible features',
+        ),
+        ...getGroupLines(
+          'major',
+          red,
+          'Major',
+          'potentially breaking API changes',
+        ),
+        ...getGroupLines(
+          'majorVersionZero',
+          magenta,
+          'Major version zero',
+          'not stable, anything may change',
+        ),
+        ...getGroupLines('unknown', blue, 'Missing', 'not installed'),
+        '',
+      ].filter((line) => line !== undefined) as string[],
+    );
+  } else {
+    console.log(green('🎉 Packages are up-to-date'));
+  }
+};
+
+const checkVersions = async (
+  packages: Package | Package[] | PackageJson,
+  skipMissing: boolean,
+  options: LatestVersionOptions = { useCache: true },
+): Promise<void> => {
+  const ora = (await import('ora')).default;
+  const spinner = ora({ text: cyan('Checking versions...') });
+  spinner.start();
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  let latestVersionPackages: LatestVersionPackage[] = await latestVersion(
+    packages,
+    options,
+  );
+  if (skipMissing) {
+    latestVersionPackages = latestVersionPackages.filter(
+      (pkg) => pkg.local ?? pkg.globalNpm ?? 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 (existsSync(args[0])) {
+      process.chdir(dirname(args[0]));
+      await checkVersions(
+        JSON.parse(readFileSync(args[0]).toString()) as PackageJson,
+        skipMissing,
+      );
+    } else {
+      console.log(cyan('No package.json file were found'));
+    }
+  }
+  // else..
+  else {
+    // Check if a local package.json file exists
+    let localPkgJson: PackageJson | undefined;
+    if (existsSync('package.json')) {
+      localPkgJson = JSON.parse(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) => {
+        if (localPkgJson?.dependencies?.[arg]) {
+          return `${arg}@${localPkgJson.dependencies?.[arg]}`;
+        }
+        if (localPkgJson?.devDependencies?.[arg]) {
+          return `${arg}@${localPkgJson.devDependencies?.[arg]}`;
+        }
+        if (localPkgJson?.peerDependencies?.[arg]) {
+          return `${arg}@${localPkgJson.peerDependencies?.[arg]}`;
+        }
+        return arg;
+      });
+      await checkVersions(args, skipMissing);
+    }
+    // ...else check the local package.json if any
+    else if (localPkgJson) {
+      await checkVersions(localPkgJson, skipMissing);
+    }
+    // ...else do nothing
+    else {
+      console.log(cyan('No packages were found'));
+    }
+  }
+})();