@equinor/fusion-framework-react-app 14.0.0 → 15.0.0-next.0

package/src/__tests__/useCurrentBookmark.test.tsx

@@ -0,0 +1,108 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { mockFramework } from '@equinor/fusion-framework/mock';
+import { enableAppManifestMock } from '@equinor/fusion-framework-app/mock';
+import type { AppMockConfigureFn } from '@equinor/fusion-framework-app/mock';
+import type { AppModule } from '@equinor/fusion-framework-module-app';
+import { enableBookmarkMock } from '@equinor/fusion-framework-module-bookmark/mock';
+import type { Bookmark, BookmarkModule } from '@equinor/fusion-framework-module-bookmark';
+
+import { useCurrentBookmark } from '../bookmark/useCurrentBookmark';
+import { renderAppHook } from '@equinor/fusion-framework-vitest-plugin-react-app/test';
+import { useAppModules } from '../useAppModules';
+
+const env = {
+  manifest: {
+    appKey: 'test-app',
+    displayName: 'Test App',
+    description: 'A test application',
+    type: 'standalone' as const,
+  },
+};
+
+/** A fully-formed seeded bookmark, so tests only override what they care about. */
+const createBookmark = (overrides: Partial<Bookmark> = {}): Bookmark => ({
+  id: 'bookmark-1',
+  name: 'My Bookmark',
+  appKey: 'test-app',
+  created: new Date('2024-01-01T00:00:00.000Z'),
+  createdBy: { id: 'seed-user', name: 'Seed User' },
+  ...overrides,
+});
+
+describe('useCurrentBookmark', () => {
+  it('returns the app-scoped current bookmark once it belongs to the active app', async () => {
+    const bookmark = createBookmark();
+    const fusion = await mockFramework<[AppModule]>((configurator) =>
+      enableAppManifestMock(configurator, env),
+    );
+    fusion.modules.app.setCurrentApp(env.manifest.appKey);
+
+    const configure: AppMockConfigureFn<[BookmarkModule]> = (configurator) =>
+      enableBookmarkMock(configurator, (builder) => {
+        builder.setBookmarks([bookmark]);
+        builder.setCurrentBookmark(bookmark.id);
+      });
+
+    const { result } = await renderAppHook(() => useCurrentBookmark(), { env, fusion, configure });
+
+    await vi.waitFor(() =>
+      expect(result.current.currentBookmark).toMatchObject({ id: bookmark.id }),
+    );
+  });
+
+  it('hides the current bookmark once it belongs to a different app', async () => {
+    const bookmark = createBookmark({ appKey: 'some-other-app' });
+    const fusion = await mockFramework<[AppModule]>((configurator) =>
+      enableAppManifestMock(configurator, env),
+    );
+    fusion.modules.app.setCurrentApp(env.manifest.appKey);
+
+    const configure: AppMockConfigureFn<[BookmarkModule]> = (configurator) =>
+      enableBookmarkMock(configurator, (builder) => {
+        builder.setBookmarks([bookmark]);
+        builder.setCurrentBookmark(bookmark.id);
+      });
+
+    const { result } = await renderAppHook(
+      () => ({
+        bookmark: useCurrentBookmark(),
+        // unfiltered provider state, so we can tell the seeded bookmark actually
+        // resolved rather than the filter trivially matching a still-pending value
+        provider: useAppModules<[BookmarkModule]>().bookmark,
+      }),
+      { env, fusion, configure },
+    );
+
+    await vi.waitFor(() =>
+      expect(result.current.provider.currentBookmark).toMatchObject({ id: bookmark.id }),
+    );
+    expect(result.current.bookmark.currentBookmark).toBeNull();
+  });
+
+  it('falls back to the framework-scoped bookmark provider, warning about the deprecation', async () => {
+    const bookmark = createBookmark();
+    const fusion = await mockFramework<[AppModule, BookmarkModule]>((configurator) => {
+      enableAppManifestMock(configurator, env);
+      enableBookmarkMock(configurator, (builder) => {
+        builder.setBookmarks([bookmark]);
+        builder.setCurrentBookmark(bookmark.id);
+      });
+    });
+    fusion.modules.app.setCurrentApp(env.manifest.appKey);
+
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    const { result } = await renderAppHook(() => useCurrentBookmark(), { env, fusion });
+
+    await vi.waitFor(() =>
+      expect(result.current.currentBookmark).toMatchObject({ id: bookmark.id }),
+    );
+    expect(warnSpy).toHaveBeenCalledWith(
+      '@deprecation',
+      expect.stringContaining('has not enabled bookmarks'),
+    );
+
+    warnSpy.mockRestore();
+  });
+});

