@equinor/fusion-framework-vitest-plugin-react-app 0.2.0-next.0

package/dist/types/app-test.d.ts

@@ -0,0 +1,6 @@
+export { renderAppHook, type RenderAppHookOptions, type RenderAppHookResult, } from './render-app-hook';
+export { renderAppComponent, type RenderAppComponentOptions, type RenderAppComponentResult, } from './render-app-component';
+export { testApp } from './test-app';
+export type { AppMockConfigureFn } from '@equinor/fusion-framework-app/mock';
+export { test } from './test';
+export { render } from './render';

package/dist/types/define-project.d.ts

@@ -0,0 +1,41 @@
+import { type UserWorkspaceConfig } from 'vitest/config';
+/**
+ * A config override for {@link defineProject}: an object is deep-merged onto the default
+ * config via Vite's own `mergeConfig`; a function receives the default config and returns the
+ * config used outright, for changes `mergeConfig` can't express (e.g. removing a field).
+ */
+export type AppTestConfigOverride = Partial<UserWorkspaceConfig> | ((config: UserWorkspaceConfig) => UserWorkspaceConfig);
+/**
+ * Builds a ready-to-export Vitest project config for testing a Fusion Framework React app:
+ * registers {@link appTestVitePlugin} (with its own defaults) and wires up Vitest browser mode
+ * with the Playwright/`chromium` provider, so a consuming app's own `vitest.config.ts` needs no
+ * browser-provider boilerplate of its own.
+ *
+ * @remarks
+ * Drop-in replacement for Vitest's own `defineProject` — same `export default`, just pre-wired.
+ * Playwright/`chromium` is only the *default* — pass `override` to change or replace anything
+ * (e.g. `test.name`, or swap `test.browser.provider` for a different `@vitest/browser-*`
+ * provider) without hand-rolling `appTestVitePlugin`'s own wiring.
+ *
+ * @example
+ * ```ts
+ * import { defineProject } from '@equinor/fusion-framework-vitest-plugin-react-app/config';
+ * import { name, version } from './package.json' with { type: 'json' };
+ *
+ * export default defineProject({ test: { name: `${name}@${version}` } });
+ * ```
+ *
+ * @example
+ * Overriding the browser provider:
+ * ```ts
+ * import { webdriverio } from '@vitest/browser-webdriverio';
+ *
+ * export default defineProject({ test: { browser: { provider: webdriverio() } } });
+ * ```
+ *
+ * @param override - Deep-merged onto the default config (a plain object), or applied to it
+ * outright (a function receiving the default config); see {@link AppTestConfigOverride}.
+ * @returns A Vitest project config, ready to `export default`.
+ */
+export declare const defineProject: (override?: AppTestConfigOverride) => UserWorkspaceConfig;
+export default defineProject;

package/dist/types/index.d.ts

@@ -0,0 +1,45 @@
+import type { Plugin } from 'vite';
+import { type ResolveAppTestEnvOptions } from './resolve-app-test-env.js';
+/**
+ * Options for {@link appTestVitePlugin}.
+ */
+export type AppTestVitePluginOptions = ResolveAppTestEnvOptions & {
+    /**
+     * Path (relative to `entrypoint`) to the app's module-configurator export, mirroring the
+     * `configure` argument passed to `makeComponent` in the app's own entry point. Defaults to the
+     * first of `src/config.ts`, `src/config.tsx`, `src/config.js` that exists.
+     *
+     * @remarks
+     * Unlike `manifest`/`config`, this can't be an inline function: it's live application code
+     * (with its own imports and closures) re-exported as-is into the test bundle rather than
+     * JSON-serialized data, so Vite needs a real file on disk to resolve and transform.
+     */
+    configure?: string;
+};
+/**
+ * Vite plugin serving an application's manifest/config (resolved the same way `ffc app build`/
+ * `ffc app dev` do) and its own module-configurator export as virtual modules, so
+ * `@equinor/fusion-framework-vitest-plugin-react-app/test`'s `test`/`render` need no per-test
+ * `env`/`configure` wiring.
+ *
+ * @remarks
+ * A plain Vite plugin — Vitest configs are Vite configs, so this registers directly in your
+ * own `vitest.config.ts`, no CLI command required:
+ * ```ts
+ * import { defineConfig } from 'vitest/config';
+ * import { appTestVitePlugin } from '@equinor/fusion-framework-vitest-plugin-react-app';
+ *
+ * export default defineConfig({
+ *   plugins: [appTestVitePlugin()],
+ *   // ...your own browser-mode config
+ * });
+ * ```
+ * Exposes two virtual modules: `virtual:fusion-app-test-env` (`manifest`/`config`, as JSON) and
+ * `virtual:fusion-app-test-configure` (a re-export of the resolved `configure` module, or
+ * `undefined` if none exists). Not intended to be imported directly by application code.
+ *
+ * @param options - Resolution options; `entrypoint` defaults to the current working directory.
+ * @returns A Vite plugin instance.
+ */
+export declare const appTestVitePlugin: (options?: AppTestVitePluginOptions) => Plugin;
+export default appTestVitePlugin;

