@24i/smartapps-bigscreen-rnv-build-engine 0.0.2-alpha.1321 → 0.0.2-alpha.1323

package/engine/src/tasks/task.rnv.project.configure.js

@@ -0,0 +1,109 @@
+import { configurePlugins, overrideTemplatePlugins, resolvePluginDependants } from 'rnv/dist/core/pluginManager';
+import { chalk, logTask, logInfo } from 'rnv/dist/core/systemManager/logger';
+import { checkIsRenativeProject, generateRuntimeConfig } from 'rnv/dist/core/configManager';
+import { updateRenativeConfigs, configureRuntimeDefaults } from 'rnv/dist/core/runtimeManager';
+import { applyTemplate, checkIfTemplateConfigured, configureTemplateFiles, isTemplateInstalled } from 'rnv/dist/core/templateManager';
+import { fsExistsSync, fsMkdirSync } from 'rnv/dist/core/systemManager/fileutils';
+import { checkCrypto } from 'rnv/dist/core/systemManager/crypto';
+import { checkAndMigrateProject } from 'rnv/dist/core/projectManager/migrator';
+import { TASK_INSTALL, TASK_PROJECT_CONFIGURE, TASK_TEMPLATE_APPLY, TASK_APP_CONFIGURE, TASK_WORKSPACE_CONFIGURE, PARAMS } from 'rnv/dist/core/constants';
+import { checkAndCreateBabelConfig, copyRuntimeAssets, cleanPlaformAssets, checkAndCreateGitignore, versionCheck } from 'rnv/dist/core/projectManager';
+import { configureEngines, getEngineRunnerByPlatform } from 'rnv/dist/core/engineManager';
+import { executeTask, initializeTask, findSuitableTask } from 'rnv/dist/core/taskManager';
+import { replaceRelevantStringsInConfig } from '../utils/replaceRelevantStringsInConfig';
+import * as path from 'path';
+
+const patchEngineTemplatesPath = (c) => {
+    const engineTemplatesPath = path.join(process.cwd(), 'node_modules', '@24i', 'smartapps-bigscreen-rnv-build-engine', 'dist', 'templates');
+    const engine = getEngineRunnerByPlatform(c, c.platform);
+
+    engine.originalTemplatePlatformsDir = path.join(engineTemplatesPath, 'platforms');
+    engine.originalTemplateAssetsDir = path.join(engineTemplatesPath, 'assets');
+    engine.originalTemplatePlatformProjectDir = path.join(engineTemplatesPath, 'platforms', 'project');
+
+    c.paths.project.platformTemplatesDirs[c.platform] = engine.originalTemplatePlatformsDir;
+};
+
+export const taskRnvProjectConfigure = async (c, parentTask, originTask) => {
+    logTask('taskRnvProjectConfigure');
+
+    patchEngineTemplatesPath(c);
+
+    if (c.paths.project.builds.dir && !fsExistsSync(c.paths.project.builds.dir)) {
+        logInfo(`Creating folder ${c.paths.project.builds.dir} ...DONE`);
+        fsMkdirSync(c.paths.project.builds.dir);
+    }
+    await checkAndMigrateProject(c);
+    await updateRenativeConfigs(c);
+    await checkIsRenativeProject(c);
+    await executeTask(c, TASK_WORKSPACE_CONFIGURE, TASK_PROJECT_CONFIGURE, originTask);
+
+    if (c.program.only && !!parentTask) {
+        await configureRuntimeDefaults(c);
+        await executeTask(c, TASK_APP_CONFIGURE, TASK_PROJECT_CONFIGURE, originTask);
+        await generateRuntimeConfig(c);
+        return true;
+    }
+
+    await checkIfTemplateConfigured(c);
+    await executeTask(c, TASK_INSTALL, TASK_PROJECT_CONFIGURE, originTask);
+    await checkCrypto(c, parentTask, originTask);
+    await configureRuntimeDefaults(c);
+
+    if (originTask !== TASK_TEMPLATE_APPLY) {
+        if (c.runtime.requiresBootstrap || !isTemplateInstalled(c)) {
+            await applyTemplate(c);
+            // We'll have to install the template first and reset current engine
+            logInfo('Your template has been bootstraped. Command reset is required. RESTRATING...DONE');
+
+            const taskInstance = await findSuitableTask(c);
+            c.runtime.requiresBootstrap = false;
+            return initializeTask(c, taskInstance.task);
+        }
+        await applyTemplate(c);
+        await configureRuntimeDefaults(c);
+        await executeTask(c, TASK_INSTALL, TASK_PROJECT_CONFIGURE, originTask);
+        await executeTask(c, TASK_APP_CONFIGURE, TASK_PROJECT_CONFIGURE, originTask);
+        // IMPORTANT: configurePlugins must run after appConfig present to ensure merge of all configs/plugins
+        await versionCheck(c);
+        await configureEngines(c);
+        await resolvePluginDependants(c);
+        await configurePlugins(c);
+
+        await configureRuntimeDefaults(c);
+        if (!c.runtime.disableReset) {
+            if (c.program.resetHard) {
+                logInfo(
+                    `You passed ${chalk().white('-R, --resetHard')} argument. "${chalk().white('./platformAssets')}" will be cleaned up first`
+                );
+                await cleanPlaformAssets(c);
+            } else if (c.program.resetAssets) {
+                logInfo(
+                    `You passed ${chalk().white('-a, --resetAssets')} argument. "${chalk().white('./platformAssets')}" will be cleaned up first`
+                );
+                await cleanPlaformAssets(c);
+            }
+        }
+
+        await copyRuntimeAssets(c);
+        await configureTemplateFiles(c);
+        await checkAndCreateGitignore(c);
+        await checkAndCreateBabelConfig(c);
+        if (!c.buildConfig.platforms) {
+            await updateRenativeConfigs(c);
+        }
+        replaceRelevantStringsInConfig(c);
+        await generateRuntimeConfig(c);
+        await overrideTemplatePlugins(c);
+    }
+
+    return true;
+};
+
+export default {
+    description: 'Configure current project',
+    fn: taskRnvProjectConfigure,
+    task: TASK_PROJECT_CONFIGURE,
+    params: PARAMS.withBase(),
+    platforms: [],
+};