package/src/__tests__/useCurrentContext.test.tsx

@@ -0,0 +1,72 @@
+import { act } from 'react';
+import { describe, expect, it, vi } from 'vitest';
+
+import { mockFramework } from '@equinor/fusion-framework/mock';
+import { enableAppManifestMock } from '@equinor/fusion-framework-app/mock';
+import type { AppMockConfigureFn } from '@equinor/fusion-framework-app/mock';
+import type { AppModule } from '@equinor/fusion-framework-module-app';
+import { enableContextMock } from '@equinor/fusion-framework-module-context/mock';
+import type { ContextItem, ContextModule } from '@equinor/fusion-framework-module-context';
+
+import { useCurrentContext } from '../context/useCurrentContext';
+import { renderAppHook } from '@equinor/fusion-framework-vitest-plugin-react-app/test';
+
+const env = {
+  manifest: {
+    appKey: 'test-app',
+    displayName: 'Test App',
+    description: 'A test application',
+    type: 'standalone' as const,
+  },
+};
+
+const project: ContextItem = {
+  id: 'ctx-1',
+  title: 'My project',
+  type: { id: 'ProjectMaster' },
+  value: {},
+};
+const facility: ContextItem = {
+  id: 'ctx-2',
+  title: 'My facility',
+  type: { id: 'Facility' },
+  value: {},
+};
+
+describe('useCurrentContext', () => {
+  it('resolves the context item selected on startup from the app-scoped context module', async () => {
+    const fusion = await mockFramework<[AppModule]>((configurator) =>
+      enableAppManifestMock(configurator, env),
+    );
+    const configure: AppMockConfigureFn<[ContextModule]> = (configurator) =>
+      enableContextMock(configurator, (mock) => {
+        mock.setCurrentContext(project);
+      });
+
+    const { result } = await renderAppHook(() => useCurrentContext(), { env, fusion, configure });
+
+    await vi.waitFor(() => expect(result.current.currentContext).toMatchObject({ id: project.id }));
+  });
+
+  it('switches the current context when setCurrentContext is called with another seeded item', async () => {
+    const fusion = await mockFramework<[AppModule]>((configurator) =>
+      enableAppManifestMock(configurator, env),
+    );
+    const configure: AppMockConfigureFn<[ContextModule]> = (configurator) =>
+      enableContextMock(configurator, (mock) => {
+        mock.setCurrentContext(project);
+        mock.addContext(facility);
+      });
+
+    const { result } = await renderAppHook(() => useCurrentContext(), { env, fusion, configure });
+    await vi.waitFor(() => expect(result.current.currentContext).toMatchObject({ id: project.id }));
+
+    await act(async () => {
+      await result.current.setCurrentContext(facility.id);
+    });
+
+    await vi.waitFor(() =>
+      expect(result.current.currentContext).toMatchObject({ id: facility.id }),
+    );
+  });
+});

package/src/__tests__/useFeature.test.tsx

