react-native-update-cli 2.8.5 → 2.9.0

package/lib/diff.js

@@ -73,7 +73,6 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-var _loadDiffModule;
 const loadDiffModule = (pkgName)=>{
     const resolvePaths = [
         '.',
@@ -91,28 +90,25 @@ const loadDiffModule = (pkgName)=>{
     } catch (e) {}
     return undefined;
 };
-let hdiff;
-hdiff = (_loadDiffModule = loadDiffModule('node-hdiffpatch')) == null ? void 0 : _loadDiffModule.diff;
-let bsdiff;
-let diff;
-bsdiff = loadDiffModule('node-bsdiff');
+const hdiff = loadDiffModule('node-hdiffpatch');
+const bsdiff = loadDiffModule('node-bsdiff');
 function basename(fn) {
     const m = /^(.+\/)[^\/]+\/?$/.exec(fn);
     return m == null ? void 0 : m[1];
 }
-async function diffFromPPK(origin, next, output) {
+async function diffFromPPK(origin, next, output, diffFn) {
     _fsextra.ensureDirSync(_path.default.dirname(output));
     const originEntries = {};
     const originMap = {};
     let originSource;
-    await (0, _zipentries.enumZipEntries)(origin, (entry, zipFile)=>{
+    await (0, _zipentries.enumZipEntries)(origin, async (entry, zipFile)=>{
         originEntries[entry.fileName] = entry;
         if (!/\/$/.test(entry.fileName)) {
             // isFile
             originMap[entry.crc32] = entry.fileName;
             if ((0, _constants.isPPKBundleFileName)(entry.fileName)) {
                 // This is source.
-                return (0, _zipentries.readEntry)(entry, zipFile).then((v)=>originSource = v);
+                originSource = await (0, _zipentries.readEntry)(entry, zipFile);
             }
         }
     });
@@ -122,9 +118,7 @@ async function diffFromPPK(origin, next, output) {
     const copies = {};
     const zipfile = new _yazl.ZipFile();
     const writePromise = new Promise((resolve, reject)=>{
-        zipfile.outputStream.on('error', (err)=>{
-            throw err;
-        });
+        zipfile.outputStream.on('error', reject);
         zipfile.outputStream.pipe(_fsextra.createWriteStream(output)).on('close', ()=>{
             resolve(void 0);
         });
@@ -135,6 +129,7 @@ async function diffFromPPK(origin, next, output) {
         if (!fn || addedEntry[fn]) {
             return;
         }
+        addedEntry[fn] = true;
         const base = basename(fn);
         if (base) {
             addEntry(base);
@@ -142,7 +137,7 @@ async function diffFromPPK(origin, next, output) {
         zipfile.addEmptyDirectory(fn);
     }
     const newEntries = {};
-    await (0, _zipentries.enumZipEntries)(next, (entry, nextZipfile)=>{
+    await (0, _zipentries.enumZipEntries)(next, async (entry, nextZipfile)=>{
         newEntries[entry.fileName] = entry;
         if (/\/$/.test(entry.fileName)) {
             // Directory
@@ -151,11 +146,10 @@ async function diffFromPPK(origin, next, output) {
             }
         } else if ((0, _constants.isPPKBundleFileName)(entry.fileName)) {
             //console.log('Found bundle');
-            return (0, _zipentries.readEntry)(entry, nextZipfile).then((newSource)=>{
-                //console.log('Begin diff');
-                zipfile.addBuffer(diff(originSource, newSource), `${entry.fileName}.patch`);
-            //console.log('End diff');
-            });
+            const newSource = await (0, _zipentries.readEntry)(entry, nextZipfile);
+            //console.log('Begin diff');
+            zipfile.addBuffer(diffFn(originSource, newSource), `${entry.fileName}.patch`);
+        //console.log('End diff');
         } else {
             // If same file.
             const originEntry = originEntries[entry.fileName];
@@ -164,21 +158,28 @@ async function diffFromPPK(origin, next, output) {
                 return;
             }
             // If moved from other place
-            if (originMap[entry.crc32]) {
+            const movedFrom = originMap[entry.crc32];
+            if (movedFrom) {
                 const base = basename(entry.fileName);
-                if (!originEntries[base]) {
+                if (base && !originEntries[base]) {
                     addEntry(base);
                 }
-                copies[entry.fileName] = originMap[entry.crc32];
+                copies[entry.fileName] = movedFrom;
                 return;
             }
             // New file.
-            addEntry(basename(entry.fileName));
-            return new Promise((resolve, reject)=>{
+            const basePath = basename(entry.fileName);
+            if (basePath) {
+                addEntry(basePath);
+            }
+            await new Promise((resolve, reject)=>{
                 nextZipfile.openReadStream(entry, (err, readStream)=>{
                     if (err) {
                         return reject(err);
                     }
+                    if (!readStream) {
+                        return reject(new Error(`Unable to read zip entry: ${entry.fileName}`));
+                    }
                     zipfile.addReadStream(readStream, entry.fileName);
                     readStream.on('end', ()=>{
                         //console.log('add finished');
@@ -205,12 +206,12 @@ async function diffFromPPK(origin, next, output) {
     zipfile.end();
     await writePromise;
 }
-async function diffFromPackage(origin, next, output, originBundleName, transformPackagePath = (v)=>v) {
+async function diffFromPackage(origin, next, output, diffFn, originBundleName, transformPackagePath = (v)=>v) {
     _fsextra.ensureDirSync(_path.default.dirname(output));
     const originEntries = {};
     const originMap = {};
     let originSource;
-    await (0, _zipentries.enumZipEntries)(origin, (entry, zipFile)=>{
+    await (0, _zipentries.enumZipEntries)(origin, async (entry, zipFile)=>{
         if (!/\/$/.test(entry.fileName)) {
             const fn = transformPackagePath(entry.fileName);
             if (!fn) {
@@ -222,7 +223,7 @@ async function diffFromPackage(origin, next, output, originBundleName, transform
             originMap[entry.crc32] = fn;
             if (fn === originBundleName) {
                 // This is source.
-                return (0, _zipentries.readEntry)(entry, zipFile).then((v)=>originSource = v);
+                originSource = await (0, _zipentries.readEntry)(entry, zipFile);
             }
         }
     });
@@ -232,24 +233,21 @@ async function diffFromPackage(origin, next, output, originBundleName, transform
     const copies = {};
     const zipfile = new _yazl.ZipFile();
     const writePromise = new Promise((resolve, reject)=>{
-        zipfile.outputStream.on('error', (err)=>{
-            throw err;
-        });
+        zipfile.outputStream.on('error', reject);
         zipfile.outputStream.pipe(_fsextra.createWriteStream(output)).on('close', ()=>{
             resolve(void 0);
         });
     });
-    await (0, _zipentries.enumZipEntries)(next, (entry, nextZipfile)=>{
+    await (0, _zipentries.enumZipEntries)(next, async (entry, nextZipfile)=>{
         if (/\/$/.test(entry.fileName)) {
             // Directory
             zipfile.addEmptyDirectory(entry.fileName);
         } else if ((0, _constants.isPPKBundleFileName)(entry.fileName)) {
             //console.log('Found bundle');
-            return (0, _zipentries.readEntry)(entry, nextZipfile).then((newSource)=>{
-                //console.log('Begin diff');
-                zipfile.addBuffer(diff(originSource, newSource), `${entry.fileName}.patch`);
-            //console.log('End diff');
-            });
+            const newSource = await (0, _zipentries.readEntry)(entry, nextZipfile);
+            //console.log('Begin diff');
+            zipfile.addBuffer(diffFn(originSource, newSource), `${entry.fileName}.patch`);
+        //console.log('End diff');
         } else {
             // If same file.
             if (originEntries[entry.fileName] === entry.crc32) {
@@ -257,15 +255,19 @@ async function diffFromPackage(origin, next, output, originBundleName, transform
                 return;
             }
             // If moved from other place
-            if (originMap[entry.crc32]) {
-                copies[entry.fileName] = originMap[entry.crc32];
+            const movedFrom = originMap[entry.crc32];
+            if (movedFrom) {
+                copies[entry.fileName] = movedFrom;
                 return;
             }
-            return new Promise((resolve, reject)=>{
+            await new Promise((resolve, reject)=>{
                 nextZipfile.openReadStream(entry, (err, readStream)=>{
                     if (err) {
                         return reject(err);
                     }
+                    if (!readStream) {
+                        return reject(new Error(`Unable to read zip entry: ${entry.fileName}`));
+                    }
                     zipfile.addReadStream(readStream, entry.fileName);
                     readStream.on('end', ()=>{
                         //console.log('add finished');
@@ -281,106 +283,125 @@ async function diffFromPackage(origin, next, output, originBundleName, transform
     zipfile.end();
     await writePromise;
 }
-function diffArgsCheck(args, options, diffFn) {
+function resolveDiffImplementation(useHdiff, options) {
+    if (options.customDiff) {
+        return options.customDiff;
+    }
+    if (useHdiff) {
+        if (!hdiff) {
+            throw new Error((0, _i18n.t)('nodeHdiffpatchRequired', {
+                scriptName: _constants.scriptName
+            }));
+        }
+        return hdiff;
+    }
+    if (!bsdiff) {
+        throw new Error((0, _i18n.t)('nodeBsdiffRequired', {
+            scriptName: _constants.scriptName
+        }));
+    }
+    return bsdiff;
+}
+function diffArgsCheck(args, options, diffFnName, useHdiff) {
     const [origin, next] = args;
     if (!origin || !next) {
-        console.error((0, _i18n.t)('usageDiff', {
-            command: diffFn
+        throw new Error((0, _i18n.t)('usageDiff', {
+            command: diffFnName
         }));
-        process.exit(1);
-    }
-    if (options == null ? void 0 : options.customDiff) {
-        diff = options.customDiff;
-    } else {
-        if (diffFn.startsWith('hdiff')) {
-            if (!hdiff) {
-                console.error((0, _i18n.t)('nodeHdiffpatchRequired', {
-                    scriptName: _constants.scriptName
-                }));
-                process.exit(1);
-            }
-            diff = hdiff;
-        } else {
-            if (!bsdiff) {
-                console.error((0, _i18n.t)('nodeBsdiffRequired', {
-                    scriptName: _constants.scriptName
-                }));
-                process.exit(1);
-            }
-            diff = bsdiff;
-        }
     }
+    const diffFn = resolveDiffImplementation(useHdiff, options);
     const { output } = (0, _utils.translateOptions)({
         ...options,
         tempDir: _constants.tempDir
     });
+    if (typeof output !== 'string') {
+        throw new Error('Output path is required.');
+    }
     return {
         origin,
         next,
+        diffFn,
         realOutput: output.replace(/\$\{time\}/g, `${Date.now()}`)
     };
 }
-const diffCommands = {
-    async diff ({ args, options }) {
-        const { origin, next, realOutput } = diffArgsCheck(args, options, 'diff');
-        await diffFromPPK(origin, next, realOutput);
-        console.log((0, _i18n.t)('diffPackageGenerated', {
-            output: realOutput
-        }));
-    },
-    async hdiff ({ args, options }) {
-        const { origin, next, realOutput } = diffArgsCheck(args, options, 'hdiff');
-        await diffFromPPK(origin, next, realOutput);
-        console.log((0, _i18n.t)('diffPackageGenerated', {
-            output: realOutput
-        }));
-    },
-    async diffFromApk ({ args, options }) {
-        const { origin, next, realOutput } = diffArgsCheck(args, options, 'diffFromApk');
-        await diffFromPackage(origin, next, realOutput, 'assets/index.android.bundle');
-        console.log((0, _i18n.t)('diffPackageGenerated', {
-            output: realOutput
-        }));
-    },
-    async hdiffFromApk ({ args, options }) {
-        const { origin, next, realOutput } = diffArgsCheck(args, options, 'hdiffFromApk');
-        await diffFromPackage(origin, next, realOutput, 'assets/index.android.bundle');
-        console.log((0, _i18n.t)('diffPackageGenerated', {
-            output: realOutput
-        }));
-    },
-    async diffFromApp ({ args, options }) {
-        const { origin, next, realOutput } = diffArgsCheck(args, options, 'diffFromApp');
-        await diffFromPackage(origin, next, realOutput, 'resources/rawfile/bundle.harmony.js');
-        console.log((0, _i18n.t)('diffPackageGenerated', {
-            output: realOutput
-        }));
-    },
-    async hdiffFromApp ({ args, options }) {
-        const { origin, next, realOutput } = diffArgsCheck(args, options, 'hdiffFromApp');
-        await diffFromPackage(origin, next, realOutput, 'resources/rawfile/bundle.harmony.js');
-        console.log((0, _i18n.t)('diffPackageGenerated', {
-            output: realOutput
-        }));
-    },
-    async diffFromIpa ({ args, options }) {
-        const { origin, next, realOutput } = diffArgsCheck(args, options, 'diffFromIpa');
-        await diffFromPackage(origin, next, realOutput, 'main.jsbundle', (v)=>{
-            const m = /^Payload\/[^/]+\/(.+)$/.exec(v);
-            return m == null ? void 0 : m[1];
-        });
-        console.log((0, _i18n.t)('diffPackageGenerated', {
-            output: realOutput
-        }));
-    },
-    async hdiffFromIpa ({ args, options }) {
-        const { origin, next, realOutput } = diffArgsCheck(args, options, 'hdiffFromIpa');
-        await diffFromPackage(origin, next, realOutput, 'main.jsbundle', (v)=>{
-            const m = /^Payload\/[^/]+\/(.+)$/.exec(v);
-            return m == null ? void 0 : m[1];
-        });
+const transformIpaPackagePath = (v)=>{
+    const match = /^Payload\/[^/]+\/(.+)$/.exec(v);
+    return match == null ? void 0 : match[1];
+};
+const createDiffCommand = ({ diffFnName, useHdiff, target })=>async ({ args, options })=>{
+        const { origin, next, realOutput, diffFn } = diffArgsCheck(args, options, diffFnName, useHdiff);
+        if (target.kind === 'ppk') {
+            await diffFromPPK(origin, next, realOutput, diffFn);
+        } else {
+            await diffFromPackage(origin, next, realOutput, diffFn, target.originBundleName, target.transformPackagePath);
+        }
         console.log((0, _i18n.t)('diffPackageGenerated', {
             output: realOutput
         }));
-    }
+    };
+const diffCommands = {
+    diff: createDiffCommand({
+        diffFnName: 'diff',
+        useHdiff: false,
+        target: {
+            kind: 'ppk'
+        }
+    }),
+    hdiff: createDiffCommand({
+        diffFnName: 'hdiff',
+        useHdiff: true,
+        target: {
+            kind: 'ppk'
+        }
+    }),
+    diffFromApk: createDiffCommand({
+        diffFnName: 'diffFromApk',
+        useHdiff: false,
+        target: {
+            kind: 'package',
+            originBundleName: 'assets/index.android.bundle'
+        }
+    }),
+    hdiffFromApk: createDiffCommand({
+        diffFnName: 'hdiffFromApk',
+        useHdiff: true,
+        target: {
+            kind: 'package',
+            originBundleName: 'assets/index.android.bundle'
+        }
+    }),
+    diffFromApp: createDiffCommand({
+        diffFnName: 'diffFromApp',
+        useHdiff: false,
+        target: {
+            kind: 'package',
+            originBundleName: 'resources/rawfile/bundle.harmony.js'
+        }
+    }),
+    hdiffFromApp: createDiffCommand({
+        diffFnName: 'hdiffFromApp',
+        useHdiff: true,
+        target: {
+            kind: 'package',
+            originBundleName: 'resources/rawfile/bundle.harmony.js'
+        }
+    }),
+    diffFromIpa: createDiffCommand({
+        diffFnName: 'diffFromIpa',
+        useHdiff: false,
+        target: {
+            kind: 'package',
+            originBundleName: 'main.jsbundle',
+            transformPackagePath: transformIpaPackagePath
+        }
+    }),
+    hdiffFromIpa: createDiffCommand({
+        diffFnName: 'hdiffFromIpa',
+        useHdiff: true,
+        target: {
+            kind: 'package',
+            originBundleName: 'main.jsbundle',
+            transformPackagePath: transformIpaPackagePath
+        }
+    })
 };

package/lib/exports.d.ts

@@ -0,0 +1,12 @@
+export { moduleManager } from './module-manager';
+export { CLIProviderImpl } from './provider';
+export type { CLIProvider, CLIModule, CommandDefinition, CustomWorkflow, WorkflowStep, CommandContext, CommandResult, BundleOptions, PublishOptions, UploadOptions, Platform, Session, Version, Package, } from './types';
+export { builtinModules } from './modules';
+export { bundleModule } from './modules/bundle-module';
+export { versionModule } from './modules/version-module';
+export { appModule } from './modules/app-module';
+export { userModule } from './modules/user-module';
+export { packageModule } from './modules/package-module';
+export { loadSession, getSession } from './api';
+export { getPlatform, getSelectedApp } from './app';
+export { question, saveToLocal } from './utils';

package/lib/index.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import { moduleManager } from './module-manager';
+export { moduleManager };
+export { CLIProviderImpl } from './provider';
+export type { CLIProvider, CLIModule, CommandDefinition, CustomWorkflow, WorkflowStep, } from './types';

package/lib/index.js

@@ -43,27 +43,18 @@ function printUsage() {
     console.log('React Native Update CLI');
     console.log('');
     console.log('Traditional commands:');
-    const legacyCommands = {
-        ..._user.userCommands,
-        ..._bundle.bundleCommands,
-        ..._diff.diffCommands,
-        ..._app.appCommands,
-        ..._package.packageCommands,
-        ..._versions.versionCommands,
-        ..._install.installCommands
-    };
-    for (const [name, handler] of Object.entries(legacyCommands)){
+    for (const name of Object.keys(legacyCommands)){
         console.log(`  ${name}: Legacy command`);
     }
     console.log('');
     console.log('Modular commands:');
-    const commands = _modulemanager.moduleManager.getRegisteredCommands();
+    const commands = _modulemanager.moduleManager.listCommands();
     for (const command of commands){
         console.log(`  ${command.name}: ${command.description || 'No description'}`);
     }
     console.log('');
     console.log('Available workflows:');
-    const workflows = _modulemanager.moduleManager.getRegisteredWorkflows();
+    const workflows = _modulemanager.moduleManager.listWorkflows();
     for (const workflow of workflows){
         console.log(`  ${workflow.name}: ${workflow.description || 'No description'}`);
     }
@@ -121,7 +112,8 @@ async function run() {
             }
             console.log('Workflow completed successfully:', result.data);
         } else if (legacyCommands[argv.command]) {
-            await legacyCommands[argv.command](argv);
+            const legacyHandler = legacyCommands[argv.command];
+            await legacyHandler(argv);
         } else {
             const result = await _modulemanager.moduleManager.executeCommand(argv.command, context);
             if (!result.success) {

package/lib/install.d.ts

@@ -0,0 +1,4 @@
+import type { CommandContext } from './types';
+export declare const installCommands: {
+    install: ({ args }: CommandContext) => Promise<void>;
+};

package/lib/locales/en.d.ts

@@ -0,0 +1,137 @@
+declare const _default: {
+    addedToGitignore: string;
+    androidCrunchPngsWarning: string;
+    aabOpenApksFailed: string;
+    aabReadUniversalApkFailed: string;
+    aabUniversalApkNotFound: string;
+    aabBundletoolDownloadHint: string;
+    aabManifestNotFound: string;
+    aabParseResourcesWarning: string;
+    aabParseFailed: string;
+    aabParseManifestError: string;
+    aabParseResourcesError: string;
+    appId: string;
+    appIdMismatchApk: string;
+    appIdMismatchApp: string;
+    appIdMismatchIpa: string;
+    appKeyMismatchApk: string;
+    appKeyMismatchApp: string;
+    appKeyMismatchIpa: string;
+    appName: string;
+    appNameQuestion: string;
+    appNotSelected: string;
+    appUploadSuccess: string;
+    apkUploadSuccess: string;
+    boundTo: string;
+    buildTimeNotFound: string;
+    bundleCommandError: string;
+    bundleNotFound: string;
+    bundlingWithRN: string;
+    cancelled: string;
+    composingSourceMap: string;
+    copyFileFailed: string;
+    copyHarmonyBundleError: string;
+    copyingDebugId: string;
+    createAppSuccess: string;
+    deleteFile: string;
+    deletingFile: string;
+    enterAppIdQuestion: string;
+    enterNativePackageId: string;
+    errorInHarmonyApp: string;
+    expiredStatus: string;
+    failedToParseIcon: string;
+    failedToParseUpdateJson: string;
+    fileGenerated: string;
+    fileSizeExceeded: string;
+    forceHermes: string;
+    hermesEnabledCompiling: string;
+    ipaUploadSuccess: string;
+    keyStrings: string;
+    latestVersionTag: string;
+    lockBestPractice: string;
+    lockNotFound: string;
+    loggedOut: string;
+    loginExpired: string;
+    loginFirst: string;
+    multipleLocksFound: string;
+    nativePackageId: string;
+    nativeVersion: string;
+    nativeVersionNotFoundGte: string;
+    nativeVersionNotFoundLte: string;
+    nativeVersionNotFoundMatch: string;
+    nativePackageIdNotFound: string;
+    noPackagesFound: string;
+    offset: string;
+    operationComplete: string;
+    operationSuccess: string;
+    packageIdRequired: string;
+    packageUploadSuccess: string;
+    depsChangeSummary: string;
+    depsChangeTargetPackage: string;
+    depsChangeDependencyHeader: string;
+    depsChangeVersionHeader: string;
+    depsChangeAddedLabel: string;
+    depsChangeRemovedLabel: string;
+    depsChangeChangedLabel: string;
+    depsChangeArrow: string;
+    depsChangeRiskWarning: string;
+    depsChangeFetchFailed: string;
+    depsChangeNonBlockingHint: string;
+    packing: string;
+    pausedStatus: string;
+    platform: string;
+    platformPrompt: string;
+    platformQuestion: string;
+    platformRequired: string;
+    pluginDetectionError: string;
+    pluginDetected: string;
+    ppkPackageGenerated: string;
+    processingError: string;
+    processingPackage: string;
+    processingStringPool: string;
+    publishUsage: string;
+    rnuVersionNotFound: string;
+    rolloutConfigSet: string;
+    rolloutRangeError: string;
+    runningHermesc: string;
+    sentryCliNotFound: string;
+    sentryReleaseCreated: string;
+    totalApps: string;
+    totalPackages: string;
+    typeStrings: string;
+    unsupportedPlatform: string;
+    uploadBundlePrompt: string;
+    uploadingSourcemap: string;
+    usageDiff: string;
+    usageParseApk: string;
+    usageParseAab: string;
+    usageExtractApk: string;
+    usageParseApp: string;
+    usageParseIpa: string;
+    usageUnderDevelopment: string;
+    usageUploadApk: string;
+    usageUploadAab: string;
+    usageUploadApp: string;
+    usageUploadIpa: string;
+    versionBind: string;
+    welcomeMessage: string;
+    versionNameQuestion: string;
+    versionDescriptionQuestion: string;
+    versionMetaInfoQuestion: string;
+    updateNativePackageQuestion: string;
+    unnamed: string;
+    dryRun: string;
+    usingCustomVersion: string;
+    confirmDeletePackage: string;
+    deletePackageSuccess: string;
+    deletePackageError: string;
+    usageDeletePackage: string;
+    deleteVersionSuccess: string;
+    deleteVersionError: string;
+    bundleFileNotFound: string;
+    diffPackageGenerated: string;
+    nodeBsdiffRequired: string;
+    nodeHdiffpatchRequired: string;
+    apkExtracted: string;
+};
+export default _default;