package/engine/src/tasks/task.rnv.start.js

@@ -0,0 +1,52 @@
+import open from 'better-opn';
+import { TaskManager, Constants, Logger, PlatformManager, Common, WebpackUtils } from 'rnv';
+import { enginePlatformList, enginePlatforms } from '../enginePlatforms';
+
+const { getConfigProp } = Common;
+const { logErrorPlatform } = PlatformManager;
+const { logTask, logError } = Logger;
+const { TASK_START, TASK_CONFIGURE, REMOTE_DEBUGGER_ENABLED_PLATFORMS, PARAMS } = Constants;
+const { runWebpackServer, waitForWebpack } = WebpackUtils;
+const { executeTask } = TaskManager;
+
+export const taskRnvStart = async (c, parentTask, originTask) => {
+    const { platform, runtime, program } = c;
+    const { port } = runtime;
+    const { hosted } = program;
+
+    logTask('taskRnvStart', `parent:${parentTask} port:${port} hosted:${!!hosted}`);
+
+    if (!parentTask) {
+        await executeTask(c, TASK_CONFIGURE, TASK_START, originTask);
+    }
+
+    if (hosted) {
+        waitForWebpack(c)
+            .then(() => open(`http://${c.runtime.localhost}:${port}/`))
+            .catch(logError);
+    }
+    const bundleAssets = getConfigProp(c, c.platform, 'bundleAssets');
+    const isWeinreEnabled = REMOTE_DEBUGGER_ENABLED_PLATFORMS.includes(platform) && !bundleAssets && !hosted;
+
+    switch (platform) {
+        case enginePlatforms.ENTONE:
+        case enginePlatforms.HBBTV:
+        case enginePlatforms.TIZEN:
+        case enginePlatforms.WEBOS:
+        case enginePlatforms.WEBTV:
+            return runWebpackServer(c, isWeinreEnabled);
+        default:
+            if (hosted) {
+                return logError('This platform does not support hosted mode', true);
+            }
+            return logErrorPlatform(c);
+    }
+};
+
+export default {
+    description: 'Starts bundler / server',
+    fn: taskRnvStart,
+    task: 'start',
+    params: PARAMS.withBase(PARAMS.withConfigure()),
+    platforms: enginePlatformList,
+};