package/dist/types/render-app-component.d.ts

@@ -0,0 +1,86 @@
+import type { ReactElement } from 'react';
+import type { RenderOptions, RenderResult } from 'vitest-browser-react';
+import type { AppMockConfigureFn } from '@equinor/fusion-framework-app/mock';
+import type { AppEnv, AppModulesInstance } from '@equinor/fusion-framework-app';
+import type { Fusion } from '@equinor/fusion-framework';
+import type { AnyModule } from '@equinor/fusion-framework-module';
+/**
+ * Options for {@link renderAppComponent}.
+ *
+ * @template TModules - Module descriptors beyond the default set.
+ * @template TEnv - The application environment descriptor.
+ */
+export interface RenderAppComponentOptions<TModules extends Array<AnyModule> | unknown = unknown, TEnv extends AppEnv = AppEnv> extends Omit<RenderOptions, 'wrapper'> {
+    /** Configuration callback forwarded to {@link mockAppModules}. */
+    configure?: AppMockConfigureFn<TModules, TEnv>;
+    /** The application environment; defaults to a generic standalone test app. */
+    env?: TEnv;
+    /**
+     * The parent Fusion instance; defaults to a fresh {@link mockFramework} instance with
+     * this app's own manifest served. Pass one built beforehand to reuse a single instance
+     * across multiple render calls, or to pre-configure parent-level modules (e.g. `http`,
+     * `context`, `serviceDiscovery`, or `app` itself for a component that loads another app).
+     */
+    fusion?: Fusion;
+}
+/**
+ * The result of {@link renderAppComponent}: the `vitest-browser-react` render result,
+ * plus the resolved application module scope and its parent Fusion instance.
+ *
+ * @template TModules - Module descriptors beyond the default set.
+ */
+export interface RenderAppComponentResult<TModules extends Array<AnyModule> | unknown = unknown> extends RenderResult {
+    /**
+     * The Fusion instances backing the rendered component, nested under this single key so
+     * `vitest-browser-react`'s own `RenderResult` fields stay free to evolve without ever
+     * colliding with it.
+     */
+    fusion: {
+        /** The parent Fusion instance the component's `FrameworkProvider` was given. */
+        framework: Fusion;
+        /**
+         * The resolved application module instance backing the rendered component — the same
+         * instance a real app would read via `useAppModule`/`useAppModules`. Drive a module
+         * directly (e.g. `fusion.app.context.setCurrentContextByIdAsync(id)`) to exercise a
+         * state change after the initial render, then assert the component re-rendered accordingly.
+         */
+        app: AppModulesInstance<TModules>;
+    };
+}
+/**
+ * Renders a component inside a real, mock-backed application module scope.
+ *
+ * @remarks
+ * Wraps `vitest-browser-react`'s `render` with the same provider nesting
+ * `createComponent` uses in production — a `FrameworkProvider` (the parent Fusion
+ * instance, from `mockFramework`) around a `ModuleProvider` (this app's own modules,
+ * from `mockAppModules`, `@equinor/fusion-framework-app/mock`). See {@link renderAppHook}
+ * for the equivalent helper when testing a hook in isolation, rather than a component.
+ *
+ * @template TModules - Module descriptors beyond the default set.
+ * @template TEnv - The application environment descriptor.
+ * @param ui - The component to render.
+ * @param options - A `configure` callback and `env` for `mockAppModules`, plus any other `render` option.
+ * @returns The `render` result plus `fusion.framework` and `fusion.app`, once the mocked application module scope resolves.
+ *
+ * @example
+ * ```tsx
+ * const { getByText } = await renderAppComponent(<Apploader appKey="child-app" />, {
+ *   fusion: await mockFramework<[AppModule]>((configurator) => {
+ *     // register the child app's own manifest against the `app` module
+ *   }),
+ * });
+ * await expect.element(getByText(/mounted/)).toBeInTheDocument();
+ * ```
+ *
+ * @example Drive a module directly and assert the re-render
+ * ```tsx
+ * const { getByText, fusion } = await renderAppComponent<[ContextModule]>(<App />, {
+ *   configure: (configurator) => enableContextMock(configurator, (mock) => mock.setCurrentContext(projectA)),
+ * });
+ * await fusion.app.context.setCurrentContextByIdAsync(projectB.id);
+ * await expect.element(getByText(/project-b/)).toBeInTheDocument();
+ * ```
+ */
+export declare function renderAppComponent<TModules extends Array<AnyModule> | unknown = unknown, TEnv extends AppEnv = AppEnv>(ui: ReactElement, options?: RenderAppComponentOptions<TModules, TEnv>): Promise<RenderAppComponentResult<TModules>>;
+export default renderAppComponent;

package/dist/types/render-app-hook.d.ts

