react-native-update-cli 2.8.4 → 2.9.0

package/lib/versions.js

@@ -21,6 +21,7 @@ const _utils = require("./utils");
 const _i18n = require("./utils/i18n");
 const _chalk = /*#__PURE__*/ _interop_require_default(require("chalk"));
 const _compareversions = require("compare-versions");
+const _ttytable = /*#__PURE__*/ _interop_require_default(require("tty-table"));
 const _app = require("./app");
 const _package = require("./package");
 const _depversions = require("./utils/dep-versions");
@@ -30,6 +31,181 @@ function _interop_require_default(obj) {
         default: obj
     };
 }
+function normalizeDeps(input) {
+    if (!input) {
+        return undefined;
+    }
+    let raw = input;
+    if (typeof input === 'string') {
+        try {
+            raw = JSON.parse(input);
+        } catch (_e) {
+            return undefined;
+        }
+    }
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return undefined;
+    }
+    const deps = {};
+    for (const [name, version] of Object.entries(raw)){
+        if (typeof version === 'string' && version) {
+            deps[name] = version;
+        }
+    }
+    return Object.keys(deps).length > 0 ? deps : undefined;
+}
+function getDepsChanges(oldDeps, newDeps) {
+    if (!oldDeps || !newDeps) {
+        return [];
+    }
+    const rows = [];
+    const keys = Object.keys({
+        ...oldDeps,
+        ...newDeps
+    }).sort((a, b)=>a.localeCompare(b));
+    for (const key of keys){
+        const oldVersion = oldDeps[key];
+        const newVersion = newDeps[key];
+        if (oldVersion === undefined && newVersion !== undefined) {
+            rows.push({
+                dependency: key,
+                oldVersion: '-',
+                newVersion,
+                type: 'added'
+            });
+            continue;
+        }
+        if (oldVersion !== undefined && newVersion === undefined) {
+            rows.push({
+                dependency: key,
+                oldVersion,
+                newVersion: '-',
+                type: 'removed'
+            });
+            continue;
+        }
+        if (oldVersion !== undefined && newVersion !== undefined && oldVersion !== newVersion) {
+            rows.push({
+                dependency: key,
+                oldVersion,
+                newVersion,
+                type: 'changed'
+            });
+        }
+    }
+    return rows;
+}
+function getDepsChangeSummary(changes) {
+    return changes.reduce((acc, item)=>{
+        if (item.type === 'added') {
+            acc.added += 1;
+        } else if (item.type === 'removed') {
+            acc.removed += 1;
+        } else {
+            acc.changed += 1;
+        }
+        return acc;
+    }, {
+        added: 0,
+        removed: 0,
+        changed: 0
+    });
+}
+function renderVersionChange(change) {
+    const arrow = _chalk.default.gray(` ${(0, _i18n.t)('depsChangeArrow')} `);
+    if (change.type === 'added') {
+        return `${_chalk.default.red((0, _i18n.t)('depsChangeAddedLabel'))} | ${_chalk.default.gray(change.oldVersion)}${arrow}${_chalk.default.red(change.newVersion)}`;
+    }
+    if (change.type === 'removed') {
+        return `${_chalk.default.green((0, _i18n.t)('depsChangeRemovedLabel'))} | ${_chalk.default.green(change.oldVersion)}${arrow}${_chalk.default.gray(change.newVersion)}`;
+    }
+    return `${_chalk.default.yellow((0, _i18n.t)('depsChangeChangedLabel'))} | ${_chalk.default.yellow(change.oldVersion)}${arrow}${_chalk.default.yellow(change.newVersion)}`;
+}
+function printDepsChangesForPackage({ pkg, versionDeps }) {
+    const pkgDeps = normalizeDeps(pkg.deps);
+    if (!pkgDeps) {
+        return false;
+    }
+    const changes = getDepsChanges(pkgDeps, versionDeps);
+    if (changes.length === 0) {
+        return false;
+    }
+    const summary = getDepsChangeSummary(changes);
+    const summaryText = (0, _i18n.t)('depsChangeSummary', {
+        added: _chalk.default.red(String(summary.added)),
+        removed: _chalk.default.green(String(summary.removed)),
+        changed: _chalk.default.yellow(String(summary.changed))
+    });
+    const header = [
+        {
+            value: (0, _i18n.t)('depsChangeDependencyHeader')
+        },
+        {
+            value: (0, _i18n.t)('depsChangeVersionHeader')
+        }
+    ];
+    const rows = changes.map((change)=>[
+            change.dependency,
+            renderVersionChange(change)
+        ]);
+    console.log('');
+    console.log(_chalk.default.yellow((0, _i18n.t)('depsChangeTargetPackage', {
+        packageName: pkg.name,
+        packageId: pkg.id
+    })));
+    console.log(summaryText);
+    console.log((0, _ttytable.default)(header, rows).render());
+    console.log(_chalk.default.yellow((0, _i18n.t)('depsChangeRiskWarning')));
+    return true;
+}
+async function findVersionDeps(appId, versionId) {
+    const targetId = String(versionId);
+    const limit = 100;
+    let offset = 0;
+    while(true){
+        const { data, count } = await (0, _api.get)(`/app/${appId}/version/list?offset=${offset}&limit=${limit}`);
+        const versions = Array.isArray(data) ? data : [];
+        const version = versions.find((item)=>String(item.id) === targetId);
+        if (version) {
+            return normalizeDeps(version.deps);
+        }
+        offset += versions.length;
+        if (versions.length === 0 || offset >= Number(count || 0)) {
+            break;
+        }
+    }
+    return undefined;
+}
+async function printDepsChangesForPublish({ appId, versionId, pkgs, providedVersionDeps }) {
+    if (!versionId || pkgs.length === 0) {
+        return;
+    }
+    let versionDeps = normalizeDeps(providedVersionDeps);
+    if (!versionDeps) {
+        try {
+            versionDeps = await findVersionDeps(appId, versionId);
+        } catch (error) {
+            console.warn(_chalk.default.yellow((0, _i18n.t)('depsChangeFetchFailed', {
+                error: (error == null ? void 0 : error.message) || String(error)
+            })));
+            return;
+        }
+    }
+    if (!versionDeps) {
+        return;
+    }
+    let hasChanges = false;
+    for (const pkg of pkgs){
+        const printed = printDepsChangesForPackage({
+            pkg,
+            versionDeps
+        });
+        hasChanges = hasChanges || printed;
+    }
+    if (hasChanges) {
+        console.log(_chalk.default.yellow((0, _i18n.t)('depsChangeNonBlockingHint')));
+    }
+}
 async function showVersion(appId, offset) {
     const { data, count } = await (0, _api.get)(`/app/${appId}/version/list`);
     console.log((0, _i18n.t)('offset', {
@@ -164,7 +340,8 @@ const versionCommands = {
                     minPackageVersion,
                     maxPackageVersion,
                     rollout,
-                    dryRun
+                    dryRun,
+                    versionDeps: _depversions.depVersions
                 }
             });
         } else {
@@ -173,7 +350,8 @@ const versionCommands = {
                 await this.update({
                     options: {
                         versionId: id,
-                        platform
+                        platform,
+                        versionDeps: _depversions.depVersions
                     }
                 });
             }
@@ -269,6 +447,12 @@ const versionCommands = {
                 }));
             }
         }