package/engine/src/utils/forEachSupportedPlatformFlavour.js

@@ -0,0 +1,29 @@
+const getProgressMessage = (platforms, platformIndex, flavours, flavourIndex) => {
+    let string = `\nProcessing "${platforms[platformIndex]}" platform`;
+    string += ` (${platformIndex + 1}/${platforms.length})`;
+    string += ` and its "${flavours[flavourIndex]}" flavour`;
+    string += ` (${flavourIndex + 1}/${flavours.length})...`;
+
+    return string;
+};
+
+const forEachSupportedPlatformFlavour = (c, cb) => {
+
+    const processPlatformFlavours = (platform, platformIndex, platforms) => {
+
+        const processFlavour = (flavour, flavourIndex, flavours) => {
+            console.log(getProgressMessage(platforms, platformIndex, flavours, flavourIndex));
+            return cb({ platform, flavour, scheme: c.runtime.scheme });
+        };
+
+        const { supportedFlavours = [] } = c.buildConfig.platforms[platform]?.deploy || {};
+        supportedFlavours.forEach(processFlavour);
+    };
+
+    const { supportedPlatforms = [] } = c.buildConfig.defaults || {};
+    supportedPlatforms.forEach(processPlatformFlavours);
+};
+
+export {
+    forEachSupportedPlatformFlavour,
+};

package/engine/src/utils/getBaseConfig.js

@@ -0,0 +1,57 @@
+import fs from 'fs';
+import path from 'path';
+import * as ConfigManager from 'rnv/dist/core/configManager';
+import { replaceRelevantStringsInConfig } from './replaceRelevantStringsInConfig';
+
+export function isObject(item) {
+    return (item && typeof item === 'object' && !Array.isArray(item));
+}
+
+const mergeDeep = (target, ...sources) => {
+    if (!sources.length) return target;
+
+    const source = sources.shift();
+
+    if (isObject(target) && isObject(source)) {
+        Object.keys(source).forEach((key) => {
+            if (isObject(source[key])) {
+                if (!target[key]) Object.assign(target, { [key]: {} });
+                mergeDeep(target[key], source[key]);
+            } else {
+                Object.assign(target, { [key]: source[key] });
+            }
+        });
+    }
+
+    return mergeDeep(target, ...sources);
+};
+
+const mergeFileJsonIntoObject = (filePath = '', targetObject = {}) => {
+    const fileContentAsString = fs.readFileSync(filePath).toString();
+    const fileContentAsJSON = JSON.parse(fileContentAsString);
+    mergeDeep(targetObject, fileContentAsJSON);
+};
+
+const getBaseConfig = () => {
+    const c = ConfigManager.createRnvConfig({ ci: true }, process);
+
+    c.buildConfig = {};
+
+    const packageJsonfileContent = fs.readFileSync('package.json').toString();
+    c.files.project.package = JSON.parse(packageJsonfileContent)
+
+    // renative.json
+    mergeFileJsonIntoObject(c.paths.project.config, c.buildConfig);
+
+    // appConfigs/base/renative.json
+    const baseConfigPath = path.join(c.paths.project.appConfigBase.dir, 'renative.json');
+    mergeFileJsonIntoObject(baseConfigPath, c.buildConfig);
+
+    replaceRelevantStringsInConfig(c);
+
+    return c;
+};
+
+export {
+    getBaseConfig,
+};

package/engine/src/utils/getDeployLocations.js

