@24i/bigscreen-sdk 1.0.16 → 1.0.17-alpha.2324

package/packages/rnv-build-engine/dist/src/scripts/releaseAllWithScheme.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const forEachSupportedPlatformFlavour_1 = require("../utils/forEachSupportedPlatformFlavour");
+const resolvers_1 = require("../resolvers");
+const zipBuildsByPlatforms_1 = require("../utils/zipBuildsByPlatforms");
+const deleteSourceMaps_1 = require("./release/deleteSourceMaps");
+const deployToAppCenter_1 = require("./release/deployToAppCenter");
+const githubRelease_1 = require("./release/githubRelease");
+const notifySlack_1 = require("./release/notifySlack/notifySlack");
+const sentryRelease_1 = require("./release/sentryRelease");
+const constants_1 = require("../constants");
+const deployTask = (options) => {
+    const { scheme, platform, flavour } = options;
+    const cmd = `npx rnv deploy -s ${scheme} -p ${platform} -c ${flavour} --ci --only`;
+    (0, child_process_1.execSync)(cmd, { stdio: 'inherit' });
+};
+const deployBuilds = (c) => {
+    console.log('Deploying the builds...');
+    (0, forEachSupportedPlatformFlavour_1.forEachSupportedPlatformFlavour)(c, deployTask);
+    return true;
+};
+const doLatestDevelopmentRelease = (c) => {
+    console.log('doLatestDevelopmentRelease');
+    return deployBuilds(c);
+};
+const doLatestReleaseCandidateRelease = (c) => {
+    console.log('doLatestReleaseCandidateRelease');
+    deployBuilds(c);
+    (0, notifySlack_1.notifySlack)(c);
+    return true;
+};
+const doLatestRelease = (c) => {
+    console.log('doLatestRelease');
+    return deployBuilds(c);
+};
+const doDistributionRelease = (c) => {
+    console.log('doDistributionRelease');
+    (0, zipBuildsByPlatforms_1.zipBuildsByPlatforms)(c);
+    deployBuilds(c);
+    (0, sentryRelease_1.sentryRelease)(c);
+    (0, deleteSourceMaps_1.deleteSourceMaps)(c);
+    (0, githubRelease_1.githubRelease)(c);
+    (0, deployToAppCenter_1.deployToAppCenter)(c);
+    (0, notifySlack_1.notifySlack)(c);
+    return true;
+};
+const releaseAllWithScheme = () => {
+    const scheme = process.argv[2];
+    if (!scheme) {
+        throw new Error('No scheme name to use found! Please use rnv scheme name as a param.');
+    }
+    const c = (0, resolvers_1.getBaseConfig)();
+    c.runtime.scheme = scheme;
+    switch (scheme) {
+        case constants_1.BuildSchemes.DEV_LATEST:
+            doLatestDevelopmentRelease(c);
+            break;
+        case constants_1.BuildSchemes.RC_LATEST:
+            doLatestReleaseCandidateRelease(c);
+            break;
+        case constants_1.BuildSchemes.RELEASE_LATEST:
+            doLatestRelease(c);
+            break;
+        case constants_1.BuildSchemes.RELEASE_DIST:
+            doDistributionRelease(c);
+            break;
+        default:
+            throw new Error('Unsupported scheme to release!');
+    }
+    const spacing = 4;
+    console.log(JSON.stringify((0, resolvers_1.resolveDeployLocations)(c), null, spacing));
+    return true;
+};
+const startTimestamp = Date.now();
+releaseAllWithScheme();
+const msPerSecond = 1000;
+const scriptTotalTimeInSeconds = Math.ceil((Date.now() - startTimestamp) / msPerSecond);
+console.log(`buildAllWithScheme: done in ${scriptTotalTimeInSeconds} second(s)!`);

package/packages/rnv-build-engine/dist/src/scripts/utils/cmdUtils.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmdSyncTrimOut = exports.cmdSyncPipeOut = exports.cmdSyncInheritOut = exports.cmdSync = void 0;
+const child_process_1 = require("child_process");
+const cmdSync = (command, options) => (0, child_process_1.execSync)(command, options);
+exports.cmdSync = cmdSync;
+const cmdSyncInheritOut = (command) => cmdSync(command, { stdio: 'inherit' });
+exports.cmdSyncInheritOut = cmdSyncInheritOut;
+const cmdSyncPipeOut = (command) => cmdSync(command, { stdio: 'pipe' });
+exports.cmdSyncPipeOut = cmdSyncPipeOut;
+const cmdSyncTrimOut = (command) => cmdSync(command).toString().trim();
+exports.cmdSyncTrimOut = cmdSyncTrimOut;

