react-native-update-cli 2.8.5 → 2.9.1

package/src/utils/app-info-parser/xml-parser/manifest.ts

@@ -15,7 +15,9 @@ export class ManifestParser {
 
   private collapseAttributes(element: any) {
     const collapsed: Record<string, any> = Object.create(null);
-    for (const attr of Array.from(element.attributes)) {
+    for (const attr of Array.from(
+      element.attributes as Array<{ name: string; typedValue: { value: any } }>,
+    )) {
       collapsed[attr.name] = attr.typedValue.value;
     }
     return collapsed;

package/src/utils/app-info-parser/zip.ts

@@ -1,19 +1,16 @@
-import { decodeNullUnicode } from './utils';
 import path from 'path';
+import { decodeNullUnicode } from './utils';
 
 const Unzip = require('isomorphic-unzip');
 
 import { enumZipEntries, readEntry } from '../zip-entries';
 
 export class Zip {
-  file: string;
+  file: string | File;
   unzip: any;
 
-  constructor(file: string) {
-    if (typeof file !== 'string') {
-      throw new Error('Param error: [file] must be file path in Node.');
-    }
-    this.file = path.resolve(file);
+  constructor(file: string | File) {
+    this.file = typeof file === 'string' ? path.resolve(file) : file;
     this.unzip = new Unzip(this.file);
   }
 
@@ -56,16 +53,17 @@ export class Zip {
     });
   }
 
-  async getEntryFromHarmonyApp(regex: RegExp) {
+  async getEntryFromHarmonyApp(
+    regex: RegExp,
+  ): Promise<Buffer | Blob | undefined> {
     try {
       let originSource: Buffer | Blob | undefined;
-      await enumZipEntries(this.file, (entry: any, zipFile: any) => {
+      if (typeof this.file !== 'string') {
+        throw new Error('Param error: [file] must be file path in Node.');
+      }
+      await enumZipEntries(this.file, async (entry, zipFile) => {
         if (regex.test(entry.fileName)) {
-          return readEntry(entry, zipFile).then(
-            (value: Buffer | Blob | undefined) => {
-              originSource = value;
-            },
-          );
+          originSource = await readEntry(entry, zipFile);
         }
       });
       return originSource;

package/src/utils/command-result.ts

@@ -0,0 +1,24 @@
+import type { CommandResult } from '../types';
+
+export function toErrorMessage(error: unknown, fallback: string): string {
+  return error instanceof Error ? error.message : fallback;
+}
+
+export async function runAsCommandResult<T>(
+  task: () => Promise<T>,
+  fallbackError: string,
+  mapSuccess?: (result: T) => unknown,
+): Promise<CommandResult> {
+  try {
+    const result = await task();
+    return {
+      success: true,
+      data: mapSuccess ? mapSuccess(result) : result,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: toErrorMessage(error, fallbackError),
+    };
+  }
+}

package/src/utils/index.ts

@@ -3,6 +3,8 @@ import path from 'path';
 import chalk from 'chalk';
 import { satisfies } from 'compare-versions';
 import fs from 'fs-extra';
+import type { Root as ProtobufRoot } from 'protobufjs';
+import { type Entry as YauzlEntry, open as openZipFile } from 'yauzl';
 import pkg from '../../package.json';
 import latestVersion from '../utils/latest-version';
 import AppInfoParser from './app-info-parser';
@@ -13,6 +15,77 @@ import { IS_CRESC, tempDir } from './constants';
 import { depVersions } from './dep-versions';
 import { t } from './i18n';
 
+type ApkMetaEntry = {
+  name?: string;
+  value?: string | number | Array<string | number>;
+};
+
+type ParsedApkInfo = {
+  versionName: string;
+  application: {
+    metaData?: ApkMetaEntry[];
+  };
+};
+
+type ParsedIpaInfo = {
+  CFBundleShortVersionString: string;
+};
+
+type ParsedAppMetaInfo = {
+  versionName?: string;
+  pushy_build_time?: number | string;
+};
+
+type AabXmlAttr = {
+  name: string;
+  value: string;
+  compiledItem?: {
+    ref?: {
+      id?: number;
+    };
+    prim?: {
+      intDecimalValue?: number;
+    };
+  };
+};
+
+type AabXmlElement = {
+  name: string;
+  attribute: AabXmlAttr[];
+  child: Array<{ element?: AabXmlElement }>;
+};
+
+type AabXmlNodeObject = {
+  element: AabXmlElement;
+};
+
+type AabResourceEntry = {
+  entryId: number;
+  configValue?: Array<{
+    value?: {
+      item?: {
+        str?: {
+          value?: string;
+        };
+      };
+    };
+  }>;
+};
+
+type AabResourceType = {
+  typeId: number;
+  entry: AabResourceEntry[];
+};
+
+type AabResourcePackage = {
+  packageId: number;
+  type: AabResourceType[];
+};
+
+type AabResourceTableObject = {
+  package: AabResourcePackage[];
+};
+
 export async function question(query: string, password?: boolean) {
   if (NO_INTERACTIVE) {
     return '';
@@ -24,20 +97,29 @@ export async function question(query: string, password?: boolean) {
   });
 }
 
-export function translateOptions(options: Record<string, string>) {
-  const ret: Record<string, string> = {};
+export function translateOptions<T extends Record<string, unknown>>(
+  options: T,
+): T & Record<string, unknown> {
+  const ret: Record<string, unknown> = {};
   for (const key in options) {
-    const v = options[key];
-    if (typeof v === 'string') {
-      ret[key] = v.replace(
-        /\$\{(\w+)\}/g,
-        (v, n) => options[n] || process.env[n] || v,
-      );
+    const value = options[key];
+    if (typeof value === 'string') {
+      ret[key] = value.replace(/\$\{(\w+)\}/g, (placeholder, name) => {
+        const replacement = options[name] ?? process.env[name];
+        if (
+          typeof replacement === 'string' ||
+          typeof replacement === 'number' ||
+          typeof replacement === 'boolean'
+        ) {
+          return String(replacement);
+        }
+        return placeholder;
+      });
     } else {
-      ret[key] = v;
+      ret[key] = value;
     }
   }
-  return ret;
+  return ret as T & Record<string, unknown>;
 }
 
 export async function getApkInfo(fn: string) {
@@ -60,12 +142,18 @@ export async function getApkInfo(fn: string) {
   if (updateJsonFile) {
     appCredential = JSON.parse(updateJsonFile.toString()).android;
   }
-  const { versionName, application } = await appInfoParser.parse();
+  const { versionName, application } =
+    await appInfoParser.parse<ParsedApkInfo>();
   let buildTime = 0;
   if (Array.isArray(application.metaData)) {
     for (const meta of application.metaData) {
       if (meta.name === 'pushy_build_time') {
-        buildTime = meta.value[0];
+        if (Array.isArray(meta.value)) {
+          const firstValue = meta.value[0];
+          buildTime = Number(firstValue);
+        } else if (meta.value !== undefined) {
+          buildTime = Number(meta.value);
+        }
       }
     }
   }
@@ -96,14 +184,14 @@ export async function getAppInfo(fn: string) {
   }
   const metaJsonFile =
     await appInfoParser.parser.getEntryFromHarmonyApp(/rawfile\/meta.json/);
-  let metaData: Record<string, any> = {};
+  let metaData: ParsedAppMetaInfo = {};
   if (metaJsonFile) {
-    metaData = JSON.parse(metaJsonFile.toString());
+    metaData = JSON.parse(metaJsonFile.toString()) as ParsedAppMetaInfo;
   }
   const { versionName, pushy_build_time } = metaData;
   let buildTime = 0;
   if (pushy_build_time) {
-    buildTime = pushy_build_time;
+    buildTime = Number(pushy_build_time);
   }
   if (buildTime == 0) {
     throw new Error(t('buildTimeNotFound'));
@@ -132,7 +220,7 @@ export async function getIpaInfo(fn: string) {
     appCredential = JSON.parse(updateJsonFile.toString()).ios;
   }
   const { CFBundleShortVersionString: versionName } =
-    await appInfoParser.parse();
+    await appInfoParser.parse<ParsedIpaInfo>();
   let buildTimeTxtBuffer = await appInfoParser.parser.getEntry(
     /payload\/.+?\.app\/pushy_build_time.txt/,
   );
@@ -150,7 +238,7 @@ export async function getIpaInfo(fn: string) {
 }
 
 export async function getAabInfo(fn: string) {
-  const protobuf = require('protobufjs');
+  const protobuf = require('protobufjs') as typeof import('protobufjs');
   const root = await protobuf.load(
     path.join(__dirname, '../../proto/Resources.proto'),
   );
@@ -165,7 +253,7 @@ export async function getAabInfo(fn: string) {
     bytes: String,
     defaults: true,
     arrays: true,
-  });
+  }) as AabXmlNodeObject;
 
   const manifestElement = object.element;
   if (manifestElement.name !== 'manifest') {
@@ -184,18 +272,23 @@ export async function getAabInfo(fn: string) {
 
   // Find application node
   const applicationNode = manifestElement.child.find(
-    (c: any) => c.element && c.element.name === 'application',
+    (child) => child.element?.name === 'application',
   );
-  if (applicationNode) {
-    const metaDataNodes = applicationNode.element.child.filter(
-      (c: any) => c.element && c.element.name === 'meta-data',
+  const applicationElement = applicationNode?.element;
+  if (applicationElement) {
+    const metaDataNodes = applicationElement.child.filter(
+      (child) => child.element?.name === 'meta-data',
     );
     for (const meta of metaDataNodes) {
       let name = '';
       let value = '';
       let resourceId = 0;
 
-      for (const attr of meta.element.attribute) {
+      const metaElement = meta.element;
+      if (!metaElement) {
+        continue;
+      }
+      for (const attr of metaElement.attribute) {
         if (attr.name === 'name') {
           name = attr.value;
         }
@@ -229,19 +322,24 @@ export async function getAabInfo(fn: string) {
 }
 
 async function readZipEntry(fn: string, entryName: string): Promise<Buffer> {
-  const yauzl = require('yauzl');
   return new Promise((resolve, reject) => {
-    yauzl.open(fn, { lazyEntries: true }, (err: any, zipfile: any) => {
-      if (err) return reject(err);
+    openZipFile(fn, { lazyEntries: true }, (err, zipfile) => {
+      if (err || !zipfile) {
+        reject(err ?? new Error('Failed to open zip file'));
+        return;
+      }
       let found = false;
       zipfile.readEntry();
-      zipfile.on('entry', (entry: any) => {
+      zipfile.on('entry', (entry: YauzlEntry) => {
         if (entry.fileName === entryName) {
           found = true;
-          zipfile.openReadStream(entry, (err: any, readStream: any) => {
-            if (err) return reject(err);
-            const chunks: any[] = [];
-            readStream.on('data', (chunk: any) => chunks.push(chunk));
+          zipfile.openReadStream(entry, (streamError, readStream) => {
+            if (streamError || !readStream) {
+              reject(streamError ?? new Error('Failed to read zip entry'));
+              return;
+            }
+            const chunks: Buffer[] = [];
+            readStream.on('data', (chunk: Buffer) => chunks.push(chunk));
             readStream.on('end', () => resolve(Buffer.concat(chunks)));
             readStream.on('error', reject);
           });
@@ -260,7 +358,7 @@ async function readZipEntry(fn: string, entryName: string): Promise<Buffer> {
 async function resolveResource(
   fn: string,
   resourceId: number,
-  root: any,
+  root: ProtobufRoot,
 ): Promise<string | null> {
   const pkgId = (resourceId >> 24) & 0xff;
   const typeId = (resourceId >> 16) & 0xff;
@@ -276,25 +374,26 @@ async function resolveResource(
       bytes: String,
       defaults: true,
       arrays: true,
-    });
+    }) as AabResourceTableObject;
 
     // Find package
-    const pkg = object.package.find((p: any) => p.packageId === pkgId);
+    const pkg = object.package.find((pkgItem) => pkgItem.packageId === pkgId);
     if (!pkg) return null;
 
     // Find type
-    const type = pkg.type.find((t: any) => t.typeId === typeId);
+    const type = pkg.type.find((typeItem) => typeItem.typeId === typeId);
     if (!type) return null;
 
     // Find entry
-    const entry = type.entry.find((e: any) => e.entryId === entryId);
+    const entry = type.entry.find((entryItem) => entryItem.entryId === entryId);
     if (!entry) return null;
 
     // Get value from configValue
     if (entry.configValue && entry.configValue.length > 0) {
-      const val = entry.configValue[0].value;
-      if (val.item?.str) {
-        return val.item.str.value;
+      const val = entry.configValue[0]?.value;
+      const stringValue = val?.item?.str?.value;
+      if (typeof stringValue === 'string') {
+        return stringValue;
       }
     }
   } catch (e) {

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

@@ -122,13 +122,13 @@ const drawBox = (
   );
 
   console.log(color(`┌${'─'.repeat(maxLineWidth + horizontalPadding * 2)}┐`));
-  lines.forEach((row) => {
+  for (const row of lines) {
     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)}┘`));
 };
 
@@ -191,15 +191,15 @@ const getTableColumns = (rows: TableRow[]): TableColumn[] => {
       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;
 };
 
@@ -217,13 +217,16 @@ const getTableRows = (updates: LatestVersionPackage[]): TableRow[] => {
     const getGroup = (a?: string, b?: string): TableRowGroup => {
       if (b && semverMajor(b) === 0) {
         return 'majorVersionZero';
-      } else if (a && b) {
+      }
+      if (a && b) {
         const releaseType = semverDiff(a, b) ?? '';
         if (['major', 'premajor', 'prerelease'].includes(releaseType)) {
           return 'major';
-        } else if (['minor', 'preminor'].includes(releaseType)) {
+        }
+        if (['minor', 'preminor'].includes(releaseType)) {
           return 'minor';
-        } else if (['patch', 'prepatch'].includes(releaseType)) {
+        }
+        if (['patch', 'prepatch'].includes(releaseType)) {
           return 'patch';
         }
       }
@@ -236,7 +239,7 @@ const getTableRows = (updates: LatestVersionPackage[]): TableRow[] => {
       wanted?: string,
     ) =>
       all.push({
-        name: ' ' + name,
+        name: ` ${name}`,
         location,
         installed: installed ?? 'unknown',
         latest: latest ?? 'unknown',
@@ -368,21 +371,20 @@ const checkVersions = async (
   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,
-  );
+  console.log(cyan('Checking versions...'));
+  let latestVersionPackages: LatestVersionPackage[];
+  if (typeof packages === 'string') {
+    latestVersionPackages = [await latestVersion(packages, options)];
+  } else if (Array.isArray(packages)) {
+    latestVersionPackages = await latestVersion(packages, options);
+  } else {
+    latestVersionPackages = await latestVersion(packages, options);
+  }
   if (skipMissing) {
     latestVersionPackages = latestVersionPackages.filter(
       (pkg) => pkg.local ?? pkg.globalNpm ?? pkg.globalYarn,
     );
   }
-  spinner.stop();
   displayTable(latestVersionPackages);
 };
 

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

@@ -363,7 +363,8 @@ const getInstalledVersion = (
     if (location === 'globalNpm') {
       return require(join(npm.packages, pkgName, 'package.json'))
         ?.version as string;
-    } else if (location === 'globalYarn') {
+    }
+    if (location === 'globalYarn') {
       // Make sure package is globally installed by Yarn
       const yarnGlobalPkg = require(
         pathResolve(yarn.packages, '..', 'package.json'),
@@ -373,25 +374,24 @@ const getInstalledVersion = (
       }
       return require(join(yarn.packages, pkgName, 'package.json'))
         ?.version as string;
-    } 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 } = parse(process.cwd());
-      let path = process.cwd();
-      const localPaths = [join(path, 'node_modules')];
-      while (path !== root) {
-        path = dirname(path);
-        localPaths.push(join(path, 'node_modules'));
-      }
-      for (const localPath of localPaths) {
-        const pkgPath = join(localPath, pkgName, 'package.json');
-        if (existsSync(pkgPath)) {
-          return require(pkgPath)?.version as string;
-        }
+    }
+    /**
+     * 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 } = parse(process.cwd());
+    let path = process.cwd();
+    const localPaths = [join(path, 'node_modules')];
+    while (path !== root) {
+      path = dirname(path);
+      localPaths.push(join(path, 'node_modules'));
+    }
+    for (const localPath of localPaths) {
+      const pkgPath = join(localPath, pkgName, 'package.json');
+      if (existsSync(pkgPath)) {
+        return require(pkgPath)?.version as string;
       }
     }
     return undefined;

package/src/utils/options.ts

@@ -0,0 +1,56 @@
+export function getBooleanOption(
+  options: Record<string, unknown>,
+  key: string,
+  fallback = false,
+): boolean {
+  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;
+}
+
+export function getStringOption(
+  options: Record<string, unknown>,
+  key: string,
+  fallback = '',
+): string {
+  const value = options[key];
+  if (typeof value === 'string') {
+    return value;
+  }
+  if (typeof value === 'number' || typeof value === 'boolean') {
+    return String(value);
+  }
+  return fallback;
+}
+
+export function getOptionalStringOption(
+  options: Record<string, unknown>,
+  key: string,
+): string | undefined {
+  const value = options[key];
+  if (typeof value === 'string') {
+    return value || undefined;
+  }
+  if (typeof value === 'number' || typeof value === 'boolean') {
+    return String(value);
+  }
+  return undefined;
+}
+
+export function toObjectState<T extends Record<string, unknown>>(
+  value: unknown,
+  fallback: T,
+): T {
+  if (value && typeof value === 'object') {
+    return value as T;
+  }
+  return fallback;
+}

package/src/utils/zip-entries.ts

@@ -34,7 +34,7 @@ export async function enumZipEntries(
     entry: Entry,
     zipFile: YauzlZipFile,
     nestedPath?: string,
-  ) => Promise<any>,
+  ) => Promise<any> | undefined,
   nestedPath = '',
 ) {
   return new Promise((resolve, reject) => {

package/src/workflow-runner.ts

@@ -0,0 +1,24 @@
+import type { CommandContext, CustomWorkflow } from './types';
+
+export async function runWorkflow(
+  workflowName: string,
+  workflow: CustomWorkflow,
+  context: CommandContext,
+): Promise<unknown> {
+  if (workflow.validate && !workflow.validate(context)) {
+    throw new Error(`Workflow '${workflowName}' validation failed`);
+  }
+
+  let previousResult: unknown;
+  for (const step of workflow.steps) {
+    if (step.condition && !step.condition(context)) {
+      console.log(`Skipping step '${step.name}' due to condition`);
+      continue;
+    }
+
+    console.log(`Executing step '${step.name}'`);
+    previousResult = await step.execute(context, previousResult);
+  }
+
+  return previousResult;
+}

package/index.js

@@ -1 +0,0 @@
-module.exports = require('./lib');