@algocare/react-native-code-push 12.6.3 → 13.0.0-rc.0

package/cli/dist/utils/fsUtils.js

@@ -0,0 +1,44 @@
+import fs from "fs";
+import path from "path";
+import { createRequire } from "module";
+const nodeRequire = createRequire(import.meta.url);
+/**
+ * allows to require a config file with .ts extension
+ */
+function requireConfig(filePath) {
+    const ext = path.extname(filePath);
+    if (ext === '.ts') {
+        try {
+            nodeRequire('ts-node/register');
+        }
+        catch {
+            console.error('ts-node not found. Please install ts-node as a devDependency.');
+            process.exit(1);
+        }
+    }
+    else if (ext === '.js') {
+        // do nothing
+    }
+    else {
+        throw new Error(`Unsupported file extension: ${ext}`);
+    }
+    return nodeRequire(filePath);
+}
+export function findAndReadConfigFile(startDir, configFileName) {
+    // If the default `code-push.config.ts` is not found, fall back to the compiled/plain-JS
+    // `code-push.config.js`. (algocare apps ship a JS config; an explicitly passed -c option is used as-is.)
+    const candidateFileNames = configFileName === 'code-push.config.ts'
+        ? [configFileName, 'code-push.config.js']
+        : [configFileName];
+    for (const candidate of candidateFileNames) {
+        let dir = startDir;
+        while (dir !== path.parse(dir).root) {
+            const configPath = path.join(dir, candidate);
+            if (fs.existsSync(configPath)) {
+                return requireConfig(configPath);
+            }
+            dir = path.dirname(dir);
+        }
+    }
+    throw new Error(`${configFileName} not found.`);
+}

package/cli/{utils → dist/utils}/hash-utils.js

@@ -1,165 +1,85 @@
 /**
  * code based on appcenter-cli
  */
-
 /**
  * NOTE!!! This utility file is duplicated for use by the CodePush service (for server-driven hashing/
  * integrity checks) and Management SDK (for end-to-end code signing), please keep them in sync.
  */
-
-const crypto = require('crypto');
-const fs = require('fs');
-const path = require('path');
-const { isDirectory } = require('./file-utils');
-const { walk } = require('./promisfied-fs');
-
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+import { isDirectory } from "./file-utils.js";
+import { walk } from "./promisfied-fs.js";
 // Do not throw an exception if either of these modules are missing, as they may not be needed by the
 // consumer of this file.
 const HASH_ALGORITHM = 'sha256';
 class PackageManifest {
-    /**
-     * @type {Map<string, string>}
-     * @private
-     */
     _map;
-
-    /**
-     * @param map {Map<string, string>?}
-     * @public
-     */
     constructor(map) {
         if (map == null) {
             map = new Map();
         }
         this._map = map;
     }
-
-    /**
-     * @return {Map<string, string>}
-     * @public
-     */
     toMap() {
         return this._map;
     }
-
-    /**
-     * @return {string}
-     * @public
-     */
     computePackageHash() {
-        /**
-         * @type {string[]}
-         */
         let entries = [];
         this._map.forEach((hash, name) => {
             entries.push(name + ':' + hash);
         });
-
         // Make sure this list is alphabetically ordered so that other clients
         // can also compute this hash easily given the update contents.
         entries = entries.sort();
-
         return crypto.createHash(HASH_ALGORITHM).update(JSON.stringify(entries)).digest('hex');
     }
-
-    /**
-     * @return {string}
-     * @public
-     */
     serialize() {
         const obj = {};
-
         this._map.forEach(function (value, key) {
             obj[key] = value;
         });
-
         return JSON.stringify(obj);
     }
-
-    /**
-     * @param filePath {string}
-     * @return {string}
-     * @public
-     */
     static normalizePath(filePath) {
         //replace all backslashes coming from cli running on windows machines by slashes
         return filePath.replace(/\\/g, '/');
     }
-
-    /**
-     * @param relativeFilePath {string}
-     * @return {boolean}
-     * @public
-     */
     static isIgnored(relativeFilePath) {
         const __MACOSX = '__MACOSX/';
         const DS_STORE = '.DS_Store';
-        const CODEPUSH_METADATA = '.codepushrelease';
-        return (
-            relativeFilePath.startsWith(__MACOSX) ||
+        return (relativeFilePath.startsWith(__MACOSX) ||
             relativeFilePath === DS_STORE ||
-            relativeFilePath.endsWith('/' + DS_STORE) ||
-            relativeFilePath === CODEPUSH_METADATA ||
-            relativeFilePath.endsWith('/' + CODEPUSH_METADATA)
-        );
+            relativeFilePath.endsWith('/' + DS_STORE));
     }
 }
