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

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

@@ -0,0 +1,83 @@
+"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.deployToAppCenter = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const rnv_1 = require("rnv");
+const resolvers_1 = require("../../resolvers");
+const urlsMarkdown_1 = require("./urlsMarkdown");
+const appCenterRelease = (params) => {
+    const { filePath, releaseNotesPath, buildVersion, token, projectName } = params;
+    const app = `24i-Media/${projectName}`;
+    (0, child_process_1.execSync)('appcenter distribute release '
+        + `--file "${filePath}" `
+        + `--release-notes-file "${releaseNotesPath}" `
+        + `--build-version "${buildVersion}" `
+        + `--app "${app}" `
+        + `--token "${token}" `
+        + '--group "Collaborators" '
+        + '--disable-telemetry', { stdio: 'inherit' });
+};
+const getAppCenterConfigByPlatformName = (c, platformName) => {
+    try {
+        return c.buildConfig.platforms[platformName]?.deploy?.appCenter || null;
+    }
+    catch (error) {
+        return null;
+    }
+};
+const getTokenByPlatform = (platformName = '') => {
+    const envVariableName = `APPCENTER_TOKEN_${platformName.toUpperCase()}`;
+    return process.env[envVariableName] || '';
+};
+const processPlatform = (c, platformName) => {
+    const { getConfigProp } = rnv_1.Common;
+    const appCenterConfig = getAppCenterConfigByPlatformName(c, platformName);
+    if (!appCenterConfig)
+        return;
+    const { appName } = appCenterConfig;
+    const token = getTokenByPlatform(platformName);
+    const zipPath = (0, resolvers_1.resolveZippedPlatformBuildsRelativeFilePath)(c, platformName);
+    const buildVersion = getConfigProp(c, platformName, 'packageVersion', '');
+    const releaseNotesPath = getConfigProp(c, platformName, 'releaseNotes', {}).relativePath || '';
+    if (!appName || !token || !releaseNotesPath || !zipPath || !buildVersion)
+        return;
+    const tempReleaseNotesPath = `RELEASE_NOTES_APPCENTER_${platformName.toUpperCase()}.md`;
+    if (fs.existsSync(tempReleaseNotesPath)) {
+        fs.unlinkSync(tempReleaseNotesPath);
+    }
+    (0, child_process_1.execSync)(`cat ${releaseNotesPath} >> ${tempReleaseNotesPath}`);
+    const urlsMarkdown = (0, urlsMarkdown_1.getUrlsMarkdown)(c, [platformName]);
+    (0, child_process_1.execSync)(`echo "${urlsMarkdown}" >> ${tempReleaseNotesPath}`);
+    console.log(`Deploying ${platformName} platform to AppCenter.ms...`);
+    appCenterRelease({
+        projectName: appName,
+        buildVersion,
+        filePath: zipPath,
+        releaseNotesPath: tempReleaseNotesPath,
+        token,
+    });
+};
+const deployToAppCenter = (c) => {
+    (0, resolvers_1.resolveSupportedPlatforms)(c).forEach((platformName) => processPlatform(c, platformName));
+};
+exports.deployToAppCenter = deployToAppCenter;

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