package/packages/rnv-build-engine/dist/src/scripts/utils/fsUtils.js

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDir = exports.assertPath = exports.getFileContentAsString = void 0;
+const fs = __importStar(require("fs"));
+const assert_1 = require("assert");
+const getFileContentAsString = (filePath) => fs.readFileSync(filePath).toString();
+exports.getFileContentAsString = getFileContentAsString;
+const assertPath = (path) => {
+    const errorMsg = `File or path ${path} does not exist!`;
+    (0, assert_1.ok)(fs.existsSync(path), errorMsg);
+};
+exports.assertPath = assertPath;
+const isDir = (verifiedPath) => (fs.existsSync(verifiedPath) && fs.lstatSync(verifiedPath).isDirectory());
+exports.isDir = isDir;

package/packages/rnv-build-engine/dist/src/scripts/utils/generateIcons.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateIcons = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const generatePngSpriteMap_1 = require("../../utils/generatePngSpriteMap");
+const generateSvgSpriteMap_1 = require("../../utils/generateSvgSpriteMap");
+const mergeSvgAndPngIcons_1 = require("../../utils/mergeSvgAndPngIcons");
+const resolvers_1 = require("../../resolvers");
+const createPlatformAssetsFolders = (c) => {
+    const rnvBuildDirPath = `${c.paths.project.builds.dir}/${c.runtime.appId}_${c.platform}`;
+    const platformAssetsPath = path_1.default.resolve(rnvBuildDirPath, '../../platformAssets');
+    const runtimePath = path_1.default.resolve(rnvBuildDirPath, '../../platformAssets/runtime');
+    fs_1.default.mkdirSync(platformAssetsPath, { recursive: true });
+    fs_1.default.mkdirSync(runtimePath, { recursive: true });
+};
+const generateIcons = async (c) => {
+    console.log('generateIcons - started');
+    const cc = c || (0, resolvers_1.getBaseConfig)();
+    createPlatformAssetsFolders(cc);
+    await (0, generatePngSpriteMap_1.generatePngSpriteMap)(cc);
+    (0, generateSvgSpriteMap_1.generateSvgSpriteMap)(cc);
+    (0, mergeSvgAndPngIcons_1.mergeSvgAndPngIcons)(cc);
+    console.log('generateIcons - finished');
+};
+exports.generateIcons = generateIcons;