-
-/**
- *
- * @param directoryPath {string}
- * @param basePath {string}
- * @return {Promise<string>}
- */
-async function generatePackageHashFromDirectory(directoryPath, basePath) {
+export async function generatePackageHashFromDirectory(directoryPath, basePath) {
     try {
         if (!isDirectory(directoryPath)) {
             throw new Error('Not a directory. Please either create a directory, or use hashFile().');
         }
-    } catch (error) {
+    }
+    catch (error) {
         throw new Error('Directory does not exist. Please either create a directory, or use hashFile().');
     }
-
     /**
      * @type {PackageManifest}
      */
     const manifest = await generatePackageManifestFromDirectory(directoryPath, basePath);
     return manifest.computePackageHash();
 }
-
-/**
- *
- * @param directoryPath {string}
- * @param basePath {string}
- * @return {Promise<PackageManifest>}
- */
 function generatePackageManifestFromDirectory(directoryPath, basePath) {
     // eslint-disable-next-line no-async-promise-executor
     return new Promise(async (resolve, reject) => {
-        /**
-         * @type {Map<string, string>}
-         */
         const fileHashesMap = new Map();
-
-        /**
-         * @type {string[]}
-         */
         const files = await walk(directoryPath);
-
         if (!files || files.length === 0) {
             reject('Error: Cannot sign the release because no files were found.');
             return;
         }
-
-        /**
-         * @type {Promise<void>}
-         */
         // Hash the files sequentially, because streaming them in parallel is not necessarily faster
         const generateManifestPromise = files.reduce((soFar, filePath) => {
             return soFar.then(() => {
-                /**
-                 * @type {string}
-                 */
                 const relativePath = PackageManifest.normalizePath(path.relative(basePath, filePath));
                 if (!PackageManifest.isIgnored(relativePath)) {
                     return hashFile(filePath).then((hash) => {
@@ -168,60 +88,29 @@ function generatePackageManifestFromDirectory(directoryPath, basePath) {
                 }
             });
         }, Promise.resolve(null));
-
         generateManifestPromise.then(() => {
             resolve(new PackageManifest(fileHashesMap));
         }, reject);
     });
 }
-
-/**
- *
- * @param filePath {string}
- * @return {Promise<string>}
- */
 function hashFile(filePath) {
-    /**
-     * @type {fs.ReadStream}
-     */
     const readStream = fs.createReadStream(filePath);
     return hashStream(readStream);
 }
-
-/**
- *
- * @param readStream {stream.Readable}
- * @return {Promise<string>}
- */
 function hashStream(readStream) {
     return new Promise((resolve, reject) => {
-        /**
-         * @type {stream.Transform}
-         */
-        const _hashStream = crypto.createHash(HASH_ALGORITHM)
-
+        const _hashStream = crypto.createHash(HASH_ALGORITHM);
         readStream
             .on('error', (error) => {
-                _hashStream.end();
-                reject(error);
-            })
+            _hashStream.end();
+            reject(error);
+        })
             .on('end', () => {
-                _hashStream.end();
-
-                /**
-                 * @type {Buffer}
-                 */
-                const buffer = _hashStream.read();
-                /**
-                 * @type {string}
-                 */
-                const hash = buffer.toString('hex');
-
-                resolve(hash);
-            });
-
+            _hashStream.end();
+            const buffer = _hashStream.read();
+            const hash = buffer.toString('hex');
+            resolve(hash);
+        });
         readStream.pipe(_hashStream);
     });
 }
-
-module.exports = { generatePackageHashFromDirectory };

package/cli/{utils → dist/utils}/promisfied-fs.js

@@ -1,29 +1,18 @@
 /**
  * code based on appcenter-cli
  */
