@equinor/fusion-framework-app 13.1.0 → 13.1.2

package/src/__tests__/AppConfigurator.test.ts

@@ -1,49 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { firstValueFrom, take } from 'rxjs';
-import { AppConfigurator } from '../AppConfigurator';
-import type { AnyModule } from '@equinor/fusion-framework-module';
-import { SemanticVersion } from '@equinor/fusion-framework-module';
-
-describe('AppConfigurator', () => {
-  let configurator: AppConfigurator;
-
-  // Create a mock module for testing
-  const createMockModule = (name: string, version = '1.0.0'): AnyModule => ({
-    name,
-    version: new SemanticVersion(version),
-    initialize: () => ({ mockInstance: true }),
-  });
-
-  // Mock environment object
-  const mockEnv = {
-    manifest: {
-      appKey: 'test-app',
-      displayName: 'Test App',
-      description: 'A test application',
-      type: 'standalone' as const,
-      build: {
-        version: '1.0.0',
-        entryPoint: 'index.js',
-      },
-    },
-  };
-
-  beforeEach(() => {
-    configurator = new AppConfigurator(mockEnv);
-  });
-
-  describe('Event Name Prefixing', () => {
-    it('should prefix event names with "AppConfigurator::"', async () => {
-      // Trigger event by adding a config
-      configurator.addConfig({
-        module: createMockModule('test', '1.0.0'),
-        configure: () => {},
-      });
-
-      // Wait for the first event to be emitted
-      const event = await firstValueFrom(configurator.event$.pipe(take(1)));
-
-      expect(event.name).toMatch(/^AppConfigurator::/);
-    });
-  });
-});

package/src/__tests__/mock/AppMockConfigurator.test.ts

@@ -1,96 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { AppConfig } from '@equinor/fusion-framework-module-app';
-import { enableTelemetry } from '@equinor/fusion-framework-module-telemetry';
-
-import { AppConfigurator } from '../../AppConfigurator.js';
-import { AppMockConfigurator } from '../../mock/AppMockConfigurator.js';
-
-const mockEnv = {
-  manifest: {
-    appKey: 'test-app',
-    displayName: 'Test App',
-    description: 'A test application',
-    type: 'standalone' as const,
-    build: {
-      version: '1.0.0',
-      entryPoint: 'index.js',
-    },
-  },
-};
-
-describe('AppMockConfigurator', () => {
-  it('is a real AppConfigurator', () => {
-    const configurator = new AppMockConfigurator(mockEnv);
-
-    expect(configurator).toBeInstanceOf(AppMockConfigurator);
-    expect(configurator).toBeInstanceOf(AppConfigurator);
-  });
-
-  it('constructs without throwing when env.config declares endpoints', async () => {
-    // the base AppConfigurator constructor auto-registers these via addConfig,
-    // before this class's own fields (#pinnedModules) are initialized
-    const env = {
-      ...mockEnv,
-      config: new AppConfig({
-        endpoints: { status: { url: 'https://status.example.com', scopes: [] } },
-      }),
-    };
-
-    const configurator = new AppMockConfigurator(env);
-    configurator.http.addMiddleware(async (uri, init, next) =>
-      uri === 'https://status.example.com/health' ? Response.json({ ok: true }) : next(uri, init),
-    );
-
-    enableTelemetry(configurator);
-    const modules = await configurator.initialize();
-
-    await expect(modules.http.createClient('status').json('/health')).resolves.toEqual({
-      ok: true,
-    });
-  });
-
-  it('exposes the same http configurator the http module is built from', async () => {
-    const configurator = new AppMockConfigurator(mockEnv);
-
-    configurator.http.configureClient('catalog', { baseUri: 'https://api.example.com' });
-    configurator.http.addMiddleware(async (uri, init, next) =>
-      uri === 'https://api.example.com/items' ? Response.json([{ id: 1 }]) : next(uri, init),
-    );
-
-    // msal's config schema requires a telemetry module, normally wired by configureModules
-    enableTelemetry(configurator);
-    const modules = await configurator.initialize();
-
-    await expect(modules.http.createClient('catalog').json('/items')).resolves.toEqual([{ id: 1 }]);
-  });
-
-  it('exposes the same msal configurator the auth module is built from', async () => {
-    const configurator = new AppMockConfigurator(mockEnv);
-
-    configurator.msal.setAccount({ name: 'Ada Lovelace' });
-
-    // msal's config schema requires a telemetry module, normally wired by configureModules
-    enableTelemetry(configurator);
-    const modules = await configurator.initialize();
-
-    expect(modules.auth.account?.name).toBe('Ada Lovelace');
-  });
-
-  it('answers a client registered through configureHttpClient via addMiddleware', async () => {
-    const configurator = new AppMockConfigurator(mockEnv);
-
-    configurator.configureHttpClient('status-api', { baseUri: 'https://status.example.com' });
-    configurator.http.addMiddleware(async (uri, init, next) =>
-      uri === 'https://status.example.com/status' ? Response.json({ ok: true }) : next(uri, init),
-    );
-
-    // msal's config schema requires a telemetry module, normally wired by configureModules
-    enableTelemetry(configurator);
-    const modules = await configurator.initialize();
-
-    await expect(modules.http.createClient('status-api').json('/status')).resolves.toEqual({
-      ok: true,
-    });
-  });
-});