package/packages/rnv-build-engine/dist/src/scripts/utils/gitUtils.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertRemoteBranch = exports.assertCurrentBranch = exports.assertEmptyStatusList = exports.push = exports.commit = exports.createBranch = exports.checkout = exports.add = exports.addAll = exports.pull = exports.remoteBranchExists = exports.pullRequest = exports.getCurrentBranchName = exports.statusList = void 0;
+const assert_1 = require("assert");
+const cmdUtils_1 = require("./cmdUtils");
+const stringUtils_1 = require("./stringUtils");
+const statusList = () => {
+    const gitCmd = 'git status --porcelain';
+    const outputString = (0, cmdUtils_1.cmdSyncTrimOut)(gitCmd);
+    if (!outputString)
+        return [];
+    const handleMultipleWhitespaces = (rowString) => {
+        const spaceChar = ' ';
+        const parts = rowString.split(spaceChar);
+        return parts.filter(Boolean).join(spaceChar);
+    };
+    return (0, stringUtils_1.splitByNewLine)(outputString).map(handleMultipleWhitespaces);
+};
+exports.statusList = statusList;
+const getCurrentBranchName = () => (0, cmdUtils_1.cmdSyncTrimOut)('git branch --show-current');
+exports.getCurrentBranchName = getCurrentBranchName;
+const pullRequest = (fromBranch, toBranch, prTitle) => {
+    const cmdTool = 'hub';
+    const installDocUrl = 'https://github.com/github/hub#installation';
+    const errorMsg = `${cmdTool} is not installed! See ${installDocUrl}\n`;
+    try {
+        const toolPath = (0, cmdUtils_1.cmdSyncTrimOut)(`${cmdTool} --version`);
+        (0, assert_1.ok)(toolPath, errorMsg);
+    }
+    catch (error) {
+        throw new Error(errorMsg);
+    }
+    const cmd = `${cmdTool} pull-request -m "${prTitle}" --head ${fromBranch} --base ${toBranch}`;
+    (0, cmdUtils_1.cmdSyncInheritOut)(cmd);
+};
+exports.pullRequest = pullRequest;
+const remoteBranchExists = (expectedBranchName) => {
+    const gitCmd = `git ls-remote --heads origin ${expectedBranchName}`;
+    const output = (0, cmdUtils_1.cmdSyncTrimOut)(gitCmd);
+    return Boolean(output);
+};
+exports.remoteBranchExists = remoteBranchExists;
+const pull = () => (0, cmdUtils_1.cmdSyncPipeOut)('git remote update -p && git merge --ff-only @{u}');
+exports.pull = pull;
+const addAll = () => (0, cmdUtils_1.cmdSyncPipeOut)('git add --all');
+exports.addAll = addAll;
+const add = (fileList) => (0, cmdUtils_1.cmdSyncPipeOut)(`git add ${fileList.join(' ')}`);
+exports.add = add;
+const checkout = (branchName) => (0, cmdUtils_1.cmdSyncPipeOut)(`git checkout ${branchName}`);
+exports.checkout = checkout;
+const createBranch = (branchName) => (0, cmdUtils_1.cmdSyncPipeOut)(`git branch ${branchName}`);
+exports.createBranch = createBranch;
+const commit = (commitMessage, noVerify) => {
+    const maybeNoVerifyParam = noVerify ? '--no-verify' : '';
+    return (0, cmdUtils_1.cmdSyncPipeOut)(`git commit -m "${commitMessage}" ${maybeNoVerifyParam}`.trimEnd());
+};
+exports.commit = commit;
+const push = (branchName, noVerify) => {
+    const maybeNoVerifyParam = noVerify ? '--no-verify' : '';
+    const cmd = `git push --set-upstream origin ${branchName} ${maybeNoVerifyParam}`.trimEnd();
+    return (0, cmdUtils_1.cmdSyncPipeOut)(cmd);
+};
+exports.push = push;
+const assertEmptyStatusList = () => {
+    (0, assert_1.ok)(statusList().length === 0, 'An empty GIT stage is expected!');
+};
+exports.assertEmptyStatusList = assertEmptyStatusList;
+const assertCurrentBranch = (expectedBranchName) => {
+    const currentGitBranchName = getCurrentBranchName();
+    const errorMsg = `The ${expectedBranchName} branch is expected to be active, not "${currentGitBranchName}"`;
+    (0, assert_1.ok)(currentGitBranchName === expectedBranchName, errorMsg);
+};
+exports.assertCurrentBranch = assertCurrentBranch;
+const assertRemoteBranch = (expectedBranchName) => {
+    const errorMsg = `Remote branch ${expectedBranchName} does not exist!`;
+    (0, assert_1.ok)(remoteBranchExists(expectedBranchName), errorMsg);
+};
+exports.assertRemoteBranch = assertRemoteBranch;

package/packages/rnv-build-engine/dist/src/scripts/utils/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateIcons = exports.stringUtils = exports.gitUtils = exports.fsUtils = exports.cmdUtils = void 0;
+exports.cmdUtils = __importStar(require("./cmdUtils"));
+exports.fsUtils = __importStar(require("./fsUtils"));
+exports.gitUtils = __importStar(require("./gitUtils"));
+exports.stringUtils = __importStar(require("./stringUtils"));
+exports.generateIcons = __importStar(require("./generateIcons"));

package/packages/rnv-build-engine/dist/src/scripts/utils/stringUtils.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitByNewLine = void 0;
+const splitByNewLine = (string = '') => string.split(/\r?\n/);
+exports.splitByNewLine = splitByNewLine;

package/packages/rnv-build-engine/dist/src/sdks/index.js

