update changelog and fix lint

packages/remote-feature-flag-controller/CHANGELOG.md

@@ -11,14 +11,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Add override functionality to remote feature flags ([#7271](https://github.com/MetaMask/core/pull/7271))
   - `setFlagOverride(flagName, value)` - Set a local override for a specific feature flag
-  - `getFlagOverride(flagName)` - Get the current override value for a specific feature flag
   - `clearFlagOverride(flagName)` - Clear the local override for a specific feature flag
   - `clearAllOverrides()` - Clear all local feature flag overrides
-  - `getFlag(flagName)` - Get the effective value of a feature flag (override takes precedence over remote)
-  - `getAllFlags()` - Get all effective feature flags, combining remote flags with local overrides
-- Add A/B test visibility functionality ([#7271](https://github.com/MetaMask/core/pull/7271))
-  - `getAvailableABTestGroups(flagName)` - Get available A/B test groups for a specific feature flag
-  - `getAllABTestFlags()` - Get all feature flags that have A/B test groups available
 - Add new controller state properties ([#7271](https://github.com/MetaMask/core/pull/7271))
   - `localOverrides` - Local overrides for feature flags that take precedence over remote flags
   - `rawProcessedRemoteFeatureFlags` - Raw flag value for arrays that were processed from arrays to single value

packages/remote-feature-flag-controller/src/remote-feature-flag-controller.test.ts

@@ -783,7 +783,9 @@ describe('RemoteFeatureFlagController', () => {
         controller.setFlagOverride('testFlagForThreshold', 'overriddenValue');
 
         // Access flag value with override taking precedence
-        const flagValue = controller.state.localOverrides['testFlagForThreshold'] ?? controller.state.remoteFeatureFlags['testFlagForThreshold'];
+        const flagValue =
+          controller.state.localOverrides.testFlagForThreshold ??
+          controller.state.remoteFeatureFlags.testFlagForThreshold;
         expect(flagValue).toBe('overriddenValue');
       });
     });
@@ -799,9 +801,8 @@ describe('RemoteFeatureFlagController', () => {
 
         await controller.updateRemoteFeatureFlags();
 
-        const groups = controller.state.rawProcessedRemoteFeatureFlags[
-          'testFlagForThreshold'
-        ];
+        const groups =
+          controller.state.rawProcessedRemoteFeatureFlags.testFlagForThreshold;
 
         expect(groups).toStrictEqual([
           {
@@ -831,15 +832,15 @@ describe('RemoteFeatureFlagController', () => {
         await controller.updateRemoteFeatureFlags();
 
         expect(
-          controller.state.rawProcessedRemoteFeatureFlags['simpleFlag']
+          controller.state.rawProcessedRemoteFeatureFlags.simpleFlag,
         ).toBeUndefined();
       });
 
       it('returns undefined for non-existent flags', () => {
         const controller = createController();
 
         expect(
-          controller.state.rawProcessedRemoteFeatureFlags['nonExistentFlag']
+          controller.state.rawProcessedRemoteFeatureFlags.nonExistentFlag,
         ).toBeUndefined();
       });
     });
@@ -886,13 +887,17 @@ describe('RemoteFeatureFlagController', () => {
 
         await controller.updateRemoteFeatureFlags();
 
-        expect(controller.state.rawProcessedRemoteFeatureFlags).toStrictEqual({});
+        expect(controller.state.rawProcessedRemoteFeatureFlags).toStrictEqual(
+          {},
+        );
       });
 
       it('returns empty object when no flags exist', () => {
         const controller = createController();
 
-        expect(controller.state.rawProcessedRemoteFeatureFlags).toStrictEqual({});
+        expect(controller.state.rawProcessedRemoteFeatureFlags).toStrictEqual(
+          {},
+        );
       });
     });
 
@@ -911,15 +916,17 @@ describe('RemoteFeatureFlagController', () => {
         await controller.updateRemoteFeatureFlags();
 
         // Only A/B test flags should be stored in rawProcessedRemoteFeatureFlags
-        expect(Object.keys(controller.state.rawProcessedRemoteFeatureFlags)).toStrictEqual([
-          'testFlagForThreshold',
-        ]);
+        expect(
+          Object.keys(controller.state.rawProcessedRemoteFeatureFlags),
+        ).toStrictEqual(['testFlagForThreshold']);
         expect(
           controller.state.rawProcessedRemoteFeatureFlags.testFlagForThreshold,
         ).toStrictEqual(MOCK_FLAGS_WITH_THRESHOLD.testFlagForThreshold);
 
         // Simple flags should not be in rawProcessedRemoteFeatureFlags
-        expect(controller.state.rawProcessedRemoteFeatureFlags.simpleFlag).toBeUndefined();
+        expect(
+          controller.state.rawProcessedRemoteFeatureFlags.simpleFlag,
+        ).toBeUndefined();
         expect(
           controller.state.rawProcessedRemoteFeatureFlags.anotherSimpleFlag,
         ).toBeUndefined();
@@ -939,9 +946,8 @@ describe('RemoteFeatureFlagController', () => {
         await controller.updateRemoteFeatureFlags();
 
         // Get available groups
-        const groups = controller.state.rawProcessedRemoteFeatureFlags[
-          'testFlagForThreshold'
-        ];
+        const groups =
+          controller.state.rawProcessedRemoteFeatureFlags.testFlagForThreshold;
         expect(groups).toBeDefined();
         // Ensure groups is not undefined before accessing array elements
         if (!groups) {
@@ -950,12 +956,18 @@ describe('RemoteFeatureFlagController', () => {
         expect(groups).toHaveLength(3); // Expecting 3 groups based on MOCK_FLAGS_WITH_THRESHOLD
 
         // Override with a specific group value
-        const firstGroup = Array.isArray(groups) && groups.length > 0 ? groups[0] : null;
-        const groupValue = firstGroup && typeof firstGroup === 'object' && 'value' in firstGroup ? firstGroup.value : 'valueA';
+        const firstGroup =
+          Array.isArray(groups) && groups.length > 0 ? groups[0] : null;
+        const groupValue =
+          firstGroup && typeof firstGroup === 'object' && 'value' in firstGroup
+            ? firstGroup.value
+            : 'valueA';
         controller.setFlagOverride('testFlagForThreshold', groupValue); // groupA value
 
         // Access flag value with override taking precedence
-        const flagValue = controller.state.localOverrides['testFlagForThreshold'] ?? controller.state.remoteFeatureFlags['testFlagForThreshold'];
+        const flagValue =
+          controller.state.localOverrides.testFlagForThreshold ??
+          controller.state.remoteFeatureFlags.testFlagForThreshold;
         expect(flagValue).toBe('valueA');
       });
 
@@ -969,9 +981,8 @@ describe('RemoteFeatureFlagController', () => {
         controller.setFlagOverride('testFlagForThreshold', 'overrideValue');
 
         // A/B test raw flags should still be available
-        const groups = controller.state.rawProcessedRemoteFeatureFlags[
-          'testFlagForThreshold'
-        ];
+        const groups =
+          controller.state.rawProcessedRemoteFeatureFlags.testFlagForThreshold;
         expect(groups).toHaveLength(3);
         expect(
           controller.state.rawProcessedRemoteFeatureFlags.testFlagForThreshold,

packages/remote-feature-flag-controller/src/remote-feature-flag-controller.ts

@@ -12,7 +12,6 @@
   FeatureFlags,
   ServiceResponse,
   FeatureFlagScopeValue,
-  FeatureFlagScope,
 } from './remote-feature-flag-controller-types';
 import {
   generateDeterministicRandomNumber,
@@ -97,7 +96,7 @@
   | RemoteFeatureFlagControllerUpdateRemoteFeatureFlagsAction
   | RemoteFeatureFlagControllerSetFlagOverrideAction
   | RemoteFeatureFlagControllerClearFlagOverrideAction
-  | RemoteFeatureFlagControllerClearAllOverridesAction
+  | RemoteFeatureFlagControllerClearAllOverridesAction;
 
 export type RemoteFeatureFlagControllerStateChangeEvent =
   ControllerStateChangeEvent<
@@ -274,9 +273,10 @@
     return getVersionData(flagValue, this.#clientVersion);
   }
 
-  async #processRemoteFeatureFlags(
-    remoteFeatureFlags: FeatureFlags,
-  ): Promise<{ processedFlags: FeatureFlags; rawProcessedRemoteFeatureFlags: FeatureFlags }> {
+  async #processRemoteFeatureFlags(remoteFeatureFlags: FeatureFlags): Promise<{
+    processedFlags: FeatureFlags;
+    rawProcessedRemoteFeatureFlags: FeatureFlags;
+  }> {
     const processedRemoteFeatureFlags: FeatureFlags = {};
     const rawProcessedRemoteFeatureFlags: FeatureFlags = {};
     const metaMetricsId = this.#getMetaMetricsId();
@@ -295,8 +295,9 @@
 
       if (Array.isArray(processedValue) && thresholdValue) {
         // Store the raw A/B test array for later use
-        rawProcessedRemoteFeatureFlags[remoteFeatureFlagName] = remoteFeatureFlagValue;
+        rawProcessedRemoteFeatureFlags[remoteFeatureFlagName] =
+          remoteFeatureFlagValue;
 
         const selectedGroup = processedValue.find(
           (featureFlag): featureFlag is FeatureFlagScopeValue => {
             if (!isFeatureFlagWithScopeValue(featureFlag)) {
@@ -316,7 +317,10 @@
 
       processedRemoteFeatureFlags[remoteFeatureFlagName] = processedValue;
     }
-    return { processedFlags: processedRemoteFeatureFlags, rawProcessedRemoteFeatureFlags };
+    return {
+      processedFlags: processedRemoteFeatureFlags,
+      rawProcessedRemoteFeatureFlags,
+    };
   }
 
   /**
@@ -347,12 +351,13 @@
           ...this.state.localOverrides,
           [flagName]: value,
         },
-        rawProcessedRemoteFeatureFlags: this.state.rawProcessedRemoteFeatureFlags,
+        rawProcessedRemoteFeatureFlags:
+          this.state.rawProcessedRemoteFeatureFlags,
         cacheTimestamp: this.state.cacheTimestamp,
       };
     });
   }
-  
+
   /**
    * Clears the local override for a specific feature flag.
    *
@@ -365,7 +370,8 @@
       return {
         remoteFeatureFlags: this.state.remoteFeatureFlags,
         localOverrides: newOverrides,
-        rawProcessedRemoteFeatureFlags: this.state.rawProcessedRemoteFeatureFlags,
+        rawProcessedRemoteFeatureFlags:
+          this.state.rawProcessedRemoteFeatureFlags,
         cacheTimestamp: this.state.cacheTimestamp,
       };
     });
@@ -379,7 +385,8 @@
       return {
         remoteFeatureFlags: this.state.remoteFeatureFlags,
         localOverrides: {},
-        rawProcessedRemoteFeatureFlags: this.state.rawProcessedRemoteFeatureFlags,
+        rawProcessedRemoteFeatureFlags:
+          this.state.rawProcessedRemoteFeatureFlags,
         cacheTimestamp: this.state.cacheTimestamp,
       };
     });