@@ -0,0 +1,78 @@
+import fs from 'fs';
+import { getHbbTVDeployUrl } from '../tasks/deploy/hbbtv/deployHbbtv';
+import { resolveBaseUrl } from './resolveBaseUrl';
+import { resolveBuildVersion } from './resolveBuildVersion';
+
+const getBuildVersion = (c) => {
+    const { platform, runtime } = c;
+    const { scheme, appId } = runtime;
+
+    return resolveBuildVersion({
+        platform,
+        scheme,
+        appConfigId: appId,
+    });
+};
+
+const getSupportedPlatforms = (c) => {
+    const { supportedPlatforms = [] } = c.buildConfig.defaults || {};
+    return supportedPlatforms;
+};
+
+const getSupportedFlavoursForPlatform = (c, platformName) => {
+    const { supportedFlavours = [] } = c.buildConfig.platforms[platformName]?.deploy || {};
+    return supportedFlavours;
+};
+
+const makeOutputObject = (buildVersion = '') => ({
+    versions: {
+        [buildVersion]: {
+            platforms: {},
+        },
+    },
+});
+
+const makeUrls = (c, platformName, flavourName) => {
+    const isHbbTVPlatform = platformName === 'hbbtv';
+    const baseUrl = resolveBaseUrl({
+        platform: platformName,
+        scheme: c.runtime.scheme || '',
+        appConfigId: flavourName,
+    });
+    if (!baseUrl) return null;
+
+    const packageOutputDirPath = `platformBuilds/${flavourName}_${platformName}/output`;
+    const outputFilenameList = fs.readdirSync(packageOutputDirPath);
+    const packageFileName = outputFilenameList[0];
+
+    const packageUrl = packageFileName ? `${baseUrl}/build/${packageFileName}` : '';
+    const indexUrl = isHbbTVPlatform
+        ? getHbbTVDeployUrl(c, c.runtime.scheme, flavourName)
+        : `${baseUrl}/public/index.html`;
+
+    return { packageUrl, indexUrl };
+};
+
+const getDeployLocations = (c) => {
+    const buildVersion = getBuildVersion(c);
+    const output = makeOutputObject(buildVersion);
+    const outputPlatforms = output.versions[buildVersion].platforms;
+
+    const processPlatform = (platformName) => {
+        const processPlatformFlavour = (flavourName) => ({
+            [flavourName]: makeUrls(c, platformName, flavourName),
+        });
+
+        const outputPlatformData = getSupportedFlavoursForPlatform(c, platformName)
+            .map(processPlatformFlavour);
+        outputPlatforms[platformName] = Object.assign({}, ...outputPlatformData)
+    };
+
+    getSupportedPlatforms(c).forEach(processPlatform);
+
+    return output;
+};
+
+export {
+    getDeployLocations,
+};

package/engine/src/utils/getVersionOffset.js

@@ -0,0 +1,39 @@
+import { execSync } from 'child_process';
+
+const getCurrentGitBranchName = () => {
+    if (process.env.BRANCH) return process.env.BRANCH; // exported in Travis CI config
+
+    const gitCommand = 'git branch --show-current';
+    return execSync(gitCommand, { stdio: 'pipe' }).toString().trim();
+};
+
+const getMergedPullRequestsOffsetFromBranch = (branch) => {
+    const defaultValue = '';
+    const mergeTitleRegex = '^Merge pull request #'; // it's a default title for GitHub
+    const cmd = `git rev-list --count --merges --grep="${mergeTitleRegex}" HEAD ^origin/${branch}`;
+
+    try {
+        const diffCount = execSync(cmd, { stdio: 'pipe' }).toString().trim();
+        const diffCountNumeric = parseInt(diffCount, 10);
+
+        return diffCountNumeric > 0 ? String(diffCountNumeric) : defaultValue;
+    } catch (error) {
+        return defaultValue;
+    }
+};
+
+const getVersionOffset = (c) => {
+    const { branchNames = {} } = c.buildConfig?.common?.git || {};
+
+    switch (getCurrentGitBranchName()) {
+        case branchNames.dev:
+            return getMergedPullRequestsOffsetFromBranch(branchNames.dist);
+        case branchNames.rc:
+            return getMergedPullRequestsOffsetFromBranch(branchNames.dev);
+        default: return '';
+    }
+};
+
+export {
+    getVersionOffset,
+};

