@donotuse/eas-cli 18.5.0-rc.1

package/build/build/validate.d.ts

@@ -0,0 +1,5 @@
+import { Platform } from '@expo/eas-build-job';
+import { CommonContext } from './context';
+export declare function checkNodeEnvVariable(ctx: CommonContext<Platform>): void;
+export declare function checkGoogleServicesFileAsync<T extends Platform>(ctx: CommonContext<T>): Promise<void>;
+export declare function validatePNGsForManagedProjectAsync<T extends Platform>(ctx: CommonContext<T>): Promise<void>;

package/build/build/validate.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkNodeEnvVariable = checkNodeEnvVariable;
+exports.checkGoogleServicesFileAsync = checkGoogleServicesFileAsync;
+exports.validatePNGsForManagedProjectAsync = validatePNGsForManagedProjectAsync;
+const tslib_1 = require("tslib");
+const eas_build_job_1 = require("@expo/eas-build-job");
+const core_1 = require("@oclif/core");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const semver_1 = tslib_1.__importDefault(require("semver"));
+const log_1 = tslib_1.__importStar(require("../log"));
+const image_1 = require("../utils/image");
+function checkNodeEnvVariable(ctx) {
+    if (ctx.env?.NODE_ENV === 'production') {
+        log_1.default.warn('You set NODE_ENV=production in the build profile or environment variables. Remember that it will be available during the entire build process. In particular, it will make yarn/npm install only production packages.');
+        log_1.default.newLine();
+    }
+}
+async function checkGoogleServicesFileAsync(ctx) {
+    if (ctx.workflow === eas_build_job_1.Workflow.GENERIC || ctx.buildProfile?.env?.GOOGLE_SERVICES_FILE) {
+        return;
+    }
+    const googleServicesFilePath = ctx.exp[ctx.platform]?.googleServicesFile;
+    if (!googleServicesFilePath) {
+        return;
+    }
+    const googleServicesEnvVar = ctx.platform === eas_build_job_1.Platform.ANDROID
+        ? ctx.env.GOOGLE_SERVICES_JSON
+        : ctx.env.GOOGLE_SERVICES_INFO_PLIST;
+    const rootDir = path_1.default.normalize(await ctx.vcsClient.getRootPathAsync());
+    const absGoogleServicesFilePath = path_1.default.resolve(ctx.projectDir, googleServicesFilePath);
+    if ((await fs_extra_1.default.pathExists(absGoogleServicesFilePath)) &&
+        (!isInsideDirectory(absGoogleServicesFilePath, rootDir) ||
+            (await ctx.vcsClient.isFileIgnoredAsync(path_1.default.relative(rootDir, absGoogleServicesFilePath)))) &&
+        !googleServicesEnvVar) {
+        log_1.default.warn(`File specified via "${ctx.platform}.googleServicesFile" field in your app.json is not checked in to your repository and won't be uploaded to the builder.`);
+        log_1.default.warn(`Use EAS file environment variables with secret or sensitive visibility to pass all values that you don't want to include in your version control to build process. ${(0, log_1.learnMore)('https://docs.expo.dev/eas/environment-variables/#file-environment-variables')}`);
+        log_1.default.newLine();
+    }
+}
+function isInsideDirectory(file, directory) {
+    return file.startsWith(directory);
+}
+async function validatePNGsForManagedProjectAsync(ctx) {
+    if (ctx.workflow !== eas_build_job_1.Workflow.MANAGED) {
+        return;
+    }
+    // don't run PNG checks on SDK 47 and newer
+    // see https://github.com/expo/eas-cli/pull/1477#issuecomment-1293914917
+    if (!ctx.exp.sdkVersion || semver_1.default.satisfies(ctx.exp.sdkVersion, '>= 47.0.0')) {
+        return;
+    }
+    if (ctx.platform === eas_build_job_1.Platform.ANDROID) {
+        await validateAndroidPNGsAsync(ctx);
+    }
+    // Validating iOS PNGs is currently disabled
+    // See https://github.com/expo/eas-cli/pull/1477 for context
+    //
+    // else {
+    //   await validateIosPNGsAsync(ctx as CommonContext<Platform.IOS>);
+    // }
+}
+async function validateAndroidPNGsAsync(ctx) {
+    const pngs = [
+        {
+            configPath: 'exp.icon',
+            pngPath: ctx.exp.icon,
+        },
+        {
+            configPath: 'exp.android.icon',
+            pngPath: ctx.exp.android?.icon,
+        },
+        {
+            configPath: 'exp.android.adaptiveIcon.foregroundImage',
+            pngPath: ctx.exp.android?.adaptiveIcon?.foregroundImage,
+        },
+        {
+            configPath: 'exp.android.adaptiveIcon.backgroundImage',
+            pngPath: ctx.exp.android?.adaptiveIcon?.backgroundImage,
+        },
+        {
+            configPath: 'exp.splash.image',
+            pngPath: ctx.exp.splash?.image,
+        },
+        {
+            configPath: 'exp.notification.icon',
+            pngPath: ctx.exp.notification?.icon,
+        },
+    ];
+    await validatePNGsAsync(pngs);
+}
+// Validating iOS PNGs is currently disabled
+// See https://github.com/expo/eas-cli/pull/1477 for context
+//
+// async function validateIosPNGsAsync(ctx: CommonContext<Platform.IOS>): Promise<void> {
+//   const pngs: ConfigPng[] = [
+//     {
+//       configPath: 'exp.icon',
+//       pngPath: ctx.exp.icon,
+//     },
+//     {
+//       configPath: 'exp.ios.icon',
+//       pngPath: ctx.exp.ios?.icon,
+//     },
+//     {
+//       configPath: 'exp.splash.image',
+//       pngPath: ctx.exp.splash?.image,
+//     },
+//     {
+//       configPath: 'exp.notification.icon',
+//       pngPath: ctx.exp.notification?.icon,
+//     },
+//   ];
+//   await validatePNGsAsync(pngs);
+//   const icon = ctx.exp.ios?.icon ?? ctx.exp.icon;
+//   if (!icon) {
+//     return;
+//   }
+//   const iconConfigPath = `expo${ctx.exp.ios?.icon ? '.ios' : ''}.icon`;
+//   try {
+//     await ensurePNGIsNotTransparentAsync(icon);
+//   } catch (err: any) {
+//     if (err instanceof ImageTransparencyError) {
+//       Log.error(
+//         `Your iOS app icon (${iconConfigPath}) can't have transparency if you wish to upload your app to the Apple App Store.`
+//       );
+//       Log.error(learnMore('https://expo.fyi/remove-alpha-channel', { dim: false }));
+//       Errors.exit(1);
+//     } else {
+//       throw err;
+//     }
+//   }
+// }
+async function validatePNGsAsync(configPngs) {
+    const validationPromises = configPngs.map(configPng => validatePNGAsync(configPng));
+    const validationResults = await Promise.allSettled(validationPromises);
+    const failedValidations = validationResults.filter((result) => result.status === 'rejected');
+    if (failedValidations.length === 0) {
+        return;
+    }
+    log_1.default.error('PNG images validation failed:');
+    for (const { reason } of failedValidations) {
+        const error = reason;
+        log_1.default.error(`- ${error.message}`);
+    }
+    core_1.Errors.exit(1);
+}
+async function validatePNGAsync({ configPath, pngPath }) {
+    if (!pngPath) {
+        return;
+    }
+    if (!pngPath.endsWith('.png')) {
+        throw new Error(`"${configPath}" is not a PNG file`);
+    }
+    if (!(await (0, image_1.isPNGAsync)(pngPath))) {
+        throw new Error(`"${configPath}" is not valid PNG`);
+    }
+}