package/src/__tests__/mock/mock-app.test.ts

@@ -1,112 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import type { Fusion } from '@equinor/fusion-framework';
-import { mockFramework } from '@equinor/fusion-framework/mock';
-import { AppConfig, type AppModule } from '@equinor/fusion-framework-module-app';
-
-import { AppMockConfigurator } from '../../mock/AppMockConfigurator.js';
-import { mockAppModules } from '../../mock/mock-app-modules.js';
-
-const env = {
-  manifest: {
-    appKey: 'test-app',
-    displayName: 'Test App',
-    description: 'A test application',
-    type: 'standalone' as const,
-    build: {
-      version: '1.0.0',
-      entryPoint: 'index.js',
-    },
-  },
-  config: new AppConfig({ environment: { foo: 'bar' } }),
-};
-
-describe('mockApp', () => {
-  it('initializes the app module pipeline with no configuration', async () => {
-    const modules = await mockAppModules(undefined, env);
-
-    expect(modules.event).toBeDefined();
-    expect(modules.auth).toBeDefined();
-    expect(modules.http).toBeDefined();
-  });
-
-  it('passes a real AppConfigurator to the callback', async () => {
-    expect.assertions(1);
-
-    await mockAppModules((configurator) => {
-      expect(configurator).toBeInstanceOf(AppMockConfigurator);
-    }, env);
-  });
-
-  it('answers a service-discovery-resolved client from the app’s own mocked http module', async () => {
-    const modules = await mockAppModules((configurator) => {
-      configurator.useFrameworkServiceClient('portal-api');
-      // matches against the full resolved URL, so the host is part of the match to keep this
-      // from also answering a different client's request
-      configurator.http.addMiddleware(async (uri, init, next) =>
-        uri === 'https://portal-api.fusion.test/items'
-          ? Response.json([{ id: 1 }])
-          : next(uri, init),
-      );
-    }, env);
-
-    await expect(modules.http.createClient('portal-api').json('/items')).resolves.toEqual([
-      { id: 1 },
-    ]);
-  });
-
-  it('reuses an already-mocked fusion instance instead of creating a new one', async () => {
-    expect.assertions(1);
-
-    const fusion = await mockFramework((configurator) => {
-      configurator.msal.setAccount({ name: 'Ada Lovelace' });
-    });
-
-    await mockAppModules(
-      (_configurator, { fusion: parent }) => {
-        expect(parent.modules.auth.account?.name).toBe('Ada Lovelace');
-      },
-      env,
-      fusion,
-    );
-  });
-
-  it('awaits an async configure callback before initialize resolves', async () => {
-    const modules = await mockAppModules(async (configurator) => {
-      await Promise.resolve();
-      configurator.msal.setAccount({ name: 'Ada Lovelace' });
-    }, env);
-
-    expect(modules.auth.account?.name).toBe('Ada Lovelace');
-  });
-
-  it('serves this app’s own manifest and config through the default parent’s app module', async () => {
-    expect.assertions(2);
-
-    await mockAppModules(async (_configurator, { fusion }) => {
-      // the default parent always has `app` enabled; typed as plain `Fusion` since callers
-      // may pass in a parent without it, so the module set is narrowed just for this assertion
-      const { app } = (fusion as Fusion<[AppModule]>).modules;
-      app.setCurrentApp(env.manifest.appKey);
-
-      await expect(app.current?.getManifestAsync()).resolves.toMatchObject({
-        appKey: env.manifest.appKey,
-        displayName: env.manifest.displayName,
-      });
-      await expect(app.current?.getConfigAsync()).resolves.toMatchObject({
-        environment: env.config.environment,
-      });
-    }, env);
-  });
-
-  it('falls through to the real client for a manifest not matching this app’s own', async () => {
-    expect.assertions(1);
-
-    await mockAppModules(async (_configurator, { fusion }) => {
-      const { app } = (fusion as Fusion<[AppModule]>).modules;
-      app.setCurrentApp('some-other-app');
-
-      await expect(app.current?.getManifestAsync()).rejects.toThrow();
-    }, env);
-  });
-});