package/engine/src/utils/replaceRelevantStringsInConfig/index.js

@@ -0,0 +1 @@
+export { replaceRelevantStringsInConfig } from './replaceRelevantStringsInConfig';

package/engine/src/utils/replaceRelevantStringsInConfig/replaceRelevantStringsInConfig.js

@@ -0,0 +1,36 @@
+import { replaceTemplateString } from './replaceTemplateString';
+
+const processObject = (c, object, excludedPropsList = []) => {
+    if (!object) return;
+    const objectKeys = Object.keys(object);
+
+    const processStringValue = (string, objectKeyName) => {
+        const replacedString = replaceTemplateString(c, string);
+        if (replacedString !== string) {
+            object[objectKeyName] = replacedString;
+        }
+    };
+
+    objectKeys.forEach((key) => {
+        const keyValue = object[key];
+        if (typeof keyValue === 'string') {
+            processStringValue(keyValue, key);
+        } else if (typeof keyValue === 'object' && keyValue !== null) {
+            if (!excludedPropsList.includes(key)) {
+                processObject(c, keyValue);
+            }
+        }
+    });
+};
+
+const replaceRelevantStringsInConfig = (c) => {
+    const { defaults, common, platforms } = c.buildConfig;
+
+    processObject(c, defaults);
+    processObject(c, common, ['']);
+    processObject(c, platforms);
+};
+
+export {
+    replaceRelevantStringsInConfig,
+};

package/engine/src/utils/replaceRelevantStringsInConfig/replaceTemplateString.js

@@ -0,0 +1,70 @@
+import { Common } from 'rnv';
+import { getVersionOffset } from '../getVersionOffset';
+
+const { getConfigProp } = Common;
+
+const getValueFromConfigByStringPath = (c, stringPathToObjectProp = '') => {
+    const pathToPropList = stringPathToObjectProp.split('.');
+    const listLength = pathToPropList.length;
+    let currentPropValue = c;
+
+    try {
+        for (let i = 1; i < listLength; i++) { // i = 1 to skip processing parent (base) object
+            currentPropValue = currentPropValue[pathToPropList[i]];
+            if (currentPropValue === undefined) {
+                return null;
+            }
+        }
+        return currentPropValue;
+    } catch (error) {
+        return null;
+    }
+};
+
+const getValue = (c, stringInsideBracelets = '') => {
+    if (stringInsideBracelets.startsWith('c.')) {
+        return getValueFromConfigByStringPath(c, stringInsideBracelets);
+    }
+    if (stringInsideBracelets.startsWith('configProps.')) {
+        return getConfigProp(c, c.platform, stringInsideBracelets.replace('configProps.', ''));
+    }
+    if (stringInsideBracelets === 'BRANCH_COMMIT_OFFSET') {
+        return getVersionOffset(c);
+    }
+
+    return stringInsideBracelets;
+};
+
+const handleStringEnd = (string) => {
+    // string ends with "[[X]]" - instead X, there can be any char(s) except "[" and "]"
+    let outputString = string.replace(/\[\[[^[\]]+]]$/, '');
+
+    const matches = outputString.match(/\[\[[^[\]]+]]/g);
+    if (!matches || !matches.length) return outputString;
+
+    const getStringInside = (templateString = '') => templateString.slice(2, -2);
+    const removeBracelets = (match) => {
+        outputString = outputString.replace(match, getStringInside(match));
+    };
+    matches.forEach(removeBracelets);
+    return outputString;
+};
+
+const injectorStartMark = '{{';
+const injectorEndMark = '}}';
+const injectorRegexp = new RegExp(`${injectorStartMark}.*?${injectorEndMark}`, 'g');
+
+const replaceTemplateString = (c, string = '') => {
+    if (!string || typeof string !== 'string') return '';
+    const replacer = (match) => {
+        const stringInBracelets = match.slice(injectorStartMark.length, -injectorEndMark.length);
+        const value = getValue(c, stringInBracelets);
+        return value === match ? value : replaceTemplateString(c, value);
+    };
+    const parsedString = string.replace(injectorRegexp, replacer);
+    return handleStringEnd(parsedString);
+};
+
+export {
+    replaceTemplateString,
+};