@@ -0,0 +1,104 @@
+import { act } from 'react';
+import { describe, expect, it, vi } from 'vitest';
+
+import { mockFramework } from '@equinor/fusion-framework/mock';
+import { enableAppManifestMock } from '@equinor/fusion-framework-app/mock';
+import type { AppMockConfigureFn } from '@equinor/fusion-framework-app/mock';
+import type { AppModule } from '@equinor/fusion-framework-module-app';
+import { enableFeatureFlagMock } from '@equinor/fusion-framework-module-feature-flag/mock';
+import type { FeatureFlagModule } from '@equinor/fusion-framework-module-feature-flag';
+
+import { useFeature } from '../feature-flag/useFeature';
+import { renderAppHook } from '@equinor/fusion-framework-vitest-plugin-react-app/test';
+
+const env = {
+  manifest: {
+    appKey: 'test-app',
+    displayName: 'Test App',
+    description: 'A test application',
+    type: 'standalone' as const,
+  },
+};
+
+describe('useFeature', () => {
+  it('resolves a flag seeded on the app scope when the framework has no feature-flag module', async () => {
+    const fusion = await mockFramework<[AppModule]>((configurator) =>
+      enableAppManifestMock(configurator, env),
+    );
+    const configure: AppMockConfigureFn<[FeatureFlagModule]> = (configurator) => {
+      enableFeatureFlagMock(configurator, (mock) => {
+        mock.addFeature({ key: 'dark-mode', enabled: true });
+      });
+    };
+
+    const { result } = await renderAppHook(() => useFeature('dark-mode'), {
+      env,
+      fusion,
+      configure,
+    });
+
+    await vi.waitFor(() => expect(result.current.feature?.enabled).toBe(true));
+  });
+
+  it('lets an app-scoped flag override a framework-scoped flag with the same key', async () => {
+    const fusion = await mockFramework<[AppModule, FeatureFlagModule]>((configurator) => {
+      enableAppManifestMock(configurator, env);
+      enableFeatureFlagMock(configurator, (mock) => {
+        mock.addFeature({ key: 'dark-mode', enabled: false });
+      });
+    });
+    const configure: AppMockConfigureFn<[FeatureFlagModule]> = (configurator) => {
+      enableFeatureFlagMock(configurator, (mock) => {
+        mock.addFeature({ key: 'dark-mode', enabled: true });
+      });
+    };
+
+    const { result } = await renderAppHook(() => useFeature('dark-mode'), {
+      env,
+      fusion,
+      configure,
+    });
+
+    await vi.waitFor(() => expect(result.current.feature?.enabled).toBe(true));
+  });
+
+  it('exposes a framework-only flag through the merged stream when the app has not seeded it', async () => {
+    const fusion = await mockFramework<[AppModule, FeatureFlagModule]>((configurator) => {
+      enableAppManifestMock(configurator, env);
+      enableFeatureFlagMock(configurator, (mock) => {
+        mock.addFeature({ key: 'framework-only', enabled: true });
+      });
+    });
+    const configure: AppMockConfigureFn<[FeatureFlagModule]> = (configurator) => {
+      enableFeatureFlagMock(configurator);
+    };
+
+    const { result } = await renderAppHook(() => useFeature('framework-only'), {
+      env,
+      fusion,
+      configure,
+    });
+
+    await vi.waitFor(() => expect(result.current.feature?.enabled).toBe(true));
+  });
+
+  it('inverts the current value when toggleFeature is called without an explicit value', async () => {
+    const fusion = await mockFramework<[AppModule]>((configurator) =>
+      enableAppManifestMock(configurator, env),
+    );
+    const configure: AppMockConfigureFn<[FeatureFlagModule]> = (configurator) => {
+      enableFeatureFlagMock(configurator, (mock) => {
+        mock.addFeature({ key: 'my-flag', enabled: false });
+      });
+    };
+
+    const { result } = await renderAppHook(() => useFeature('my-flag'), { env, fusion, configure });
+    await vi.waitFor(() => expect(result.current.feature?.enabled).toBe(false));
+
+    act(() => {
+      result.current.toggleFeature();
+    });
+
+    await vi.waitFor(() => expect(result.current.feature?.enabled).toBe(true));
+  });
+});

