react-native-update-cli 1.20.0 → 1.20.6

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

@@ -0,0 +1,224 @@
+'use strict';
+
+// From https://github.com/openstf/adbkit-apkreader
+const BinaryXmlParser = require('./binary');
+
+const INTENT_MAIN = 'android.intent.action.MAIN';
+const CATEGORY_LAUNCHER = 'android.intent.category.LAUNCHER';
+
+class ManifestParser {
+  constructor(buffer, options = {}) {
+    this.buffer = buffer;
+    this.xmlParser = new BinaryXmlParser(this.buffer, options);
+  }
+
+  collapseAttributes(element) {
+    const collapsed = Object.create(null);
+    for (let attr of Array.from(element.attributes)) {
+      collapsed[attr.name] = attr.typedValue.value;
+    }
+    return collapsed;
+  }
+
+  parseIntents(element, target) {
+    target.intentFilters = [];
+    target.metaData = [];
+
+    return element.childNodes.forEach(element => {
+      switch (element.nodeName) {
+        case 'intent-filter':
+          {
+            const intentFilter = this.collapseAttributes(element);
+
+            intentFilter.actions = [];
+            intentFilter.categories = [];
+            intentFilter.data = [];
+
+            element.childNodes.forEach(element => {
+              switch (element.nodeName) {
+                case 'action':
+                  intentFilter.actions.push(this.collapseAttributes(element));
+                  break;
+                case 'category':
+                  intentFilter.categories.push(this.collapseAttributes(element));
+                  break;
+                case 'data':
+                  intentFilter.data.push(this.collapseAttributes(element));
+                  break;
+              }
+            });
+
+            target.intentFilters.push(intentFilter);
+            break;
+          }
+        case 'meta-data':
+          target.metaData.push(this.collapseAttributes(element));
+          break;
+      }
+    });
+  }
+
+  parseApplication(element) {
+    const app = this.collapseAttributes(element);
+
+    app.activities = [];
+    app.activityAliases = [];
+    app.launcherActivities = [];
+    app.services = [];
+    app.receivers = [];
+    app.providers = [];
+    app.usesLibraries = [];
+    app.metaData = [];
+
+    element.childNodes.forEach(element => {
+      switch (element.nodeName) {
+        case 'activity':
+          {
+            const activity = this.collapseAttributes(element);
+            this.parseIntents(element, activity);
+            app.activities.push(activity);
+            if (this.isLauncherActivity(activity)) {
+              app.launcherActivities.push(activity);
+            }
+            break;
+          }
+        case 'activity-alias':
+          {
+            const activityAlias = this.collapseAttributes(element);
+            this.parseIntents(element, activityAlias);
+            app.activityAliases.push(activityAlias);
+            if (this.isLauncherActivity(activityAlias)) {
+              app.launcherActivities.push(activityAlias);
+            }
+            break;
+          }
+        case 'service':
+          {
+            const service = this.collapseAttributes(element);
+            this.parseIntents(element, service);
+            app.services.push(service);
+            break;
+          }
+        case 'receiver':
+          {
+            const receiver = this.collapseAttributes(element);
+            this.parseIntents(element, receiver);
+            app.receivers.push(receiver);
+            break;
+          }
+        case 'provider':
+          {
+            const provider = this.collapseAttributes(element);
+
+            provider.grantUriPermissions = [];
+            provider.metaData = [];
+            provider.pathPermissions = [];
+
+            element.childNodes.forEach(element => {
+              switch (element.nodeName) {
+                case 'grant-uri-permission':
+                  provider.grantUriPermissions.push(this.collapseAttributes(element));
+                  break;
+                case 'meta-data':
+                  provider.metaData.push(this.collapseAttributes(element));
+                  break;
+                case 'path-permission':
+                  provider.pathPermissions.push(this.collapseAttributes(element));
+                  break;
+              }
+            });
+
+            app.providers.push(provider);
+            break;
+          }
+        case 'uses-library':
+          app.usesLibraries.push(this.collapseAttributes(element));
+          break;
+        case 'meta-data':
+          app.metaData.push(this.collapseAttributes(element));
+          break;
+      }
+    });
+
+    return app;
+  }
+
+  isLauncherActivity(activity) {
+    return activity.intentFilters.some(function (filter) {
+      const hasMain = filter.actions.some(action => action.name === INTENT_MAIN);
+      if (!hasMain) {
+        return false;
+      }
+      return filter.categories.some(category => category.name === CATEGORY_LAUNCHER);
+    });
+  }
+
+  parse() {
+    const document = this.xmlParser.parse();
+    const manifest = this.collapseAttributes(document);
+
+    manifest.usesPermissions = [];
+    manifest.usesPermissionsSDK23 = [];
+    manifest.permissions = [];
+    manifest.permissionTrees = [];
+    manifest.permissionGroups = [];
+    manifest.instrumentation = null;
+    manifest.usesSdk = null;
+    manifest.usesConfiguration = null;
+    manifest.usesFeatures = [];
+    manifest.supportsScreens = null;
+    manifest.compatibleScreens = [];
+    manifest.supportsGlTextures = [];
+    manifest.application = Object.create(null);
+
+    document.childNodes.forEach(element => {
+      switch (element.nodeName) {
+        case 'uses-permission':
+          manifest.usesPermissions.push(this.collapseAttributes(element));
+          break;
+        case 'uses-permission-sdk-23':
+          manifest.usesPermissionsSDK23.push(this.collapseAttributes(element));
+          break;
+        case 'permission':
+          manifest.permissions.push(this.collapseAttributes(element));
+          break;
+        case 'permission-tree':
+          manifest.permissionTrees.push(this.collapseAttributes(element));
+          break;
+        case 'permission-group':
+          manifest.permissionGroups.push(this.collapseAttributes(element));
+          break;
+        case 'instrumentation':
+          manifest.instrumentation = this.collapseAttributes(element);
+          break;
+        case 'uses-sdk':
+          manifest.usesSdk = this.collapseAttributes(element);
+          break;
+        case 'uses-configuration':
+          manifest.usesConfiguration = this.collapseAttributes(element);
+          break;
+        case 'uses-feature':
+          manifest.usesFeatures.push(this.collapseAttributes(element));
+          break;
+        case 'supports-screens':
+          manifest.supportsScreens = this.collapseAttributes(element);
+          break;
+        case 'compatible-screens':
+          element.childNodes.forEach(screen => {
+            return manifest.compatibleScreens.push(this.collapseAttributes(screen));
+          });
+          break;
+        case 'supports-gl-texture':
+          manifest.supportsGlTextures.push(this.collapseAttributes(element));
+          break;
+        case 'application':
+          manifest.application = this.parseApplication(element);
+          break;
+      }
+    });
+
+    return manifest;
+  }
+}
+
+module.exports = ManifestParser;

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