-
-const { promises: fs } = require('fs');
-const path = require('path');
-
-/**
- *
- * @param dir {string}
- * @return {Promise<string[]>}
- */
-async function walk(dir) {
+import { promises as fs } from "fs";
+import path from "path";
+export async function walk(dir) {
     const stats = await fs.stat(dir);
     if (stats.isDirectory()) {
-        /**
-         * @type {string[]}
-         */
         let files = [];
         for (const file of await fs.readdir(dir)) {
             files = files.concat(await walk(path.join(dir, file)));
         }
         return files;
-    } else {
+    }
+    else {
         return [dir];
     }
 }
-
-module.exports = { walk };

package/cli/dist/utils/showLogo.js

@@ -0,0 +1,21 @@
+export function showLogo() {
+    const logo = `
+    
++------------------------------------------------------------------+
+|                                                                  |
+|             ______          __     ____             __           |
+|             / ____/___  ____/ /__  / __ \\__  _______/ /_         |
+|            / /   / __ \\/ __  / _ \\/ /_/ / / / / ___/ __ \\        |
+|           / /___/ /_/ / /_/ /  __/ ____/ /_/ (__  ) / / /        |
+|           \\____/\\____/\\__,_/\\___/_/    \\__,_/____/_/ /_/         |
+|                                                                  |
+|                                                                  |
+|              🚀 @bravemobile/react-native-code-push              |
++------------------------------------------------------------------+                                     
+
+Please refer to help command for more information.
+
+(interactive mode is not supported yet.)
+    `;
+    console.log(logo);
+}

package/cli/dist/utils/unzip.js

@@ -0,0 +1,41 @@
+import fs from "fs";
+import path from "path";
+import yauzl from "yauzl";
+export function unzip(zipPath, outputDir) {
+    return new Promise((resolve, reject) => {
+        yauzl.open(zipPath, { lazyEntries: true }, (err, zipFile) => {
+            if (err)
+                return reject(err);
+            zipFile.readEntry();
+            zipFile.on("entry", (entry) => {
+                const fullPath = path.join(outputDir, entry.fileName);
+                // Handle directory entry
+                if (/\/$/.test(entry.fileName)) {
+                    fs.mkdir(fullPath, { recursive: true }, (err) => {
+                        if (err)
+                            return reject(err);
+                        zipFile.readEntry();
+                    });
+                    return;
+                }
+                // Handle file entry
+                zipFile.openReadStream(entry, (err, readStream) => {
+                    if (err)
+                        return reject(err);
+                    fs.mkdir(path.dirname(fullPath), { recursive: true }, (err) => {
+                        if (err)
+                            return reject(err);
+                        const writeStream = fs.createWriteStream(fullPath);
+                        readStream.pipe(writeStream);
+                        // Continue to the next entry after writing
+                        writeStream.on("close", () => {
+                            zipFile.readEntry();
+                        });
+                    });
+                });
+            });
+            zipFile.on("end", resolve);
+            zipFile.on("error", reject);
+        });
+    });
+}

package/cli/{utils → dist/utils}/zip.js

@@ -1,30 +1,15 @@
 /**
  * code based on appcenter-cli
  */
-
-const fs = require('fs');
-const path = require('path');
-const yazl = require('yazl');
-const { generateRandomFilename, normalizePath, isDirectory } = require('./file-utils');
-const { walk } = require('./promisfied-fs');
-
-/**
- * @typedef {{ sourceLocation: string, targetLocation: string }} ReleaseFile
- */
-
-/**
- * @param updateContentsPath {string}
- * @return {Promise<string>}
- */
-function zip(updateContentsPath) {
-
+import fs from "fs";
+import path from "path";
+import yazl from "yazl";
+import { generateRandomFilename, normalizePath, isDirectory } from "./file-utils.js";
+import { walk } from "./promisfied-fs.js";
+export function zip(updateContentsPath) {
     // eslint-disable-next-line no-async-promise-executor
     return new Promise(async (resolve, reject) => {
-        /**
-         * @type {ReleaseFile[]}
-         */
         const releaseFiles = [];
-
         try {
             if (!isDirectory(updateContentsPath)) {
                 releaseFiles.push({
@@ -32,58 +17,37 @@ function zip(updateContentsPath) {
                     targetLocation: normalizePath(path.basename(updateContentsPath)), // Put the file in the root
                 });
             }
-        } catch (error) {
-            error.message = error.message + ' Make sure you have added the platform you are making a release to.`.';
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                error.message = error.message + " Make sure you have added the platform you are making a release to.`.";
+            }
             reject(error);
         }
-
-        /**
-         * @type {string}
-         */
         const directoryPath = updateContentsPath;
         const baseDirectoryPath = path.join(directoryPath, '..'); // For legacy reasons, put the root directory in the zip
-
-        /**
-         * @type {string[]}
-         */
         const files = await walk(updateContentsPath);
-
         files.forEach((filePath) => {
-            /**
-             * @type {string}
-             */
             const relativePath = path.relative(baseDirectoryPath, filePath);
             releaseFiles.push({
                 sourceLocation: filePath,
                 targetLocation: normalizePath(relativePath),
             });
         });
-
-        /**
-         * @type {string}
-         */
         const packagePath = path.join(process.cwd(), generateRandomFilename(15) + '.zip');
         const zipFile = new yazl.ZipFile();
-        /**
-         * @type {fs.WriteStream}
-         */
         const writeStream = fs.createWriteStream(packagePath);
-
         zipFile.outputStream
             .pipe(writeStream)
             .on('error', (error) => {
-                reject(error);
-            })
+            reject(error);
+        })
             .on('close', () => {
-                resolve(packagePath);
-            });
-
+            resolve(packagePath);
+        });
         releaseFiles.forEach((releaseFile) => {
             zipFile.addFile(releaseFile.sourceLocation, releaseFile.targetLocation);
         });
-
         zipFile.end();
     });
 }