@@ -0,0 +1,99 @@
+import type { RenderHookOptions, RenderHookResult } from 'vitest-browser-react';
+import type { AppMockConfigureFn } from '@equinor/fusion-framework-app/mock';
+import type { AppEnv, AppModulesInstance } from '@equinor/fusion-framework-app';
+import type { Fusion } from '@equinor/fusion-framework';
+import type { AnyModule } from '@equinor/fusion-framework-module';
+/**
+ * Options for {@link renderAppHook}.
+ *
+ * @template TModules - Module descriptors beyond the default set.
+ * @template TEnv - The application environment descriptor.
+ * @template Props - The props type accepted by the rendered hook.
+ */
+export interface RenderAppHookOptions<TModules extends Array<AnyModule> | unknown = unknown, TEnv extends AppEnv = AppEnv, Props = undefined> extends Omit<RenderHookOptions<Props>, 'wrapper'> {
+    /** Configuration callback forwarded to {@link mockAppModules}. */
+    configure?: AppMockConfigureFn<TModules, TEnv>;
+    /** The application environment; defaults to a generic standalone test app. */
+    env?: TEnv;
+    /**
+     * The parent Fusion instance; defaults to a fresh {@link mockFramework} instance with
+     * this app's own manifest served. Pass one built beforehand to reuse a single instance
+     * across multiple `renderAppHook` calls, or to pre-configure parent-level modules (e.g.
+     * `http`, `context`, `serviceDiscovery`) the app reads through `useFramework`.
+     */
+    fusion?: Fusion;
+}
+/**
+ * The result of {@link renderAppHook}: the `vitest-browser-react` `renderHook` result,
+ * plus the resolved application module scope and its parent Fusion instance.
+ *
+ * @template Result - The value returned by the rendered hook.
+ * @template Props - The props accepted by the rendered hook.
+ * @template TModules - Module descriptors beyond the default set.
+ */
+export interface RenderAppHookResult<Result, Props, TModules extends Array<AnyModule> | unknown = unknown> extends RenderHookResult<Result, Props> {
+    /**
+     * The Fusion instances backing the rendered hook, nested under this single key so
+     * `vitest-browser-react`'s own `RenderHookResult` fields stay free to evolve without
+     * ever colliding with it.
+     */
+    fusion: {
+        /** The parent Fusion instance the hook's `FrameworkProvider` was given. */
+        framework: Fusion;
+        /**
+         * The resolved application module instance backing the rendered hook — the same
+         * instance a real app would read via `useAppModule`/`useAppModules`. Drive a module
+         * not returned by the hook itself (e.g. `fusion.app.context.setCurrentContextByIdAsync(id)`)
+         * to exercise a state change after the initial render.
+         */
+        app: AppModulesInstance<TModules>;
+    };
+}
+/**
+ * Renders a hook inside a real, mock-backed application module scope.
+ *
+ * @remarks
+ * Wraps `vitest-browser-react`'s `renderHook` with the same provider nesting
+ * `createComponent` uses in production — a `FrameworkProvider` (the parent Fusion
+ * instance, from `mockFramework`) around a `ModuleProvider` (this app's own modules,
+ * from `mockAppModules`, `@equinor/fusion-framework-app/mock`) — the real
+ * `event`/`http`/`msal` module pipeline. Only requests a seeded middleware answers are
+ * faked; a request with no matching middleware still reaches the real network. Use this
+ * for any hook that reads from the application module scope or the parent framework
+ * (e.g. `useAppModule`, `useAccessToken`, `useFramework`), instead of hand-wiring
+ * `mockFramework`, `mockAppModules`, `FrameworkProvider` and `ModuleProvider` in every test.
+ *
+ * @template Result - The value returned by the rendered hook.
+ * @template Props - The props accepted by the rendered hook.
+ * @template TModules - Module descriptors beyond the default set.
+ * @template TEnv - The application environment descriptor.
+ * @param render - The hook to render, receiving `initialProps`.
+ * @param options - A `configure` callback and `env` for `mockAppModules`, plus any other
+ *   `renderHook` option.
+ * @returns The `renderHook` result plus `fusion.framework` and `fusion.app`, once the mocked application module scope resolves.
+ *
+ * @example
+ * ```tsx
+ * const { result } = await renderAppHook(() => useAccessToken({ scopes: ['User.Read'] }));
+ * await vi.waitFor(() => expect(result.current.pending).toBe(false));
+ * ```
+ *
+ * @example Sign in a named user
+ * ```tsx
+ * const { result } = await renderAppHook(() => useCurrentAccount(), {
+ *   configure: (configurator) => configurator.msal.setAccount({ name: 'Ada Lovelace' }),
+ * });
+ * ```
+ *
+ * @example Reuse a pre-built parent Fusion instance
+ * ```tsx
+ * const fusion = await mockFramework<[AppModule]>((configurator) =>
+ *   enableAppManifestMock(configurator, env),
+ * );
+ *
+ * const { result: a } = await renderAppHook(() => useAccessToken({ scopes: ['User.Read'] }), { fusion });
+ * const { result: b } = await renderAppHook(() => useCurrentAccount(), { fusion });
+ * ```
+ */
+export declare function renderAppHook<Result, Props = undefined, TModules extends Array<AnyModule> | unknown = unknown, TEnv extends AppEnv = AppEnv>(render: (initialProps?: Props) => Result, options?: RenderAppHookOptions<TModules, TEnv, Props>): Promise<RenderAppHookResult<Result, Props, TModules>>;
+export default renderAppHook;