package/src/__tests__/mock/msal-hoisting.test.ts

@@ -1,54 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-
-import { mockFramework } from '@equinor/fusion-framework/mock';
-import type { AuthenticationResult } from '@equinor/fusion-framework-module-msal';
-
-import { mockAppModules } from '../../mock/mock-app-modules.js';
-
-const env = {
-  manifest: {
-    appKey: 'test-app',
-    displayName: 'Test App',
-    description: 'A test application',
-    type: 'standalone' as const,
-  },
-};
-
-describe('msal hoisting', () => {
-  it('delegates acquireToken to the parent’s auth module instead of building its own client', async () => {
-    const fusion = await mockFramework();
-    const result = { accessToken: 'parent-issued-token' } as AuthenticationResult;
-    vi.spyOn(fusion.modules.auth, 'acquireToken').mockResolvedValue(result);
-
-    const modules = await mockAppModules(undefined, env, fusion);
-
-    // the app's own `auth` is a distinct (proxying) object, not the parent's instance itself
-    expect(modules.auth).not.toBe(fusion.modules.auth);
-    await expect(
-      modules.auth.acquireToken({ request: { scopes: ['User.Read'] } }),
-    ).resolves.toMatchObject({ accessToken: 'parent-issued-token' });
-  });
-
-  it('surfaces the parent’s acquisition failures instead of falling back to its own client', async () => {
-    const fusion = await mockFramework();
-    vi.spyOn(fusion.modules.auth, 'acquireToken').mockRejectedValue(
-      new Error('acquisition failed'),
-    );
-
-    const modules = await mockAppModules(undefined, env, fusion);
-
-    await expect(modules.auth.acquireToken({ request: { scopes: ['User.Read'] } })).rejects.toThrow(
-      'acquisition failed',
-    );
-  });
-
-  it('reflects the parent’s signed-in account rather than signing in its own', async () => {
-    const fusion = await mockFramework((configurator) => {
-      configurator.msal.setAccount({ name: 'Ada Lovelace' });
-    });
-
-    const modules = await mockAppModules(undefined, env, fusion);
-
-    expect(modules.auth.account?.name).toBe('Ada Lovelace');
-  });
-});

package/src/configure-modules.ts