+        await printDepsChangesForPublish({
+            appId,
+            versionId,
+            pkgs: pkgsToBind,
+            providedVersionDeps: options.versionDeps
+        });
         await bindVersionToPackages({
             appId,
             versionId,

package/lib/workflow-runner.d.ts

@@ -0,0 +1,2 @@
+import type { CommandContext, CustomWorkflow } from './types';
+export declare function runWorkflow(workflowName: string, workflow: CustomWorkflow, context: CommandContext): Promise<unknown>;

package/lib/workflow-runner.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "runWorkflow", {
+    enumerable: true,
+    get: function() {
+        return runWorkflow;
+    }
+});
+async function runWorkflow(workflowName, workflow, context) {
+    if (workflow.validate && !workflow.validate(context)) {
+        throw new Error(`Workflow '${workflowName}' validation failed`);
+    }
+    let previousResult;
+    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/package.json

@@ -1,12 +1,25 @@
 {
   "name": "react-native-update-cli",
-  "version": "2.8.4",
+  "version": "2.9.0",
   "description": "command line tool for react-native-update (remote updates for react native)",
-  "main": "index.js",
+  "main": "lib/exports.js",
+  "types": "lib/exports.d.ts",
   "bin": {
     "pushy": "lib/index.js",
     "cresc": "lib/index.js"
   },
+  "exports": {
+    ".": {
+      "types": "./lib/exports.d.ts",
+      "require": "./lib/exports.js",
+      "default": "./lib/exports.js"
+    },
+    "./cli": {
+      "types": "./lib/index.d.ts",
+      "require": "./lib/index.js",
+      "default": "./lib/index.js"
+    }
+  },
   "files": [
     "lib",
     "src",
@@ -14,9 +27,11 @@
     "cli.json"
   ],
   "scripts": {
-    "build": "swc src -d lib --strip-leading-paths",
-    "prepublishOnly": "bun scripts/prepublish.js && bun run build && chmod +x lib/index.js",
-    "lint": "tsc --noEmit & biome check --write ."
+    "build": "rm -rf lib && swc src -d lib --strip-leading-paths && tsc -p tsconfig.build.json",
+    "prepublishOnly": "bun scripts/prepublish.ts && bun run build && chmod +x lib/index.js",
+    "lint": "tsc --noEmit && biome check --write .",
+    "test": "bun test",
+    "test:coverage": "bun test --coverage --coverage-reporter=text --coverage-reporter=lcov"
   },
   "repository": {
     "type": "git",

package/src/api.ts

@@ -9,7 +9,7 @@ import tcpp from 'tcp-ping';
 import { getBaseUrl } from 'utils/http-helper';
 import packageJson from '../package.json';
 import type { Package, Session } from './types';
-import { credentialFile, pricingPageUrl, IS_CRESC } from './utils/constants';
+import { IS_CRESC, credentialFile, pricingPageUrl } from './utils/constants';
 import { t } from './utils/i18n';
 
 const tcpPing = util.promisify(tcpp.ping);

package/src/app.ts

@@ -6,7 +6,13 @@ import { doDelete, get, post } from './api';
 import type { Platform } from './types';
 import { t } from './utils/i18n';
 
-const validPlatforms = ['ios', 'android', 'harmony'];
+interface AppSummary {
+  id: number;
+  name: string;
+  platform: Platform;
+}
+
+const validPlatforms = ['ios', 'android', 'harmony'] as const;
 
 export async function getPlatform(platform?: string) {
   return assertPlatform(
@@ -14,11 +20,11 @@ export async function getPlatform(platform?: string) {
   ) as Platform;
 }
 
-export function assertPlatform(platform: string) {
-  if (!validPlatforms.includes(platform)) {
+export function assertPlatform(platform: string): Platform {
+  if (!validPlatforms.includes(platform as Platform)) {
     throw new Error(t('unsupportedPlatform', { platform }));
   }
-  return platform;
+  return platform as Platform;
 }
 
 export function getSelectedApp(platform: Platform) {
@@ -36,7 +42,10 @@ export function getSelectedApp(platform: Platform) {
 
 export async function listApp(platform: Platform | '' = '') {
   const { data } = await get('/app/list');
-  const list = platform ? data.filter((v) => v.platform === platform) : data;
+  const allApps = data as AppSummary[];
+  const list = platform
+    ? allApps.filter((app: AppSummary) => app.platform === platform)
+    : allApps;
 
   const header = [
     { value: t('appId') },
@@ -59,7 +68,7 @@ export async function chooseApp(platform: Platform) {
 
   while (true) {
     const id = await question(t('enterAppIdQuestion'));
-    const app = list.find((v) => v.id === Number(id));
+    const app = list.find((item: AppSummary) => item.id === Number(id));
     if (app) {
       return app;
     }
@@ -70,7 +79,7 @@ export const appCommands = {
   createApp: async function ({
     options,
   }: {
-    options: { name: string; downloadUrl: string; platform: Platform };
+    options: { name: string; downloadUrl: string; platform?: Platform | '' };
   }) {
     const name = options.name || (await question(t('appNameQuestion')));
     const { downloadUrl } = options;
@@ -97,16 +106,16 @@ export const appCommands = {
     await doDelete(`/app/${id}`);
     console.log(t('operationSuccess'));
   },
-  apps: async ({ options }: { options: { platform: Platform } }) => {
-    const { platform } = options;
-    listApp(platform);
+  apps: async ({ options }: { options: { platform?: Platform | '' } }) => {
+    const { platform = '' } = options;
+    await listApp(platform);
   },
   selectApp: async ({
     args,
     options,
   }: {
     args: string[];
-    options: { platform: Platform };
+    options: { platform?: Platform | '' };
   }) => {
     const platform = await getPlatform(options.platform);
     const id = args[0]

package/src/bundle-pack.ts

@@ -0,0 +1,51 @@
+import path from 'path';
+import * as fs from 'fs-extra';
+import { ZipFile as YazlZipFile } from 'yazl';
+import { t } from './utils/i18n';
+
+const ignorePackingFileNames = [
+  '.',
+  '..',
+  'index.bundlejs.map',
+  'bundle.harmony.js.map',
+];
+const ignorePackingExtensions = ['DS_Store', 'txt.map'];
+
+export async function packBundle(dir: string, output: string): Promise<void> {
+  console.log(t('packing'));
+  fs.ensureDirSync(path.dirname(output));
+  await new Promise<void>((resolve, reject) => {
+    const zipfile = new YazlZipFile();
+
+    function addDirectory(root: string, rel: string) {
+      if (rel) {
+        zipfile.addEmptyDirectory(rel);
+      }
+      const children = fs.readdirSync(root);
+      for (const name of children) {
+        if (
+          ignorePackingFileNames.includes(name) ||
+          ignorePackingExtensions.some((ext) => name.endsWith(`.${ext}`))
+        ) {
+          continue;
+        }
+        const fullPath = path.join(root, name);
+        const stat = fs.statSync(fullPath);
+        if (stat.isFile()) {
+          zipfile.addFile(fullPath, rel + name);
+        } else if (stat.isDirectory()) {
+          addDirectory(fullPath, `${rel}${name}/`);
+        }
+      }
+    }
+
+    addDirectory(dir, '');
+
+    zipfile.outputStream.on('error', (err: unknown) => reject(err));
+    zipfile.outputStream.pipe(fs.createWriteStream(output)).on('close', () => {
+      resolve();
+    });
+    zipfile.end();
+  });
+  console.log(t('fileGenerated', { file: output }));
+}