package/engine/src/utils/resolveBaseUrl.js

@@ -0,0 +1,35 @@
+import { getBaseConfig } from './getBaseConfig';
+
+const resolveBaseUrl = ({ platform = '', scheme = '', appConfigId = '' }) => {
+    const c = getBaseConfig();
+    c.platform = platform;
+    c.runtime.scheme = scheme;
+    c.runtime.appConfigId = appConfigId;
+
+    const { packageVersion = '', deploy = {} } = c.buildConfig?.common || {};
+    const bucketName = deploy.aws3?.bucketName || '';
+
+    const bucketUrl = `http://${bucketName}.s3.amazonaws.com`;
+    const appFolderUrl = `${bucketUrl}/builds/${platform}/${appConfigId}`;
+
+    if (!packageVersion) {
+        return '';
+    }
+
+    switch (scheme) {
+        case 'dev:latest':
+            return `${appFolderUrl}/latest/dev`;
+        case 'rc:latest':
+            return `${appFolderUrl}/latest/rc`;
+        case 'release:latest':
+            return `${appFolderUrl}/latest/release`;
+        case 'release:dist':
+            return `${appFolderUrl}/dist/v${packageVersion}`;
+        default:
+            return '';
+    }
+};
+
+export {
+    resolveBaseUrl,
+};

package/engine/src/utils/resolveBuildVersion.js

@@ -0,0 +1,47 @@
+import { getBaseConfig } from './getBaseConfig';
+import { getVersionOffset } from './getVersionOffset';
+
+const resolvePackageVersion = (c) => c.buildConfig.common.packageVersion || '';
+
+const resolveBuildType = (c) => {
+    switch (c.runtime.scheme) {
+        case 'debug':
+            return '.debug';
+        case 'dev':
+        case 'dev:latest':
+            return '.dev';
+        case 'rc':
+        case 'rc:latest':
+            return '.rc';
+        case 'release':
+        case 'release:latest':
+        case 'release:dist':
+            return '';
+        default:
+            throw new Error(`resolveBuildType: scheme "${c.runtime.scheme}" is not defined!`);
+    }
+};
+
+const resolveVersionOffset = (c) => {
+    const versionOffsetString = getVersionOffset(c);
+    return versionOffsetString
+        ? `-${versionOffsetString}`
+        : '';
+};
+
+const resolveBuildVersion = ({ platform = '', scheme = '', appConfigId = '' }) => {
+    const c = getBaseConfig();
+    c.platform = platform;
+    c.runtime.scheme = scheme;
+    c.runtime.appConfigId = appConfigId;
+
+    const packageVersion = resolvePackageVersion(c);
+    const buildType = resolveBuildType(c);
+    const maybeGitCommitsOffset = resolveVersionOffset(c);
+
+    return `v${packageVersion}${buildType}${maybeGitCommitsOffset}`;
+};
+
+export {
+    resolveBuildVersion,
+};

package/engine/src/utils/zipBuildsByPlatforms.js