package/src/__tests__/useHelpCenter.test.tsx

@@ -0,0 +1,64 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { mockFramework } from '@equinor/fusion-framework/mock';
+import { enableAppManifestMock } from '@equinor/fusion-framework-app/mock';
+import type { AppModule } from '@equinor/fusion-framework-module-app';
+
+import useAppModule from '../useAppModule';
+import { useHelpCenter } from '../help-center/useHelpCenter';
+import { EVENT_NAME } from '../help-center/event-name.js';
+import { renderAppHook } from '@equinor/fusion-framework-vitest-plugin-react-app/test';
+
+const env = {
+  manifest: {
+    appKey: 'test-app',
+    displayName: 'Test App',
+    description: 'A test application',
+    type: 'standalone' as const,
+  },
+};
+
+describe('useHelpCenter', () => {
+  it('dispatches the expected page and detail for every help-center action', async () => {
+    const fusion = await mockFramework<[AppModule]>((configurator) =>
+      enableAppManifestMock(configurator, env),
+    );
+
+    const { result } = await renderAppHook(
+      () => ({ helpCenter: useHelpCenter(), eventModule: useAppModule('event') }),
+      { env, fusion },
+    );
+
+    const received: Array<{ page: string } & Record<string, unknown>> = [];
+    result.current.eventModule.addEventListener(EVENT_NAME, (event) => {
+      received.push(event.detail as { page: string } & Record<string, unknown>);
+    });
+
+    result.current.helpCenter.openHelp();
+    await vi.waitFor(() => expect(received).toHaveLength(1));
+
+    result.current.helpCenter.openArticle('my-article');
+    await vi.waitFor(() => expect(received).toHaveLength(2));
+
+    result.current.helpCenter.openFaqs();
+    await vi.waitFor(() => expect(received).toHaveLength(3));
+
+    result.current.helpCenter.openSearch('my search');
+    await vi.waitFor(() => expect(received).toHaveLength(4));
+
+    result.current.helpCenter.openGovernance();
+    await vi.waitFor(() => expect(received).toHaveLength(5));
+
+    result.current.helpCenter.openReleaseNotes();
+    await vi.waitFor(() => expect(received).toHaveLength(6));
+
+    expect(received).toEqual([
+      { page: 'home' },
+      { page: 'article', articleId: 'my-article' },
+      { page: 'faqs' },
+      { page: 'search', search: 'my search' },
+      { page: 'governance' },
+      { page: 'release-notes' },
+    ]);
+  });
+});

package/src/__tests__/useStateSyncEvents.test.ts

@@ -1,9 +1,9 @@
+import { act } from 'react';
 import { describe, it, expect, vi } from 'vitest';
 import { Subject } from 'rxjs';
 
-import { act, renderHook } from '@testing-library/react';
-
 import { StateSyncEvent, type StateSyncEventType } from '@equinor/fusion-framework-module-state';
+import { renderAppHook } from '@equinor/fusion-framework-vitest-plugin-react-app/test';
 
 const event$ = new Subject<StateSyncEventType>();
 