@@ -1,71 +0,0 @@
-/**
- * @fileoverview Application module configuration factory
- *
- * Provides the core factory function for configuring and initializing
- * application-specific modules in the Fusion framework.
- */
-
-import type { Fusion } from '@equinor/fusion-framework';
-import type { AnyModule } from '@equinor/fusion-framework-module';
-
-import { AppConfigurator } from './AppConfigurator';
-
-import type { AppModulesInstance, AppModuleInitiator, AppEnv } from './types';
-import { initializeAppModules } from './initialize-app-modules';
-
-/**
- * Create an application module initializer for a Fusion application.
- *
- * `configureModules` is the primary entry point for setting up an application’s
- * module pipeline. It returns an async function that, when called with the Fusion
- * instance and the application environment, will:
- *
- * 1. Create an {@link AppConfigurator} with the provided environment.
- * 2. Wire up telemetry scoped to the application.
- * 3. Invoke the optional user-supplied configuration callback.
- * 4. Initialize all registered modules and dispatch an `onAppModulesLoaded` event.
- *
- * @template TModules - Additional application-specific modules to register.
- * @template TRef - The Fusion instance type, used as a configuration reference.
- * @template TEnv - The application environment descriptor (manifest, config, basename).
- *
- * @param cb - Optional configuration callback invoked before modules are initialized.
- *             Use this to register HTTP clients, enable bookmarks, or add custom modules.
- * @returns An async initializer function that accepts `{ fusion, env }` and resolves
- *          with the fully initialized application module instance.
- *
- * @example
- * ```ts
- * import { configureModules } from '@equinor/fusion-framework-app';
- *
- * const initialize = configureModules((configurator, { fusion, env }) => {
- *   configurator.useFrameworkServiceClient('my-service');
- * });
- *
- * // Later, during app bootstrap:
- * const modules = await initialize({ fusion, env });
- * ```
- */
-export const configureModules =
-  <
-    TModules extends Array<AnyModule> | never,
-    TRef extends Fusion = Fusion,
-    TEnv extends AppEnv = AppEnv,
-  >(
-    cb?: AppModuleInitiator<TModules, TRef, TEnv>,
-  ): ((args: { fusion: TRef; env: TEnv }) => Promise<AppModulesInstance<TModules>>) =>
-  /**
-   * Async initializer that bootstraps application modules.
-   *
-   * @param args - Object containing the Fusion instance and the application environment.
-   * @param args.fusion - The active Fusion framework instance.
-   * @param args.env - The application environment with manifest, config, and basename.
-   * @returns The fully initialized application module instance.
-   */
-  async (args: { fusion: TRef; env: TEnv }): Promise<AppModulesInstance<TModules>> => {
-    // Create app configurator
-    const configurator = new AppConfigurator<TModules, TRef['modules'], TEnv>(args.env);
-    return initializeAppModules(configurator, cb, args);
-  };
-
-export default configureModules;

package/src/enable-bookmark.ts

@@ -1,95 +0,0 @@
-import type {
-  BookmarkModule,
-  BookmarkPayloadGenerator,
-} from '@equinor/fusion-framework-module-bookmark';
-import type { IAppConfigurator } from './AppConfigurator';
-
-/**
- * Enable the bookmark module for a Fusion application.
- *
- * Adds bookmark support by wiring the portal’s bookmark provider into the
- * application’s module set. Payload generators registered by the application
- * are automatically cleaned up when the module is disposed, preventing memory
- * leaks across application load/unload cycles.
- *
- * Import this function from `@equinor/fusion-framework-app/enable-bookmark` or, for
- * React apps, from `@equinor/fusion-framework-react-app/bookmark`.
- *
- * @remarks
- * - The portal must expose a bookmark provider on `ref.bookmark`; if it is
- *   missing, an error is logged and the module initializes as a no-op.
- * - The `@equinor/fusion-framework-module-bookmark` package must be installed,
- *   but do **not** call its `enableBookmark` directly in app code — use this
- *   app-level enabler instead.
- *
- * @param config - The application configurator to register the bookmark module on.
- *
- * @example
- * ```ts
- * import { configureModules } from '@equinor/fusion-framework-app';
- * import { enableBookmark } from '@equinor/fusion-framework-app/enable-bookmark';
- *
- * const initialize = configureModules((configurator) => {
- *   enableBookmark(configurator);
- * });
- * ```
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const enableBookmark = (config: IAppConfigurator): void => {
-  // collection of cleanup functions
-  const cleanupFunctions = new Set<VoidFunction>();
-  config.addConfig({
-    module: {
-      name: 'bookmark',
-      initialize(args) {
-        // get the bookmark provider from the ref (portal)
-        const provider = args.ref?.bookmark;
-        // Bail out early if the portal did not expose a bookmark provider.
-        if (!provider) {
-          console.error('Bookmark provider not found');
-          return {};
-        }
-        // create a proxy to intercept the addPayloadGenerator method
-        return new Proxy(provider, {
-          get(target, prop) {
-            // Intercept specific property access to wrap bookmark lifecycle management.
-            switch (prop) {
-              case 'addPayloadGenerator':
-                return (generator: BookmarkPayloadGenerator) => {
-                  // catch the teardown function and add it to the cleanup functions
-                  const cleanupHandler = target.addPayloadGenerator(generator);
-                  cleanupFunctions.add(cleanupHandler);
-                  // wrap the teardown function to remove it from the cleanup functions
-                  return () => {
-                    cleanupFunctions.delete(cleanupHandler);
-                    cleanupHandler();
-                  };
-                };
-            }
-            /**
-             * If the property is not addPayloadGenerator, we want to access the property on the provider
-             *
-             * @remarks we can not use the Reflect API to access the property, as the provider is a proxy
-             * and the Reflect API will not work as expected (can not access private properties)
-             */
-            if (prop in target) {
-              // if the property is a function, bind it to the provider
-              if (typeof target[prop] === 'function') {
-                return target[prop].bind(target);
-              }
-              // access the property
-              return target[prop];
-            }
-          },
-        });
-      },
-      dispose() {
-        // Run all registered cleanup functions to prevent memory leaks on module disposal.
-        for (const teardown of cleanupFunctions) {
-          teardown();
-        }
-        cleanupFunctions.clear();
-      },
-    } satisfies BookmarkModule,
-  });
-};