package/build/channel/actions/SelectChannel.d.ts

@@ -0,0 +1,33 @@
+import { EASUpdateAction, EASUpdateContext } from '../../eas-update/utils';
+import { UpdateChannelBasicInfoFragment } from '../../graphql/generated';
+import { Connection, Edge, QueryParams } from '../../utils/relay';
+/**
+ * Select a channel for the project.
+ *
+ * @constructor
+ * @param {function} options.filterPredicate - A predicate to filter the channels that are shown to the user. It takes a channelInfo object as a parameter and returns a boolean.
+ * @param {string} options.printedType - The type of channel printed to the user. Defaults to 'channel'.
+ * @param {number} options.pageSize - The number of channels to show per page. Defaults to 100.
+ * @param {function} options.beforeEachFilterQuery Optional. If a filter predicate was specified, this callback function will be called before each query.
+ * @args externalQueryParams The query params for the pagination.
+ * @args totalNodesFetched The total number of nodes fetched so far.
+ * @args dataset The dataset so far.
+ * @param {function} options.afterEachFilterQuery Optional. If a filter predicate was specified, this callback function will be called after each query.
+ * @args externalQueryParams The query params for the pagination.
+ * @args totalNodesFetched The total number of nodes fetched so far.
+ * @args dataset The dataset so far.
+ * @args willFetchAgain If the query will fetch again to get a complete page.
+ */
+export declare class SelectChannel implements EASUpdateAction<UpdateChannelBasicInfoFragment | null> {
+    private readonly options;
+    constructor(options?: {
+        filterPredicate?: (channelInfo: UpdateChannelBasicInfoFragment) => boolean;
+        printedType?: string;
+        pageSize?: number;
+        beforeEachFilterQuery?: (externalQueryParams: QueryParams, totalNodesFetched: number, dataset: Edge<UpdateChannelBasicInfoFragment>[]) => void;
+        afterEachFilterQuery?: (externalQueryParams: QueryParams, totalNodesFetched: number, dataset: Edge<UpdateChannelBasicInfoFragment>[], willFetchAgain: boolean) => void;
+    });
+    queryAsync(ctx: EASUpdateContext, queryParams: QueryParams): Promise<Connection<UpdateChannelBasicInfoFragment>>;
+    filterQueryAsync(ctx: EASUpdateContext, queryParams: QueryParams, filterPredicate: (channelInfo: UpdateChannelBasicInfoFragment) => boolean): Promise<Connection<UpdateChannelBasicInfoFragment>>;
+    runAsync(ctx: EASUpdateContext): Promise<UpdateChannelBasicInfoFragment | null>;
+}

