react-native-update-cli 2.7.1 → 2.7.2

package/lib/esm/utils/app-info-parser/index..mjs

@@ -0,0 +1,44 @@
+import { AabParser } from "./aab";
+import { ApkParser } from "./apk";
+import { AppParser } from "./app";
+import { IpaParser } from "./ipa";
+const supportFileTypes = [
+    'ipa',
+    'apk',
+    'app',
+    'aab'
+];
+class AppInfoParser {
+    parse() {
+        return this.parser.parse();
+    }
+    /**
+   * parser for parsing .ipa or .apk file
+   * @param {String | File} file // file's path in Node, instance of File in Browser
+   */ constructor(file){
+        if (!file) {
+            throw new Error("Param miss: file(file's path in Node, instance of File in browser).");
+        }
+        const splits = (typeof file === 'string' ? file : file.name).split('.');
+        const fileType = splits[splits.length - 1].toLowerCase();
+        if (!supportFileTypes.includes(fileType)) {
+            throw new Error('Unsupported file type, only support .ipa, .apk, .app, or .aab file.');
+        }
+        this.file = file;
+        switch(fileType){
+            case 'ipa':
+                this.parser = new IpaParser(this.file);
+                break;
+            case 'apk':
+                this.parser = new ApkParser(this.file);
+                break;
+            case 'app':
+                this.parser = new AppParser(this.file);
+                break;
+            case 'aab':
+                this.parser = new AabParser(this.file);
+                break;
+        }
+    }
+}
+export default AppInfoParser;

package/lib/esm/utils/app-info-parser/ipa..mjs

@@ -0,0 +1,73 @@
+const parsePlist = require('plist').parse;
+const parseBplist = require('bplist-parser').parseBuffer;
+const cgbiToPng = require('cgbi-to-png');
+import { findIpaIconPath, getBase64FromBuffer, isBrowser } from "./utils";
+import { Zip } from "./zip";
+const PlistName = /payload\/[^\/]+?.app\/info.plist$/i;
+const ProvisionName = /payload\/.+?\.app\/embedded.mobileprovision/;
+export class IpaParser extends Zip {
+    parse() {
+        return new Promise((resolve, reject)=>{
+            this.getEntries([
+                PlistName,
+                ProvisionName
+            ]).then((buffers)=>{
+                if (!buffers[PlistName]) {
+                    throw new Error("Info.plist can't be found.");
+                }
+                const plistInfo = this._parsePlist(buffers[PlistName]);
+                const provisionInfo = this._parseProvision(buffers[ProvisionName]);
+                plistInfo.mobileProvision = provisionInfo;
+                const iconRegex = new RegExp(findIpaIconPath(plistInfo).toLowerCase());
+                this.getEntry(iconRegex).then((iconBuffer)=>{
+                    try {
+                        plistInfo.icon = iconBuffer ? getBase64FromBuffer(cgbiToPng.revert(iconBuffer)) : null;
+                    } catch (err) {
+                        if (isBrowser()) {
+                            plistInfo.icon = iconBuffer ? getBase64FromBuffer(window.btoa(String.fromCharCode(...iconBuffer))) : null;
+                        } else {
+                            plistInfo.icon = null;
+                            console.warn('[Warning] failed to parse icon: ', err);
+                        }
+                    }
+                    resolve(plistInfo);
+                }).catch((e)=>{
+                    reject(e);
+                });
+            }).catch((e)=>{
+                reject(e);
+            });
+        });
+    }
+    /**
+   * Parse plist
+   * @param {Buffer} buffer // plist file's buffer
+   */ _parsePlist(buffer) {
+        let result;
+        const bufferType = buffer[0];
+        if (bufferType === 60 || bufferType === '<' || bufferType === 239) {
+            result = parsePlist(buffer.toString());
+        } else if (bufferType === 98) {
+            result = parseBplist(buffer)[0];
+        } else {
+            throw new Error('Unknown plist buffer type.');
+        }
+        return result;
+    }
+    /**
+   * parse provision
+   * @param {Buffer} buffer // provision file's buffer
+   */ _parseProvision(buffer) {
+        let info = {};
+        if (buffer) {
+            let content = buffer.toString('utf-8');
+            const firstIndex = content.indexOf('<?xml');
+            const endIndex = content.indexOf('</plist>');
+            content = content.slice(firstIndex, endIndex + 8);
+            if (content) {
+                info = parsePlist(content);
+            }
+        }
+        return info;
+    }
+}