package/dist/types/render.d.ts

@@ -0,0 +1,37 @@
+import type { ReactElement } from 'react';
+import type { AnyModule } from '@equinor/fusion-framework-module';
+import type { AppEnv } from '@equinor/fusion-framework-app';
+import { type RenderAppComponentOptions, type RenderAppComponentResult } from './render-app-component';
+/**
+ * Renders a component inside the application's own module scope for use in plain `describe`/`it`
+ * tests, using the manifest, config, and module-configurator resolved for this application — no
+ * per-test wiring, and no custom `test` fixture required.
+ *
+ * @remarks
+ * Requires `appTestVitePlugin` (`@equinor/fusion-framework-vitest-plugin-react-app`) registered in
+ * your `vitest.config.ts` `plugins`, which serves the virtual modules backing the resolved
+ * `env`/`configure`. Running the same test file without the plugin registered fails to resolve
+ * those imports.
+ *
+ * Pass `env` or `configure` in `options` to override the resolved values for a single render.
+ *
+ * @template TModules - Module descriptors beyond the default set.
+ * @param ui - The component to render.
+ * @param options - Overrides for `env`/`configure`, plus any other `renderAppComponent` option.
+ * @returns The `render` result plus `fusion.framework` and `fusion.app`, once the mocked application module scope resolves.
+ * @example
+ * ```tsx
+ * import { describe, expect, it } from 'vitest';
+ * import { render } from '@equinor/fusion-framework-vitest-plugin-react-app/test';
+ * import { App } from '../App';
+ *
+ * describe('App', () => {
+ *   it('renders the app', async () => {
+ *     const { getByRole } = await render(<App />);
+ *     await expect.element(getByRole('heading')).toBeVisible();
+ *   });
+ * });
+ * ```
+ */
+export declare function render<TModules extends Array<AnyModule> | unknown = unknown>(ui: ReactElement, options?: RenderAppComponentOptions<TModules, AppEnv>): Promise<RenderAppComponentResult<TModules>>;
+export default render;

package/dist/types/resolve-app-test-env.d.ts

@@ -0,0 +1,56 @@
+import type { AppManifest } from '@equinor/fusion-framework-module-app';
+import { type AppManifestFn, type AppConfigFn, type ApiAppConfig } from '@equinor/fusion-framework-cli/app';
+/**
+ * The application manifest and config resolved for a test run.
+ */
+export type AppTestEnv = {
+    manifest: AppManifest;
+    config: ApiAppConfig;
+};
+/**
+ * Options for {@link resolveAppTestEnv}.
+ */
+export type ResolveAppTestEnvOptions = {
+    /** Directory to resolve the package, manifest, and config from. Defaults to `process.cwd()`. */
+    entrypoint?: string;
+    /**
+     * An explicit manifest file to load instead of the default `app.manifest(.*)?` lookup, or a
+     * manifest function (same shape as `defineAppManifest`'s argument) applied directly.
+     */
+    manifest?: string | AppManifestFn;
+    /**
+     * An explicit config file to load instead of the default `app.config(.*)?` lookup, or a
+     * config function (same shape as `defineAppConfig`'s argument) applied directly.
+     */
+    config?: string | AppConfigFn;
+};
+/**
+ * Resolves an application's manifest and config using the same pipeline `ffc app build`/
+ * `ffc app dev` use: a base manifest generated from `package.json`, merged with a local
+ * `app.manifest.ts` if one exists; and `app.config.ts` for endpoints/environment, falling
+ * back to an empty config if none exists.
+ *
+ * @remarks
+ * Intended to seed `@equinor/fusion-framework-vitest-plugin-react-app/test`'s `testApp` `env` fixture, so
+ * a test suite exercises the application's real manifest/config instead of a hand-maintained
+ * duplicate. Anything a specific test still needs faked (a missing endpoint, a different
+ * `appKey`) can be layered on top with `testApp.extend('env', ...)` or a per-test
+ * `test.override('env', ...)`.
+ *
+ * @param options - Resolution options; `entrypoint` defaults to the current working directory.
+ * @returns The resolved application manifest and config.
+ * @throws If no `package.json` can be found from `entrypoint` upward, or an explicitly requested
+ * `manifest`/`config` file does not exist.
+ * @example
+ * ```ts
+ * import { resolveAppTestEnv } from '@equinor/fusion-framework-vitest-plugin-react-app';
+ * import { testApp } from '@equinor/fusion-framework-vitest-plugin-react-app/test';
+ * import { configure } from '../config';
+ *
+ * const test = testApp
+ *   .extend('env', { injected: true }, () => resolveAppTestEnv())
+ *   .extend('configure', { injected: true }, () => configure);
+ * ```
+ */
+export declare const resolveAppTestEnv: (options?: ResolveAppTestEnvOptions) => Promise<AppTestEnv>;
+export default resolveAppTestEnv;