@@ -0,0 +1,42 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handlePlatformSdk = exports.SDKXbox = exports.SDKWebpack = exports.SDKTizen = exports.SDKWebos = void 0;
+const constants_1 = require("../constants");
+const SDKWebos = __importStar(require("./sdk-webos"));
+exports.SDKWebos = SDKWebos;
+const SDKTizen = __importStar(require("./sdk-tizen"));
+exports.SDKTizen = SDKTizen;
+const SDKWebpack = __importStar(require("./sdk-webpack"));
+exports.SDKWebpack = SDKWebpack;
+const SDKXbox = __importStar(require("./sdk-xbox"));
+exports.SDKXbox = SDKXbox;
+const handlePlatformSdk = async (c) => {
+    switch (c.platform) {
+        case constants_1.Platforms.TIZEN:
+            return SDKTizen.handleTizenSdk(c);
+        case constants_1.Platforms.WEBOS:
+            return SDKWebos.handleWebosSdk(c);
+        default:
+            return true;
+    }
+};
+exports.handlePlatformSdk = handlePlatformSdk;

package/packages/rnv-build-engine/dist/src/sdks/sdk-tizen/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./sdkTizen"), exports);

package/packages/rnv-build-engine/dist/src/sdks/sdk-tizen/sdkTizen.js