package/src/enable-state.ts

@@ -1,49 +0,0 @@
-import { enableStateModule } from '@equinor/fusion-framework-module-state';
-import type { IStateModuleConfigurator } from '@equinor/fusion-framework-module-state';
-import type { IAppConfigurator } from './AppConfigurator';
-import type { AnyModule } from '@equinor/fusion-framework-module';
-import type { FusionModulesInstance } from '@equinor/fusion-framework';
-
-/**
- * Enables state management for the application with persistent storage.
- *
- * This is a thin, app-scoped convenience wrapper around `enableStateModule` — it registers
- * the state module on the app's configurator so app code can reach it via the app namespace,
- * and scopes the module's default storage to this app's own `manifest.appKey` (so unrelated
- * apps or widgets hosted alongside it never share its state). The state module resolves a
- * local PouchDB database, optionally synced with the Fusion App State backend when service
- * discovery and auth are configured; call `setStorage` on the configurator to override it.
- *
- * @warning Local storage is NOT encrypted. Do not store sensitive data such as passwords,
- * tokens, personal information, or any data that requires security protection.
- *
- * @see {@link https://github.com/equinor/fusion-framework/blob/main/packages/modules/state/README.md | State Module Documentation} for comprehensive usage examples and API reference.
- *
- * @template M - Array of modules to be configured.
- * @template R - The fusion modules instance type.
- * @param configurator - The application configurator to enable state management on.
- * @param configure - Optional config callback, receiving the module's `IStateModuleConfigurator`.
- *
- * @example
- * ```typescript
- * import { enableState } from '@equinor/fusion-framework-app';
- *
- * export const configure = (configurator) => {
- *   enableState(configurator);
- * };
- *
- * // Later in your app, access the state provider
- * const stateProvider = modules.state;
- * await stateProvider.storeItem({ key: 'user-preference', value: { theme: 'dark' } });
- * const item = await stateProvider.getItem('user-preference');
- * ```
- */
-export function enableState<M extends AnyModule[], R extends FusionModulesInstance>(
-  configurator: IAppConfigurator<M, R>,
-  configure?: (builder: IStateModuleConfigurator) => void | Promise<void>,
-): void {
-  enableStateModule(configurator, async (builder) => {
-    builder.setName(configurator.manifest.appKey);
-    await configure?.(builder);
-  });
-}

package/src/index.ts

@@ -1,34 +0,0 @@
-/**
- * @packageDocumentation
- *
- * `@equinor/fusion-framework-app` provides the configuration and initialization
- * layer for Fusion applications. Use this package to set up application modules,
- * configure HTTP clients, enable bookmarks, and integrate with telemetry and
- * service discovery.
- *
- * The main entry points are:
- *
- * - {@link configureModules} — factory that creates an application initializer
- * - {@link AppConfigurator} / {@link IAppConfigurator} — configurator for registering modules and HTTP clients
- * - Type aliases such as {@link AppModuleInitiator}, {@link AppEnv}, and {@link AppRenderFn}
- *
- * Bookmark support is available via the `@equinor/fusion-framework-app/enable-bookmark`
- * sub-path export.
- */
-
-export { AppConfigurator, IAppConfigurator, AppConfiguratorConstructor } from './AppConfigurator';
-
-export * from './types';
-
-export { configureModules, default } from './configure-modules';
-
-export { AppConfiguratorError } from './AppConfiguratorError';
-
-export { AppModulesConfiguredEvent } from './AppModulesConfiguredEvent';
-
-export { AppModulesInitializedEvent } from './AppModulesInitializedEvent';
-
-/**
- * @deprecated Use {@link configureModules} instead. This alias will be removed in a future major version.
- */
-export { configureModules as initAppModules } from './configure-modules';

