async function initialize()

in src/background/background-init.ts [52:226]
140 lines of code
1 McCabe index (conditional complexity)

async function initialize(): Promise<void> {
    const userAgentParser = new UAParser(window.navigator.userAgent);
    const browserAdapterFactory = new BrowserAdapterFactory(userAgentParser);
    const browserAdapter = browserAdapterFactory.makeFromUserAgent();

    // This only removes keys that are unused by current versions of the extension, so it's okay for it to race with everything else
    const cleanKeysFromStoragePromise = cleanKeysFromStorage(
        browserAdapter,
        deprecatedStorageDataKeys,
    );

    const windowUtils = new WindowUtils();

    const urlValidator = new UrlValidator(browserAdapter);
    const indexedDBInstance: IndexedDBAPI = new IndexedDBUtil(getIndexedDBStore());
    const indexedDBDataKeysToFetch = [
        IndexedDBDataKeys.assessmentStore,
        IndexedDBDataKeys.userConfiguration,
    ];

    // These can run concurrently, both because they are read-only and because they use different types of underlying storage
    const persistedDataPromise = getPersistedData(indexedDBInstance, indexedDBDataKeysToFetch);
    const userDataPromise = browserAdapter.getUserData(storageDataKeys);
    const persistedData = await persistedDataPromise;
    const userData = await userDataPromise;

    const assessmentsProvider = Assessments;
    const telemetryDataFactory = new TelemetryDataFactory();

    const logger = createDefaultLogger();
    const telemetryLogger = new TelemetryLogger(logger);

    const { installationData } = userData;

    const applicationTelemetryDataFactory = getApplicationTelemetryDataFactory(
        installationData,
        browserAdapter,
        browserAdapter,
        title,
    );

    const consoleTelemetryClient = new ConsoleTelemetryClient(
        applicationTelemetryDataFactory,
        telemetryLogger,
    );

    const debugToolsTelemetryClient = new DebugToolsTelemetryClient(
        browserAdapter,
        applicationTelemetryDataFactory,
    );
    debugToolsTelemetryClient.initialize();

    const telemetryClient = getTelemetryClient(applicationTelemetryDataFactory, AppInsights, [
        consoleTelemetryClient,
        debugToolsTelemetryClient,
    ]);

    const usageLogger = new UsageLogger(browserAdapter, DateProvider.getCurrentDate, logger);

    const telemetryEventHandler = new TelemetryEventHandler(telemetryClient);

    const browserSpec = new NavigatorUtils(window.navigator, logger).getBrowserSpec();

    const toolData = createToolData(
        'axe-core',
        AxeInfo.Default.version,
        toolName,
        browserAdapter.getVersion(),
        browserSpec,
    );

    const globalContext = await GlobalContextFactory.createContext(
        browserAdapter,
        telemetryEventHandler,
        userData,
        assessmentsProvider,
        telemetryDataFactory,
        indexedDBInstance,
        persistedData,
        IssueFilingServiceProviderImpl,
        toolData,
        browserAdapter,
        browserAdapter,
        logger,
    );
    telemetryLogger.initialize(globalContext.featureFlagsController);

    const telemetryStateListener = new TelemetryStateListener(
        globalContext.stores.userConfigurationStore,
        telemetryEventHandler,
    );
    telemetryStateListener.initialize();

    const messageBroadcasterFactory = new BrowserMessageBroadcasterFactory(browserAdapter, logger);
    const detailsViewController = new ExtensionDetailsViewController(browserAdapter);

    const tabToContextMap: TabToContextMap = {};

    const visualizationConfigurationFactory = new WebVisualizationConfigurationFactory();
    const notificationCreator = new NotificationCreator(
        browserAdapter,
        visualizationConfigurationFactory,
        logger,
    );

    const keyboardShortcutHandler = new KeyboardShortcutHandler(
        tabToContextMap,
        browserAdapter,
        urlValidator,
        notificationCreator,
        visualizationConfigurationFactory,
        telemetryDataFactory,
        globalContext.stores.userConfigurationStore,
        browserAdapter,
        logger,
        usageLogger,
    );
    keyboardShortcutHandler.initialize();

    const messageDistributor = new MessageDistributor(
        globalContext,
        tabToContextMap,
        browserAdapter,
        logger,
    );
    messageDistributor.initialize();

    const targetTabController = new TargetTabController(
        browserAdapter,
        visualizationConfigurationFactory,
    );

    const promiseFactory = createDefaultPromiseFactory();

    const tabContextFactory = new TabContextFactory(
        visualizationConfigurationFactory,
        telemetryEventHandler,
        targetTabController,
        notificationCreator,
        promiseFactory,
        logger,
        usageLogger,
        windowUtils,
    );

    const targetPageController = new TargetPageController(
        tabToContextMap,
        messageBroadcasterFactory,
        browserAdapter,
        detailsViewController,
        tabContextFactory,
        logger,
    );

    await targetPageController.initialize();

    const devToolsBackgroundListener = new DevToolsListener(tabToContextMap, browserAdapter);
    devToolsBackgroundListener.initialize();

    const postMessageContentRepository = new PostMessageContentRepository(
        DateProvider.getCurrentDate,
    );

    const postMessageContentHandler = new PostMessageContentHandler(
        postMessageContentRepository,
        browserAdapter,
    );

    postMessageContentHandler.initialize();

    window.insightsFeatureFlags = globalContext.featureFlagsController;
    window.insightsUserConfiguration = globalContext.userConfigurationController;

    await cleanKeysFromStoragePromise;
}