package/build/channel/actions/SelectChannel.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectChannel = void 0;
+const utils_1 = require("../../eas-update/utils");
+const ChannelQuery_1 = require("../../graphql/queries/ChannelQuery");
+const relay_1 = require("../../utils/relay");
+/**
+ * Select a channel for the project.
+ *
+ * @constructor
+ * @param {function} options.filterPredicate - A predicate to filter the channels that are shown to the user. It takes a channelInfo object as a parameter and returns a boolean.
+ * @param {string} options.printedType - The type of channel printed to the user. Defaults to 'channel'.
+ * @param {number} options.pageSize - The number of channels to show per page. Defaults to 100.
+ * @param {function} options.beforeEachFilterQuery Optional. If a filter predicate was specified, this callback function will be called before each query.
+ * @args externalQueryParams The query params for the pagination.
+ * @args totalNodesFetched The total number of nodes fetched so far.
+ * @args dataset The dataset so far.
+ * @param {function} options.afterEachFilterQuery Optional. If a filter predicate was specified, this callback function will be called after each query.
+ * @args externalQueryParams The query params for the pagination.
+ * @args totalNodesFetched The total number of nodes fetched so far.
+ * @args dataset The dataset so far.
+ * @args willFetchAgain If the query will fetch again to get a complete page.
+ */
+class SelectChannel {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async queryAsync(ctx, queryParams) {
+        const { graphqlClient, app } = ctx;
+        const { projectId } = app;
+        return await ChannelQuery_1.ChannelQuery.viewUpdateChannelsBasicInfoPaginatedOnAppAsync(graphqlClient, {
+            appId: projectId,
+            ...queryParams,
+        });
+    }
+    async filterQueryAsync(ctx, queryParams, filterPredicate) {
+        const queryAsync = async (queryParams) => await this.queryAsync(ctx, queryParams);
+        return await relay_1.FilterPagination.getPageAsync({
+            queryParams,
+            queryAsync,
+            filterPredicate,
+            beforeEachQuery: this.options.beforeEachFilterQuery,
+            afterEachQuery: this.options.afterEachFilterQuery,
+        });
+    }
+    async runAsync(ctx) {
+        const { nonInteractive } = ctx;
+        const { filterPredicate } = this.options;
+        const printedType = this.options.printedType ?? 'channel';
+        const pageSize = this.options.pageSize ?? 100;
+        if (nonInteractive) {
+            throw new utils_1.NonInteractiveError(`${printedType} selection cannot be run in non-interactive mode.`);
+        }
+        const queryAsync = async (queryParams) => filterPredicate
+            ? await this.filterQueryAsync(ctx, queryParams, filterPredicate)
+            : await this.queryAsync(ctx, queryParams);
+        const getTitleAsync = async (channelInfo) => channelInfo.name;
+        return await (0, relay_1.selectPaginatedAsync)({
+            queryAsync,
+            getTitleAsync,
+            printedType,
+            pageSize,
+        });
+    }
+}
+exports.SelectChannel = SelectChannel;