@@ -0,0 +1,50 @@
+'use strict';
+
+const Unzip = require('isomorphic-unzip');
+const { isBrowser, decodeNullUnicode } = require('./utils');
+
+class Zip {
+  constructor(file) {
+    if (isBrowser()) {
+      if (!(file instanceof window.Blob || typeof file.size !== 'undefined')) {
+        throw new Error('Param error: [file] must be an instance of Blob or File in browser.');
+      }
+      this.file = file;
+    } else {
+      if (typeof file !== 'string') {
+        throw new Error('Param error: [file] must be file path in Node.');
+      }
+      this.file = require('path').resolve(file);
+    }
+    this.unzip = new Unzip(this.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, type = 'buffer') {
+    regexps = regexps.map(regex => decodeNullUnicode(regex));
+    return new Promise((resolve, reject) => {
+      this.unzip.getBuffer(regexps, { type }, (err, buffers) => {
+        err ? reject(err) : resolve(buffers);
+      });
+    });
+  }
+  /**
+   * 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, type = 'buffer') {
+    regex = decodeNullUnicode(regex);
+    return new Promise((resolve, reject) => {
+      this.unzip.getBuffer([regex], { type }, (err, buffers) => {
+        err ? reject(err) : resolve(buffers[regex]);
+      });
+    });
+  }
+}
+
+module.exports = Zip;

package/lib/utils/index.js

@@ -31,7 +31,7 @@ var _package = require('../../package.json');
 
 var _package2 = _interopRequireDefault(_package);
 
-var _appInfoParser = require('app-info-parser');
+var _appInfoParser = require('./app-info-parser');
 
 var _appInfoParser2 = _interopRequireDefault(_appInfoParser);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-update-cli",
-  "version": "1.20.0",
+  "version": "1.20.6",
   "description": "Command tools for javaScript updater with `pushy` service for react native apps.",
   "main": "index.js",
   "bin": {
@@ -31,7 +31,6 @@
   },
   "homepage": "https://github.com/reactnativecn/react-native-pushy/tree/master/react-native-pushy-cli",
   "dependencies": {
-    "app-info-parser": "^1.1.6",
     "cli-arguments": "^0.2.1",
     "filesize-parser": "^1.5.0",
     "fs-extra": "8",
@@ -56,10 +55,5 @@
   },
   "engines": {
     "node": ">= 10"
-  },
-  "pnpm": {
-    "patchedDependencies": {
-      "app-info-parser@1.1.6": "patches/app-info-parser@1.1.6.patch"
-    }
   }
 }

package/src/utils/app-info-parser/apk.js

@@ -0,0 +1,90 @@
+const Zip = require('./zip')
+const { mapInfoResource, findApkIconPath, getBase64FromBuffer } = require('./utils')
+const ManifestName = /^androidmanifest\.xml$/
+const ResourceName = /^resources\.arsc$/
+
+const ManifestXmlParser = require('./xml-parser/manifest')
+const ResourceFinder = require('./resource-finder')
+
+class ApkParser extends Zip {
+  /**
+   * parser for parsing .apk file
+   * @param {String | File | Blob} file // file's path in Node, instance of File or Blob in Browser
+   */
+  constructor (file) {
+    super(file)
+    if (!(this instanceof ApkParser)) {
+      return new ApkParser(file)
+    }
+  }
+  parse () {
+    return new Promise((resolve, reject) => {
+      this.getEntries([ManifestName, ResourceName]).then(buffers => {
+        if (!buffers[ManifestName]) {
+          throw new Error('AndroidManifest.xml can\'t be found.')
+        }
+        let apkInfo = this._parseManifest(buffers[ManifestName])
+        let resourceMap
+        if (!buffers[ResourceName]) {
+          resolve(apkInfo)
+        } else {
+          // parse resourceMap
+          resourceMap = this._parseResourceMap(buffers[ResourceName])
+          // update apkInfo with resourceMap
+          apkInfo = mapInfoResource(apkInfo, resourceMap)
+
+          // find icon path and parse icon
+          const iconPath = findApkIconPath(apkInfo)
+          if (iconPath) {
+            this.getEntry(iconPath).then(iconBuffer => {
+              apkInfo.icon = iconBuffer ? getBase64FromBuffer(iconBuffer) : null
+              resolve(apkInfo)
+            }).catch(e => {
+              apkInfo.icon = null
+              resolve(apkInfo)
+              console.warn('[Warning] failed to parse icon: ', e)
+            })
+          } else {
+            apkInfo.icon = null
+            resolve(apkInfo)
+          }
+        }
+      }).catch(e => {
+        reject(e)
+      })
+    })
+  }
+  /**
+   * Parse manifest
+   * @param {Buffer} buffer // manifest file's buffer
+   */
+  _parseManifest (buffer) {
+    try {
+      const parser = new ManifestXmlParser(buffer, {
+        ignore: [
+          'application.activity',
+          'application.service',
+          'application.receiver',
+          'application.provider',
+          'permission-group'
+        ]
+      })
+      return parser.parse()
+    } catch (e) {
+      throw new Error('Parse AndroidManifest.xml error: ', e)
+    }
+  }
+  /**
+   * Parse resourceMap
+   * @param {Buffer} buffer // resourceMap file's buffer
+   */
+  _parseResourceMap (buffer) {
+    try {
+      return new ResourceFinder().processResourceTable(buffer)
+    } catch (e) {
+      throw new Error('Parser resources.arsc error: ' + e)
+    }
+  }
+}
+
+module.exports = ApkParser

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

@@ -0,0 +1,35 @@
+const ApkParser = require('./apk')
+const IpaParser = require('./ipa')
+const supportFileTypes = ['ipa', 'apk']
+
+class AppInfoParser {
+  /**
+   * parser for parsing .ipa or .apk file
+   * @param {String | File | Blob} file // file's path in Node, instance of File or Blob in Browser
+   */
+  constructor (file) {
+    if (!file) {
+      throw new Error('Param miss: file(file\'s path in Node, instance of File or Blob in browser).')
+    }
+    const splits = (file.name || file).split('.')
+    const fileType = splits[splits.length - 1].toLowerCase()
+    if (!supportFileTypes.includes(fileType)) {
+      throw new Error('Unsupported file type, only support .ipa or .apk file.')
+    }
+    this.file = file
+
+    switch (fileType) {
+      case 'ipa':
+        this.parser = new IpaParser(this.file)
+        break
+      case 'apk':
+        this.parser = new ApkParser(this.file)
+        break
+    }
+  }
+  parse () {
+    return this.parser.parse()
+  }
+}
+
+module.exports = AppInfoParser

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

@@ -0,0 +1,92 @@
+const parsePlist = require('plist').parse
+const parseBplist = require('bplist-parser').parseBuffer
+const cgbiToPng = require('cgbi-to-png')
+
+const Zip = require('./zip')
+const { findIpaIconPath, getBase64FromBuffer, isBrowser } = require('./utils')
+
+const PlistName = new RegExp('payload/[^/]+?.app/info.plist$', 'i')
+const ProvisionName = /payload\/.+?\.app\/embedded.mobileprovision/
+
+class IpaParser extends Zip {
+  /**
+   * parser for parsing .ipa file
+   * @param {String | File | Blob} file // file's path in Node, instance of File or Blob in Browser
+   */
+  constructor (file) {
+    super(file)
+    if (!(this instanceof IpaParser)) {
+      return new IpaParser(file)
+    }
+  }
+  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])
+        // parse mobile provision
+        const provisionInfo = this._parseProvision(buffers[ProvisionName])
+        plistInfo.mobileProvision = provisionInfo
+
+        // find icon path and parse icon
+        const iconRegex = new RegExp(findIpaIconPath(plistInfo).toLowerCase())
+        this.getEntry(iconRegex).then(iconBuffer => {
+          try {
+            // In general, the ipa file's icon has been specially processed, should be converted
+            plistInfo.icon = iconBuffer ? getBase64FromBuffer(cgbiToPng.revert(iconBuffer)) : null
+          } catch (err) {
+            if (isBrowser()) {
+              // Normal conversion in other cases
+              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
+  }
+}
+
+module.exports = IpaParser