@@ -0,0 +1,70 @@
+import { mkdirSync, copyFileSync, rmdirSync } from 'fs';
+import { basename, dirname } from 'path';
+import { execSync } from 'child_process';
+import glob from 'glob';
+import { getConfigProp } from 'rnv/dist/core/common';
+
+const zipDir = (dir, outputFile) => execSync(`zip ${outputFile} -0 -j ${dir}/*`);
+
+const getPlatformBuildFileExtension = (platformName) => {
+    switch (platformName) {
+        case 'tizen': return 'wgt';
+        case 'webos': return 'ipk';
+        default: return 'zip';
+    }
+};
+
+const getPlatformBuildsPaths = (c, platformName) => {
+    const { platformBuildsDir } = c.buildConfig.paths;
+    const outputGlob = `${platformBuildsDir}/**/output`;
+    const platformBuildsGlob = `${outputGlob}/*.${getPlatformBuildFileExtension(platformName)}`;
+    const buildsPathsCandidates = glob.sync(platformBuildsGlob);
+
+    return buildsPathsCandidates.filter(
+        (path) => path.includes(platformName),
+    );
+};
+
+
+const getZippedPlatformBuildsFilePath = (c, platformName = '') => {
+    const { platformBuildsDir } = c.buildConfig.paths;
+    const zippedFilesParentDir = 'zipped_by_platform';
+    const appNameInFileName = getConfigProp(c, platformName, 'appNameInFileName', '');
+    const buildVersion = getConfigProp(c, platformName, 'packageVersion', '');
+    const fileExtension = 'zip';
+
+    const relativePathToDir = `${platformBuildsDir}/${zippedFilesParentDir}`;
+    const zipFileName = `${appNameInFileName}_${platformName}_${buildVersion}.${fileExtension}`;
+
+    return `${relativePathToDir}/${zipFileName}`;
+};
+
+const processPlatform = (c, platformName) => {
+    const platformBuildsPaths = getPlatformBuildsPaths(c, platformName);
+    if (platformBuildsPaths.length === 0) return;
+
+    const outputZipFilePath = getZippedPlatformBuildsFilePath(c, platformName);
+
+    const tempPlatformDir = `${dirname(outputZipFilePath)}/${platformName}`;
+    mkdirSync(tempPlatformDir, { recursive: true });
+
+    const copyBuildFileIntoTempPlatformDir = (buildFilePath) => {
+        const buildFileName = basename(buildFilePath);
+        const dest = `${tempPlatformDir}/${buildFileName}`;
+        copyFileSync(buildFilePath, dest);
+    };
+    platformBuildsPaths.forEach(copyBuildFileIntoTempPlatformDir);
+
+    zipDir(tempPlatformDir, outputZipFilePath);
+    rmdirSync(tempPlatformDir, { recursive: true });
+};
+
+const zipBuildsByPlatforms = (c) => {
+    const { supportedPlatforms = [] } = c.buildConfig.defaults || {};
+    supportedPlatforms.forEach((platformName) => processPlatform(c, platformName));
+};
+
+export {
+    zipBuildsByPlatforms,
+    getZippedPlatformBuildsFilePath,
+};

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@24i/smartapps-bigscreen-rnv-build-engine",
-  "version": "0.0.2-alpha.1321+d729a850",
+  "version": "0.0.2-alpha.1323+8a3de07d",
   "description": "",
   "main": "dist/src/index.js",
   "scripts": {
     "build:clean": "rm -rf dist",
-    "build:engine": "babel src -d dist/src --copy-files --include-dotfiles",
+    "build:engine": "babel engine/src -d dist/src --copy-files --include-dotfiles",
     "build:templates": "babel templates -d dist/templates --copy-files --include-dotfiles",
     "build": "npm run build:clean && npm run build:engine && npm run build:templates",
     "eslint": "eslint \"./src/**/*.{ts,tsx}\"",
@@ -28,6 +28,7 @@
     "glob": "7.1.7",
     "html-webpack-harddisk-plugin": "1.0.2",
     "html-webpack-plugin": "4.5.2",
+    "inquirer": "8.1.1",
     "mini-css-extract-plugin": "1.6.2",
     "node-ssh": "11.1.1",
     "raf": "3.4.1",
@@ -53,5 +54,5 @@
   "keywords": [],
   "author": "24i",
   "license": "ISC",
-  "gitHead": "d729a8504e74750ca6f92b2ce8229a07c5dd0b2a"
+  "gitHead": "8a3de07d684fab7b0e5524d8fe38a16397e59f77"
 }