package/build/channel/branch-mapping.d.ts

@@ -0,0 +1,55 @@
+import { ChannelBasicInfo } from './utils';
+export type BranchMappingOperator = '==' | '!=' | '<' | '>' | '<=' | '>=' | 'in' | 'regex' | 'hash_lt' | 'hash_lte' | 'hash_gt' | 'hash_gte';
+export type BranchMappingObject = {
+    clientKey: string;
+    branchMappingOperator: BranchMappingOperator;
+    operand: number | string | string[];
+};
+export type BranchMappingAlwaysTrue = 'true';
+export type BranchMappingStatement = ['and' | 'or', ...BranchMappingNode[]] | ['not', BranchMappingNode];
+export type BranchMappingNode = BranchMappingAlwaysTrue | BranchMappingObject | BranchMappingStatement;
+export type BranchMapping = {
+    version: number;
+    data: {
+        branchId: string;
+        branchMappingLogic: BranchMappingNode;
+    }[];
+};
+export type AlwaysTrueBranchMapping = {
+    version: number;
+    data: [
+        {
+            branchId: string;
+            branchMappingLogic: BranchMappingAlwaysTrue;
+        }
+    ];
+};
+export type EmptyBranchMapping = {
+    version: number;
+    data: [];
+};
+export declare function getEmptyBranchMapping(): EmptyBranchMapping;
+export declare function getAlwaysTrueBranchMapping(branchId: string): AlwaysTrueBranchMapping;
+export declare function hasEmptyBranchMap(channelInfo: ChannelBasicInfo): boolean;
+export declare function hasStandardBranchMap(channelInfo: ChannelBasicInfo): boolean;
+export declare function getStandardBranchId(channelInfo: ChannelBasicInfo): string;
+export declare function isEmptyBranchMapping(branchMapping: BranchMapping): branchMapping is EmptyBranchMapping;
+export declare function isAlwaysTrueBranchMapping(branchMapping: BranchMapping): branchMapping is AlwaysTrueBranchMapping;
+export declare function getBranchIds(branchMapping: BranchMapping): string[];
+export declare function getBranchMapping(branchMappingString: string): BranchMapping;
+export declare function getNodesFromStatement(statement: BranchMappingStatement): BranchMappingNode[];
+export declare function isAndStatement(statement: BranchMappingStatement): statement is BranchMappingStatement;
+export declare function isStatement(node: BranchMappingNode): node is BranchMappingStatement;
+export declare function isNodeObject(node: BranchMappingNode): node is BranchMappingObject;
+export declare function andStatement(nodes: BranchMappingNode[]): ['and', ...BranchMappingNode[]];
+export declare function isAlwaysTrue(node: BranchMappingNode): boolean;
+export declare function alwaysTrue(): BranchMappingAlwaysTrue;
+export declare function equalsOperator(): BranchMappingOperator;
+export declare function hashLtOperator(): BranchMappingOperator;
+export declare function assertVersion(channelInfo: ChannelBasicInfo, version: number): void;
+export declare function assertStatement(node: BranchMappingNode): asserts node is BranchMappingStatement;
+export declare function assertNodeObject(node: BranchMappingNode): asserts node is BranchMappingObject;
+export declare function assertNumber(operand: string | number | string[]): asserts operand is number;
+export declare function assertString(operand: string | number | string[]): asserts operand is string;
+export declare class BranchMappingValidationError extends Error {
+}