package/lib/esm/utils/app-info-parser/resource-finder..mjs

@@ -0,0 +1,401 @@
+/**
+ * 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.
+ */ const ByteBuffer = require('bytebuffer');
+const DEBUG = false;
+const RES_STRING_POOL_TYPE = 0x0001;
+const RES_TABLE_TYPE = 0x0002;
+const RES_TABLE_PACKAGE_TYPE = 0x0200;
+const RES_TABLE_TYPE_TYPE = 0x0201;
+const RES_TABLE_TYPE_SPEC_TYPE = 0x0202;
+const TYPE_REFERENCE = 0x01;
+const TYPE_STRING = 0x03;
+export class ResourceFinder {
+    /**
+   * Same to C# BinaryReader.readBytes
+   *
+   * @param bb ByteBuffer
+   * @param len length
+   * @returns {Buffer}
+   */ static readBytes(bb, len) {
+        const uint8Array = new Uint8Array(len);
+        for(let i = 0; i < len; i++){
+            uint8Array[i] = bb.readUint8();
+        }
+        return ByteBuffer.wrap(uint8Array, 'binary', true);
+    }
+    /**
+   *
+   * @param {ByteBuffer} bb
+   * @return {Map<String, Set<String>>}
+   */ processResourceTable(resourceBuffer) {
+        const bb = ByteBuffer.wrap(resourceBuffer, 'binary', true);
+        const type = bb.readShort();
+        const headerSize = bb.readShort();
+        const size = bb.readInt();
+        const packageCount = bb.readInt();
+        let buffer;
+        let bb2;
+        if (type !== RES_TABLE_TYPE) {
+            throw new Error('No RES_TABLE_TYPE found!');
+        }
+        if (size !== bb.limit) {
+            throw new Error('The buffer size not matches to the resource table size.');
+        }
+        bb.offset = headerSize;
+        let realStringPoolCount = 0;
+        let realPackageCount = 0;
+        while(true){
+            let pos = 0;
+            let t = 0;
+            let hs = 0;
+            let s = 0;
+            try {
+                pos = bb.offset;
+                t = bb.readShort();
+                hs = bb.readShort();
+                s = bb.readInt();
+            } catch (e) {
+                break;
+            }
+            if (t === RES_STRING_POOL_TYPE) {
+                if (realStringPoolCount === 0) {
+                    if (DEBUG) {
+                        console.log('Processing the string pool ...');
+                    }
+                    buffer = new ByteBuffer(s);
+                    bb.offset = pos;
+                    bb.prependTo(buffer);
+                    bb2 = ByteBuffer.wrap(buffer, 'binary', true);
+                    bb2.LE();
+                    this.valueStringPool = this.processStringPool(bb2);
+                }
+                realStringPoolCount++;
+            } else if (t === RES_TABLE_PACKAGE_TYPE) {
+                if (DEBUG) {
+                    console.log(`Processing the package ${realPackageCount} ...`);
+                }
+                buffer = new ByteBuffer(s);
+                bb.offset = pos;
+                bb.prependTo(buffer);
+                bb2 = ByteBuffer.wrap(buffer, 'binary', true);
+                bb2.LE();
+                this.processPackage(bb2);
+                realPackageCount++;
+            } else {
+                throw new Error('Unsupported type');
+            }
+            bb.offset = pos + s;
+            if (!bb.remaining()) break;
+        }
+        if (realStringPoolCount !== 1) {
+            throw new Error('More than 1 string pool found!');
+        }
+        if (realPackageCount !== packageCount) {
+            throw new Error('Real package count not equals the declared count.');
+        }
+        return this.responseMap;
+    }
+    /**
+   *
+   * @param {ByteBuffer} bb
+   */ processPackage(bb) {
+        const type = bb.readShort();
+        const headerSize = bb.readShort();
+        const size = bb.readInt();
+        const id = bb.readInt();
+        void type;
+        void size;
+        this.packageId = id;
+        for(let i = 0; i < 256; ++i){
+            bb.readUint8();
+        }
+        const typeStrings = bb.readInt();
+        const lastPublicType = bb.readInt();
+        const keyStrings = bb.readInt();
+        const lastPublicKey = bb.readInt();
+        void lastPublicType;
+        void lastPublicKey;
+        if (typeStrings !== headerSize) {
+            throw new Error('TypeStrings must immediately following the package structure header.');
+        }
+        if (DEBUG) {
+            console.log('Type strings:');
+        }
+        let lastPosition = bb.offset;
+        bb.offset = typeStrings;
+        const bbTypeStrings = ResourceFinder.readBytes(bb, bb.limit - bb.offset);
+        bb.offset = lastPosition;
+        this.typeStringPool = this.processStringPool(bbTypeStrings);
+        if (DEBUG) {
+            console.log('Key strings:');
+        }
+        bb.offset = keyStrings;
+        const keyType = bb.readShort();
+        const keyHeaderSize = bb.readShort();
+        const keySize = bb.readInt();
+        void keyType;
+        void keyHeaderSize;
+        lastPosition = bb.offset;
+        bb.offset = keyStrings;
+        const bbKeyStrings = ResourceFinder.readBytes(bb, bb.limit - bb.offset);
+        bb.offset = lastPosition;
+        this.keyStringPool = this.processStringPool(bbKeyStrings);
+        let typeSpecCount = 0;
+        let typeCount = 0;
+        bb.offset = keyStrings + keySize;
+        let bb2;
+        while(true){
+            const pos = bb.offset;
+            try {
+                const t = bb.readShort();
+                const hs = bb.readShort();
+                const s = bb.readInt();
+                void hs;
+                if (t === RES_TABLE_TYPE_SPEC_TYPE) {
+                    bb.offset = pos;
+                    bb2 = ResourceFinder.readBytes(bb, s);
+                    this.processTypeSpec(bb2);
+                    typeSpecCount++;
+                } else if (t === RES_TABLE_TYPE_TYPE) {
+                    bb.offset = pos;
+                    bb2 = ResourceFinder.readBytes(bb, s);
+                    this.processType(bb2);
+                    typeCount++;
+                }
+                if (s === 0) {
+                    break;
+                }
+                bb.offset = pos + s;
+                if (!bb.remaining()) {
+                    break;
+                }
+            } catch (e) {
+                break;
+            }
+        }
+        void typeSpecCount;
+        void typeCount;
+    }
+    /**
+   *
+   * @param {ByteBuffer} bb
+   */ processType(bb) {
+        const type = bb.readShort();
+        const headerSize = bb.readShort();
+        const size = bb.readInt();
+        const id = bb.readByte();
+        const res0 = bb.readByte();
+        const res1 = bb.readShort();
+        const entryCount = bb.readInt();
+        const entriesStart = bb.readInt();
+        void type;
+        void size;
+        void res0;
+        void res1;
+        const refKeys = {};
+        const configSize = bb.readInt();
+        void configSize;
+        bb.offset = headerSize;
+        if (headerSize + entryCount * 4 !== entriesStart) {
+            throw new Error('HeaderSize, entryCount and entriesStart are not valid.');
+        }
+        const entryIndices = new Array(entryCount);
+        for(let i = 0; i < entryCount; ++i){
+            entryIndices[i] = bb.readInt();
+        }
+        for(let i = 0; i < entryCount; ++i){
+            if (entryIndices[i] === -1) continue;
+            const resourceId = this.packageId << 24 | id << 16 | i;
+            let entrySize = 0;
+            let entryFlag = 0;
+            let entryKey = 0;
+            try {
+                entrySize = bb.readShort();
+                entryFlag = bb.readShort();
+                entryKey = bb.readInt();
+            } catch (e) {
+                break;
+            }
+            void entrySize;
+            const FLAG_COMPLEX = 0x0001;
+            if ((entryFlag & FLAG_COMPLEX) === 0) {
+                const valueSize = bb.readShort();
+                const valueRes0 = bb.readByte();
+                const valueDataType = bb.readByte();
+                const valueData = bb.readInt();
+                void valueSize;
+                void valueRes0;
+                const idStr = Number(resourceId).toString(16);
+                const keyStr = this.keyStringPool ? this.keyStringPool[entryKey] : '';
+                let data = null;
+                if (DEBUG) {
+                    console.log(`Entry 0x${idStr}, key: ${keyStr}, simple value type: `);
+                }
+                const key = Number.parseInt(idStr, 16);
+                var _this_entryMap_key;
+                const entryArr = (_this_entryMap_key = this.entryMap[key]) != null ? _this_entryMap_key : [];
+                entryArr.push(keyStr);
+                this.entryMap[key] = entryArr;
+                if (valueDataType === TYPE_STRING) {
+                    data = this.valueStringPool ? this.valueStringPool[valueData] : null;
+                    if (DEBUG && this.valueStringPool) {
+                        console.log(`, data: ${this.valueStringPool[valueData]}`);
+                    }
+                } else if (valueDataType === TYPE_REFERENCE) {
+                    refKeys[idStr] = valueData;
+                } else {
+                    data = `${valueData}`;
+                    if (DEBUG) {
+                        console.log(`, data: ${valueData}`);
+                    }
+                }
+                this.putIntoMap(`@${idStr}`, data);
+            } else {
+                const entryParent = bb.readInt();
+                const entryCountValue = bb.readInt();
+                void entryParent;
+                for(let j = 0; j < entryCountValue; ++j){
+                    const refName = bb.readInt();
+                    const valueSize = bb.readShort();
+                    const valueRes0 = bb.readByte();
+                    const valueDataType = bb.readByte();
+                    const valueData = bb.readInt();
+                    void refName;
+                    void valueSize;
+                    void valueRes0;
+                    void valueDataType;
+                    void valueData;
+                }
+                if (DEBUG) {
+                    const keyStr = this.keyStringPool ? this.keyStringPool[entryKey] : '';
+                    console.log(`Entry 0x${Number(resourceId).toString(16)}, key: ${keyStr}, complex value, not printed.`);
+                }
+            }
+        }
+        for(const refKey in refKeys){
+            const values = this.responseMap[`@${Number(refKeys[refKey]).toString(16).toUpperCase()}`];
+            if (values != null && Object.keys(values).length < 1000) {
+                for (const value of values){
+                    this.putIntoMap(`@${refKey}`, value);
+                }
+            }
+        }
+    }
+    /**
+   *
+   * @param {ByteBuffer} bb
+   * @return {Array}
+   */ processStringPool(bb) {
+        const type = bb.readShort();
+        const headerSize = bb.readShort();
+        const size = bb.readInt();
+        const stringCount = bb.readInt();
+        const styleCount = bb.readInt();
+        const flags = bb.readInt();
+        const stringsStart = bb.readInt();
+        const stylesStart = bb.readInt();
+        void type;
+        void headerSize;
+        void size;
+        void styleCount;
+        void stylesStart;
+        const isUtf8 = (flags & 256) !== 0;
+        const offsets = new Array(stringCount);
+        for(let i = 0; i < stringCount; ++i){
+            offsets[i] = bb.readInt();
+        }
+        const strings = new Array(stringCount);
+        for(let i = 0; i < stringCount; ++i){
+            const pos = stringsStart + offsets[i];
+            bb.offset = pos;
+            strings[i] = '';
+            if (isUtf8) {
+                let u16len = bb.readUint8();
+                if ((u16len & 0x80) !== 0) {
+                    u16len = ((u16len & 0x7f) << 8) + bb.readUint8();
+                }
+                let u8len = bb.readUint8();
+                if ((u8len & 0x80) !== 0) {
+                    u8len = ((u8len & 0x7f) << 8) + bb.readUint8();
+                }
+                if (u8len > 0) {
+                    const buffer = ResourceFinder.readBytes(bb, u8len);
+                    try {
+                        strings[i] = ByteBuffer.wrap(buffer, 'utf8', true).toString('utf8');
+                    } catch (e) {
+                        if (DEBUG) {
+                            console.error(e);
+                            console.log('Error when turning buffer to utf-8 string.');
+                        }
+                    }
+                } else {
+                    strings[i] = '';
+                }
+            } else {
+                let u16len = bb.readUint16();
+                if ((u16len & 0x8000) !== 0) {
+                    u16len = ((u16len & 0x7fff) << 16) + bb.readUint16();
+                }
+                if (u16len > 0) {
+                    const len = u16len * 2;
+                    const buffer = ResourceFinder.readBytes(bb, len);
+                    try {
+                        strings[i] = ByteBuffer.wrap(buffer, 'utf8', true).toString('utf8');
+                    } catch (e) {
+                        if (DEBUG) {
+                            console.error(e);
+                            console.log('Error when turning buffer to utf-8 string.');
+                        }
+                    }
+                }
+            }
+            if (DEBUG) {
+                console.log('Parsed value: {0}', strings[i]);
+            }
+        }
+        return strings;
+    }
+    /**
+   *
+   * @param {ByteBuffer} bb
+   */ processTypeSpec(bb) {
+        const type = bb.readShort();
+        const headerSize = bb.readShort();
+        const size = bb.readInt();
+        const id = bb.readByte();
+        const res0 = bb.readByte();
+        const res1 = bb.readShort();
+        const entryCount = bb.readInt();
+        void type;
+        void headerSize;
+        void size;
+        void res0;
+        void res1;
+        if (DEBUG && this.typeStringPool) {
+            console.log(`Processing type spec ${this.typeStringPool[id - 1]}...`);
+        }
+        const flags = new Array(entryCount);
+        for(let i = 0; i < entryCount; ++i){
+            flags[i] = bb.readInt();
+        }
+    }
+    putIntoMap(resId, value) {
+        const key = resId.toUpperCase();
+        if (this.responseMap[key] == null) {
+            this.responseMap[key] = [];
+        }
+        if (value) {
+            this.responseMap[key].push(value);
+        }
+    }
+    constructor(){
+        this.valueStringPool = null;
+        this.typeStringPool = null;
+        this.keyStringPool = null;
+        this.packageId = 0;
+        this.responseMap = {};
+        this.entryMap = {};
+    }
+}