@@ -14,8 +14,8 @@ vi.mock('../useAppModule', () => ({
 import { useStateSyncEvents } from '../state/useStateSyncEvents';
 
 describe('useStateSyncEvents', () => {
-  it('collects dispatched onStateSync.* events, oldest first', () => {
-    const { result } = renderHook(() => useStateSyncEvents(10));
+  it('collects dispatched onStateSync.* events, oldest first', async () => {
+    const { result } = await renderAppHook(() => useStateSyncEvents(10));
 
     expect(result.current).toEqual([]);
 
@@ -24,13 +24,14 @@ describe('useStateSyncEvents', () => {
       event$.next(new StateSyncEvent.Status({ detail: { status: 'paused' } }));
     });
 
-    expect(result.current).toHaveLength(2);
-    expect(result.current[0].detail.status).toBe('active');
-    expect(result.current[1].detail.status).toBe('paused');
+    expect(result.current).toMatchObject([
+      { detail: { status: 'active' } },
+      { detail: { status: 'paused' } },
+    ]);
   });
 
-  it('ignores events unrelated to state sync and trims the log to the given limit', () => {
-    const { result } = renderHook(() => useStateSyncEvents(1));
+  it('ignores events unrelated to state sync and trims the log to the given limit', async () => {
+    const { result } = await renderAppHook(() => useStateSyncEvents(1));
 
     act(() => {
       event$.next(new StateSyncEvent.Status({ detail: { status: 'active' } }));
@@ -43,8 +44,8 @@ describe('useStateSyncEvents', () => {
     expect(result.current[0]).toBeInstanceOf(StateSyncEvent.Error);
   });
 
-  it('unsubscribes from the event stream on unmount', () => {
-    const { result, unmount } = renderHook(() => useStateSyncEvents(10));
+  it('unsubscribes from the event stream on unmount', async () => {
+    const { result, unmount } = await renderAppHook(() => useStateSyncEvents(10));
 
     unmount();
 

package/src/__tests__/useToken.test.tsx

@@ -0,0 +1,71 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { mockFramework } from '@equinor/fusion-framework/mock';
+
+import { useToken } from '../msal/useToken';
+import { renderAppHook } from '@equinor/fusion-framework-vitest-plugin-react-app/test';
+
+describe('useToken', () => {
+  it('resolves a full AuthenticationResult from the app scope’s real, mock-backed auth module', async () => {
+    const { result, unmount } = await renderAppHook(() => useToken({ scopes: ['User.Read'] }));
+
+    // `renderAppHook` awaits the render, and the mock resolves near-instantly,
+    // so the pending state may have already settled by the time we can observe it
+    await vi.waitFor(() => expect(result.current.pending).toBe(false));
+
+    expect(result.current.error).toBeNull();
+    expect(result.current.token?.scopes).toEqual(['User.Read']);
+    // a structurally valid JWT has three dot-separated segments
+    expect(result.current.token?.accessToken.split('.')).toHaveLength(3);
+    expect(result.current.token?.account).toMatchObject({ username: 'test.user@equinor.com' });
+
+    // unmount before the next test's environment tears down, so no acquisition
+    // effect can flush a state update against an already-destroyed `window`
+    await unmount();
+  });
+
+  it('surfaces an acquisition error instead of throwing', async () => {
+    const fusion = await mockFramework();
+    // persistent, not `-Once`: the app module hoists via a version-compat proxy that
+    // may call through before the hook's own effect does, consuming a one-shot mock
+    vi.spyOn(fusion.modules.auth, 'acquireToken').mockRejectedValue(
+      new Error('acquisition failed'),
+    );
+
+    const { result, unmount } = await renderAppHook(() => useToken({ scopes: ['User.Read'] }), {
+      fusion,
+    });
+
+    await vi.waitFor(() => expect(result.current.pending).toBe(false));
+
+    expect(result.current.token).toBeUndefined();
+    expect(result.current.error).toBeInstanceOf(Error);
+
+    await unmount();
+  });
+
+  it('only re-acquires the token when the scopes\u2019 contents change, not on every re-render', async () => {
+    const fusion = await mockFramework();
+    const acquireToken = vi.spyOn(fusion.modules.auth, 'acquireToken');
+
+    const { result, rerender, unmount } = await renderAppHook((props) => useToken(props), {
+      initialProps: { scopes: ['User.Read'] },
+      fusion,
+    });
+
+    await vi.waitFor(() => expect(result.current.pending).toBe(false));
+    expect(acquireToken).toHaveBeenCalledTimes(1);
+
+    // a fresh array literal with the same contents must not trigger a re-acquisition
+    await rerender({ scopes: ['User.Read'] });
+    await vi.waitFor(() => expect(result.current.pending).toBe(false));
+    expect(acquireToken).toHaveBeenCalledTimes(1);
+
+    // changed scope contents must trigger a second acquisition
+    await rerender({ scopes: ['User.Read', 'Mail.Read'] });
+    await vi.waitFor(() => expect(result.current.pending).toBe(false));
+    expect(acquireToken).toHaveBeenCalledTimes(2);
+
+    await unmount();
+  });
+});

package/src/__tests__/useTrackFeature.test.tsx

@@ -0,0 +1,83 @@
+import { describe, expect, it } from 'vitest';
+
+import { mockFramework } from '@equinor/fusion-framework/mock';
+import { enableAppManifestMock } from '@equinor/fusion-framework-app/mock';
+import type { AppModule } from '@equinor/fusion-framework-module-app';
+import { enableAnalytics, type AnalyticsModule } from '@equinor/fusion-framework-module-analytics';
+import { MockAnalyticsAdapter } from '@equinor/fusion-framework-module-analytics/mock';
+import type { MockTelemetryAdapter } from '@equinor/fusion-framework-module-telemetry/mock';
+
+import { useTrackFeature } from '../analytics/useTrackFeature';
+import { renderAppHook } from '@equinor/fusion-framework-vitest-plugin-react-app/test';
+
+const env = {
+  manifest: {
+    appKey: 'test-app',
+    displayName: 'Test App',
+    description: 'A test application',
+    type: 'standalone' as const,
+  },
+};
+
+describe('useTrackFeature', () => {
+  it('tracks an app-feature analytics event carrying the current app’s key, leaving telemetry untouched', async () => {
+    const recorder = new MockAnalyticsAdapter();
+
+    const fusion = await mockFramework<[AppModule, AnalyticsModule]>((configurator) => {
+      enableAppManifestMock(configurator, env);
+      enableAnalytics(configurator, (builder) => {
+        builder.setAdapter('mock', async () => recorder);
+      });
+    });
+    fusion.modules.app.setCurrentApp('test-app');
+
+    const { result } = await renderAppHook(() => useTrackFeature(), { env, fusion });
+    result.current('button-click', { section: 'header' });
+
+    // analytics is the only channel a successful call should reach
+    expect(recorder.getAnalytics()).toMatchObject([
+      {
+        name: 'app-feature',
+        value: { feature: 'button-click', data: { section: 'header' } },
+        attributes: { appKey: 'test-app', context: undefined },
+      },
+    ]);
+    // the framework logs its own telemetry regardless; the fallback diagnostic
+    // specifically must not fire when analytics was reached successfully
+    const telemetry = fusion.modules.telemetry.getAdapter('mock') as MockTelemetryAdapter;
+    expect(telemetry.getItems('AnalyticsProviderNotFound')).toHaveLength(0);
+  });
+
+  it('includes the current context alongside the app key', async () => {
+    const recorder = new MockAnalyticsAdapter();
+    const project = { id: 'ctx-1', title: 'My project', type: { id: 'ProjectMaster' }, value: {} };
+
+    const fusion = await mockFramework<[AppModule, AnalyticsModule]>((configurator) => {
+      enableAppManifestMock(configurator, env);
+      enableAnalytics(configurator, (builder) => {
+        builder.setAdapter('mock', async () => recorder);
+      });
+      configurator.context.setCurrentContext(project);
+    });
+
+    const { result } = await renderAppHook(() => useTrackFeature(), { env, fusion });
+    result.current('button-click');
+
+    const [event] = recorder.getAnalytics('app-feature');
+    expect(event.attributes?.context).toMatchObject({ id: project.id, type: 'ProjectMaster' });
+  });
+
+  it('reports to telemetry instead of throwing when no analytics provider is registered', async () => {
+    const fusion = await mockFramework<[AppModule]>((configurator) => {
+      enableAppManifestMock(configurator, env);
+    });
+
+    const { result } = await renderAppHook(() => useTrackFeature(), { env, fusion });
+
+    // the missing-analytics diagnostic is a telemetry concern, not an analytics one —
+    // it must not throw and must not fabricate an analytics event of its own
+    expect(() => result.current('button-click')).not.toThrow();
+    const telemetry = fusion.modules.telemetry.getAdapter('mock') as MockTelemetryAdapter;
+    expect(telemetry.getItems('AnalyticsProviderNotFound')).toHaveLength(1);
+  });
+});

package/src/create-component.tsx

@@ -41,7 +41,7 @@ export type ComponentRenderer<TFusion extends Fusion = Fusion, TEnv = AppEnv> =
  * @example
  * ```tsx
  * const configCallback: AppConfigurator = (configurator) => {
- *  configurator.http.configureClient(
+ *  configurator.configureHttpClient(
  *     'bar', {
  *       baseUri: 'https://somewhere-test.com',
  *       defaultScopes: ['foo/.default']

package/src/msal/useToken.ts

@@ -1,4 +1,4 @@
-import { useEffect, useState } from 'react';
+import { useEffect, useRef, useState } from 'react';
 
 import type { AuthenticationResult } from '@equinor/fusion-framework-module-msal';
 
@@ -32,11 +32,22 @@ export const useToken = (req: {
   const [token, setToken] = useState<AuthenticationResult | undefined>(undefined);
   const [pending, setPending] = useState<boolean>(false);
   const [error, setError] = useState<unknown>(null);
+
+  // `req` is typically a fresh object literal each render; key the effect on its
+  // scopes' content instead of identity, so it doesn't re-run (and reset `pending`
+  // to `true` forever) every time the caller re-renders. `JSON.stringify` (rather than
+  // `.join(',')`) keeps scopes with different array boundaries (e.g. `['a,b']` vs.
+  // `['a', 'b']`) from colliding on the same key.
+  const scopesKey = JSON.stringify(req.scopes);
+  const reqRef = useRef(req);
+  reqRef.current = req;
+
+  // biome-ignore lint/correctness/useExhaustiveDependencies: scopesKey is a re-run trigger, not read in the body
   useEffect(() => {
     setPending(true);
     setToken(undefined);
     msalProvider
-      .acquireToken({ request: req })
+      .acquireToken({ request: reqRef.current })
       .then((result) => {
         // Only update state when a token was actually acquired
         if (result) {
@@ -45,7 +56,7 @@ export const useToken = (req: {
       })
       .catch(setError)
       .finally(() => setPending(false));
-  }, [msalProvider, req]);
+  }, [msalProvider, scopesKey]);
   return { token, pending, error };
 };
 

package/src/version.ts

@@ -1,2 +1,2 @@
 // Generated by genversion.
-export const version = '14.0.0';
+export const version = '15.0.0-next.0';

package/tsconfig.json

@@ -12,6 +12,9 @@
     {
       "path": "../../app"
     },
+    {
+      "path": "../../framework"
+    },
     {
       "path": "../framework"
     },

package/vitest.config.ts

@@ -1,15 +1,9 @@
-import { defineProject } from 'vitest/config';
+import { defineProject } from '@equinor/fusion-framework-vitest-plugin-react-app/config';
 
-import { name, version } from './package.json';
+import { name, version } from './package.json' with { type: 'json' };
 
 export default defineProject({
-  resolve: {
-    // @ts-expect-error -- tsconfigPaths is a Vite 8 option; vitest 4.x ships Vite 7 types
-    tsconfigPaths: true,
-  },
   test: {
-    include: ['src/__tests__/**'],
     name: `${name}@${version}`,
-    environment: 'happy-dom',
   },
 });