package/build/channel/branch-mapping.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BranchMappingValidationError = void 0;
+exports.getEmptyBranchMapping = getEmptyBranchMapping;
+exports.getAlwaysTrueBranchMapping = getAlwaysTrueBranchMapping;
+exports.hasEmptyBranchMap = hasEmptyBranchMap;
+exports.hasStandardBranchMap = hasStandardBranchMap;
+exports.getStandardBranchId = getStandardBranchId;
+exports.isEmptyBranchMapping = isEmptyBranchMapping;
+exports.isAlwaysTrueBranchMapping = isAlwaysTrueBranchMapping;
+exports.getBranchIds = getBranchIds;
+exports.getBranchMapping = getBranchMapping;
+exports.getNodesFromStatement = getNodesFromStatement;
+exports.isAndStatement = isAndStatement;
+exports.isStatement = isStatement;
+exports.isNodeObject = isNodeObject;
+exports.andStatement = andStatement;
+exports.isAlwaysTrue = isAlwaysTrue;
+exports.alwaysTrue = alwaysTrue;
+exports.equalsOperator = equalsOperator;
+exports.hashLtOperator = hashLtOperator;
+exports.assertVersion = assertVersion;
+exports.assertStatement = assertStatement;
+exports.assertNodeObject = assertNodeObject;
+exports.assertNumber = assertNumber;
+exports.assertString = assertString;
+function getEmptyBranchMapping() {
+    return {
+        version: 0,
+        data: [],
+    };
+}
+function getAlwaysTrueBranchMapping(branchId) {
+    return {
+        version: 0,
+        data: [
+            {
+                branchId,
+                branchMappingLogic: 'true',
+            },
+        ],
+    };
+}
+function hasEmptyBranchMap(channelInfo) {
+    const branchMapping = getBranchMapping(channelInfo.branchMapping);
+    return isEmptyBranchMapping(branchMapping);
+}
+function hasStandardBranchMap(channelInfo) {
+    const branchMapping = getBranchMapping(channelInfo.branchMapping);
+    return isAlwaysTrueBranchMapping(branchMapping);
+}
+function getStandardBranchId(channelInfo) {
+    const branchMapping = getBranchMapping(channelInfo.branchMapping);
+    assertAlwaysTrueBranchMapping(branchMapping);
+    return getBranchIdFromStandardMapping(branchMapping);
+}
+function isEmptyBranchMapping(branchMapping) {
+    return branchMapping.data.length === 0;
+}
+function isAlwaysTrueBranchMapping(branchMapping) {
+    const numBranches = branchMapping.data.length;
+    if (numBranches !== 1) {
+        return false;
+    }
+    const branchMappingLogic = branchMapping.data[0].branchMappingLogic;
+    return isAlwaysTrue(branchMappingLogic);
+}
+function getBranchIdFromStandardMapping(branchMapping) {
+    return branchMapping.data[0].branchId;
+}
+function getBranchIds(branchMapping) {
+    return branchMapping.data.map(data => data.branchId);
+}
+function getBranchMapping(branchMappingString) {
+    try {
+        return JSON.parse(branchMappingString);
+    }
+    catch {
+        throw new Error(`Could not parse branchMapping string into a JSON: "${branchMappingString}"`);
+    }
+}
+function getNodesFromStatement(statement) {
+    return statement.slice(1);
+}
+function isAndStatement(statement) {
+    return statement[0] === 'and';
+}
+function isStatement(node) {
+    return Array.isArray(node);
+}
+function isNodeObject(node) {
+    return typeof node === 'object' && !isStatement(node);
+}
+function andStatement(nodes) {
+    return ['and', ...nodes];
+}
+function isAlwaysTrue(node) {
+    return node === 'true';
+}
+function alwaysTrue() {
+    return 'true';
+}
+function equalsOperator() {
+    return '==';
+}
+function hashLtOperator() {
+    return 'hash_lt';
+}
+function isVersion(branchMapping, version) {
+    return branchMapping.version === version;
+}
+function assertVersion(channelInfo, version) {
+    const branchMapping = getBranchMapping(channelInfo.branchMapping);
+    if (!isVersion(branchMapping, version)) {
+        throw new BranchMappingValidationError(`Expected branch mapping version ${version}. Received: ${JSON.stringify(branchMapping)}`);
+    }
+}
+function assertStatement(node) {
+    if (!isStatement(node)) {
+        throw new BranchMappingValidationError('Branch mapping node must be a statement. Received: ' + JSON.stringify(node));
+    }
+}
+function assertNodeObject(node) {
+    if (!isNodeObject(node)) {
+        throw new BranchMappingValidationError('Branch mapping node must be an object. Received: ' + JSON.stringify(node));
+    }
+}
+function assertNumber(operand) {
+    if (typeof operand !== 'number') {
+        throw new BranchMappingValidationError('Expected a number. Received: ' + JSON.stringify(operand));
+    }
+}
+function assertString(operand) {
+    if (typeof operand !== 'string') {
+        throw new BranchMappingValidationError('Expected a string. Received: ' + JSON.stringify(operand));
+    }
+}
+function assertAlwaysTrueBranchMapping(branchMapping) {
+    if (!isAlwaysTrueBranchMapping(branchMapping)) {
+        throw new BranchMappingValidationError('Expected standard branch mapping. Received: ' + JSON.stringify(branchMapping));
+    }
+}
+class BranchMappingValidationError extends Error {
+}
+exports.BranchMappingValidationError = BranchMappingValidationError;