package/lib/esm/utils/app-info-parser/utils..mjs

@@ -0,0 +1,121 @@
+const objectType = (value)=>Object.prototype.toString.call(value).slice(8, -1).toLowerCase();
+const isArray = (value)=>objectType(value) === 'array';
+const isObject = (value)=>objectType(value) === 'object';
+const isPrimitive = (value)=>value === null || [
+        'boolean',
+        'number',
+        'string',
+        'undefined'
+    ].includes(objectType(value));
+const isBrowser = ()=>typeof process === 'undefined' || Object.prototype.toString.call(process) !== '[object process]';
+/**
+ * map file place with resourceMap
+ * @param {Object} apkInfo // json info parsed from .apk file
+ * @param {Object} resourceMap // resourceMap
+ */ const mapInfoResource = (apkInfo, resourceMap)=>{
+    const iteratorObj = (obj)=>{
+        for(const i in obj){
+            if (isArray(obj[i])) {
+                iteratorArray(obj[i]);
+            } else if (isObject(obj[i])) {
+                iteratorObj(obj[i]);
+            } else if (isPrimitive(obj[i])) {
+                if (isResources(obj[i])) {
+                    obj[i] = resourceMap[transKeyToMatchResourceMap(obj[i])];
+                }
+            }
+        }
+    };
+    const iteratorArray = (array)=>{
+        const l = array.length;
+        for(let i = 0; i < l; i++){
+            if (isArray(array[i])) {
+                iteratorArray(array[i]);
+            } else if (isObject(array[i])) {
+                iteratorObj(array[i]);
+            } else if (isPrimitive(array[i])) {
+                if (isResources(array[i])) {
+                    array[i] = resourceMap[transKeyToMatchResourceMap(array[i])];
+                }
+            }
+        }
+    };
+    const isResources = (attrValue)=>{
+        if (!attrValue) return false;
+        const value = typeof attrValue === 'string' ? attrValue : attrValue.toString();
+        return value.indexOf('resourceId:') === 0;
+    };
+    const transKeyToMatchResourceMap = (resourceId)=>`@${resourceId.replace('resourceId:0x', '').toUpperCase()}`;
+    iteratorObj(apkInfo);
+    return apkInfo;
+};
+/**
+ * find .apk file's icon path from json info
+ * @param info // json info parsed from .apk file
+ */ const findApkIconPath = (info)=>{
+    if (!info.application.icon || !info.application.icon.splice) {
+        return '';
+    }
+    const rulesMap = {
+        mdpi: 48,
+        hdpi: 72,
+        xhdpi: 96,
+        xxdpi: 144,
+        xxxhdpi: 192
+    };
+    const resultMap = {};
+    const maxDpiIcon = {
+        dpi: 120,
+        icon: ''
+    };
+    for(const i in rulesMap){
+        info.application.icon.some((icon)=>{
+            if (icon && icon.indexOf(i) !== -1) {
+                resultMap[`application-icon-${rulesMap[i]}`] = icon;
+                return true;
+            }
+            return false;
+        });
+        if (resultMap[`application-icon-${rulesMap[i]}`] && rulesMap[i] >= maxDpiIcon.dpi) {
+            maxDpiIcon.dpi = rulesMap[i];
+            maxDpiIcon.icon = resultMap[`application-icon-${rulesMap[i]}`];
+        }
+    }
+    if (Object.keys(resultMap).length === 0 || !maxDpiIcon.icon) {
+        maxDpiIcon.dpi = 120;
+        maxDpiIcon.icon = info.application.icon[0] || '';
+        resultMap['applicataion-icon-120'] = maxDpiIcon.icon;
+    }
+    return maxDpiIcon.icon;
+};
+/**
+ * find .ipa file's icon path from json info
+ * @param info // json info parsed from .ipa file
+ */ const findIpaIconPath = (info)=>{
+    var _info_CFBundleIcons_CFBundlePrimaryIcon_CFBundleIconFiles, _info_CFBundleIcons_CFBundlePrimaryIcon, _info_CFBundleIcons, _info_CFBundleIconFiles;
+    if ((_info_CFBundleIcons = info.CFBundleIcons) == null ? void 0 : (_info_CFBundleIcons_CFBundlePrimaryIcon = _info_CFBundleIcons.CFBundlePrimaryIcon) == null ? void 0 : (_info_CFBundleIcons_CFBundlePrimaryIcon_CFBundleIconFiles = _info_CFBundleIcons_CFBundlePrimaryIcon.CFBundleIconFiles) == null ? void 0 : _info_CFBundleIcons_CFBundlePrimaryIcon_CFBundleIconFiles.length) {
+        return info.CFBundleIcons.CFBundlePrimaryIcon.CFBundleIconFiles[info.CFBundleIcons.CFBundlePrimaryIcon.CFBundleIconFiles.length - 1];
+    }
+    if ((_info_CFBundleIconFiles = info.CFBundleIconFiles) == null ? void 0 : _info_CFBundleIconFiles.length) {
+        return info.CFBundleIconFiles[info.CFBundleIconFiles.length - 1];
+    }
+    return '.app/Icon.png';
+};
+/**
+ * transform buffer to base64
+ * @param {Buffer} buffer
+ */ const getBase64FromBuffer = (buffer)=>{
+    const base64 = typeof buffer === 'string' ? buffer : buffer.toString('base64');
+    return `data:image/png;base64,${base64}`;
+};
+/**
+ * 去除unicode空字符
+ * @param {String} str
+ */ const decodeNullUnicode = (value)=>{
+    if (typeof value === 'string') {
+        // biome-ignore lint/suspicious/noControlCharactersInRegex: <explanation>
+        return value.replace(/\u0000/g, '');
+    }
+    return value;
+};
+export { isArray, isObject, isPrimitive, isBrowser, mapInfoResource, findApkIconPath, findIpaIconPath, getBase64FromBuffer, decodeNullUnicode };