package/dist/types/scope/create-app-scope-wrapper.d.ts

@@ -0,0 +1,14 @@
+import type { ReactElement, ReactNode } from 'react';
+import type { AnyModule } from '@equinor/fusion-framework-module';
+import type { AppScope } from './resolve-app-scope';
+/**
+ * The provider nesting `createComponent` uses in production, for wrapping a component or
+ * hook under test in its resolved {@link AppScope}.
+ *
+ * @template TModules - Module descriptors beyond the default set.
+ * @param scope - The resolved parent Fusion instance and application module scope.
+ * @returns A wrapper component nesting a `FrameworkProvider` around a `ModuleProvider`.
+ */
+export declare function createAppScopeWrapper<TModules extends Array<AnyModule> | unknown = unknown>({ framework, app, }: AppScope<TModules>): (props: {
+    children: ReactNode;
+}) => ReactElement;

package/dist/types/scope/default-app-env.d.ts

@@ -0,0 +1,5 @@
+import type { AppEnv } from '@equinor/fusion-framework-app';
+/**
+ * The application environment used when a test does not care about its own app identity.
+ */
+export declare const defaultAppEnv: AppEnv;

package/dist/types/scope/index.d.ts

@@ -0,0 +1,4 @@
+export { defaultAppEnv } from './default-app-env';
+export { resolveFusion } from './resolve-fusion';
+export { resolveAppScope, type AppScope } from './resolve-app-scope';
+export { createAppScopeWrapper } from './create-app-scope-wrapper';

package/dist/types/scope/resolve-app-scope.d.ts

@@ -0,0 +1,31 @@
+import type { AppMockConfigureFn } from '@equinor/fusion-framework-app/mock';
+import type { AppEnv, AppModulesInstance } from '@equinor/fusion-framework-app';
+import type { Fusion } from '@equinor/fusion-framework';
+import type { AnyModule } from '@equinor/fusion-framework-module';
+/**
+ * The parent Fusion instance and resolved application module scope shared by every
+ * `packages/react/app` testing helper.
+ *
+ * @template TModules - Module descriptors beyond the default set.
+ */
+export interface AppScope<TModules extends Array<AnyModule> | unknown = unknown> {
+    /** The parent Fusion instance the application scope was resolved against. */
+    framework: Fusion;
+    /** The resolved application module instance. */
+    app: AppModulesInstance<TModules>;
+}
+/**
+ * Resolves the parent Fusion instance and application module scope shared by every
+ * `packages/react/app` testing helper.
+ *
+ * @template TModules - Module descriptors beyond the default set.
+ * @template TEnv - The application environment descriptor.
+ * @param options - A `configure` callback and `env` for {@link mockAppModules}, plus an
+ *   already-built `fusion` instance to reuse instead of a fresh one.
+ * @returns The resolved {@link AppScope}.
+ */
+export declare function resolveAppScope<TModules extends Array<AnyModule> | unknown = unknown, TEnv extends AppEnv = AppEnv>(options?: {
+    configure?: AppMockConfigureFn<TModules, TEnv>;
+    env?: TEnv;
+    fusion?: Fusion;
+}): Promise<AppScope<TModules>>;

package/dist/types/scope/resolve-fusion.d.ts

@@ -0,0 +1,13 @@
+import type { AppEnv } from '@equinor/fusion-framework-app';
+import type { Fusion } from '@equinor/fusion-framework';
+/**
+ * Resolves the parent Fusion instance backing an application module scope, building a
+ * fresh {@link mockFramework} instance with this app's own manifest served when none is
+ * given.
+ *
+ * @template TEnv - The application environment descriptor.
+ * @param env - The application environment; defaults to {@link defaultAppEnv}.
+ * @param fusion - An already-built parent Fusion instance to reuse instead.
+ * @returns The given `fusion`, or a fresh mocked parent Fusion instance.
+ */
+export declare function resolveFusion<TEnv extends AppEnv = AppEnv>(env?: TEnv, fusion?: Fusion): Promise<Fusion>;

package/dist/types/test-app.d.ts