package/build/channel/delete.d.ts

@@ -0,0 +1,5 @@
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { BackgroundJobReceiptDataFragment } from '../graphql/generated';
+export declare function scheduleChannelDeletionAsync(graphqlClient: ExpoGraphqlClient, { channelId, }: {
+    channelId: string;
+}): Promise<BackgroundJobReceiptDataFragment>;

package/build/channel/delete.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scheduleChannelDeletionAsync = scheduleChannelDeletionAsync;
+const tslib_1 = require("tslib");
+const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
+const client_1 = require("../graphql/client");
+const BackgroundJobReceipt_1 = require("../graphql/types/BackgroundJobReceipt");
+async function scheduleChannelDeletionAsync(graphqlClient, { channelId, }) {
+    const result = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+        .mutation((0, graphql_tag_1.default) `
+          mutation ScheduleChannelDeletion($channelId: ID!) {
+            updateChannel {
+              scheduleUpdateChannelDeletion(channelId: $channelId) {
+                id
+                ...BackgroundJobReceiptData
+              }
+            }
+          }
+          ${BackgroundJobReceipt_1.BackgroundJobReceiptNode}
+        `, { channelId })
+        .toPromise());
+    return result.updateChannel.scheduleUpdateChannelDeletion;
+}

package/build/channel/errors.d.ts

@@ -0,0 +1,3 @@
+export declare class ChannelNotFoundError extends Error {
+    constructor(message?: string);
+}

package/build/channel/errors.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelNotFoundError = void 0;
+class ChannelNotFoundError extends Error {
+    constructor(message) {
+        super(message ?? 'Channel not found.');
+    }
+}
+exports.ChannelNotFoundError = ChannelNotFoundError;

package/build/channel/print-utils.d.ts

@@ -0,0 +1,7 @@
+import { UpdateChannelObject } from '../graphql/queries/ChannelQuery';
+import { FormattedBranchDescription } from '../update/utils';
+/**
+ * Log all the branches associated with the channel and their most recent update group
+ */
+export declare function logChannelDetails(channel: UpdateChannelObject): void;
+export declare function getDescriptionByBranchId(channel: UpdateChannelObject): Record<string, FormattedBranchDescription>;

