react-native-update-cli 2.8.4 → 2.9.0

package/lib/utils/app-info-parser/index.d.ts

@@ -0,0 +1,16 @@
+import { AabParser } from './aab';
+import { ApkParser } from './apk';
+import { AppParser } from './app';
+import { IpaParser } from './ipa';
+type AppInfoInnerParser = AabParser | ApkParser | AppParser | IpaParser;
+declare class AppInfoParser {
+    file: string | File;
+    parser: AppInfoInnerParser;
+    /**
+     * parser for parsing .ipa or .apk file
+     * @param {String | File} file // file's path in Node, instance of File in Browser
+     */
+    constructor(file: string | File);
+    parse<T = unknown>(): Promise<T>;
+}
+export default AppInfoParser;

package/lib/utils/app-info-parser/index.js

@@ -48,6 +48,8 @@ class AppInfoParser {
             case 'aab':
                 this.parser = new _aab.AabParser(this.file);
                 break;
+            default:
+                throw new Error('Unsupported parser file type.');
         }
     }
 }

package/lib/utils/app-info-parser/ipa.d.ts

@@ -0,0 +1,14 @@
+import { Zip } from './zip';
+export declare class IpaParser extends Zip {
+    parse(): Promise<any>;
+    /**
+     * Parse plist
+     * @param {Buffer} buffer // plist file's buffer
+     */
+    private _parsePlist;
+    /**
+     * parse provision
+     * @param {Buffer} buffer // provision file's buffer
+     */
+    private _parseProvision;
+}

package/lib/utils/app-info-parser/ipa.js

