eas-cli 3.17.1 → 3.18.0

package/build/commands/build/version/get.js

@@ -39,6 +39,7 @@ class BuildVersionGetView extends EasCommand_1.default {
             easJsonAccessor,
             platforms,
             profileName: (_b = flags.profile) !== null && _b !== void 0 ? _b : undefined,
+            projectDir,
         });
         const results = {};
         for (const { profile, platform } of buildProfiles) {

package/build/commands/build/version/sync.js

@@ -38,6 +38,7 @@ class BuildVersionSyncView extends EasCommand_1.default {
             easJsonAccessor,
             platforms,
             profileName: (_b = flags.profile) !== null && _b !== void 0 ? _b : undefined,
+            projectDir,
         });
         for (const profileInfo of buildProfiles) {
             const { exp, projectId } = await getDynamicPrivateProjectConfigAsync({

package/build/commands/metadata/lint.js

@@ -28,6 +28,7 @@ class MetadataLint extends EasCommand_1.default {
             easJsonAccessor: eas_json_1.EasJsonAccessor.fromProjectPath(projectDir),
             platforms: [eas_build_job_1.Platform.IOS],
             profileName: flags.profile,
+            projectDir,
         });
         if (submitProfiles.length !== 1) {
             throw new Error('Metadata only supports iOS and a single submit profile.');

package/build/commands/metadata/pull.js

@@ -28,6 +28,7 @@ class MetadataPull extends EasCommand_1.default {
             easJsonAccessor: eas_json_1.EasJsonAccessor.fromProjectPath(projectDir),
             platforms: [eas_build_job_1.Platform.IOS],
             profileName: flags.profile,
+            projectDir,
         });
         if (submitProfiles.length !== 1) {
             throw new Error('Metadata only supports iOS and a single submit profile.');

package/build/commands/metadata/push.js

@@ -26,6 +26,7 @@ class MetadataPush extends EasCommand_1.default {
             easJsonAccessor: eas_json_1.EasJsonAccessor.fromProjectPath(projectDir),
             platforms: [eas_build_job_1.Platform.IOS],
             profileName: flags.profile,
+            projectDir,
         });
         if (submitProfiles.length !== 1) {
             throw new Error('Metadata only supports iOS and a single submit profile.');

package/build/commands/submit.js

@@ -30,6 +30,7 @@ class Submit extends EasCommand_1.default {
             easJsonAccessor: eas_json_1.EasJsonAccessor.fromProjectPath(projectDir),
             platforms,
             profileName: flagsWithPlatform.profile,
+            projectDir,
         });
         const submissions = [];
         for (const submissionProfile of submissionProfiles) {

package/build/eas-update/utils.d.ts

@@ -0,0 +1,15 @@
+import { ExpoConfig } from '@expo/config-types';
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+export type EASUpdateContext = {
+    graphqlClient: ExpoGraphqlClient;
+    nonInteractive: boolean;
+    app: {
+        exp: ExpoConfig;
+        projectId: string;
+    };
+};
+export interface EASUpdateAction<T = any> {
+    runAsync(ctx: EASUpdateContext): Promise<T>;
+}
+export declare class NonInteractiveError extends Error {
+}

package/build/eas-update/utils.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NonInteractiveError = void 0;
+class NonInteractiveError extends Error {
+}
+exports.NonInteractiveError = NonInteractiveError;

package/build/project/ios/target.d.ts

@@ -9,7 +9,7 @@ interface ResolveTargetOptions {
     env?: Record<string, string>;
     xcodeBuildContext: XcodeBuildContext;
 }
-export declare function resolveMangedProjectTargetsAsync({ exp, projectDir, xcodeBuildContext, env, }: ResolveTargetOptions): Promise<Target[]>;
+export declare function resolveManagedProjectTargetsAsync({ exp, projectDir, xcodeBuildContext, env, }: ResolveTargetOptions): Promise<Target[]>;
 export declare function resolveBareProjectTargetsAsync({ exp, projectDir, xcodeBuildContext, }: ResolveTargetOptions): Promise<Target[]>;
 export declare function resolveTargetsAsync(opts: ResolveTargetOptions): Promise<Target[]>;
 export declare function findApplicationTarget(targets: Target[]): Target;

package/build/project/ios/target.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getApplePlatformFromDeviceFamily = exports.getApplePlatformFromSdkRoot = exports.getApplePlatformFromTarget = exports.findTargetByName = exports.findApplicationTarget = exports.resolveTargetsAsync = exports.resolveBareProjectTargetsAsync = exports.resolveMangedProjectTargetsAsync = void 0;
+exports.getApplePlatformFromDeviceFamily = exports.getApplePlatformFromSdkRoot = exports.getApplePlatformFromTarget = exports.findTargetByName = exports.findApplicationTarget = exports.resolveTargetsAsync = exports.resolveBareProjectTargetsAsync = exports.resolveManagedProjectTargetsAsync = void 0;
 const tslib_1 = require("tslib");
 const config_plugins_1 = require("@expo/config-plugins");
 const eas_build_job_1 = require("@expo/eas-build-job");
@@ -15,7 +15,7 @@ const AppExtensionsConfigSchema = joi_1.default.array().items(joi_1.default.obje
     parentBundleIdentifier: joi_1.default.string(),
     entitlements: joi_1.default.object(),
 }));
-async function resolveMangedProjectTargetsAsync({ exp, projectDir, xcodeBuildContext, env, }) {
+async function resolveManagedProjectTargetsAsync({ exp, projectDir, xcodeBuildContext, env, }) {
     var _a, _b, _c, _d, _e, _f;
     const { buildScheme, buildConfiguration } = xcodeBuildContext;
     const applicationTargetName = buildScheme;
@@ -52,7 +52,7 @@ async function resolveMangedProjectTargetsAsync({ exp, projectDir, xcodeBuildCon
         ...extensionsTargets,
     ];
 }
-exports.resolveMangedProjectTargetsAsync = resolveMangedProjectTargetsAsync;
+exports.resolveManagedProjectTargetsAsync = resolveManagedProjectTargetsAsync;
 async function resolveBareProjectTargetsAsync({ exp, projectDir, xcodeBuildContext, }) {
     const { buildScheme, buildConfiguration } = xcodeBuildContext;
     const result = [];
@@ -93,7 +93,7 @@ async function resolveTargetsAsync(opts) {
         return await resolveBareProjectTargetsAsync(opts);
     }
     else if (workflow === eas_build_job_1.Workflow.MANAGED) {
-        return await resolveMangedProjectTargetsAsync(opts);
+        return await resolveManagedProjectTargetsAsync(opts);
     }
     else {
         throw new Error(`Unknown workflow: ${workflow}`);

package/build/rollout/actions/SelectRollout.d.ts

@@ -0,0 +1,8 @@
+import { EASUpdateAction, EASUpdateContext } from '../../eas-update/utils';
+import { UpdateChannelBasicInfoFragment } from '../../graphql/generated';
+/**
+ * Select an existing rollout for the project.
+ */
+export declare class SelectRollout implements EASUpdateAction<UpdateChannelBasicInfoFragment | null> {
+    runAsync(ctx: EASUpdateContext): Promise<UpdateChannelBasicInfoFragment | null>;
+}

package/build/rollout/actions/SelectRollout.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectRollout = void 0;
+const SelectChannel_1 = require("../../channel/actions/SelectChannel");
+const branch_mapping_1 = require("../../channel/branch-mapping");
+const branch_mapping_2 = require("../branch-mapping");
+/**
+ * Select an existing rollout for the project.
+ */
+class SelectRollout {
+    async runAsync(ctx) {
+        const rolloutFilterPredicate = (channelInfo) => {
+            const branchMapping = (0, branch_mapping_1.getBranchMapping)(channelInfo.branchMapping);
+            return (0, branch_mapping_2.isRollout)(branchMapping);
+        };
+        const selectChannel = new SelectChannel_1.SelectChannel({
+            printedType: 'rollout',
+            filterPredicate: rolloutFilterPredicate,
+        });
+        return await selectChannel.runAsync(ctx);
+    }
+}
+exports.SelectRollout = SelectRollout;

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

@@ -0,0 +1,80 @@
+import { BranchMapping } from '../channel/branch-mapping';
+import { UpdateChannelBasicInfoFragment } from '../graphql/generated';
+import { UpdateBranchObject, UpdateChannelObject } from '../graphql/queries/ChannelQuery';
+export type Rollout = LegacyRollout | ConstrainedRollout;
+export type RolloutInfo = LegacyRolloutInfo | ConstrainedRolloutInfo;
+type ConstrainedRollout = LegacyRollout & {
+    runtimeVersion: string;
+};
+type LegacyRollout = {
+    rolledOutBranch: UpdateBranchObject;
+    defaultBranch: UpdateBranchObject;
+} & LegacyRolloutInfo;
+type ConstrainedRolloutInfo = LegacyRolloutInfo & {
+    runtimeVersion: string;
+};
+type LegacyRolloutInfo = {
+    rolledOutBranchId: string;
+    percentRolledOut: number;
+    defaultBranchId: string;
+};
+export declare function isLegacyRolloutInfo(rollout: RolloutInfo): rollout is LegacyRolloutInfo;
+export declare function isConstrainedRolloutInfo(rollout: RolloutInfo): rollout is ConstrainedRolloutInfo;
+export declare function isConstrainedRollout(rollout: Rollout): rollout is ConstrainedRollout;
+export declare function getRolloutInfo(basicChannelInfo: UpdateChannelBasicInfoFragment): RolloutInfo;
+export declare function getRolloutInfoFromBranchMapping(branchMapping: BranchMapping): RolloutInfo;
+export declare function getRollout(channel: UpdateChannelObject): Rollout;
+/**
+ * Detect if a branch mapping is a rollout.
+ *
+ * Types of rollout:
+ * 1. Legacy unconstrained rollout:
+ * Maps to a rollout branch via a rollout token
+ * Falls back to a default branch
+ *
+ * Example:
+ * {
+    version: 0,
+    data: [
+      {
+        branchId: uuidv4(),
+        branchMappingLogic: {
+          operand: 10 / 100,
+          clientKey: 'rolloutToken',
+          branchMappingOperator: hashLtOperator(),
+        },
+      },
+      { branchId: uuidv4(), branchMappingLogic: alwaysTrue() },
+    ],
+  }
+  *
+  * 2. RTV constrained rollout:
+  * Maps to a rollout branch via a rollout token, constrained by runtime version
+  * Falls back to a default branch
+  *
+  * Example:
+  * {
+    version: 0,
+    data: [
+      {
+        branchId: uuidv4(),
+        branchMappingLogic: andStatement([
+          {
+            operand: '1.0.0',
+            clientKey: 'runtimeVersion',
+            branchMappingOperator: equalsOperator(),
+          },
+          {
+            operand: 10 / 100,
+            clientKey: 'rolloutToken',
+            branchMappingOperator: hashLtOperator(),
+          },
+        ]),
+      },
+      { branchId: uuidv4(), branchMappingLogic: alwaysTrue() },
+    ],
+  }
+ */
+export declare function isRollout(branchMapping: BranchMapping): boolean;
+export declare function editRolloutBranchMapping(branchMapping: BranchMapping, percent: number): BranchMapping;
+export {};

package/build/rollout/branch-mapping.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.editRolloutBranchMapping = exports.isRollout = exports.getRollout = exports.getRolloutInfoFromBranchMapping = exports.getRolloutInfo = exports.isConstrainedRollout = exports.isConstrainedRolloutInfo = exports.isLegacyRolloutInfo = void 0;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const branch_mapping_1 = require("../channel/branch-mapping");
+const utils_1 = require("../channel/utils");
+function isLegacyRolloutInfo(rollout) {
+    return !isConstrainedRolloutInfo(rollout);
+}
+exports.isLegacyRolloutInfo = isLegacyRolloutInfo;
+function isConstrainedRolloutInfo(rollout) {
+    return 'runtimeVersion' in rollout;
+}
+exports.isConstrainedRolloutInfo = isConstrainedRolloutInfo;
+function isConstrainedRollout(rollout) {
+    return isConstrainedRolloutInfo(rollout);
+}
+exports.isConstrainedRollout = isConstrainedRollout;
+function getRolloutInfo(basicChannelInfo) {
+    const branchMapping = (0, branch_mapping_1.getBranchMapping)(basicChannelInfo.branchMapping);
+    assertRollout(branchMapping);
+    return getRolloutInfoFromBranchMapping(branchMapping);
+}
+exports.getRolloutInfo = getRolloutInfo;
+function getRolloutInfoFromBranchMapping(branchMapping) {
+    assertRollout(branchMapping);
+    const rolledOutBranchId = branchMapping.data[0].branchId;
+    const defaultBranchId = branchMapping.data[1].branchId;
+    if (isRtvConstrainedRollout(branchMapping)) {
+        const statementNode = branchMapping.data[0].branchMappingLogic;
+        (0, branch_mapping_1.assertStatement)(statementNode);
+        const nodesFromStatement = (0, branch_mapping_1.getNodesFromStatement)(statementNode);
+        const runtimeVersionNode = nodesFromStatement.find(isRuntimeVersionNode);
+        (0, assert_1.default)(runtimeVersionNode, 'Runtime version node must be defined.');
+        (0, branch_mapping_1.assertNodeObject)(runtimeVersionNode);
+        const runtimeVersion = runtimeVersionNode.operand;
+        (0, branch_mapping_1.assertString)(runtimeVersion);
+        const rolloutNode = nodesFromStatement.find(isRolloutNode);
+        (0, assert_1.default)(rolloutNode, 'Rollout node must be defined.');
+        (0, branch_mapping_1.assertNodeObject)(rolloutNode);
+        const operand = rolloutNode.operand;
+        (0, branch_mapping_1.assertNumber)(operand);
+        return {
+            rolledOutBranchId,
+            percentRolledOut: operand * 100,
+            runtimeVersion,
+            defaultBranchId,
+        };
+    }
+    else {
+        const rolloutNode = branchMapping.data[0].branchMappingLogic;
+        (0, branch_mapping_1.assertNodeObject)(rolloutNode);
+        const operand = rolloutNode.operand;
+        (0, branch_mapping_1.assertNumber)(operand);
+        return {
+            rolledOutBranchId,
+            percentRolledOut: operand * 100,
+            defaultBranchId,
+        };
+    }
+}
+exports.getRolloutInfoFromBranchMapping = getRolloutInfoFromBranchMapping;
+function getRollout(channel) {
+    const branchMapping = (0, branch_mapping_1.getBranchMapping)(channel.branchMapping);
+    assertRollout(branchMapping);
+    const rolledOutBranchId = branchMapping.data[0].branchId;
+    const rolledOutBranch = (0, utils_1.getUpdateBranch)(channel, rolledOutBranchId);
+    const defaultBranchId = branchMapping.data[1].branchId;
+    const defaultBranch = (0, utils_1.getUpdateBranch)(channel, defaultBranchId);
+    const rolloutInfo = getRolloutInfo(channel);
+    return {
+        ...rolloutInfo,
+        rolledOutBranch,
+        defaultBranch,
+    };
+}
+exports.getRollout = getRollout;
+/**
+ * Detect if a branch mapping is a rollout.
+ *
+ * Types of rollout:
+ * 1. Legacy unconstrained rollout:
+ * Maps to a rollout branch via a rollout token
+ * Falls back to a default branch
+ *
+ * Example:
+ * {
+    version: 0,
+    data: [
+      {
+        branchId: uuidv4(),
+        branchMappingLogic: {
+          operand: 10 / 100,
+          clientKey: 'rolloutToken',
+          branchMappingOperator: hashLtOperator(),
+        },
+      },
+      { branchId: uuidv4(), branchMappingLogic: alwaysTrue() },
+    ],
+  }
+  *
+  * 2. RTV constrained rollout:
+  * Maps to a rollout branch via a rollout token, constrained by runtime version
+  * Falls back to a default branch
+  *
+  * Example:
+  * {
+    version: 0,
+    data: [
+      {
+        branchId: uuidv4(),
+        branchMappingLogic: andStatement([
+          {
+            operand: '1.0.0',
+            clientKey: 'runtimeVersion',
+            branchMappingOperator: equalsOperator(),
+          },
+          {
+            operand: 10 / 100,
+            clientKey: 'rolloutToken',
+            branchMappingOperator: hashLtOperator(),
+          },
+        ]),
+      },
+      { branchId: uuidv4(), branchMappingLogic: alwaysTrue() },
+    ],
+  }
+ */
+function isRollout(branchMapping) {
+    return isUnconstrainedRollout(branchMapping) || isRtvConstrainedRollout(branchMapping);
+}
+exports.isRollout = isRollout;
+function editRolloutBranchMapping(branchMapping, percent) {
+    (0, assert_1.default)(Number.isInteger(percent) && percent >= 0 && percent <= 100, 'The rollout percentage must be an integer between 0 and 100 inclusive.');
+    assertRollout(branchMapping);
+    if (isRtvConstrainedRollout(branchMapping)) {
+        return editRtvConstrainedRollout(branchMapping, percent);
+    }
+    else {
+        return editLegacyRollout(branchMapping, percent);
+    }
+}
+exports.editRolloutBranchMapping = editRolloutBranchMapping;
+function editRtvConstrainedRollout(branchMapping, percent) {
+    const newBranchMapping = { ...branchMapping };
+    const statementNode = newBranchMapping.data[0].branchMappingLogic;
+    (0, branch_mapping_1.assertStatement)(statementNode);
+    const nodesFromStatement = (0, branch_mapping_1.getNodesFromStatement)(statementNode);
+    const rolloutNode = nodesFromStatement.find(isRolloutNode);
+    (0, assert_1.default)(rolloutNode, 'Rollout node must be defined.');
+    (0, branch_mapping_1.assertNodeObject)(rolloutNode);
+    rolloutNode.operand = percent / 100;
+    return newBranchMapping;
+}
+function editLegacyRollout(branchMapping, percent) {
+    const newBranchMapping = { ...branchMapping };
+    const rolloutNode = newBranchMapping.data[0].branchMappingLogic;
+    (0, branch_mapping_1.assertNodeObject)(rolloutNode);
+    rolloutNode.operand = percent / 100;
+    return newBranchMapping;
+}
+function assertRollout(branchMapping) {
+    (0, assert_1.default)(isRollout(branchMapping), 'Branch mapping node must be a rollout. Received: ' + JSON.stringify(branchMapping));
+}
+function isRtvConstrainedRollout(branchMapping) {
+    if (branchMapping.data.length !== 2) {
+        return false;
+    }
+    const hasRtvRolloutNode = isRtvConstrainedRolloutNode(branchMapping.data[0].branchMappingLogic);
+    const defaultsToAlwaysTrueNode = (0, branch_mapping_1.isAlwaysTrue)(branchMapping.data[1].branchMappingLogic);
+    return hasRtvRolloutNode && defaultsToAlwaysTrueNode;
+}
+function isRtvConstrainedRolloutNode(node) {
+    if (!(0, branch_mapping_1.isStatement)(node) || !(0, branch_mapping_1.isAndStatement)(node)) {
+        return false;
+    }
+    const statementNodes = (0, branch_mapping_1.getNodesFromStatement)(node);
+    if (statementNodes.length !== 2) {
+        return false;
+    }
+    const hasRuntimeVersionNode = statementNodes.some(isRuntimeVersionNode);
+    const hasRolloutNode = statementNodes.some(isRolloutNode);
+    return hasRuntimeVersionNode && hasRolloutNode;
+}
+function isUnconstrainedRollout(branchMapping) {
+    if (branchMapping.data.length !== 2) {
+        return false;
+    }
+    const hasRolloutNode = isRolloutNode(branchMapping.data[0].branchMappingLogic);
+    const defaultsToAlwaysTrueNode = (0, branch_mapping_1.isAlwaysTrue)(branchMapping.data[1].branchMappingLogic);
+    return hasRolloutNode && defaultsToAlwaysTrueNode;
+}
+function isRuntimeVersionNode(node) {
+    if (typeof node === 'string') {
+        return false;
+    }
+    if (Array.isArray(node)) {
+        return false;
+    }
+    return node.clientKey === 'runtimeVersion' && node.branchMappingOperator === '==';
+}
+function isRolloutNode(node) {
+    if (typeof node === 'string') {
+        return false;
+    }
+    if (Array.isArray(node)) {
+        return false;
+    }
+    return node.clientKey === 'rolloutToken' && node.branchMappingOperator === 'hash_lt';
+}

package/build/rollout/utils.d.ts

@@ -1,53 +1,3 @@
-import { BranchMapping } from '../channel/branch-mapping';
-/**
- * Detect if a branch mapping is a rollout.
- *
- * Types of rollout:
- * 1. Legacy unconstrained rollout:
- * Maps to a rollout branch via a rollout token
- * Falls back to a default branch
- *
- * Example:
- * {
-    version: 0,
-    data: [
-      {
-        branchId: uuidv4(),
-        branchMappingLogic: {
-          operand: 10 / 100,
-          clientKey: 'rolloutToken',
-          branchMappingOperator: hashLtOperator(),
-        },
-      },
-      { branchId: uuidv4(), branchMappingLogic: alwaysTrue() },
-    ],
-  }
-  *
-  * 2. RTV constrained rollout:
-  * Maps to a rollout branch via a rollout token, constrained by runtime version
-  * Falls back to a default branch
-  *
-  * Example:
-  * {
-    version: 0,
-    data: [
-      {
-        branchId: uuidv4(),
-        branchMappingLogic: andStatement([
-          {
-            operand: '1.0.0',
-            clientKey: 'runtimeVersion',
-            branchMappingOperator: equalsOperator(),
-          },
-          {
-            operand: 10 / 100,
-            clientKey: 'rolloutToken',
-            branchMappingOperator: hashLtOperator(),
-          },
-        ]),
-      },
-      { branchId: uuidv4(), branchMappingLogic: alwaysTrue() },
-    ],
-  }
- */
-export declare function isRollout(branchMapping: BranchMapping): boolean;
+import { UpdateChannelObject } from '../graphql/queries/ChannelQuery';
+export declare function printRollout(channel: UpdateChannelObject): void;
+export declare function printBranch(channel: UpdateChannelObject): void;

package/build/rollout/utils.js

@@ -1,105 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRollout = void 0;
-const branch_mapping_1 = require("../channel/branch-mapping");
-/**
- * Detect if a branch mapping is a rollout.
- *
- * Types of rollout:
- * 1. Legacy unconstrained rollout:
- * Maps to a rollout branch via a rollout token
- * Falls back to a default branch
- *
- * Example:
- * {
-    version: 0,
-    data: [
-      {
-        branchId: uuidv4(),
-        branchMappingLogic: {
-          operand: 10 / 100,
-          clientKey: 'rolloutToken',
-          branchMappingOperator: hashLtOperator(),
+exports.printBranch = exports.printRollout = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const log_1 = tslib_1.__importDefault(require("../log"));
+const formatFields_1 = tslib_1.__importDefault(require("../utils/formatFields"));
+const branch_mapping_1 = require("./branch-mapping");
+function printRollout(channel) {
+    const rollout = (0, branch_mapping_1.getRollout)(channel);
+    const rolledOutPercent = rollout.percentRolledOut;
+    log_1.default.addNewLineIfNone();
+    log_1.default.log(chalk_1.default.bold('Rollout:'));
+    log_1.default.log((0, formatFields_1.default)([
+        { label: 'Channel', value: channel.name },
+        ...((0, branch_mapping_1.isConstrainedRollout)(rollout)
+            ? [{ label: 'Runtime Version', value: rollout.runtimeVersion }]
+            : []),
+        {
+            label: 'Branches',
+            value: `${rollout.rolledOutBranch.name} (${rolledOutPercent}%), ${rollout.defaultBranch.name} (${100 - rolledOutPercent}%)`,
         },
-      },
-      { branchId: uuidv4(), branchMappingLogic: alwaysTrue() },
-    ],
-  }
-  *
-  * 2. RTV constrained rollout:
-  * Maps to a rollout branch via a rollout token, constrained by runtime version
-  * Falls back to a default branch
-  *
-  * Example:
-  * {
-    version: 0,
-    data: [
-      {
-        branchId: uuidv4(),
-        branchMappingLogic: andStatement([
-          {
-            operand: '1.0.0',
-            clientKey: 'runtimeVersion',
-            branchMappingOperator: equalsOperator(),
-          },
-          {
-            operand: 10 / 100,
-            clientKey: 'rolloutToken',
-            branchMappingOperator: hashLtOperator(),
-          },
-        ]),
-      },
-      { branchId: uuidv4(), branchMappingLogic: alwaysTrue() },
-    ],
-  }
- */
-function isRollout(branchMapping) {
-    return isUnconstrainedRollout(branchMapping) || isRtvConstrainedRollout(branchMapping);
+    ]));
+    log_1.default.addNewLineIfNone();
 }
-exports.isRollout = isRollout;
-function isRtvConstrainedRollout(branchMapping) {
-    if (branchMapping.data.length !== 2) {
-        return false;
-    }
-    const hasRtvRolloutNode = isRtvConstrainedRolloutNode(branchMapping.data[0].branchMappingLogic);
-    const defaultsToAlwaysTrueNode = (0, branch_mapping_1.isAlwaysTrue)(branchMapping.data[1].branchMappingLogic);
-    return hasRtvRolloutNode && defaultsToAlwaysTrueNode;
-}
-function isRtvConstrainedRolloutNode(node) {
-    if (!(0, branch_mapping_1.isStatement)(node) || !(0, branch_mapping_1.isAndStatement)(node)) {
-        return false;
-    }
-    const statementNodes = (0, branch_mapping_1.getNodesFromStatement)(node);
-    if (statementNodes.length !== 2) {
-        return false;
-    }
-    const hasRuntimeVersionNode = statementNodes.some(isRuntimeVersionNode);
-    const hasRolloutNode = statementNodes.some(isRolloutNode);
-    return hasRuntimeVersionNode && hasRolloutNode;
-}
-function isUnconstrainedRollout(branchMapping) {
-    if (branchMapping.data.length !== 2) {
-        return false;
-    }
-    const hasRolloutNode = isRolloutNode(branchMapping.data[0].branchMappingLogic);
-    const defaultsToAlwaysTrueNode = (0, branch_mapping_1.isAlwaysTrue)(branchMapping.data[1].branchMappingLogic);
-    return hasRolloutNode && defaultsToAlwaysTrueNode;
-}
-function isRuntimeVersionNode(node) {
-    if (typeof node === 'string') {
-        return false;
-    }
-    if (Array.isArray(node)) {
-        return false;
-    }
-    return node.clientKey === 'runtimeVersion' && node.branchMappingOperator === '==';
-}
-function isRolloutNode(node) {
-    if (typeof node === 'string') {
-        return false;
-    }
-    if (Array.isArray(node)) {
-        return false;
-    }
-    return node.clientKey === 'rolloutToken' && node.branchMappingOperator === 'hash_lt';
+exports.printRollout = printRollout;
+function printBranch(channel) {
+    const rollout = (0, branch_mapping_1.getRollout)(channel);
+    const rolledOutPercent = rollout.percentRolledOut;
+    log_1.default.addNewLineIfNone();
+    log_1.default.log(chalk_1.default.bold('Rollout:'));
+    log_1.default.log((0, formatFields_1.default)([
+        { label: 'Channel', value: channel.name },
+        ...((0, branch_mapping_1.isConstrainedRollout)(rollout)
+            ? [{ label: 'Runtime Version', value: rollout.runtimeVersion }]
+            : []),
+        {
+            label: 'Branches',
+            value: `${rollout.rolledOutBranch.name} (${rolledOutPercent}%), ${rollout.defaultBranch.name} (${100 - rolledOutPercent}%)`,
+        },
+    ]));
+    log_1.default.addNewLineIfNone();
 }
+exports.printBranch = printBranch;

package/build/utils/profiles.d.ts

@@ -6,10 +6,11 @@ export type ProfileData<T extends ProfileType> = {
     platform: Platform;
     profileName: string;
 };
-export declare function getProfilesAsync<T extends ProfileType>({ easJsonAccessor, platforms, profileName, type, }: {
+export declare function getProfilesAsync<T extends ProfileType>({ easJsonAccessor, platforms, profileName, type, projectDir, }: {
     easJsonAccessor: EasJsonAccessor;
     platforms: Platform[];
     profileName?: string;
+    projectDir: string;
     type: T;
 }): Promise<ProfileData<T>[]>;
 /**