package/build/channel/print-utils.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logChannelDetails = logChannelDetails;
+exports.getDescriptionByBranchId = getDescriptionByBranchId;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const branch_mapping_1 = require("./branch-mapping");
+const log_1 = tslib_1.__importDefault(require("../log"));
+const branch_mapping_2 = require("../rollout/branch-mapping");
+const utils_1 = require("../update/utils");
+/**
+ * Log all the branches associated with the channel and their most recent update group
+ */
+function logChannelDetails(channel) {
+    (0, branch_mapping_1.assertVersion)(channel, 0);
+    const doesSupportMapping = (0, branch_mapping_1.hasEmptyBranchMap)(channel) || (0, branch_mapping_1.hasStandardBranchMap)(channel) || (0, branch_mapping_2.isRollout)(channel);
+    if (!doesSupportMapping) {
+        log_1.default.log(chalk_1.default.dim('Custom branch mapping detected.'));
+        return;
+    }
+    const branchDescriptionByBranchId = getDescriptionByBranchId(channel);
+    const entries = Object.entries(branchDescriptionByBranchId);
+    if (entries.length === 0) {
+        log_1.default.log(chalk_1.default.dim('No branches are pointed to this channel.'));
+    }
+    else {
+        log_1.default.log(entries
+            .map(([_branchId, description]) => (0, utils_1.formatBranch)(description))
+            .join(`\n\n${chalk_1.default.dim('———')}\n\n`));
+    }
+}
+function getDescriptionByBranchId(channel) {
+    return channel.updateBranches.reduce((acc, branch) => {
+        const maybeRollout = (0, branch_mapping_2.isRollout)(channel) ? (0, branch_mapping_2.getRollout)(channel) : null;
+        let maybePercentOnBranch = undefined;
+        if (maybeRollout) {
+            maybePercentOnBranch =
+                maybeRollout.rolledOutBranchId === branch.id
+                    ? maybeRollout.percentRolledOut
+                    : 100 - maybeRollout.percentRolledOut;
+        }
+        if (branch.updateGroups.length === 0) {
+            acc[branch.id] = { branch: branch.name, branchRolloutPercentage: maybePercentOnBranch };
+            return acc;
+        }
+        const updateGroupsWithBranchDescriptions = (0, utils_1.getUpdateGroupDescriptionsWithBranch)(branch.updateGroups);
+        // display the most recent update group
+        const updateGroupWithBranchDescription = updateGroupsWithBranchDescriptions[0];
+        const { branch: branchName, ...updateGroup } = updateGroupWithBranchDescription;
+        acc[branch.id] = {
+            branch: branchName,
+            branchRolloutPercentage: maybePercentOnBranch,
+            update: updateGroup,
+        };
+        return acc;
+    }, {});
+}

package/build/channel/queries.d.ts

@@ -0,0 +1,46 @@
+import { ChannelBasicInfo } from './utils';
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { PaginatedQueryOptions } from '../commandUtils/pagination';
+import { CreateUpdateChannelOnAppMutation } from '../graphql/generated';
+import { UpdateChannelObject } from '../graphql/queries/ChannelQuery';
+export declare const CHANNELS_LIMIT = 25;
+export declare function selectChannelOnAppAsync(graphqlClient: ExpoGraphqlClient, { projectId, selectionPromptTitle, paginatedQueryOptions, }: {
+    projectId: string;
+    selectionPromptTitle: string;
+    paginatedQueryOptions: PaginatedQueryOptions;
+}): Promise<UpdateChannelObject>;
+export declare function listAndRenderChannelsOnAppAsync(graphqlClient: ExpoGraphqlClient, { projectId, paginatedQueryOptions, }: {
+    projectId: string;
+    paginatedQueryOptions: PaginatedQueryOptions;
+}): Promise<void>;
+export declare function listAndRenderBranchesAndUpdatesOnChannelAsync(graphqlClient: ExpoGraphqlClient, { projectId: appId, channelName, paginatedQueryOptions, }: {
+    projectId: string;
+    channelName: string;
+    paginatedQueryOptions: PaginatedQueryOptions;
+}): Promise<void>;
+export declare function createChannelOnAppAsync(graphqlClient: ExpoGraphqlClient, { appId, branchId, channelName, }: {
+    appId: string;
+    branchId: string;
+    channelName: string;
+}): Promise<CreateUpdateChannelOnAppMutation>;
+export declare function ensureChannelExistsAsync(graphqlClient: ExpoGraphqlClient, { appId, branchId, channelName }: {
+    appId: string;
+    branchId: string;
+    channelName: string;
+}): Promise<void>;
+export declare function doesChannelExistAsync(graphqlClient: ExpoGraphqlClient, { appId, channelName }: {
+    appId: string;
+    channelName: string;
+}): Promise<boolean>;
+/**
+ * Creates a channel and links it to a branch with the same name.
+ *
+ * @param appId the app ID, also known as the project ID
+ * @param channelName the name of the channel to create
+ * @param shouldPrintJson print only the JSON output
+ */
+export declare function createAndLinkChannelAsync(graphqlClient: ExpoGraphqlClient, { appId, channelName, shouldPrintJson, }: {
+    appId: string;
+    channelName: string;
+    shouldPrintJson?: boolean;
+}): Promise<ChannelBasicInfo>;