@@ -0,0 +1,240 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTizen = exports.handleTizenSdk = exports.configureTizenProject = exports.configureTizenGlobal = exports.buildTizenProject = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const semver = __importStar(require("semver"));
+const child_process_1 = require("child_process");
+const rnv_1 = require("rnv");
+const sdk_webpack_1 = require("@rnv/sdk-webpack");
+const sdk_utils_1 = require("../sdk-utils");
+const constants_1 = require("../../constants");
+const { execCLI } = rnv_1.Exec;
+const { CLI_TIZEN, REMOTE_DEBUGGER_ENABLED_PLATFORMS } = rnv_1.Constants;
+const { getPlatformProjectDir, getAppVersion, getConfigProp, checkPortInUse, confirmActiveBundler, addSystemInjects, } = rnv_1.Common;
+const { chalk, logTask, logDebug, logError, logSuccess, logWarning, logInfo, } = rnv_1.Logger;
+const { isPlatformActive } = rnv_1.PlatformManager;
+const { writeCleanFile, fsExistsSync, updateObjectSync } = rnv_1.FileUtils;
+const { copyAssetsFolder, copyBuildsFolder } = rnv_1.ProjectManager;
+const { runTizenSimOrDevice, createDevelopTizenCertificate, DEFAULT_CERTIFICATE_NAME, DEFAULT_SECURITY_PROFILE_NAME, } = rnv_1.SDKManager.Tizen;
+const DEFAULT_CERTIFICATE_NAME_WITH_EXTENSION = `${DEFAULT_CERTIFICATE_NAME}.p12`;
+const configureTizenGlobal = (c) => new Promise((resolve, reject) => {
+    logTask('configureTizenGlobal');
+    const authorCert = path.join(c.paths.workspace.dir, DEFAULT_CERTIFICATE_NAME_WITH_EXTENSION);
+    if (fsExistsSync(authorCert)) {
+        logDebug(`${DEFAULT_CERTIFICATE_NAME_WITH_EXTENSION} file exists!`);
+        resolve();
+    }
+    else {
+        logWarning(`${DEFAULT_CERTIFICATE_NAME_WITH_EXTENSION} file missing! Creating one for you...`);
+        createDevelopTizenCertificate(c)
+            .then(() => resolve())
+            .catch((e) => reject(e));
+    }
+});
+exports.configureTizenGlobal = configureTizenGlobal;
+const handleRunTizenSimOrDevice = async (c) => {
+    try {
+        await runTizenSimOrDevice(c);
+    }
+    catch (e) {
+        return Promise.reject(e);
+    }
+    return true;
+};
+const runTizen = async (c, target) => {
+    logTask('runTizen', `target:${target}`);
+    const { platform } = c;
+    const { hosted } = c.program;
+    const isHosted = hosted && !getConfigProp(c, platform, 'bundleAssets');
+    if (isHosted) {
+        const isPortActive = await checkPortInUse(c, platform, c.runtime.port);
+        if (isPortActive) {
+            const resetCompleted = await confirmActiveBundler(c);
+            c.runtime.skipActiveServerCheck = !resetCompleted;
+        }
+    }
+    logTask('runTizen', `target:${target} hosted:${!!isHosted}`);
+    if (isHosted)
+        return;
+    const bundleAssets = getConfigProp(c, platform, 'bundleAssets') === true;
+    if (bundleAssets) {
+        await (0, sdk_webpack_1.buildCoreWebpackProject)(c);
+        await handleRunTizenSimOrDevice(c);
+    }
+    else {
+        const isPortActive = await checkPortInUse(c, platform, c.runtime.port);
+        const isDebuggerEnabledForPlatform = REMOTE_DEBUGGER_ENABLED_PLATFORMS.includes(platform);
+        const isWeinreEnabled = isDebuggerEnabledForPlatform && !hosted;
+        if (!isPortActive) {
+            logInfo(`Your ${chalk().white(platform)} devServer at port ${chalk().white(c.runtime.port)} is not running. Starting it up for you...`);
+            (0, sdk_webpack_1.waitForWebpack)(c)
+                .then(() => handleRunTizenSimOrDevice(c))
+                .catch(logError);
+            await (0, sdk_webpack_1.runWebpackServer)(c, isWeinreEnabled);
+        }
+        else {
+            const resetCompleted = await confirmActiveBundler(c);
+            if (resetCompleted) {
+                (0, sdk_webpack_1.waitForWebpack)(c)
+                    .then(() => handleRunTizenSimOrDevice(c))
+                    .catch(logError);
+                await (0, sdk_webpack_1.runWebpackServer)(c, isWeinreEnabled);
+            }
+            else {
+                await handleRunTizenSimOrDevice(c);
+            }
+        }
+    }
+};
+exports.runTizen = runTizen;
+const buildTizenProject = async (c) => {
+    logTask('buildTizenProject');
+    await (0, sdk_webpack_1.buildCoreWebpackProject)(c);
+    if (!c.program.hosted) {
+        const { buildConfig } = c;
+        const platformConfig = buildConfig.platforms[constants_1.Platforms.TIZEN];
+        const projectDir = getPlatformProjectDir(c);
+        const projectParentDir = path.join(projectDir, '..');
+        const tBuild = path.join(projectParentDir, 'build');
+        const tOut = path.join(projectParentDir, 'output');
+        const certProfile = platformConfig.certificateProfile ?? DEFAULT_SECURITY_PROFILE_NAME;
+        await execCLI(c, CLI_TIZEN, `build-web -- ${projectDir} -out ${tBuild}`);
+        await execCLI(c, CLI_TIZEN, `package -- ${tBuild} -s ${certProfile} -t wgt -o ${tOut}`);
+        logSuccess(`Your WGT package is located in ${chalk().cyan(tOut)} .`);
+    }
+    return true;
+};
+exports.buildTizenProject = buildTizenProject;
+let isGlobalConfigured = false;
+const configureProject = (c) => new Promise((resolve) => {
+    logTask('configureProject');
+    const platform = constants_1.Platforms.TIZEN;
+    const configFile = 'config.xml';
+    const p = c.buildConfig.platforms[platform];
+    const injects = [
+        { pattern: '{{PACKAGE}}', override: p.package },
+        { pattern: '{{ID}}', override: p.id },
+        { pattern: '{{APP_NAME}}', override: p.appName },
+        { pattern: '{{APP_VERSION}}', override: semver.coerce(getAppVersion(c, platform)) },
+    ];
+    addSystemInjects(c, injects);
+    const file = path.join(getPlatformProjectDir(c), configFile);
+    writeCleanFile(file, file, injects, null, c);
+    resolve();
+});
+const configureTizenProject = async (c) => {
+    logTask('configureTizenProject');
+    const { platform } = c;
+    c.runtime.platformBuildsProjectPath = `${getPlatformProjectDir(c)}`;
+    if (!isPlatformActive(c, platform)) {
+        return;
+    }
+    if (!isGlobalConfigured) {
+        isGlobalConfigured = true;
+        await configureTizenGlobal(c);
+    }
+    await copyAssetsFolder(c, platform);
+    await (0, sdk_webpack_1.configureCoreWebProject)(c);
+    await configureProject(c);
+    copyBuildsFolder(c, platform);
+};
+exports.configureTizenProject = configureTizenProject;
+const handleLinuxKeyring = () => {
+    if (process.env.CI && os.platform() === 'linux') {
+        const options = { stdio: 'inherit' };
+        (0, child_process_1.execSync)('eval $(dbus-launch --sh-syntax)', options);
+        (0, child_process_1.execSync)('mkdir -p ~/.cache', options);
+        (0, child_process_1.execSync)('mkdir -p ~/.local/share/keyrings', options);
+        (0, child_process_1.execSync)('eval "$(printf \'\\n\' | gnome-keyring-daemon --unlock)"', options);
+        (0, child_process_1.execSync)('eval "$(printf \'\\n\' | /usr/bin/gnome-keyring-daemon --start)"', options);
+    }
+};
+const setTizenCertificate = (c) => {
+    const { TIZEN_SECURITY_PROFILE_NAME = '24i-SmartApps-BigScreen', TIZEN_AUTHOR_CERTIFICATE_RELATIVE_PATH = 'certificates/24i_smartapps_bigscreen_author.p12', TIZEN_AUTHOR_CERTIFICATE_PASSWORD, } = process.env;
+    const tizenCliPath = c.cli.tizen;
+    if (!fs.existsSync(TIZEN_AUTHOR_CERTIFICATE_RELATIVE_PATH)) {
+        console.log(`'process.env.TIZEN_AUTHOR_CERTIFICATE_RELATIVE_PATH' points to not existing location: ${TIZEN_AUTHOR_CERTIFICATE_RELATIVE_PATH}`);
+        return false;
+    }
+    if (!TIZEN_AUTHOR_CERTIFICATE_PASSWORD) {
+        console.log('\'process.env.TIZEN_AUTHOR_CERTIFICATE_PASSWORD\' password is not set');
+        return false;
+    }
+    if (!tizenCliPath) {
+        console.log('\'c.cli.tizen\' is not set');
+        return false;
+    }
+    const spawnSyncReturn = (0, child_process_1.spawnSync)(tizenCliPath, [
+        'security-profiles', 'add',
+        '-n', TIZEN_SECURITY_PROFILE_NAME,
+        '-a', TIZEN_AUTHOR_CERTIFICATE_RELATIVE_PATH,
+        '-p', TIZEN_AUTHOR_CERTIFICATE_PASSWORD,
+    ]);
+    if (spawnSyncReturn.error)
+        throw spawnSyncReturn.error;
+    if (spawnSyncReturn.stdout.toString().includes('Invalid file or password')) {
+        throw new Error(spawnSyncReturn.stdout.toString());
+    }
+    process.stdout.write(spawnSyncReturn.stdout || '');
+    const rnvWorkspaceConfigPath = c.paths.workspace.config;
+    const customObjectToMerge = {
+        platforms: {
+            tizen: { certificateProfile: TIZEN_SECURITY_PROFILE_NAME },
+        },
+    };
+    updateObjectSync(rnvWorkspaceConfigPath, customObjectToMerge);
+    Object.assign(c.buildConfig, customObjectToMerge);
+    return true;
+};
+const getSdkInstallerUrl = () => {
+    switch (os.platform()) {
+        case 'darwin':
+            return 'https://s3.amazonaws.com/tools.nxg-bigscreen.24imedia.com/sdks/tizen/tizen_builder_v3.7_mac.zip';
+        case 'linux':
+            return 'https://s3.amazonaws.com/tools.nxg-bigscreen.24imedia.com/sdks/tizen/tizen_builder_v3.7_ubuntu.zip';
+        default:
+            return '';
+    }
+};
+const handleTizenSdk = async (c) => {
+    const { TIZEN_SDK_INSTALLER_URL = getSdkInstallerUrl() } = process.env;
+    const { TIZEN_SDK } = c.buildConfig.sdks || {};
+    const installPath = `${os.homedir()}/tizen-studio`;
+    const rnvSdkKey = 'TIZEN_SDK';
+    if (!TIZEN_SDK) {
+        handleLinuxKeyring();
+        if (fs.existsSync(installPath)) {
+            await (0, sdk_utils_1.registerSdkPath)(c, rnvSdkKey, installPath);
+        }
+        else {
+            const installedToPath = await (0, sdk_utils_1.sdkInstaller)(TIZEN_SDK_INSTALLER_URL, installPath, true);
+            if (installedToPath) {
+                await (0, sdk_utils_1.registerSdkPath)(c, rnvSdkKey, installedToPath);
+            }
+        }
+    }
+    await rnv_1.SDKManager.Installer.checkAndConfigureTizenSdks(c);
+    setTizenCertificate(c);
+};
+exports.handleTizenSdk = handleTizenSdk;