@@ -0,0 +1,68 @@
+import type { ReactElement } from 'react';
+import type { RenderOptions, RenderHookOptions } from 'vitest-browser-react';
+import type { AppMockConfigureFn } from '@equinor/fusion-framework-app/mock';
+import type { AppEnv } from '@equinor/fusion-framework-app';
+/**
+ * `vitest`'s `test`, extended with an application module scope fixture.
+ *
+ * @remarks
+ * An alternative to {@link renderAppComponent}/{@link renderAppHook} for a test file whose
+ * cases share seeded fixture defaults: `env`/`configure` become suite-level concerns,
+ * overridden once per file (or per `describe` block) with `testApp.extend(...)`, rather than
+ * an options object repeated on every call. `fusion`/`app` are still instantiated fresh per
+ * test — only the seeded defaults are shared, not state between tests. They also resolve
+ * lazily: a test that only destructures `app` never pays for rendering anything, and one
+ * that only destructures `render`/`renderHook` gets the same fixture wiring automatically.
+ *
+ * Both entry points stay supported: reach for `renderAppComponent`/`renderAppHook` for a
+ * one-off test whose configuration is not shared by the rest of the file; reach for
+ * `testApp` when several cases in a file share one set of seeded fixture defaults.
+ *
+ * @example
+ * ```tsx
+ * testApp('resolves current context', async ({ app, render }) => {
+ *   const screen = await render(<App />);
+ *   expect(app.context).toBeDefined();
+ * });
+ * ```
+ *
+ * @example Seed a module for every test in a suite
+ * ```tsx
+ * describe('with a seeded context module', () => {
+ *   const test = testApp.extend('configure', { injected: true }, () =>
+ *     (configurator) => enableContextMock(configurator, (mock) => mock.setCurrentContext(projectA)),
+ *   );
+ *
+ *   test('starts on the seeded context', async ({ render }) => {
+ *     const screen = await render(<App />);
+ *     await expect.element(screen.getByText(projectA.title)).toBeVisible();
+ *   });
+ * });
+ * ```
+ */
+export declare const testApp: import("vitest").TestAPI<Omit<Omit<Omit<Omit<Omit<Omit<object, "$__test"> & Record<"env", AppEnv> & {
+    readonly $__worker?: object | undefined;
+    readonly $__file?: object | undefined;
+    readonly $__test?: (object & Record<"env", AppEnv>) | undefined;
+}, "$__test"> & Record<"configure", AppMockConfigureFn | undefined> & {
+    readonly $__worker?: object | undefined;
+    readonly $__file?: object | undefined;
+    readonly $__test?: (object & Record<"env", AppEnv> & Record<"configure", AppMockConfigureFn | undefined>) | undefined;
+}, "$__test"> & Record<"fusion", import("node_modules/@equinor/fusion-framework/src/types").Fusion<unknown>> & {
+    readonly $__worker?: object | undefined;
+    readonly $__file?: object | undefined;
+    readonly $__test?: (object & Record<"env", AppEnv> & Record<"configure", AppMockConfigureFn | undefined> & Record<"fusion", import("node_modules/@equinor/fusion-framework/src/types").Fusion<unknown>>) | undefined;
+}, "$__test"> & Record<"app", import("@equinor/fusion-framework-app").AppModulesInstance<unknown>> & {
+    readonly $__worker?: object | undefined;
+    readonly $__file?: object | undefined;
+    readonly $__test?: (object & Record<"env", AppEnv> & Record<"configure", AppMockConfigureFn | undefined> & Record<"fusion", import("node_modules/@equinor/fusion-framework/src/types").Fusion<unknown>> & Record<"app", import("@equinor/fusion-framework-app").AppModulesInstance<unknown>>) | undefined;
+}, "$__test"> & Record<"render", (ui: ReactElement, options?: Omit<RenderOptions, 'wrapper'>) => Promise<import("node_modules/vitest-browser-react/dist").RenderResult>> & {
+    readonly $__worker?: object | undefined;
+    readonly $__file?: object | undefined;
+    readonly $__test?: (object & Record<"env", AppEnv> & Record<"configure", AppMockConfigureFn | undefined> & Record<"fusion", import("node_modules/@equinor/fusion-framework/src/types").Fusion<unknown>> & Record<"app", import("@equinor/fusion-framework-app").AppModulesInstance<unknown>> & Record<"render", (ui: ReactElement, options?: Omit<RenderOptions, 'wrapper'>) => Promise<import("node_modules/vitest-browser-react/dist").RenderResult>>) | undefined;
+}, "$__test"> & Record<"renderHook", <Result, Props = undefined>(cb: (initialProps?: Props) => Result, options?: Omit<RenderHookOptions<Props>, 'wrapper'>) => Promise<import("node_modules/vitest-browser-react/dist").RenderHookResult<Result, Props>>> & {
+    readonly $__worker?: object | undefined;
+    readonly $__file?: object | undefined;
+    readonly $__test?: (object & Record<"env", AppEnv> & Record<"configure", AppMockConfigureFn | undefined> & Record<"fusion", import("node_modules/@equinor/fusion-framework/src/types").Fusion<unknown>> & Record<"app", import("@equinor/fusion-framework-app").AppModulesInstance<unknown>> & Record<"render", (ui: ReactElement, options?: Omit<RenderOptions, 'wrapper'>) => Promise<import("node_modules/vitest-browser-react/dist").RenderResult>> & Record<"renderHook", <Result, Props = undefined>(cb: (initialProps?: Props) => Result, options?: Omit<RenderHookOptions<Props>, 'wrapper'>) => Promise<import("node_modules/vitest-browser-react/dist").RenderHookResult<Result, Props>>>) | undefined;
+}>;
+export default testApp;