-
-module.exports = zip;

package/cli/functions/{getReactTempDir.js → getReactTempDir.ts}

@@ -2,15 +2,11 @@
  * code based on appcenter-cli
  */
 
-const os = require('os');
+import os from "os";
 
 /**
  * Return the path of the temporary directory for react-native bundling
- *
- * @return {string}
  */
-function getReactTempDir() {
+export function getReactTempDir(): string {
     return `${os.tmpdir()}/react-*`;
 }
-
-module.exports = { getReactTempDir };

package/cli/functions/makeCodePushBundle.ts

@@ -0,0 +1,26 @@
+import path from "path";
+import shell from "shelljs";
+import { zip } from "../utils/zip.js";
+import { generatePackageHashFromDirectory } from "../utils/hash-utils.js";
+
+/**
+ * Create a CodePush bundle file and return the information.
+ *
+ * @param contentsPath {string} The directory path containing the contents to be made into a CodePush bundle (usually the 'build/CodePush' directory))
+ * @param bundleDirectory {string} The directory path to save the CodePush bundle file
+ * @return {Promise<{ bundleFileName: string }>}
+ */
+export async function makeCodePushBundle(contentsPath: string, bundleDirectory: string): Promise<{ bundleFileName: string }> {
+    const updateContentsZipPath = await zip(contentsPath);
+
+    const packageHash = await generatePackageHashFromDirectory(contentsPath, path.join(contentsPath, '..'));
+
+    shell.mkdir('-p', `./${bundleDirectory}`);
+    shell.mv(updateContentsZipPath, `./${bundleDirectory}/${packageHash}`);
+
+    return {
+        // To allow the "release" command to get the file and hash value from the result of the "bundle" command,
+        // use the hash value as the name of the file.
+        bundleFileName: packageHash,
+    };
+}

package/cli/functions/prepareToBundleJS.ts

@@ -0,0 +1,10 @@
+import shell from "shelljs";
+
+/**
+ * @param deleteDirs {string[]} Directories to delete
+ * @param makeDir {string} Directory path to create
+ */
+export function prepareToBundleJS({ deleteDirs, makeDir }: { deleteDirs: string[], makeDir: string }) {
+    shell.rm('-rf', deleteDirs);
+    shell.mkdir('-p', makeDir);
+}

package/cli/functions/runExpoBundleCommand.ts

@@ -0,0 +1,45 @@
+import path from "path";
+import shell from "shelljs";
+
+/**
+ * Run `expo bundle` CLI command
+ *
+ * @param bundleName {string} JS bundle file name
+ * @param entryFile {string} App code entry file name (default: index.ts)
+ * @param outputPath {string} Path to output JS bundle file and assets
+ * @param platform {string} Platform (ios | android)
+ * @param sourcemapOutput {string} Path to output sourcemap file (Warning: if sourcemapOutput points to the outputPath, the sourcemap will be included in the CodePush bundle and increase the deployment size)
+ * @return {void}
+ */
+export function runExpoBundleCommand(
+    bundleName: string,
+    outputPath: string,
+    platform: string,
+    sourcemapOutput: string,
+    entryFile: string,
+): void {
+    function getCliPath(): string {
+        return path.join('node_modules', '.bin', 'expo');
+    }
+
+    const expoBundleArgs: string[] = [
+        'export:embed',
+        '--assets-dest',
+        outputPath,
+        '--bundle-output',
+        path.join(outputPath, bundleName),
+        '--dev',
+        'false',
+        '--entry-file',
+        entryFile,
+        '--platform',
+        platform,
+        '--sourcemap-output',
+        sourcemapOutput,
+        '--reset-cache',
+    ];
+
+    console.log('Running "expo export:embed" command:\n');
+
+    shell.exec(`${getCliPath()} ${expoBundleArgs.join(' ')}`);
+}