@@ -0,0 +1,128 @@
+"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.githubRelease = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const assert_1 = require("assert");
+const path_1 = require("path");
+const resolvers_1 = require("../../resolvers");
+const urlsMarkdown_1 = require("./urlsMarkdown");
+const token = process.env.GITHUB_TOKEN;
+const targetCommit = process.env.TRAVIS_COMMIT;
+const githubContentType = 'application/vnd.github.v3+json';
+const githubReleaseNotesPath = 'RELEASE_NOTES_GITHUB.md';
+const handleResponseErrors = (response) => {
+    const { errors, message } = response;
+    if (message && !errors)
+        throw new Error(`GitHub error: ${message}`);
+    if (!errors)
+        return;
+    const makeErrorDetailString = (error) => Object
+        .keys(error)
+        .map((key) => `${key}: "${error[key]}"`)
+        .join(', ');
+    const errorsDetails = errors.map(makeErrorDetailString);
+    throw new Error(`GitHub error: ${message || ''}\n${errorsDetails.join('\n')}`);
+};
+const getReleaseNotesPath = (c) => {
+    try {
+        return c.buildConfig.common.releaseNotes.relativePath || '';
+    }
+    catch (error) {
+        return '';
+    }
+};
+const deleteFileIfExists = (filePath) => {
+    if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+    }
+};
+const makeGitHubReleaseNotes = (c) => {
+    const releaseNotesPath = getReleaseNotesPath(c);
+    (0, assert_1.ok)(releaseNotesPath, 'The path to the file with release notes is missing!');
+    deleteFileIfExists(githubReleaseNotesPath);
+    (0, child_process_1.execSync)(`sed '1d;2d' ${releaseNotesPath} >> ${githubReleaseNotesPath}`);
+    const textToAppend = (0, urlsMarkdown_1.getUrlsMarkdown)(c);
+    (0, child_process_1.execSync)(`echo "${textToAppend}" >> ${githubReleaseNotesPath}`);
+};
+const createRelease = (c) => {
+    const { packageVersion, git } = c.buildConfig.common;
+    const versionLabel = `v${packageVersion}`;
+    (0, assert_1.ok)(token, 'process.env.GITHUB_TOKEN is not set!');
+    (0, assert_1.ok)(targetCommit, 'process.env.TRAVIS_COMMIT is not set!');
+    (0, assert_1.ok)(git.owner, 'Missing value for rnv config prop: common.git.owner');
+    (0, assert_1.ok)(git.repo, 'Missing value for rnv config prop: common.git.repo');
+    (0, assert_1.ok)(packageVersion);
+    makeGitHubReleaseNotes(c);
+    const releaseNotesContent = fs.readFileSync(githubReleaseNotesPath).toString();
+    const data = {
+        tag_name: versionLabel,
+        target_commitish: targetCommit,
+        name: versionLabel,
+        body: releaseNotesContent,
+        draft: false,
+        prerelease: false,
+    };
+    const url = `https://api.github.com/repos/${git.owner}/${git.repo}/releases`;
+    const headers = `-H "Accept: ${githubContentType}" -H "Authorization: token ${token}"`;
+    const dataStringWithFixedSingleQuotes = JSON.stringify(data).replace(/'/g, "'\\''");
+    const cmd = `curl -X POST ${headers} ${url} -d '${dataStringWithFixedSingleQuotes}'`;
+    console.log(`Pushing GitHub Release: ${versionLabel}...`);
+    const responseString = (0, child_process_1.execSync)(cmd, { stdio: 'pipe' }).toString();
+    const response = JSON.parse(responseString);
+    handleResponseErrors(response);
+    console.log('Pushing done.');
+    return response;
+};
+const getFileMimeType = (filepath) => {
+    const cmd = `file --mime-type -b ${filepath}`;
+    return (0, child_process_1.execSync)(cmd, { stdio: 'pipe' })
+        .toString()
+        .replace(/\r?\n/, '');
+};
+const uploadAsset = (uploadUrl, filePath) => {
+    const url = `${uploadUrl.replace('{?name,label}', '')}`;
+    const headers = `-H "Accept: ${githubContentType}" -H "Authorization: token ${token}" -H "content-type: ${getFileMimeType(filePath)}" -H "content-length: ${fs.statSync(filePath).size}"`;
+    const cmd = `curl --data-binary @"${filePath}" ${headers} ${url}?name=${(0, path_1.basename)(filePath)}`;
+    console.log(`Uploading ${filePath} asset to created GitHub Release...`);
+    const responseString = (0, child_process_1.execSync)(cmd, { stdio: 'pipe' }).toString();
+    const uploadResponse = JSON.parse(responseString);
+    handleResponseErrors(uploadResponse);
+    console.log('Uploading done.');
+    return uploadResponse;
+};
+const uploadZipWithPlatformBuilds = (c, platformName, githubUploadUrl) => {
+    const zipFilePath = (0, resolvers_1.resolveZippedPlatformBuildsRelativeFilePath)(c, platformName);
+    if (zipFilePath) {
+        uploadAsset(githubUploadUrl, zipFilePath);
+    }
+};
+const githubRelease = (c) => {
+    const releaseResponse = createRelease(c) || {};
+    const uploadUrl = releaseResponse.upload_url;
+    (0, assert_1.ok)(uploadUrl, 'Missing "upload_url" in release response!');
+    (0, resolvers_1.resolveSupportedPlatforms)(c).forEach((platformName) => {
+        uploadZipWithPlatformBuilds(c, platformName, uploadUrl);
+    });
+    deleteFileIfExists(githubReleaseNotesPath);
+};
+exports.githubRelease = githubRelease;

package/packages/rnv-build-engine/dist/src/scripts/release/notifySlack/generateWebhoook.js

@@ -0,0 +1,66 @@
+"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 });
+const https = __importStar(require("https"));
+const querystring = __importStar(require("querystring"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const replaceWebhookUrl = (newWebhookUrl, channelName) => {
+    const filePath = path.resolve(process.cwd(), 'renative.json');
+    const parsedFile = JSON.parse(fs.readFileSync(filePath).toString());
+    const jsonIndentSpaces = 4;
+    parsedFile.common.deploy.slack.webhookUrl = newWebhookUrl;
+    fs.writeFileSync(filePath, JSON.stringify(parsedFile, null, jsonIndentSpaces));
+    console.log(`Webhook for "${channelName}" channel successfully written into ${filePath}.`);
+};
+const postRequestCallback = (receivedData) => {
+    const parsedData = JSON.parse(receivedData);
+    if (parsedData.ok === false)
+        throw parsedData;
+    const { channel, url } = parsedData.incoming_webhook;
+    console.log(`\nGenerated slack webhook: ${url}`);
+    replaceWebhookUrl(url, channel);
+};
+const { redirect_uri, client_id, client_secret, code } = process.env;
+const formData = querystring.stringify({ redirect_uri, client_id, client_secret, code });
+const requestOptions = {
+    hostname: 'slack.com',
+    path: '/api/oauth.v2.access',
+    method: 'POST',
+    headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'Content-Length': formData.length,
+    },
+};
+const request = https.request(requestOptions, (response) => {
+    let receivedData = '';
+    response.on('data', (d) => {
+        receivedData += d;
+    });
+    response.on('end', () => {
+        postRequestCallback(receivedData);
+    });
+});
+request.on('error', (error) => {
+    throw error;
+});
+request.write(formData);
+request.end();

package/packages/rnv-build-engine/dist/src/scripts/release/notifySlack/makePayload.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDistributionPayload = exports.makeReleaseCandidatePayload = exports.makeDevelopmentPayload = void 0;
+const slackBlockKitBuilder_1 = require("./slackBlockKitBuilder");
+const resolvers_1 = require("../../../resolvers");
+const getVersionsObject = (c) => (0, resolvers_1.resolveDeployLocations)(c).versions;
+const getVersion = (c) => Object.keys(getVersionsObject(c))[0] || '';
+const getPlatformsObject = (c) => {
+    const version = getVersion(c);
+    const { platforms = {} } = getVersionsObject(c)[version] || {};
+    return platforms;
+};
+const getCommonAppName = (c) => {
+    try {
+        return c.buildConfig.common.appName;
+    }
+    catch (error) {
+        return '';
+    }
+};
+const makeFlavoursMarkdown = (platformName, entries) => entries
+    .map(([flavour, flavourData]) => {
+    const { indexUrl, packageUrl } = flavourData;
+    return `- *${flavour}* [<${packageUrl}|Download>] [<${indexUrl}|Open deployed index.html>]`;
+})
+    .join('\n');
+const makePackagePayload = (c, platformName) => {
+    const platformData = getPlatformsObject(c)[platformName];
+    if (platformData) {
+        const flavoursEntries = Object.entries(platformData);
+        return [
+            slackBlockKitBuilder_1.Divider.plain(),
+            slackBlockKitBuilder_1.Context.mrkdwns([`Platform: *${platformName}*`]),
+            slackBlockKitBuilder_1.Context.mrkdwns([makeFlavoursMarkdown(platformName, flavoursEntries)]),
+        ];
+    }
+    return [];
+};
+const makePackagesPayload = (c) => {
+    const platformList = Object.keys(getPlatformsObject(c));
+    return platformList
+        .map((platformName) => makePackagePayload(c, platformName))
+        .flat();
+};
+const makeHeaderPayload = (c, title, buttons) => {
+    const { travisBuild, gitHubRelease } = buttons || {};
+    const { owner, repo } = c.buildConfig.common.git || {};
+    const version = getVersion(c);
+    const buttonsData = [];
+    if (travisBuild) {
+        buttonsData.push({
+            text: 'View Travis Build Log',
+            url: process.env.TRAVIS_BUILD_WEB_URL || `https://travis-ci.com/github/${owner}/${repo}/branches`,
+        });
+    }
+    if (gitHubRelease) {
+        buttonsData.push({
+            text: 'View GitHub Release',
+            url: `https://github.com/${owner}/${repo}/releases/tag/${version}`,
+        });
+    }
+    return [
+        slackBlockKitBuilder_1.Divider.plain(),
+        slackBlockKitBuilder_1.Section.mrkdwn(title),
+        slackBlockKitBuilder_1.Context.mrkdwns([`Version: *${version}*`]),
+        slackBlockKitBuilder_1.Actions.buttons(buttonsData),
+    ];
+};
+const makePayload = (c, title, buttons) => ({
+    blocks: [
+        ...makeHeaderPayload(c, title, buttons),
+        ...makePackagesPayload(c),
+    ],
+});
+const makeDevelopmentPayload = (c) => {
+    const title = `There are new *development* builds for *${getCommonAppName(c)}* app!`;
+    const buttons = { travisBuild: true };
+    return makePayload(c, title, buttons);
+};
+exports.makeDevelopmentPayload = makeDevelopmentPayload;
+const makeReleaseCandidatePayload = (c) => {
+    const title = `There are new *release candidate* builds for *${getCommonAppName(c)}* app!`;
+    const buttons = { travisBuild: true };
+    return makePayload(c, title, buttons);
+};
+exports.makeReleaseCandidatePayload = makeReleaseCandidatePayload;
+const makeDistributionPayload = (c) => {
+    const title = `There are new *distribution* builds for *${getCommonAppName(c)}* app!`;
+    const buttons = { travisBuild: true, gitHubRelease: true };
+    return makePayload(c, title, buttons);
+};
+exports.makeDistributionPayload = makeDistributionPayload;

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

@@ -0,0 +1,44 @@
+"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.notifySlack = void 0;
+const child_process_1 = require("child_process");
+const payload = __importStar(require("./makePayload"));
+const constants_1 = require("../../../constants");
+const getPayload = (c) => {
+    const releaseType = c.runtime.scheme;
+    switch (releaseType) {
+        case constants_1.BuildSchemes.DEV_LATEST: return payload.makeDevelopmentPayload(c);
+        case constants_1.BuildSchemes.RC_LATEST: return payload.makeReleaseCandidatePayload(c);
+        case constants_1.BuildSchemes.RELEASE_DIST: return payload.makeDistributionPayload(c);
+        default: throw new Error('Notify Slack: unsupported or undefined release type! Did you pass it as an argument?');
+    }
+};
+const notifySlack = (c) => {
+    const contentType = '"Content-type: application/json"';
+    const data = `--data '${JSON.stringify(getPayload(c))}'`;
+    const webHookUrl = c.buildConfig.common.deploy.slack?.webhookUrl || '';
+    if (webHookUrl) {
+        const cmd = `curl -X POST -H ${contentType} ${data} ${webHookUrl}`;
+        (0, child_process_1.execSync)(cmd, { stdio: 'inherit' });
+    }
+};
+exports.notifySlack = notifySlack;

package/packages/rnv-build-engine/dist/src/scripts/release/notifySlack/slackBlockKitBuilder.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = exports.Divider = exports.Actions = exports.Section = void 0;
+const mrkdwn = (text) => ({ type: 'mrkdwn', text });
+const plainText = (text) => ({
+    type: 'plain_text',
+    text,
+    emoji: true,
+});
+const buttonWithUrl = (buttonProps) => ({
+    type: 'button',
+    text: plainText(buttonProps.text),
+    url: buttonProps.url,
+});
+const Section = {
+    mrkdwn: (text) => ({
+        type: 'section',
+        text: mrkdwn(text),
+    }),
+};
+exports.Section = Section;
+const Actions = {
+    buttons: (btnsData) => ({
+        type: 'actions',
+        elements: btnsData.map(buttonWithUrl),
+    }),
+};
+exports.Actions = Actions;
+const Divider = {
+    plain: () => ({ type: 'divider' }),
+};
+exports.Divider = Divider;
+const Context = {
+    mrkdwns: (texts) => ({
+        type: 'context',
+        elements: texts.map(mrkdwn),
+    }),
+};
+exports.Context = Context;

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

@@ -0,0 +1,85 @@
+"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.sentryRelease = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const constants_1 = require("../../constants");
+const resolvers_1 = require("../../resolvers");
+const UNSUPPORTED_PLATFORMS = [constants_1.Platforms.WEBTV];
+const executeSync = (cmd) => (0, child_process_1.execSync)(cmd, { stdio: 'inherit' });
+const createNewRelease = (version) => {
+    executeSync(`sentry-cli releases new ${version}`);
+};
+const uploadSourceMaps = (params) => {
+    const { version, sourceMapsPath, urlPrefix } = params;
+    executeSync('sentry-cli releases '
+        + `files ${version} `
+        + `upload-sourcemaps ${sourceMapsPath} `
+        + `--url-prefix "~/${urlPrefix}" `
+        + '--rewrite --validate');
+};
+const setReleaseCommits = (version) => {
+    try {
+        executeSync(`sentry-cli releases set-commits ${version} --auto --log-level=debug`);
+    }
+    catch (error) {
+        console.log('Sentry release commits failed: ', error);
+    }
+};
+const finalizeRelease = (version) => {
+    executeSync(`sentry-cli releases finalize ${version}`);
+};
+const processPlatform = (c, platform, version) => {
+    const processFlavour = (flavour) => {
+        const { platformBuildsDir } = c.buildConfig.paths;
+        const mapsPath = `${platformBuildsDir}/${flavour}_${platform}-public/public/content/js`;
+        const urlPrefix = `builds/${platform}/${flavour}/dist/${version}/public/content/js/`;
+        if (!fs.existsSync(mapsPath))
+            return;
+        console.log(`Uploading ${flavour}_${platform} sourcemaps to Sentry...`);
+        uploadSourceMaps({ version, sourceMapsPath: mapsPath, urlPrefix });
+    };
+    const { supportedFlavours = [] } = c.buildConfig.platforms[platform]?.deploy || {};
+    supportedFlavours.forEach(processFlavour);
+};
+const isSentryProjectConfigured = () => {
+    const cmd = (0, child_process_1.execSync)('sentry-cli info --config-status-json');
+    const sentryConfig = JSON.parse(cmd.toString()) || {};
+    return !!sentryConfig.config?.project;
+};
+const sentryRelease = (c) => {
+    if (!isSentryProjectConfigured()) {
+        console.log('Project is not defined...');
+        return;
+    }
+    const version = `v${c.buildConfig.common?.packageVersion}`;
+    if (!version)
+        return;
+    const supportedPlatforms = (0, resolvers_1.resolveSupportedPlatforms)(c);
+    const supportedPlatformsBySentry = supportedPlatforms.filter((platform) => !UNSUPPORTED_PLATFORMS.includes(platform));
+    createNewRelease(version);
+    supportedPlatformsBySentry.forEach((platform) => processPlatform(c, platform, version));
+    setReleaseCommits(version);
+    finalizeRelease(version);
+    console.log('Source Maps uploaded...');
+};
+exports.sentryRelease = sentryRelease;

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUrlsMarkdown = void 0;
+const constants_1 = require("../../constants");
+const resolvers_1 = require("../../resolvers");
+const newLine = '\r\n';
+const getDataToProceed = (c, customPlatformList = []) => {
+    const locations = (0, resolvers_1.resolveDeployLocations)(c);
+    const { versions } = locations;
+    const { platforms } = versions[Object.keys(versions)[0]];
+    if (!customPlatformList.length)
+        return platforms;
+    const outputData = {};
+    const addToOutputIfPlatformHasData = (platformName) => {
+        const platformData = platforms[platformName];
+        if (platformData) {
+            outputData[platformName] = platformData;
+        }
+    };
+    customPlatformList.forEach(addToOutputIfPlatformHasData);
+    return outputData;
+};
+const beautifyPlatformName = (platformName) => {
+    switch (platformName.toLowerCase()) {
+        case constants_1.Platforms.ENTONE: return 'Entone';
+        case constants_1.Platforms.HBBTV: return 'HbbTV';
+        case constants_1.Platforms.KREATV: return 'KreaTV';
+        case constants_1.Platforms.SAPHI: return 'Saphi (Philips)';
+        case constants_1.Platforms.TIZEN: return 'Tizen (Samsung)';
+        case constants_1.Platforms.WEBOS: return 'webOS (LG)';
+        case constants_1.Platforms.WEBTV: return 'WebTV';
+        case constants_1.Platforms.XBOX: return 'Xbox';
+        default: return platformName;
+    }
+};
+const getPlatformOutput = (data, platformName) => {
+    if (platformName === constants_1.Platforms.TIZEN || platformName === constants_1.Platforms.WEBOS) {
+        return '';
+    }
+    const platformData = data[platformName];
+    let output = `**${beautifyPlatformName(platformName)}**${newLine}`;
+    const processPlatformEntry = (platformEntry) => {
+        const [flavour, flavourData] = platformEntry;
+        const { indexUrl } = flavourData;
+        output += `* [${flavour}](${indexUrl})${newLine}`;
+    };
+    Object.entries(platformData).forEach(processPlatformEntry);
+    return output;
+};
+const getUrlsMarkdown = (c, customPlatformList) => {
+    const dataToProceed = getDataToProceed(c, customPlatformList);
+    const markdownWithoutHeader = Object.keys(dataToProceed)
+        .map((platformName) => getPlatformOutput(dataToProceed, platformName))
+        .filter(Boolean)
+        .join(newLine);
+    if (markdownWithoutHeader.length) {
+        const urlHeader = `${newLine}## URL${newLine}`;
+        return urlHeader + markdownWithoutHeader;
+    }
+    return '';
+};
+exports.getUrlsMarkdown = getUrlsMarkdown;