package/packages/rnv-build-engine/dist/src/sdks/sdk-utils/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./sdk-installer"), exports);
+__exportStar(require("./registerSdkPath"), exports);

package/packages/rnv-build-engine/dist/src/sdks/sdk-utils/registerSdkPath.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSdkPath = void 0;
+const rnv_1 = require("rnv");
+const registerSdkPath = async (c, sdkKey, sdkValue) => {
+    const rnvWorkspaceConfigPath = c.paths.workspace.config;
+    const sdkEntry = { [sdkKey]: sdkValue };
+    rnv_1.FileUtils.updateObjectSync(rnvWorkspaceConfigPath, { sdks: sdkEntry });
+    if (!c.buildConfig.sdks) {
+        c.buildConfig.sdks = {};
+    }
+    Object.assign(c.buildConfig.sdks, sdkEntry);
+};
+exports.registerSdkPath = registerSdkPath;

package/packages/rnv-build-engine/dist/src/sdks/sdk-utils/sdk-installer/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sdkInstaller = void 0;
+var sdkInstaller_1 = require("./sdkInstaller");
+Object.defineProperty(exports, "sdkInstaller", { enumerable: true, get: function () { return sdkInstaller_1.sdkInstaller; } });

package/packages/rnv-build-engine/dist/src/sdks/sdk-utils/sdk-installer/sdkInstaller.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sdkInstaller = void 0;
+const path_1 = require("path");
+const url_1 = require("url");
+const services_1 = require("./services");
+const log = (message) => process.stdout.write(message);
+const noLog = () => false;
+const sdkInstaller = async (remoteZipPath, installToPath, enableLogs = false) => {
+    const logger = enableLogs ? log : noLog;
+    const pathsToDelete = [];
+    let usedInstallPath;
+    try {
+        const parsedZipPath = (0, path_1.parse)(remoteZipPath);
+        const parsedZipUrl = (0, url_1.parse)(remoteZipPath);
+        if (!parsedZipUrl.protocol) {
+            throw new Error('Installation from local packages is not supported yet.');
+        }
+        logger('Downloading...');
+        const downloadedFilePath = `${process.cwd()}/${parsedZipPath.base}`;
+        pathsToDelete.push(downloadedFilePath);
+        await (0, services_1.download)(remoteZipPath, downloadedFilePath);
+        logger('\rUnpacking...');
+        const unzippedDirPath = `${process.cwd()}/${parsedZipPath.name}`;
+        pathsToDelete.push(unzippedDirPath);
+        (0, services_1.unzip)(downloadedFilePath);
+        logger('\rInstalling...');
+        usedInstallPath = (0, services_1.install)(unzippedDirPath, installToPath);
+    }
+    catch (e) {
+        (0, services_1.clean)(pathsToDelete);
+        throw e;
+    }
+    logger('\rCleaning...');
+    (0, services_1.clean)(pathsToDelete);
+    logger(`\rInstalled to ${usedInstallPath}\n`);
+    return usedInstallPath;
+};
+exports.sdkInstaller = sdkInstaller;

package/packages/rnv-build-engine/dist/src/sdks/sdk-utils/sdk-installer/services/clean.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clean = void 0;
+const child_process_1 = require("child_process");
+const deleteFileOrDirectory = (path) => {
+    (0, child_process_1.spawnSync)('rm', ['-r', path]);
+};
+const clean = (pathsToBeDeleted) => {
+    pathsToBeDeleted.forEach(deleteFileOrDirectory);
+};
+exports.clean = clean;