refactor(snap-network-utils): rename RemoteFeatureFlagProvider to RemoteFeatureFlagsProvider

packages/snap-networks-utils/CHANGELOG.md

@@ -9,6 +9,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
-- Initial package release (#102](https://github.com/MetaMask/internal-snaps/pull/102), [#99](https://github.com/MetaMask/internal-snaps/pull/99), [#82](https://github.com/MetaMask/internal-snaps/pull/82), [#79](https://github.com/MetaMask/internal-snaps/pull/79))
+- Initial package release ([#104](https://github.com/MetaMask/internal-snaps/pull/104), [#102](https://github.com/MetaMask/internal-snaps/pull/102), [#99](https://github.com/MetaMask/internal-snaps/pull/99), [#82](https://github.com/MetaMask/internal-snaps/pull/82), [#79](https://github.com/MetaMask/internal-snaps/pull/79))
 
 [Unreleased]: https://github.com/MetaMask/internal-snaps/

packages/snap-networks-utils/src/index.ts

@@ -6,7 +6,7 @@ export {
   type AssetsProviderMessenger,
 } from './providers/assets/AssetsProvider';
 export {
-  REMOTE_FEATURE_FLAG_PROVIDER_NAME,
-  RemoteFeatureFlagProvider,
-  type RemoteFeatureFlagProviderMessenger,
-} from './providers/remote-feature-flag/RemoteFeatureFlagProvider';
+  REMOTE_FEATURE_FLAGS_PROVIDER_NAME,
+  RemoteFeatureFlagsProvider,
+  type RemoteFeatureFlagsProviderMessenger,
+} from './providers/remote-feature-flags/RemoteFeatureFlagsProvider';

packages/snap-networks-utils/src/providers/remote-feature-flag/RemoteFeatureFlagProvider.test.ts → packages/snap-networks-utils/src/providers/remote-feature-flags/RemoteFeatureFlagsProvider.test.ts

@@ -1,7 +1,7 @@
 import type { RemoteFeatureFlagControllerState } from '@metamask/remote-feature-flag-controller';
 
-import type { RemoteFeatureFlagProviderMessenger } from './RemoteFeatureFlagProvider';
-import { RemoteFeatureFlagProvider } from './RemoteFeatureFlagProvider';
+import type { RemoteFeatureFlagsProviderMessenger } from './RemoteFeatureFlagsProvider';
+import { RemoteFeatureFlagsProvider } from './RemoteFeatureFlagsProvider';
 
 const FLAG_KEY_A = 'flag-a';
 const FLAG_KEY_B = 'flag-b';
@@ -14,42 +14,42 @@ const DEFAULT_STATE: RemoteFeatureFlagControllerState = {
   cacheTimestamp: 0,
 };
 
-type WithRemoteFeatureFlagProviderCallback<ReturnValue> = (payload: {
-  remoteFeatureFlagProvider: RemoteFeatureFlagProvider;
-  mockMessenger: jest.Mocked<RemoteFeatureFlagProviderMessenger>;
+type WithRemoteFeatureFlagsProviderCallback<ReturnValue> = (payload: {
+  remoteFeatureFlagsProvider: RemoteFeatureFlagsProvider;
+  mockMessenger: jest.Mocked<RemoteFeatureFlagsProviderMessenger>;
 }) => Promise<ReturnValue> | ReturnValue;
 
 /**
- * Wraps tests for RemoteFeatureFlagProvider by creating a fresh provider with a
+ * Wraps tests for RemoteFeatureFlagsProvider by creating a fresh provider with a
  * mock messenger. The callback receives the provider and mock for test configuration.
  *
  * @param testFunction - The test body receiving the provider and mocks.
  * @returns The return value of the callback.
  */
-async function withRemoteFeatureFlagProvider<ReturnValue>(
-  testFunction: WithRemoteFeatureFlagProviderCallback<ReturnValue>,
+async function withRemoteFeatureFlagsProvider<ReturnValue>(
+  testFunction: WithRemoteFeatureFlagsProviderCallback<ReturnValue>,
 ): Promise<ReturnValue> {
-  const mockMessenger: jest.Mocked<RemoteFeatureFlagProviderMessenger> = {
+  const mockMessenger: jest.Mocked<RemoteFeatureFlagsProviderMessenger> = {
     call: jest.fn().mockResolvedValue(DEFAULT_STATE),
   };
 
-  const remoteFeatureFlagProvider = new RemoteFeatureFlagProvider({
+  const remoteFeatureFlagsProvider = new RemoteFeatureFlagsProvider({
     messenger: mockMessenger,
   });
 
   return await testFunction({
-    remoteFeatureFlagProvider,
+    remoteFeatureFlagsProvider,
     mockMessenger,
   });
 }
 
-describe('RemoteFeatureFlagProvider', () => {
+describe('RemoteFeatureFlagsProvider', () => {
   describe('getFeatureFlag', () => {
-    it('calls RemoteFeatureFlagController:getState and returns the flag value', async () => {
-      await withRemoteFeatureFlagProvider(
-        async ({ remoteFeatureFlagProvider, mockMessenger }) => {
+    it('calls `RemoteFeatureFlagController:getState` and returns the flag value', async () => {
+      await withRemoteFeatureFlagsProvider(
+        async ({ remoteFeatureFlagsProvider, mockMessenger }) => {
           const value =
-            await remoteFeatureFlagProvider.getFeatureFlag(FLAG_KEY_A);
+            await remoteFeatureFlagsProvider.getFeatureFlag(FLAG_KEY_A);
 
           expect(mockMessenger.call).toHaveBeenCalledWith(
             'RemoteFeatureFlagController:getState',
@@ -61,10 +61,10 @@ describe('RemoteFeatureFlagProvider', () => {
     });
 
     it('returns undefined when the flag key is missing', async () => {
-      await withRemoteFeatureFlagProvider(
-        async ({ remoteFeatureFlagProvider }) => {
+      await withRemoteFeatureFlagsProvider(
+        async ({ remoteFeatureFlagsProvider }) => {
           const value =
-            await remoteFeatureFlagProvider.getFeatureFlag('missing-flag');
+            await remoteFeatureFlagsProvider.getFeatureFlag('missing-flag');
 
           expect(value).toBeUndefined();
         },
@@ -73,10 +73,10 @@ describe('RemoteFeatureFlagProvider', () => {
   });
 
   describe('getFeatureFlags', () => {
-    it('calls RemoteFeatureFlagController:getState once and returns a keyed map', async () => {
-      await withRemoteFeatureFlagProvider(
-        async ({ remoteFeatureFlagProvider, mockMessenger }) => {
-          const values = await remoteFeatureFlagProvider.getFeatureFlags([
+    it('calls `RemoteFeatureFlagController:getState` once and returns a keyed map', async () => {
+      await withRemoteFeatureFlagsProvider(
+        async ({ remoteFeatureFlagsProvider, mockMessenger }) => {
+          const values = await remoteFeatureFlagsProvider.getFeatureFlags([
             FLAG_KEY_A,
             FLAG_KEY_B,
             'missing-flag',
@@ -96,9 +96,9 @@ describe('RemoteFeatureFlagProvider', () => {
     });
 
     it('returns an empty map when no keys are requested', async () => {
-      await withRemoteFeatureFlagProvider(
-        async ({ remoteFeatureFlagProvider, mockMessenger }) => {
-          const values = await remoteFeatureFlagProvider.getFeatureFlags([]);
+      await withRemoteFeatureFlagsProvider(
+        async ({ remoteFeatureFlagsProvider, mockMessenger }) => {
+          const values = await remoteFeatureFlagsProvider.getFeatureFlags([]);
 
           expect(mockMessenger.call).toHaveBeenCalledWith(
             'RemoteFeatureFlagController:getState',

packages/snap-networks-utils/src/providers/remote-feature-flag/RemoteFeatureFlagProvider.ts → packages/snap-networks-utils/src/providers/remote-feature-flags/RemoteFeatureFlagsProvider.ts

@@ -4,34 +4,34 @@ import { AsyncMessenger } from '@metamask/snaps-sdk';
 import type { Json } from '@metamask/utils';
 
 /**
- * Namespace for the {@link RemoteFeatureFlagProvider} messenger.
+ * Namespace for the {@link RemoteFeatureFlagsProvider} messenger.
  */
-export const REMOTE_FEATURE_FLAG_PROVIDER_NAME =
-  'RemoteFeatureFlagProvider' as const;
+export const REMOTE_FEATURE_FLAGS_PROVIDER_NAME =
+  'RemoteFeatureFlagsProvider' as const;
 
 /**
- * Actions from other messengers that {@link RemoteFeatureFlagProvider} calls.
+ * Actions from other messengers that {@link RemoteFeatureFlagsProvider} calls.
  */
-export type RemoteFeatureFlagProviderAllowedActions =
+export type RemoteFeatureFlagsProviderAllowedActions =
   RemoteFeatureFlagControllerGetStateAction;
 
 /**
- * Messenger restricted to actions consumed by {@link RemoteFeatureFlagProvider}.
+ * Messenger restricted to actions consumed by {@link RemoteFeatureFlagsProvider}.
  */
-export type RemoteFeatureFlagProviderMessenger = AsyncMessenger<
+export type RemoteFeatureFlagsProviderMessenger = AsyncMessenger<
   Messenger<
-    typeof REMOTE_FEATURE_FLAG_PROVIDER_NAME,
-    RemoteFeatureFlagProviderAllowedActions
+    typeof REMOTE_FEATURE_FLAGS_PROVIDER_NAME,
+    RemoteFeatureFlagsProviderAllowedActions
   >
 >;
 
-export class RemoteFeatureFlagProvider {
-  readonly #messenger: RemoteFeatureFlagProviderMessenger;
+export class RemoteFeatureFlagsProvider {
+  readonly #messenger: RemoteFeatureFlagsProviderMessenger;
 
   constructor({
     messenger,
   }: {
-    messenger: RemoteFeatureFlagProviderMessenger;
+    messenger: RemoteFeatureFlagsProviderMessenger;
   }) {
     this.#messenger = messenger;
   }