package/dist/types/test.d.ts

@@ -0,0 +1,66 @@
+/**
+ * `vitest`'s `test`, pre-seeded with the application's own manifest, config, and
+ * module-configurator, resolved the same way `ffc app build`/`ffc app dev` resolve them.
+ *
+ * @remarks
+ * Requires `appTestVitePlugin` (`@equinor/fusion-framework-vitest-plugin-react-app`) registered in
+ * your `vitest.config.ts` `plugins`, which serves the virtual modules backing this fixture.
+ * Running the same test file without the plugin registered fails to resolve those imports.
+ *
+ * Per-test mocking still works exactly like the base `testApp`: `.extend('configure', ...)` or
+ * a per-case `test.override('env', ...)` layers on top of the resolved values.
+ *
+ * @example
+ * ```tsx
+ * import { test } from '@equinor/fusion-framework-vitest-plugin-react-app/test';
+ * import { App } from '../App';
+ *
+ * test('renders the app', async ({ render }) => {
+ *   const screen = await render(<App />);
+ *   await expect.element(screen.getByRole('heading')).toBeVisible();
+ * });
+ * ```
+ */
+export declare const test: import("vitest").TestAPI<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<object, "$__test"> & Record<"env", import("node_modules/@equinor/fusion-framework-app/src/types").AppEnv> & {
+    readonly $__worker?: object | undefined;
+    readonly $__file?: object | undefined;
+    readonly $__test?: (object & Record<"env", import("node_modules/@equinor/fusion-framework-app/src/types").AppEnv>) | undefined;
+}, "$__test"> & Record<"configure", import("node_modules/@equinor/fusion-framework-app/src/mock/mock-app-modules").AppMockConfigureFn | undefined> & {
+    readonly $__worker?: object | undefined;
+    readonly $__file?: object | undefined;
+    readonly $__test?: (object & Record<"env", import("node_modules/@equinor/fusion-framework-app/src/types").AppEnv> & Record<"configure", import("node_modules/@equinor/fusion-framework-app/src/mock/mock-app-modules").AppMockConfigureFn | undefined>) | undefined;
+}, "$__test"> & Record<"fusion", import("node_modules/@equinor/fusion-framework/src/types").Fusion<unknown>> & {
+    readonly $__worker?: object | undefined;
+    readonly $__file?: object | undefined;
+    readonly $__test?: (object & Record<"env", import("node_modules/@equinor/fusion-framework-app/src/types").AppEnv> & Record<"configure", import("node_modules/@equinor/fusion-framework-app/src/mock/mock-app-modules").AppMockConfigureFn | undefined> & Record<"fusion", import("node_modules/@equinor/fusion-framework/src/types").Fusion<unknown>>) | undefined;
+}, "$__test"> & Record<"app", import("node_modules/@equinor/fusion-framework-module-app/src/types").AppModulesInstance<unknown>> & {
+    readonly $__worker?: object | undefined;
+    readonly $__file?: object | undefined;
+    readonly $__test?: (object & Record<"env", import("node_modules/@equinor/fusion-framework-app/src/types").AppEnv> & Record<"configure", import("node_modules/@equinor/fusion-framework-app/src/mock/mock-app-modules").AppMockConfigureFn | undefined> & Record<"fusion", import("node_modules/@equinor/fusion-framework/src/types").Fusion<unknown>> & Record<"app", import("node_modules/@equinor/fusion-framework-module-app/src/types").AppModulesInstance<unknown>>) | undefined;
+}, "$__test"> & Record<"render", (ui: import("node_modules/@types/react").ReactElement, options?: Omit<import("node_modules/vitest-browser-react/dist").RenderOptions, 'wrapper'>) => Promise<import("node_modules/vitest-browser-react/dist").RenderResult>> & {
+    readonly $__worker?: object | undefined;
+    readonly $__file?: object | undefined;
+    readonly $__test?: (object & Record<"env", import("node_modules/@equinor/fusion-framework-app/src/types").AppEnv> & Record<"configure", import("node_modules/@equinor/fusion-framework-app/src/mock/mock-app-modules").AppMockConfigureFn | undefined> & Record<"fusion", import("node_modules/@equinor/fusion-framework/src/types").Fusion<unknown>> & Record<"app", import("node_modules/@equinor/fusion-framework-module-app/src/types").AppModulesInstance<unknown>> & Record<"render", (ui: import("node_modules/@types/react").ReactElement, options?: Omit<import("node_modules/vitest-browser-react/dist").RenderOptions, 'wrapper'>) => Promise<import("node_modules/vitest-browser-react/dist").RenderResult>>) | undefined;
+}, "$__test"> & Record<"renderHook", <Result, Props = undefined>(cb: (initialProps?: Props) => Result, options?: Omit<import("node_modules/vitest-browser-react/dist").RenderHookOptions<Props>, 'wrapper'>) => Promise<import("node_modules/vitest-browser-react/dist").RenderHookResult<Result, Props>>> & {
+    readonly $__worker?: object | undefined;
+    readonly $__file?: object | undefined;
+    readonly $__test?: (object & Record<"env", import("node_modules/@equinor/fusion-framework-app/src/types").AppEnv> & Record<"configure", import("node_modules/@equinor/fusion-framework-app/src/mock/mock-app-modules").AppMockConfigureFn | undefined> & Record<"fusion", import("node_modules/@equinor/fusion-framework/src/types").Fusion<unknown>> & Record<"app", import("node_modules/@equinor/fusion-framework-module-app/src/types").AppModulesInstance<unknown>> & Record<"render", (ui: import("node_modules/@types/react").ReactElement, options?: Omit<import("node_modules/vitest-browser-react/dist").RenderOptions, 'wrapper'>) => Promise<import("node_modules/vitest-browser-react/dist").RenderResult>> & Record<"renderHook", <Result, Props = undefined>(cb: (initialProps?: Props) => Result, options?: Omit<import("node_modules/vitest-browser-react/dist").RenderHookOptions<Props>, 'wrapper'>) => Promise<import("node_modules/vitest-browser-react/dist").RenderHookResult<Result, Props>>>) | undefined;
+}, "$__test"> & Record<"env", {
+    manifest: import("@equinor/fusion-framework-cli/app").AppManifest;
+    config: import("node_modules/@equinor/fusion-framework-module-app/src/AppConfig").AppConfig<import("node_modules/@equinor/fusion-framework-module-app/src/types").ConfigEnvironment> | undefined;
+}> & {
+    readonly $__worker?: object | undefined;
+    readonly $__file?: object | undefined;
+    readonly $__test?: (object & Record<"env", import("node_modules/@equinor/fusion-framework-app/src/types").AppEnv> & Record<"configure", import("node_modules/@equinor/fusion-framework-app/src/mock/mock-app-modules").AppMockConfigureFn | undefined> & Record<"fusion", import("node_modules/@equinor/fusion-framework/src/types").Fusion<unknown>> & Record<"app", import("node_modules/@equinor/fusion-framework-module-app/src/types").AppModulesInstance<unknown>> & Record<"render", (ui: import("node_modules/@types/react").ReactElement, options?: Omit<import("node_modules/vitest-browser-react/dist").RenderOptions, 'wrapper'>) => Promise<import("node_modules/vitest-browser-react/dist").RenderResult>> & Record<"renderHook", <Result, Props = undefined>(cb: (initialProps?: Props) => Result, options?: Omit<import("node_modules/vitest-browser-react/dist").RenderHookOptions<Props>, 'wrapper'>) => Promise<import("node_modules/vitest-browser-react/dist").RenderHookResult<Result, Props>>> & Record<"env", {
+        manifest: import("@equinor/fusion-framework-cli/app").AppManifest;
+        config: import("node_modules/@equinor/fusion-framework-module-app/src/AppConfig").AppConfig<import("node_modules/@equinor/fusion-framework-module-app/src/types").ConfigEnvironment> | undefined;
+    }>) | undefined;
+}, "$__test"> & Record<"configure", import("node_modules/@equinor/fusion-framework-app/src/mock/mock-app-modules").AppMockConfigureFn | undefined> & {
+    readonly $__worker?: object | undefined;
+    readonly $__file?: object | undefined;
+    readonly $__test?: (object & Record<"env", import("node_modules/@equinor/fusion-framework-app/src/types").AppEnv> & Record<"configure", import("node_modules/@equinor/fusion-framework-app/src/mock/mock-app-modules").AppMockConfigureFn | undefined> & Record<"fusion", import("node_modules/@equinor/fusion-framework/src/types").Fusion<unknown>> & Record<"app", import("node_modules/@equinor/fusion-framework-module-app/src/types").AppModulesInstance<unknown>> & Record<"render", (ui: import("node_modules/@types/react").ReactElement, options?: Omit<import("node_modules/vitest-browser-react/dist").RenderOptions, 'wrapper'>) => Promise<import("node_modules/vitest-browser-react/dist").RenderResult>> & Record<"renderHook", <Result, Props = undefined>(cb: (initialProps?: Props) => Result, options?: Omit<import("node_modules/vitest-browser-react/dist").RenderHookOptions<Props>, 'wrapper'>) => Promise<import("node_modules/vitest-browser-react/dist").RenderHookResult<Result, Props>>> & Record<"env", {
+        manifest: import("@equinor/fusion-framework-cli/app").AppManifest;
+        config: import("node_modules/@equinor/fusion-framework-module-app/src/AppConfig").AppConfig<import("node_modules/@equinor/fusion-framework-module-app/src/types").ConfigEnvironment> | undefined;
+    }>) | undefined;
+}>;
+export default test;

package/dist/types/version.d.ts

@@ -0,0 +1 @@
+export declare const version = "0.2.0-next.0";