package/src/initialize-app-modules.ts

@@ -1,98 +0,0 @@
-import type { Fusion } from '@equinor/fusion-framework';
-import type { AnyModule } from '@equinor/fusion-framework-module';
-import {
-  enableTelemetry,
-  type MetadataExtractor,
-} from '@equinor/fusion-framework-module-telemetry';
-
-import type { AppConfigurator } from './AppConfigurator';
-import type { AppModulesInstance, AppEnv } from './types';
-
-/**
- * Runs the telemetry wiring, the caller's configuration callback and module
- * initialization against an already constructed configurator.
- *
- * @remarks
- * Extracted so `mockAppModules` (`@equinor/fusion-framework-app/mock`) can drive the
- * exact same pipeline against an `AppMockConfigurator` instead of reimplementing
- * it — the same way `FrameworkConfigurator` and `FrameworkMockConfigurator`
- * share the framework's `init`.
- *
- * @param configurator - The (real or mock) app configurator to run the pipeline on.
- * @param cb - Configuration callback invoked before module initialization, or `undefined` to skip it.
- * @param args - Object containing the Fusion instance and the application environment.
- * @returns The fully initialized application module instance.
- * @template TModules - Application module descriptors beyond the default set.
- * @template TRef - The parent Fusion instance type.
- * @template TEnv - The application environment descriptor.
- * @template TConfigurator - The (real or mock) `AppConfigurator` subclass driving the pipeline.
- */
-export async function initializeAppModules<
-  TModules extends Array<AnyModule> | never,
-  TRef extends Fusion = Fusion,
-  TEnv extends AppEnv = AppEnv,
-  // Widened beyond the plain `AppConfigurator` so callers such as `mockAppModules` can
-  // drive the same pipeline against a subclass (e.g. `AppMockConfigurator`) and have `cb`
-  // typed against that subclass rather than the base `IAppConfigurator` interface.
-  TConfigurator extends AppConfigurator<TModules, TRef['modules'], TEnv> = AppConfigurator<
-    TModules,
-    TRef['modules'],
-    TEnv
-  >,
->(
-  configurator: TConfigurator,
-  cb:
-    | ((configurator: TConfigurator, args: { fusion: TRef; env: TEnv }) => void | Promise<void>)
-    | undefined,
-  args: { fusion: TRef; env: TEnv },
-): Promise<AppModulesInstance<TModules>> {
-  const { fusion } = args;
-
-  // Extract telemetry metadata from app manifest for tracking and debugging
-  const metadataExtractor: MetadataExtractor = () => {
-    return {
-      fusion: {
-        type: 'app-telemetry',
-        app: {
-          key: args.env.manifest?.appKey || 'unknown-app',
-          version: args.env.manifest?.build?.version || 'unknown-version',
-        },
-      },
-    };
-  };
-
-  // Enable telemetry collection for module configuration events
-  // attachConfiguratorEvents automatically prefixes events with configurator class name
-  enableTelemetry(configurator, {
-    attachConfiguratorEvents: true,
-    configure: (builder) => {
-      builder.setMetadata(metadataExtractor);
-      builder.setParent(fusion.modules.telemetry);
-      // Scope telemetry to 'app' level for app-specific event filtering
-      builder.setDefaultScope(['app']);
-    },
-  });
-
-  // Allow user configuration callback to run before module initialization
-  if (cb) {
-    await Promise.resolve(cb(configurator, args));
-  }
-  // Type cast is safe because AppConfigurator.initialize() returns the exact module
-  // instance that was registered and configured above. The intermediate 'unknown'
-  // cast is necessary due to TypeScript's generic inference limitations with the
-  // configurator's initialization chain, but the runtime value is guaranteed to match.
-  const modules: AppModulesInstance<TModules> = (await configurator.initialize(
-    args.fusion.modules,
-  )) as unknown as AppModulesInstance<TModules>;
-
-  // Dispatch app modules loaded event for app lifecycle tracking
-  // TODO(#5061): remove check after fusion-cli is updated (app module is not enabled in fusion-cli)
-  if (args.env.manifest?.appKey) {
-    modules.event.dispatchEvent('onAppModulesLoaded', {
-      detail: { appKey: args.env.manifest.appKey, manifest: args.env.manifest, modules },
-    });
-  }
-  return modules;
-}
-
-export default initializeAppModules;