@metamask-previews/config-registry-controller 0.0.0-preview-32ed9958c

package/dist/selectors.d.cts

@@ -0,0 +1,314 @@
+import type { RegistryNetworkConfig } from "./config-registry-api-service/index.cjs";
+import type { ConfigRegistryControllerState } from "./ConfigRegistryController.cjs";
+/**
+ * Base selector to get all networks from the controller state.
+ *
+ * @param state - The ConfigRegistryController state
+ * @returns All network configurations keyed by chain ID
+ */
+export declare const selectNetworks: (state: ConfigRegistryControllerState) => Record<string, RegistryNetworkConfig>;
+/**
+ * Selector to get featured, active, non-testnet networks.
+ * Use this for the default network list (e.g. main network picker).
+ *
+ * @param state - The ConfigRegistryController state
+ * @returns Filtered network configurations keyed by chain ID
+ */
+export declare const selectFeaturedNetworks: ((state: ConfigRegistryControllerState) => Record<string, {
+    imageUrl: string;
+    name: string;
+    chainId: string;
+    coingeckoPlatformId: string;
+    assets: {
+        listUrl: string;
+        native: {
+            symbol: string;
+            assetId: string;
+            imageUrl: string;
+            name: string;
+            decimals: number;
+            coingeckoCoinId: string;
+        };
+        governance?: {
+            symbol: string;
+            assetId: string;
+            imageUrl: string;
+            name: string;
+            decimals: number;
+            coingeckoCoinId: string;
+        } | undefined;
+    };
+    rpcProviders: {
+        default: {
+            url: string;
+            type: string;
+            networkClientId: string;
+        };
+        fallbacks: string[];
+    };
+    blockExplorerUrls: {
+        default: string;
+        fallbacks: string[];
+    };
+    config: {
+        isActive: boolean;
+        isTestnet: boolean;
+        isDefault: boolean;
+        isFeatured: boolean;
+        isDeprecated: boolean;
+        isDeletable: boolean;
+        priority: number;
+    };
+    geckoTerminalPlatformId?: string | undefined;
+}>) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, {
+        imageUrl: string;
+        name: string;
+        chainId: string;
+        coingeckoPlatformId: string;
+        assets: {
+            listUrl: string;
+            native: {
+                symbol: string;
+                assetId: string;
+                imageUrl: string;
+                name: string;
+                decimals: number;
+                coingeckoCoinId: string;
+            };
+            governance?: {
+                symbol: string;
+                assetId: string;
+                imageUrl: string;
+                name: string;
+                decimals: number;
+                coingeckoCoinId: string;
+            } | undefined;
+        };
+        rpcProviders: {
+            default: {
+                url: string;
+                type: string;
+                networkClientId: string;
+            };
+            fallbacks: string[];
+        };
+        blockExplorerUrls: {
+            default: string;
+            fallbacks: string[];
+        };
+        config: {
+            isActive: boolean;
+            isTestnet: boolean;
+            isDefault: boolean;
+            isFeatured: boolean;
+            isDeprecated: boolean;
+            isDeletable: boolean;
+            priority: number;
+        };
+        geckoTerminalPlatformId?: string | undefined;
+    }>) => Record<string, {
+        imageUrl: string;
+        name: string;
+        chainId: string;
+        coingeckoPlatformId: string;
+        assets: {
+            listUrl: string;
+            native: {
+                symbol: string;
+                assetId: string;
+                imageUrl: string;
+                name: string;
+                decimals: number;
+                coingeckoCoinId: string;
+            };
+            governance?: {
+                symbol: string;
+                assetId: string;
+                imageUrl: string;
+                name: string;
+                decimals: number;
+                coingeckoCoinId: string;
+            } | undefined;
+        };
+        rpcProviders: {
+            default: {
+                url: string;
+                type: string;
+                networkClientId: string;
+            };
+            fallbacks: string[];
+        };
+        blockExplorerUrls: {
+            default: string;
+            fallbacks: string[];
+        };
+        config: {
+            isActive: boolean;
+            isTestnet: boolean;
+            isDefault: boolean;
+            isFeatured: boolean;
+            isDeprecated: boolean;
+            isDeletable: boolean;
+            priority: number;
+        };
+        geckoTerminalPlatformId?: string | undefined;
+    }>;
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, {
+        imageUrl: string;
+        name: string;
+        chainId: string;
+        coingeckoPlatformId: string;
+        assets: {
+            listUrl: string;
+            native: {
+                symbol: string;
+                assetId: string;
+                imageUrl: string;
+                name: string;
+                decimals: number;
+                coingeckoCoinId: string;
+            };
+            governance?: {
+                symbol: string;
+                assetId: string;
+                imageUrl: string;
+                name: string;
+                decimals: number;
+                coingeckoCoinId: string;
+            } | undefined;
+        };
+        rpcProviders: {
+            default: {
+                url: string;
+                type: string;
+                networkClientId: string;
+            };
+            fallbacks: string[];
+        };
+        blockExplorerUrls: {
+            default: string;
+            fallbacks: string[];
+        };
+        config: {
+            isActive: boolean;
+            isTestnet: boolean;
+            isDefault: boolean;
+            isFeatured: boolean;
+            isDeprecated: boolean;
+            isDeletable: boolean;
+            priority: number;
+        };
+        geckoTerminalPlatformId?: string | undefined;
+    }>) => Record<string, {
+        imageUrl: string;
+        name: string;
+        chainId: string;
+        coingeckoPlatformId: string;
+        assets: {
+            listUrl: string;
+            native: {
+                symbol: string;
+                assetId: string;
+                imageUrl: string;
+                name: string;
+                decimals: number;
+                coingeckoCoinId: string;
+            };
+            governance?: {
+                symbol: string;
+                assetId: string;
+                imageUrl: string;
+                name: string;
+                decimals: number;
+                coingeckoCoinId: string;
+            } | undefined;
+        };
+        rpcProviders: {
+            default: {
+                url: string;
+                type: string;
+                networkClientId: string;
+            };
+            fallbacks: string[];
+        };
+        blockExplorerUrls: {
+            default: string;
+            fallbacks: string[];
+        };
+        config: {
+            isActive: boolean;
+            isTestnet: boolean;
+            isDefault: boolean;
+            isFeatured: boolean;
+            isDeprecated: boolean;
+            isDeletable: boolean;
+            priority: number;
+        };
+        geckoTerminalPlatformId?: string | undefined;
+    }>) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Record<string, {
+        imageUrl: string;
+        name: string;
+        chainId: string;
+        coingeckoPlatformId: string;
+        assets: {
+            listUrl: string;
+            native: {
+                symbol: string;
+                assetId: string;
+                imageUrl: string;
+                name: string;
+                decimals: number;
+                coingeckoCoinId: string;
+            };
+            governance?: {
+                symbol: string;
+                assetId: string;
+                imageUrl: string;
+                name: string;
+                decimals: number;
+                coingeckoCoinId: string;
+            } | undefined;
+        };
+        rpcProviders: {
+            default: {
+                url: string;
+                type: string;
+                networkClientId: string;
+            };
+            fallbacks: string[];
+        };
+        blockExplorerUrls: {
+            default: string;
+            fallbacks: string[];
+        };
+        config: {
+            isActive: boolean;
+            isTestnet: boolean;
+            isDefault: boolean;
+            isFeatured: boolean;
+            isDeprecated: boolean;
+            isDeletable: boolean;
+            priority: number;
+        };
+        geckoTerminalPlatformId?: string | undefined;
+    }>;
+    dependencies: [(state: ConfigRegistryControllerState) => Record<string, RegistryNetworkConfig>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+//# sourceMappingURL=selectors.d.cts.map

package/dist/selectors.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.d.cts","sourceRoot":"","sources":["../src/selectors.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,gDAAsC;AAC3E,OAAO,KAAK,EAAE,6BAA6B,EAAE,uCAAmC;AAEhF;;;;;GAKG;AACH,eAAO,MAAM,cAAc,UAClB,6BAA6B,KACnC,OAAO,MAAM,EAAE,qBAAqB,CAA2B,CAAC;AAEnE;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAV1B,6BAA6B,KACnC,OAAO,MAAM,EAAE,qBAAqB,CAAC;;;;;;;;CAwBvC,CAAC"}

package/dist/selectors.d.mts

@@ -0,0 +1,314 @@
+import type { RegistryNetworkConfig } from "./config-registry-api-service/index.mjs";
+import type { ConfigRegistryControllerState } from "./ConfigRegistryController.mjs";
+/**
+ * Base selector to get all networks from the controller state.
+ *
+ * @param state - The ConfigRegistryController state
+ * @returns All network configurations keyed by chain ID
+ */
+export declare const selectNetworks: (state: ConfigRegistryControllerState) => Record<string, RegistryNetworkConfig>;
+/**
+ * Selector to get featured, active, non-testnet networks.
+ * Use this for the default network list (e.g. main network picker).
+ *
+ * @param state - The ConfigRegistryController state
+ * @returns Filtered network configurations keyed by chain ID
+ */
+export declare const selectFeaturedNetworks: ((state: ConfigRegistryControllerState) => Record<string, {
+    imageUrl: string;
+    name: string;
+    chainId: string;
+    coingeckoPlatformId: string;
+    assets: {
+        listUrl: string;
+        native: {
+            symbol: string;
+            assetId: string;
+            imageUrl: string;
+            name: string;
+            decimals: number;
+            coingeckoCoinId: string;
+        };
+        governance?: {
+            symbol: string;
+            assetId: string;
+            imageUrl: string;
+            name: string;
+            decimals: number;
+            coingeckoCoinId: string;
+        } | undefined;
+    };
+    rpcProviders: {
+        default: {
+            url: string;
+            type: string;
+            networkClientId: string;
+        };
+        fallbacks: string[];
+    };
+    blockExplorerUrls: {
+        default: string;
+        fallbacks: string[];
+    };
+    config: {
+        isActive: boolean;
+        isTestnet: boolean;
+        isDefault: boolean;
+        isFeatured: boolean;
+        isDeprecated: boolean;
+        isDeletable: boolean;
+        priority: number;
+    };
+    geckoTerminalPlatformId?: string | undefined;
+}>) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, {
+        imageUrl: string;
+        name: string;
+        chainId: string;
+        coingeckoPlatformId: string;
+        assets: {
+            listUrl: string;
+            native: {
+                symbol: string;
+                assetId: string;
+                imageUrl: string;
+                name: string;
+                decimals: number;
+                coingeckoCoinId: string;
+            };
+            governance?: {
+                symbol: string;
+                assetId: string;
+                imageUrl: string;
+                name: string;
+                decimals: number;
+                coingeckoCoinId: string;
+            } | undefined;
+        };
+        rpcProviders: {
+            default: {
+                url: string;
+                type: string;
+                networkClientId: string;
+            };
+            fallbacks: string[];
+        };
+        blockExplorerUrls: {
+            default: string;
+            fallbacks: string[];
+        };
+        config: {
+            isActive: boolean;
+            isTestnet: boolean;
+            isDefault: boolean;
+            isFeatured: boolean;
+            isDeprecated: boolean;
+            isDeletable: boolean;
+            priority: number;
+        };
+        geckoTerminalPlatformId?: string | undefined;
+    }>) => Record<string, {
+        imageUrl: string;
+        name: string;
+        chainId: string;
+        coingeckoPlatformId: string;
+        assets: {
+            listUrl: string;
+            native: {
+                symbol: string;
+                assetId: string;
+                imageUrl: string;
+                name: string;
+                decimals: number;
+                coingeckoCoinId: string;
+            };
+            governance?: {
+                symbol: string;
+                assetId: string;
+                imageUrl: string;
+                name: string;
+                decimals: number;
+                coingeckoCoinId: string;
+            } | undefined;
+        };
+        rpcProviders: {
+            default: {
+                url: string;
+                type: string;
+                networkClientId: string;
+            };
+            fallbacks: string[];
+        };
+        blockExplorerUrls: {
+            default: string;
+            fallbacks: string[];
+        };
+        config: {
+            isActive: boolean;
+            isTestnet: boolean;
+            isDefault: boolean;
+            isFeatured: boolean;
+            isDeprecated: boolean;
+            isDeletable: boolean;
+            priority: number;
+        };
+        geckoTerminalPlatformId?: string | undefined;
+    }>;
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, {
+        imageUrl: string;
+        name: string;
+        chainId: string;
+        coingeckoPlatformId: string;
+        assets: {
+            listUrl: string;
+            native: {
+                symbol: string;
+                assetId: string;
+                imageUrl: string;
+                name: string;
+                decimals: number;
+                coingeckoCoinId: string;
+            };
+            governance?: {
+                symbol: string;
+                assetId: string;
+                imageUrl: string;
+                name: string;
+                decimals: number;
+                coingeckoCoinId: string;
+            } | undefined;
+        };
+        rpcProviders: {
+            default: {
+                url: string;
+                type: string;
+                networkClientId: string;
+            };
+            fallbacks: string[];
+        };
+        blockExplorerUrls: {
+            default: string;
+            fallbacks: string[];
+        };
+        config: {
+            isActive: boolean;
+            isTestnet: boolean;
+            isDefault: boolean;
+            isFeatured: boolean;
+            isDeprecated: boolean;
+            isDeletable: boolean;
+            priority: number;
+        };
+        geckoTerminalPlatformId?: string | undefined;
+    }>) => Record<string, {
+        imageUrl: string;
+        name: string;
+        chainId: string;
+        coingeckoPlatformId: string;
+        assets: {
+            listUrl: string;
+            native: {
+                symbol: string;
+                assetId: string;
+                imageUrl: string;
+                name: string;
+                decimals: number;
+                coingeckoCoinId: string;
+            };
+            governance?: {
+                symbol: string;
+                assetId: string;
+                imageUrl: string;
+                name: string;
+                decimals: number;
+                coingeckoCoinId: string;
+            } | undefined;
+        };
+        rpcProviders: {
+            default: {
+                url: string;
+                type: string;
+                networkClientId: string;
+            };
+            fallbacks: string[];
+        };
+        blockExplorerUrls: {
+            default: string;
+            fallbacks: string[];
+        };
+        config: {
+            isActive: boolean;
+            isTestnet: boolean;
+            isDefault: boolean;
+            isFeatured: boolean;
+            isDeprecated: boolean;
+            isDeletable: boolean;
+            priority: number;
+        };
+        geckoTerminalPlatformId?: string | undefined;
+    }>) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Record<string, {
+        imageUrl: string;
+        name: string;
+        chainId: string;
+        coingeckoPlatformId: string;
+        assets: {
+            listUrl: string;
+            native: {
+                symbol: string;
+                assetId: string;
+                imageUrl: string;
+                name: string;
+                decimals: number;
+                coingeckoCoinId: string;
+            };
+            governance?: {
+                symbol: string;
+                assetId: string;
+                imageUrl: string;
+                name: string;
+                decimals: number;
+                coingeckoCoinId: string;
+            } | undefined;
+        };
+        rpcProviders: {
+            default: {
+                url: string;
+                type: string;
+                networkClientId: string;
+            };
+            fallbacks: string[];
+        };
+        blockExplorerUrls: {
+            default: string;
+            fallbacks: string[];
+        };
+        config: {
+            isActive: boolean;
+            isTestnet: boolean;
+            isDefault: boolean;
+            isFeatured: boolean;
+            isDeprecated: boolean;
+            isDeletable: boolean;
+            priority: number;
+        };
+        geckoTerminalPlatformId?: string | undefined;
+    }>;
+    dependencies: [(state: ConfigRegistryControllerState) => Record<string, RegistryNetworkConfig>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+//# sourceMappingURL=selectors.d.mts.map

package/dist/selectors.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.d.mts","sourceRoot":"","sources":["../src/selectors.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,gDAAsC;AAC3E,OAAO,KAAK,EAAE,6BAA6B,EAAE,uCAAmC;AAEhF;;;;;GAKG;AACH,eAAO,MAAM,cAAc,UAClB,6BAA6B,KACnC,OAAO,MAAM,EAAE,qBAAqB,CAA2B,CAAC;AAEnE;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAV1B,6BAA6B,KACnC,OAAO,MAAM,EAAE,qBAAqB,CAAC;;;;;;;;CAwBvC,CAAC"}

package/dist/selectors.mjs

@@ -0,0 +1,30 @@
+import { createSelector } from "reselect";
+import { filterNetworks } from "./config-registry-api-service/index.mjs";
+/**
+ * Base selector to get all networks from the controller state.
+ *
+ * @param state - The ConfigRegistryController state
+ * @returns All network configurations keyed by chain ID
+ */
+export const selectNetworks = (state) => state.configs.networks;
+/**
+ * Selector to get featured, active, non-testnet networks.
+ * Use this for the default network list (e.g. main network picker).
+ *
+ * @param state - The ConfigRegistryController state
+ * @returns Filtered network configurations keyed by chain ID
+ */
+export const selectFeaturedNetworks = createSelector(selectNetworks, (networks) => {
+    const networkArray = Object.values(networks);
+    const filtered = filterNetworks(networkArray, {
+        isFeatured: true,
+        isActive: true,
+        isTestnet: false,
+    });
+    const result = {};
+    filtered.forEach((config) => {
+        result[config.chainId] = config;
+    });
+    return result;
+});
+//# sourceMappingURL=selectors.mjs.map

package/dist/selectors.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.mjs","sourceRoot":"","sources":["../src/selectors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,iBAAiB;AAE1C,OAAO,EAAE,cAAc,EAAE,gDAAsC;AAI/D;;;;;GAKG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAC5B,KAAoC,EACG,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC;AAEnE;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,cAAc,CAClD,cAAc,EACd,CAAC,QAAQ,EAAyC,EAAE;IAClD,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAC7C,MAAM,QAAQ,GAAG,cAAc,CAAC,YAAY,EAAE;QAC5C,UAAU,EAAE,IAAI;QAChB,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,KAAK;KACjB,CAAC,CAAC;IACH,MAAM,MAAM,GAA0C,EAAE,CAAC;IACzD,QAAQ,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE;QAC1B,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,MAAM,CAAC;IAClC,CAAC,CAAC,CAAC;IACH,OAAO,MAAM,CAAC;AAChB,CAAC,CACF,CAAC","sourcesContent":["import { createSelector } from 'reselect';\n\nimport { filterNetworks } from './config-registry-api-service';\nimport type { RegistryNetworkConfig } from './config-registry-api-service';\nimport type { ConfigRegistryControllerState } from './ConfigRegistryController';\n\n/**\n * Base selector to get all networks from the controller state.\n *\n * @param state - The ConfigRegistryController state\n * @returns All network configurations keyed by chain ID\n */\nexport const selectNetworks = (\n  state: ConfigRegistryControllerState,\n): Record<string, RegistryNetworkConfig> => state.configs.networks;\n\n/**\n * Selector to get featured, active, non-testnet networks.\n * Use this for the default network list (e.g. main network picker).\n *\n * @param state - The ConfigRegistryController state\n * @returns Filtered network configurations keyed by chain ID\n */\nexport const selectFeaturedNetworks = createSelector(\n  selectNetworks,\n  (networks): Record<string, RegistryNetworkConfig> => {\n    const networkArray = Object.values(networks);\n    const filtered = filterNetworks(networkArray, {\n      isFeatured: true,\n      isActive: true,\n      isTestnet: false,\n    });\n    const result: Record<string, RegistryNetworkConfig> = {};\n    filtered.forEach((config) => {\n      result[config.chainId] = config;\n    });\n    return result;\n  },\n);\n"]}

package/dist/utils/feature-flags.cjs

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isConfigRegistryApiEnabled = void 0;
+const FEATURE_FLAG_KEY = 'configRegistryApiEnabled';
+const DEFAULT_FEATURE_FLAG_VALUE = false;
+/**
+ * Checks if the config registry API feature flag is enabled.
+ *
+ * @param messenger - The controller messenger.
+ * @returns True if the feature flag is enabled, false otherwise.
+ */
+function isConfigRegistryApiEnabled(messenger) {
+    try {
+        const state = messenger.call('RemoteFeatureFlagController:getState');
+        const featureFlags = state.remoteFeatureFlags;
+        const flagValue = featureFlags[FEATURE_FLAG_KEY];
+        if (typeof flagValue === 'boolean') {
+            return flagValue;
+        }
+        return DEFAULT_FEATURE_FLAG_VALUE;
+    }
+    catch {
+        return DEFAULT_FEATURE_FLAG_VALUE;
+    }
+}
+exports.isConfigRegistryApiEnabled = isConfigRegistryApiEnabled;
+//# sourceMappingURL=feature-flags.cjs.map

package/dist/utils/feature-flags.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-flags.cjs","sourceRoot":"","sources":["../../src/utils/feature-flags.ts"],"names":[],"mappings":";;;AAEA,MAAM,gBAAgB,GAAG,0BAA0B,CAAC;AACpD,MAAM,0BAA0B,GAAG,KAAK,CAAC;AAEzC;;;;;GAKG;AACH,SAAgB,0BAA0B,CACxC,SAAkC;IAElC,IAAI,CAAC;QACH,MAAM,KAAK,GAAG,SAAS,CAAC,IAAI,CAAC,sCAAsC,CAAC,CAAC;QACrE,MAAM,YAAY,GAAG,KAAK,CAAC,kBAAkB,CAAC;QAE9C,MAAM,SAAS,GAAG,YAAY,CAAC,gBAAgB,CAAC,CAAC;QAEjD,IAAI,OAAO,SAAS,KAAK,SAAS,EAAE,CAAC;YACnC,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,OAAO,0BAA0B,CAAC;IACpC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,0BAA0B,CAAC;IACpC,CAAC;AACH,CAAC;AAjBD,gEAiBC","sourcesContent":["import type { ConfigRegistryMessenger } from '../ConfigRegistryController';\n\nconst FEATURE_FLAG_KEY = 'configRegistryApiEnabled';\nconst DEFAULT_FEATURE_FLAG_VALUE = false;\n\n/**\n * Checks if the config registry API feature flag is enabled.\n *\n * @param messenger - The controller messenger.\n * @returns True if the feature flag is enabled, false otherwise.\n */\nexport function isConfigRegistryApiEnabled(\n  messenger: ConfigRegistryMessenger,\n): boolean {\n  try {\n    const state = messenger.call('RemoteFeatureFlagController:getState');\n    const featureFlags = state.remoteFeatureFlags;\n\n    const flagValue = featureFlags[FEATURE_FLAG_KEY];\n\n    if (typeof flagValue === 'boolean') {\n      return flagValue;\n    }\n\n    return DEFAULT_FEATURE_FLAG_VALUE;\n  } catch {\n    return DEFAULT_FEATURE_FLAG_VALUE;\n  }\n}\n"]}