@@ -55,7 +55,7 @@ class IpaParser extends _zip.Zip {
    */ _parsePlist(buffer) {
         let result;
         const bufferType = buffer[0];
-        if (bufferType === 60 || bufferType === '<' || bufferType === 239) {
+        if (bufferType === 60 || bufferType === 239) {
             result = parsePlist(buffer.toString());
         } else if (bufferType === 98) {
             result = parseBplist(buffer)[0];

package/lib/utils/app-info-parser/resource-finder.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Code translated from a C# project https://github.com/hylander0/Iteedee.ApkReader/blob/master/Iteedee.ApkReader/ApkResourceFinder.cs
+ *
+ * Decode binary file `resources.arsc` from a .apk file to a JavaScript Object.
+ */
+export declare class ResourceFinder {
+    private valueStringPool;
+    private typeStringPool;
+    private keyStringPool;
+    private packageId;
+    private responseMap;
+    private entryMap;
+    /**
+     * Same to C# BinaryReader.readBytes
+     *
+     * @param bb ByteBuffer
+     * @param len length
+     * @returns {Buffer}
+     */
+    static readBytes(bb: any, len: number): any;
+    /**
+     *
+     * @param {ByteBuffer} bb
+     * @return {Map<String, Set<String>>}
+     */
+    processResourceTable(resourceBuffer: Buffer): Record<string, any[]>;
+    /**
+     *
+     * @param {ByteBuffer} bb
+     */
+    private processPackage;
+    /**
+     *
+     * @param {ByteBuffer} bb
+     */
+    private processType;
+    /**
+     *
+     * @param {ByteBuffer} bb
+     * @return {Array}
+     */
+    private processStringPool;
+    /**
+     *
+     * @param {ByteBuffer} bb
+     */
+    private processTypeSpec;
+    private putIntoMap;
+}

package/lib/utils/app-info-parser/utils.d.ts

@@ -0,0 +1,31 @@
+declare const isArray: (value: unknown) => value is unknown[];
+declare const isObject: (value: unknown) => value is Record<string, unknown>;
+declare const isPrimitive: (value: unknown) => boolean;
+declare const isBrowser: () => boolean;
+/**
+ * map file place with resourceMap
+ * @param {Object} apkInfo // json info parsed from .apk file
+ * @param {Object} resourceMap // resourceMap
+ */
+declare const mapInfoResource: (apkInfo: Record<string, any>, resourceMap: Record<string, any>) => Record<string, any>;
+/**
+ * find .apk file's icon path from json info
+ * @param info // json info parsed from .apk file
+ */
+declare const findApkIconPath: (info: any) => string;
+/**
+ * find .ipa file's icon path from json info
+ * @param info // json info parsed from .ipa file
+ */
+declare const findIpaIconPath: (info: any) => any;
+/**
+ * transform buffer to base64
+ * @param {Buffer} buffer
+ */
+declare const getBase64FromBuffer: (buffer: Buffer | string) => string;
+/**
+ * 去除unicode空字符
+ * @param {String} str
+ */
+declare const decodeNullUnicode: (value: string | RegExp) => string | RegExp;
+export { isArray, isObject, isPrimitive, isBrowser, mapInfoResource, findApkIconPath, findIpaIconPath, getBase64FromBuffer, decodeNullUnicode, };

package/lib/utils/app-info-parser/utils.js

@@ -46,6 +46,7 @@ const isPrimitive = (value)=>value === null || [
         'string',
         'undefined'
     ].includes(objectType(value));
+const isBrowser = ()=>typeof window !== 'undefined' && typeof window.document !== 'undefined';
 /**
  * map file place with resourceMap
  * @param {Object} apkInfo // json info parsed from .apk file

package/lib/utils/app-info-parser/xml-parser/binary.d.ts

@@ -0,0 +1,56 @@
+type BinaryXmlParserOptions = {
+    debug?: boolean;
+};
+export declare class BinaryXmlParser {
+    buffer: Buffer;
+    cursor: number;
+    strings: string[];
+    resources: number[];
+    document: any;
+    parent: any;
+    stack: any[];
+    debug: boolean;
+    constructor(buffer: Buffer, options?: BinaryXmlParserOptions);
+    readU8(): number;
+    readU16(): number;
+    readS32(): number;
+    readU32(): number;
+    readLength8(): number;
+    readLength16(): number;
+    readDimension(): {
+        value: number | null;
+        unit: string | null;
+        rawUnit: number | null;
+    };
+    readFraction(): {
+        value: number | null;
+        type: string | null;
+        rawType: number | null;
+    };
+    readHex24(): string;
+    readHex32(): string;
+    readTypedValue(): {
+        value: any;
+        type: string | null;
+        rawType: number | null;
+    };
+    convertIntToFloat(int: number): number;
+    readString(encoding: string): string;
+    readChunkHeader(): {
+        startOffset: number;
+        chunkType: number;
+        headerSize: number;
+        chunkSize: number;
+    };
+    readStringPool(header: any): null;
+    readResourceMap(header: any): null;
+    readXmlNamespaceStart(): null;
+    readXmlNamespaceEnd(): null;
+    readXmlElementStart(): any;
+    readXmlAttribute(): any;
+    readXmlElementEnd(): null;
+    readXmlCData(): any;
+    readNull(header: any): null;
+    parse(): any;
+}
+export {};

package/lib/utils/app-info-parser/xml-parser/manifest.d.ts

@@ -0,0 +1,10 @@
+export declare class ManifestParser {
+    private buffer;
+    private xmlParser;
+    constructor(buffer: Buffer, options?: Record<string, any>);
+    private collapseAttributes;
+    private parseIntents;
+    private parseApplication;
+    private isLauncherActivity;
+    parse(): Record<string, any>;
+}

package/lib/utils/app-info-parser/zip.d.ts

@@ -0,0 +1,18 @@
+export declare class Zip {
+    file: string | File;
+    unzip: any;
+    constructor(file: string | File);
+    /**
+     * get entries by regexps, the return format is: { <filename>: <Buffer|Blob> }
+     * @param {Array} regexps // regexps for matching files
+     * @param {String} type // return type, can be buffer or blob, default buffer
+     */
+    getEntries(regexps: Array<RegExp | string>, type?: 'buffer' | 'blob'): Promise<Record<string, Buffer<ArrayBufferLike> | Blob>>;
+    /**
+     * get entry by regex, return an instance of Buffer or Blob
+     * @param {Regex} regex // regex for matching file
+     * @param {String} type // return type, can be buffer or blob, default buffer
+     */
+    getEntry(regex: RegExp | string, type?: 'buffer' | 'blob'): Promise<Buffer<ArrayBufferLike> | Blob | undefined>;
+    getEntryFromHarmonyApp(regex: RegExp): Promise<Buffer | Blob | undefined>;
+}

package/lib/utils/app-info-parser/zip.js

@@ -8,8 +8,8 @@ Object.defineProperty(exports, "Zip", {
         return Zip;
     }
 });
-const _utils = require("./utils");
 const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _utils = require("./utils");
 const _zipentries = require("../zip-entries");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
@@ -51,11 +51,12 @@ class Zip {
     async getEntryFromHarmonyApp(regex) {
         try {
             let originSource;
-            await (0, _zipentries.enumZipEntries)(this.file, (entry, zipFile)=>{
+            if (typeof this.file !== 'string') {
+                throw new Error('Param error: [file] must be file path in Node.');
+            }
+            await (0, _zipentries.enumZipEntries)(this.file, async (entry, zipFile)=>{
                 if (regex.test(entry.fileName)) {
-                    return (0, _zipentries.readEntry)(entry, zipFile).then((value)=>{
-                        originSource = value;
-                    });
+                    originSource = await (0, _zipentries.readEntry)(entry, zipFile);
                 }
             });
             return originSource;
@@ -64,10 +65,7 @@ class Zip {
         }
     }
     constructor(file){
-        if (typeof file !== 'string') {
-            throw new Error('Param error: [file] must be file path in Node.');
-        }
-        this.file = _path.default.resolve(file);
+        this.file = typeof file === 'string' ? _path.default.resolve(file) : file;
         this.unzip = new Unzip(this.file);
     }
 }

package/lib/utils/check-lockfile.d.ts

@@ -0,0 +1 @@
+export declare function checkLockFiles(): void;

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

@@ -0,0 +1,7 @@
+interface BundleParams {
+    sentry: boolean;
+    sourcemap: boolean;
+    [key: string]: any;
+}
+export declare function checkPlugins(): Promise<BundleParams>;
+export {};

package/lib/utils/command-result.d.ts

@@ -0,0 +1,3 @@
+import type { CommandResult } from '../types';
+export declare function toErrorMessage(error: unknown, fallback: string): string;
+export declare function runAsCommandResult<T>(task: () => Promise<T>, fallbackError: string, mapSuccess?: (result: T) => unknown): Promise<CommandResult>;

package/lib/utils/command-result.js

@@ -0,0 +1,35 @@
+"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, {
+    runAsCommandResult: function() {
+        return runAsCommandResult;
+    },
+    toErrorMessage: function() {
+        return toErrorMessage;
+    }
+});
+function toErrorMessage(error, fallback) {
+    return error instanceof Error ? error.message : fallback;
+}
+async function runAsCommandResult(task, fallbackError, mapSuccess) {
+    try {
+        const result = await task();
+        return {
+            success: true,
+            data: mapSuccess ? mapSuccess(result) : result
+        };
+    } catch (error) {
+        return {
+            success: false,
+            error: toErrorMessage(error, fallbackError)
+        };
+    }
+}

package/lib/utils/constants.d.ts

@@ -0,0 +1,9 @@
+export declare const scriptName: "cresc" | "pushy";
+export declare const IS_CRESC: boolean;
+export declare const ppkBundleFileNames: string[];
+export declare const isPPKBundleFileName: (fileName: string) => boolean;
+export declare const credentialFile: string;
+export declare const updateJson: string;
+export declare const tempDir: string;
+export declare const pricingPageUrl: string;
+export declare const defaultEndpoints: string[];

package/lib/utils/dep-versions.d.ts

@@ -0,0 +1 @@
+export declare const depVersions: Record<string, string>;

package/lib/utils/git.d.ts

@@ -0,0 +1,8 @@
+export interface CommitInfo {
+    hash: string;
+    message: string;
+    author: string;
+    timestamp: string;
+    origin: string;
+}
+export declare function getCommitInfo(): Promise<CommitInfo | undefined>;

package/lib/utils/http-helper.d.ts

@@ -0,0 +1,4 @@
+export declare function promiseAny<T>(promises: Promise<T>[]): Promise<T>;
+export declare const ping: (url: string) => Promise<string | null>;
+export declare const testUrls: (urls?: string[]) => Promise<string | null>;
+export declare const getBaseUrl: Promise<string>;

package/lib/utils/i18n.d.ts

@@ -0,0 +1,12 @@
+import en from '../locales/en';
+import zh from '../locales/zh';
+declare module 'i18next' {
+    interface CustomTypeOptions {
+        defaultNS: 'en';
+        resources: {
+            en: typeof en;
+            zh: typeof zh;
+        };
+    }
+}
+export declare function t(key: string, options?: any): string;

package/lib/utils/index.d.ts

@@ -0,0 +1,22 @@
+import { checkPlugins } from './check-plugin';
+export declare function question(query: string, password?: boolean): Promise<string>;
+export declare function translateOptions<T extends Record<string, unknown>>(options: T): T & Record<string, unknown>;
+export declare function getApkInfo(fn: string): Promise<{
+    versionName: string;
+    buildTime: number;
+}>;
+export declare function getAppInfo(fn: string): Promise<{
+    versionName: string | undefined;
+    buildTime: number;
+}>;
+export declare function getIpaInfo(fn: string): Promise<{
+    versionName: string;
+    buildTime: string;
+}>;
+export declare function getAabInfo(fn: string): Promise<{
+    versionName: string;
+    buildTime: number;
+}>;
+export declare function saveToLocal(originPath: string, destName: string): void;
+export declare function printVersionCommand(): Promise<void>;
+export { checkPlugins };

package/lib/utils/index.js

@@ -42,6 +42,7 @@ const _path = /*#__PURE__*/ _interop_require_default(require("path"));
 const _chalk = /*#__PURE__*/ _interop_require_default(require("chalk"));
 const _compareversions = require("compare-versions");
 const _fsextra = /*#__PURE__*/ _interop_require_default(require("fs-extra"));
+const _yauzl = require("yauzl");
 const _packagejson = /*#__PURE__*/ _interop_require_default(require("../../package.json"));
 const _latestversion = /*#__PURE__*/ _interop_require_default(require("./latest-version"));
 const _appinfoparser = /*#__PURE__*/ _interop_require_default(require("./app-info-parser"));
@@ -68,11 +69,18 @@ async function question(query, password) {
 function translateOptions(options) {
     const ret = {};
     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)=>{
+                var _options_name;
+                const replacement = (_options_name = options[name]) != null ? _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;
@@ -96,7 +104,12 @@ async function getApkInfo(fn) {
     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);
+                }
             }
         }
     }
@@ -131,7 +144,7 @@ async function getAppInfo(fn) {
     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((0, _i18n.t)('buildTimeNotFound'));
@@ -198,14 +211,25 @@ async function getAabInfo(fn) {
     let buildTime = 0;
     const appCredential = {};
     // Find application node
-    const applicationNode = manifestElement.child.find((c)=>c.element && c.element.name === 'application');
-    if (applicationNode) {
-        const metaDataNodes = applicationNode.element.child.filter((c)=>c.element && c.element.name === 'meta-data');
+    const applicationNode = manifestElement.child.find((child)=>{
+        var _child_element;
+        return ((_child_element = child.element) == null ? void 0 : _child_element.name) === 'application';
+    });
+    const applicationElement = applicationNode == null ? void 0 : applicationNode.element;
+    if (applicationElement) {
+        const metaDataNodes = applicationElement.child.filter((child)=>{
+            var _child_element;
+            return ((_child_element = child.element) == null ? void 0 : _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;
                 }
@@ -240,19 +264,24 @@ async function getAabInfo(fn) {
     };
 }
 async function readZipEntry(fn, entryName) {
-    const yauzl = require('yauzl');
     return new Promise((resolve, reject)=>{
-        yauzl.open(fn, {
+        (0, _yauzl.open)(fn, {
             lazyEntries: true
         }, (err, zipfile)=>{
-            if (err) return reject(err);
+            if (err || !zipfile) {
+                reject(err != null ? err : new Error('Failed to open zip file'));
+                return;
+            }
             let found = false;
             zipfile.readEntry();
             zipfile.on('entry', (entry)=>{
                 if (entry.fileName === entryName) {
                     found = true;
-                    zipfile.openReadStream(entry, (err, readStream)=>{
-                        if (err) return reject(err);
+                    zipfile.openReadStream(entry, (streamError, readStream)=>{
+                        if (streamError || !readStream) {
+                            reject(streamError != null ? streamError : new Error('Failed to read zip entry'));
+                            return;
+                        }
                         const chunks = [];
                         readStream.on('data', (chunk)=>chunks.push(chunk));
                         readStream.on('end', ()=>resolve(Buffer.concat(chunks)));
@@ -285,20 +314,21 @@ async function resolveResource(fn, resourceId, root) {
             arrays: true
         });
         // Find package
-        const pkg = object.package.find((p)=>p.packageId === pkgId);
+        const pkg = object.package.find((pkgItem)=>pkgItem.packageId === pkgId);
         if (!pkg) return null;
         // Find type
-        const type = pkg.type.find((t)=>t.typeId === typeId);
+        const type = pkg.type.find((typeItem)=>typeItem.typeId === typeId);
         if (!type) return null;
         // Find entry
-        const entry = type.entry.find((e)=>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) {
-            var _val_item;
-            const val = entry.configValue[0].value;
-            if ((_val_item = val.item) == null ? void 0 : _val_item.str) {
-                return val.item.str.value;
+            var _entry_configValue_, _val_item_str, _val_item;
+            const val = (_entry_configValue_ = entry.configValue[0]) == null ? void 0 : _entry_configValue_.value;
+            const stringValue = val == null ? void 0 : (_val_item = val.item) == null ? void 0 : (_val_item_str = _val_item.str) == null ? void 0 : _val_item_str.value;
+            if (typeof stringValue === 'string') {
+                return stringValue;
             }
         }
     } catch (e) {

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

@@ -0,0 +1 @@
+export {};