rn-update-cli 1.0.0

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

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * [INPUT]: 依赖通用 Zip 容器读取能力
+ * [OUTPUT]: 对外提供 AppParser，处理 macOS .app 包的通用归档边界
+ * [POS]: 应用包解析子域的轻量 fallback，实现与平台特定解析器一致的 parse 接口
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppParser = void 0;
+const zip_1 = require("./zip");
+class AppParser extends zip_1.Zip {
+    async parse() {
+        return {};
+    }
+}
+exports.AppParser = AppParser;

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

@@ -0,0 +1,21 @@
+/**
+ * [INPUT]: 依赖 AAB、APK、APP、IPA 四类平台包解析器与支持类型判定
+ * [OUTPUT]: 对外提供默认 AppInfoParser，按文件类型路由到具体解析器
+ * [POS]: 应用包解析子域的统一入口，隔离调用方与各平台归档格式差异
+ */
+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

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * [INPUT]: 依赖 AAB、APK、APP、IPA 四类平台包解析器与支持类型判定
+ * [OUTPUT]: 对外提供默认 AppInfoParser，按文件类型路由到具体解析器
+ * [POS]: 应用包解析子域的统一入口，隔离调用方与各平台归档格式差异
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const aab_1 = require("./aab");
+const apk_1 = require("./apk");
+const app_1 = require("./app");
+const ipa_1 = require("./ipa");
+const supportFileTypes = ['ipa', 'apk', 'app', 'aab'];
+class AppInfoParser {
+    file;
+    parser;
+    /**
+     * 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 ipa_1.IpaParser(this.file);
+                break;
+            case 'apk':
+                this.parser = new apk_1.ApkParser(this.file);
+                break;
+            case 'app':
+                this.parser = new app_1.AppParser(this.file);
+                break;
+            case 'aab':
+                this.parser = new aab_1.AabParser(this.file);
+                break;
+            default:
+                throw new Error('Unsupported parser file type.');
+        }
+    }
+    parse() {
+        return this.parser.parse();
+    }
+}
+exports.default = AppInfoParser;

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

@@ -0,0 +1,19 @@
+/**
+ * [INPUT]: 依赖 bplist/cgbi 解码、IPA ZIP、图标资源和平台元数据解析工具
+ * [OUTPUT]: 对外提供 IpaParser，提取 iOS 应用的版本、标识和图标信息
+ * [POS]: 应用包解析子域的 IPA 实现，兼容压缩 PNG 与 binary plist 变体
+ */
+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

@@ -0,0 +1,101 @@
+"use strict";
+/**
+ * [INPUT]: 依赖 bplist/cgbi 解码、IPA ZIP、图标资源和平台元数据解析工具
+ * [OUTPUT]: 对外提供 IpaParser，提取 iOS 应用的版本、标识和图标信息
+ * [POS]: 应用包解析子域的 IPA 实现，兼容压缩 PNG 与 binary plist 变体
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IpaParser = void 0;
+const parseBplist = require('bplist-parser').parseBuffer;
+const cgbiToPng = require('cgbi-to-png');
+const utils_1 = require("./utils");
+const zip_1 = require("./zip");
+const PlistName = /payload\/[^/]+?.app\/info.plist$/i;
+const ProvisionName = /payload\/.+?\.app\/embedded.mobileprovision/;
+let parsePlistPromise;
+function loadParsePlist() {
+    if (!parsePlistPromise) {
+        parsePlistPromise = Promise.resolve().then(async () => {
+            try {
+                return require('plist').parse;
+            }
+            catch (requireError) {
+                const importModule = new Function('specifier', 'return import(specifier)');
+                const plistModule = await importModule('plist');
+                const parsePlist = plistModule.parse ?? plistModule.default?.parse;
+                if (!parsePlist) {
+                    throw requireError;
+                }
+                return parsePlist;
+            }
+        });
+    }
+    return parsePlistPromise;
+}
+class IpaParser extends zip_1.Zip {
+    async parse() {
+        const parsePlist = await loadParsePlist();
+        const buffers = await this.getEntries([PlistName, ProvisionName]);
+        if (!buffers[PlistName]) {
+            throw new Error("Info.plist can't be found.");
+        }
+        const plistInfo = this._parsePlist(buffers[PlistName], parsePlist);
+        const provisionInfo = this._parseProvision(buffers[ProvisionName], parsePlist);
+        plistInfo.mobileProvision = provisionInfo;
+        const iconRegex = new RegExp((0, utils_1.findIpaIconPath)(plistInfo).toLowerCase());
+        const iconBuffer = await this.getEntry(iconRegex);
+        try {
+            plistInfo.icon = iconBuffer
+                ? (0, utils_1.getBase64FromBuffer)(cgbiToPng.revert(iconBuffer))
+                : null;
+        }
+        catch (err) {
+            if ((0, utils_1.isBrowser)()) {
+                plistInfo.icon = iconBuffer
+                    ? (0, utils_1.getBase64FromBuffer)(window.btoa(String.fromCharCode(...iconBuffer)))
+                    : null;
+            }
+            else {
+                plistInfo.icon = null;
+                console.warn('[Warning] failed to parse icon: ', err);
+            }
+        }
+        return plistInfo;
+    }
+    /**
+     * Parse plist
+     * @param {Buffer} buffer // plist file's buffer
+     */
+    _parsePlist(buffer, parsePlist) {
+        let result;
+        const bufferType = buffer[0];
+        if (bufferType === 60 || 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, parsePlist) {
+        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;
+    }
+}
+exports.IpaParser = IpaParser;

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

@@ -0,0 +1,49 @@
+/**
+ * [INPUT]: 依赖 bytebuffer 与 Android resources.arsc 二进制资源表格式
+ * [OUTPUT]: 对外提供 ResourceFinder，按资源标识解析包内字符串和图标引用
+ * [POS]: Android 资源解析底座，被 ApkParser/AabParser 消费，不负责 ZIP 生命周期
+ */
+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/resource-finder.js

@@ -0,0 +1,429 @@
+"use strict";
+/**
+ * [INPUT]: 依赖 bytebuffer 与 Android resources.arsc 二进制资源表格式
+ * [OUTPUT]: 对外提供 ResourceFinder，按资源标识解析包内字符串和图标引用
+ * [POS]: Android 资源解析底座，被 ApkParser/AabParser 消费，不负责 ZIP 生命周期
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceFinder = void 0;
+/**
+ * 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;
+class ResourceFinder {
+    valueStringPool = null;
+    typeStringPool = null;
+    keyStringPool = null;
+    packageId = 0;
+    responseMap = {};
+    entryMap = {};
+    /**
+     * 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);
+                const entryArr = 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);
+        }
+    }
+}
+exports.ResourceFinder = ResourceFinder;