@equinor/fusion-framework-app 13.1.0 → 13.1.2

package/src/mock/AppMockConfigurator.ts

@@ -1,218 +0,0 @@
-import type { FusionModulesInstance } from '@equinor/fusion-framework';
-
-import type {
-  AnyModule,
-  IModuleConfigurator,
-  ModuleConfigType,
-} from '@equinor/fusion-framework-module';
-
-import http, { type IHttpClientConfigurator } from '@equinor/fusion-framework-module-http';
-import {
-  msalMockModule,
-  type MsalMockConfigurator,
-} from '@equinor/fusion-framework-module-msal/mock';
-
-import { AppConfigurator } from '../AppConfigurator.js';
-import type { AppEnv } from '../types.js';
-
-/**
- * The real `AppConfigurator`, with the `msal` module it registers backed by
- * the same test double `FrameworkMockConfigurator` uses. `http` is the real
- * module — fake a response by registering a short-circuiting middleware
- * through `.http.addMiddleware(...)` instead of swapping the module out.
- *
- * @remarks
- * Nothing else changes: the same module set (`event`, `http`, `msal`), the same
- * configuration pipeline and the same lifecycle are used. `configureHttpClient`,
- * `useFrameworkServiceClient` and any callback written for a real
- * `AppConfigurator` work against this unchanged.
- *
- * `http` and `msal` are pinned early — mirroring `FrameworkMockConfigurator`,
- * one level down — so `.http` and `.msal` are reachable synchronously, before
- * `useFrameworkServiceClient` or a `configureModules` callback ever runs.
- * `event` is deliberately not pinned, for the same reason it isn't in
- * `FrameworkMockConfigurator`: its `configure` factory reads `ref` to wire
- * bubbling to a parent event provider, and pinning would freeze that decision
- * before a `ref` could ever be known.
- *
- * @typeParam TModules - Module descriptors beyond the default set. Supply this
- *   when a test registers application modules, so they are typed on the result.
- * @typeParam TRef - The resolved Fusion modules instance used as a reference during initialization.
- * @typeParam TEnv - The application environment descriptor.
- *
- * @example
- * ```typescript
- * const manifest = { appKey: 'my-app', displayName: 'My App', description: 'My app', type: 'standalone' } as const;
- * const configurator = new AppMockConfigurator({ manifest });
- *
- * configurator.configureHttpClient('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),
- * );
- * ```
- */
-export class AppMockConfigurator<
-  TModules extends Array<AnyModule> | unknown = unknown,
-  TRef extends FusionModulesInstance = FusionModulesInstance,
-  TEnv extends AppEnv = AppEnv,
-> extends AppConfigurator<TModules, TRef, TEnv> {
-  static override readonly className: string = 'AppMockConfigurator';
-
-  // Keyed by module name, so `_getConfig` can look a pinned configurator up
-  // without needing the module descriptor again.
-  #configurators = new Map<string, unknown>();
-
-  // Keyed by module name, so `addConfig` can redirect a registration at the
-  // pinned descriptor instead of the unpinned one it was given.
-  #pinnedModules = new Map<string, AnyModule>();
-
-  /**
-   * Creates an app configurator backed by the built-in mock modules.
-   *
-   * @param env - The application environment containing manifest, config, and optional basename.
-   */
-  constructor(env: TEnv) {
-    super(env);
-
-    // Pinning up front replaces the modules AppConfigurator's own constructor
-    // already registered, whether or not a test ever touches the accessor.
-    this._pin(http);
-    this._pin(msalMockModule);
-
-    // deferred from AppConfigurator's own constructor (see the override below) until
-    // after pinning, so endpoint-derived clients register against the pinned http module
-    super._configureHttpClientsFromAppConfig();
-  }
-
-  /**
-   * No-ops the base constructor's own call to this, since it would otherwise run
-   * before {@link _pin} has anything to redirect `addConfig` at; this class calls
-   * {@link AppConfigurator._configureHttpClientsFromAppConfig} itself once pinned.
-   */
-  protected override _configureHttpClientsFromAppConfig(): void {}
-
-  /**
-   * Registers a module configurator, redirecting registrations for a pinned module
-   * at its pinned descriptor.
-   *
-   * @remarks
-   * `configureHttpClient`, `useFrameworkServiceClient` and similar helpers always
-   * pass the real, unpinned module descriptor — the base `addConfig` replaces a
-   * module's descriptor whenever it doesn't recognize the object it's given, even
-   * under the same name, which would otherwise silently un-pin it.
-   *
-   * @param config - The module configurator descriptor to register.
-   * @template T - The module type being configured.
-   * @template TConfig - The resolved configuration type for the module.
-   */
-  public override addConfig<T extends AnyModule, TConfig = ModuleConfigType<T>>(
-    config: IModuleConfigurator<T, TRef, TConfig>,
-  ): void {
-    const pinnedModule = this.#pinnedModules.get(config.module.name) as T | undefined;
-    super.addConfig(pinnedModule ? { ...config, module: pinnedModule } : config);
-  }
-
-  /**
-   * Pins a module to a single configurator instance for the lifetime of this
-   * configurator, so it can be reached by name through {@link _getConfig}.
-   *
-   * @remarks
-   * The module system otherwise builds a fresh configurator from its own
-   * `configure` factory during the configure phase — too late for a test to
-   * reach, and a new instance on every call besides. This replaces that factory
-   * with one that always returns the same instance, and registers the result
-   * under the module's own name.
-   *
-   * An application module supplied through {@link TModules} uses this the same
-   * way `.http` and `.msal` do, to expose its own named accessor:
-   *
-   * ```typescript
-   * class MyAppMockConfigurator extends AppMockConfigurator<[WidgetsModule]> {
-   *   constructor(env: AppEnv) {
-   *     super(env);
-   *     this._pin(widgetsMockModule);
-   *   }
-   *
-   *   public get widgets(): WidgetsMockConfigurator {
-   *     return this._getConfig('widgets');
-   *   }
-   * }
-   * ```
-   *
-   * @param module - The module descriptor to pin a configurator for.
-   * @template TModule - The specific module descriptor type being pinned.
-   * @throws {Error} If the module declares no `configure` factory to pin, or
-   *   the factory returns a promise instead of a configurator — pinning is
-   *   synchronous, so a test can reach the accessor immediately.
-   */
-  protected _pin<TModule extends AnyModule>(module: TModule): void {
-    // A module without a configure factory has nothing this method could pin
-    if (!module.configure) {
-      throw new Error(`Cannot pin "${module.name}": it declares no configure factory.`);
-    }
-    const instance = module.configure();
-    // Async factories would make the pinned instance unavailable until the module system
-    // resolves it later, defeating the point of pinning it for immediate synchronous access
-    if (instance instanceof Promise) {
-      throw new Error(
-        `Cannot pin "${module.name}": its configure factory returns a promise, so it cannot be resolved synchronously.`,
-      );
-    }
-    this.#configurators.set(module.name, instance);
-    const pinnedModule = { ...module, configure: () => instance } as TModule;
-    this.#pinnedModules.set(module.name, pinnedModule);
-    this.addConfig({ module: pinnedModule });
-  }
-
-  /**
-   * Returns the configurator pinned for a module by name.
-   *
-   * @param name - The module's name, as passed to {@link _pin}.
-   * @template TConfig - The specific configurator type expected for this module.
-   * @returns The configurator pinned under `name`.
-   * @throws {Error} If no configurator has been pinned for that name.
-   */
-  protected _getConfig<TConfig>(name: string): TConfig {
-    const config = this.#configurators.get(name);
-    // A missing entry means _pin was never called for this module name
-    if (config === undefined) {
-      throw new Error(
-        `No configurator is pinned for module "${name}" — call this._pin(module) before this._getConfig("${name}").`,
-      );
-    }
-    return config as TConfig;
-  }
-
-  /**
-   * Configures the app's named HTTP clients.
-   *
-   * @remarks
-   * The same {@link IHttpClientConfigurator} the `http` module is configured
-   * from — the real one, not a test double. Every client it builds —
-   * including ones registered through
-   * {@link AppConfigurator.configureHttpClient} or
-   * {@link AppConfigurator.useFrameworkServiceClient} — is reachable here to
-   * register a short-circuiting {@link HttpMiddleware} through
-   * `addMiddleware`, so it answers from that instead of the network.
-   *
-   * @returns The real HTTP configurator.
-   */
-  public get http(): IHttpClientConfigurator {
-    return this._getConfig<IHttpClientConfigurator>(http.name);
-  }
-
-  /**
-   * Configures the user the app's `msal` module signs in.
-   *
-   * @remarks
-   * The same {@link MsalMockConfigurator} the `msal` module is configured from,
-   * so a change made here is what the module sees.
-   *
-   * @returns The MSAL mock configurator.
-   */
-  public get msal(): MsalMockConfigurator {
-    return this._getConfig<MsalMockConfigurator>(msalMockModule.name);
-  }
-}
-
-export default AppMockConfigurator;

package/src/mock/enable-app-manifest-mock.ts

@@ -1,62 +0,0 @@
-import type { FrameworkMockConfigurator } from '@equinor/fusion-framework/mock';
-import { AppConfig, enableAppModule, type AppModule } from '@equinor/fusion-framework-module-app';
-import { MockAppClient } from '@equinor/fusion-framework-module-app/mock';
-import type { ConfigEnvironment } from '@equinor/fusion-framework-module-app';
-
-import type { AppEnv } from '../types.js';
-
-/**
- * Enables the `app` module on a parent framework configurator, wrapping its
- * client in a {@link MockAppClient} so this app's manifest and config resolve
- * locally.
- *
- * @remarks
- * The underlying http client is still resolved the same way `AppConfigurator`
- * resolves it (a pre-configured client, falling back to service discovery), so
- * a caller pointing `serviceDiscovery` at something else — e.g. a real local
- * mock server — is honored for every request `MockAppClient` doesn't answer
- * itself. {@link mockAppModules} uses this to wire its zero-config default
- * parent; call it directly when building a custom parent (via
- * {@link mockFramework}) that also needs this app's own manifest servable.
- *
- * @param configurator - The parent framework's mock configurator, with `app` in its module set.
- * @param env - The application environment whose manifest (and optional config) should be served.
- * @param assetUri - Overrides the base URI a loaded app's script is imported from.
- * @template TEnv - The application environment descriptor.
- *
- * @example Custom service discovery, same manifest resolution
- * ```typescript
- * const fusion = await mockFramework<[AppModule]>((configurator) => {
- *   configurator.serviceDiscovery.setBaseUri('http://localhost:9999');
- *   enableAppManifestMock(configurator, env);
- * });
- * const modules = await mockAppModules(undefined, env, fusion);
- * ```
- */
-export function enableAppManifestMock<TEnv extends AppEnv>(
-  configurator: FrameworkMockConfigurator<[AppModule]>,
-  env: TEnv,
-  assetUri?: string,
-): void {
-  enableAppModule(configurator, (builder) => {
-    // only override the default asset base when the caller supplies one; an
-    // explicit empty string is meaningful (selects a root-relative script path)
-    if (assetUri !== undefined) {
-      builder.setAssetUri(assetUri);
-    }
-    builder.setClient(async ({ requireInstance }) => {
-      const http = await requireInstance('http');
-      const client = http.hasClient('apps')
-        ? http.createClient('apps')
-        : await (await requireInstance('serviceDiscovery')).createClient('apps');
-      // fall back to a trivial config so `App.initialize()` can resolve without a caller-supplied one
-      return new MockAppClient(
-        client,
-        env.manifest,
-        env.config ?? new AppConfig<ConfigEnvironment>({ environment: {} }),
-      );
-    });
-  });
-}
-
-export default enableAppManifestMock;

package/src/mock/index.ts

@@ -1,21 +0,0 @@
-/**
- * Zero-configuration application module pipelines for tests.
- *
- * @remarks
- * Lets a test initialize an application's real module pipeline — real
- * `event`/`http`/`msal` modules, real configuration pipeline, real lifecycle —
- * while the boundaries that reach outside the process are substituted with the
- * same deterministic fakes {@link https://www.npmjs.com/package/@equinor/fusion-framework | @equinor/fusion-framework}'s
- * own `/mock` entry point uses. No credentials, no network access and no
- * running parent portal are required.
- *
- * This entry point is test-runner agnostic: it contains no dependency on
- * Vitest or any other test framework, so the same helpers work under any
- * runner.
- *
- * @packageDocumentation
- */
-
-export { mockAppModules, type AppMockConfigureFn } from './mock-app-modules.js';
-export { AppMockConfigurator } from './AppMockConfigurator.js';
-export { enableAppManifestMock } from './enable-app-manifest-mock.js';

package/src/mock/mock-app-modules.ts

@@ -1,109 +0,0 @@
-import type { Fusion } from '@equinor/fusion-framework';
-import { mockFramework } from '@equinor/fusion-framework/mock';
-
-import type { AnyModule } from '@equinor/fusion-framework-module';
-import type { AppModule } from '@equinor/fusion-framework-module-app';
-
-import { initializeAppModules } from '../initialize-app-modules.js';
-import type { AppEnv, AppModulesInstance } from '../types.js';
-
-import { AppMockConfigurator } from './AppMockConfigurator.js';
-import { enableAppManifestMock } from './enable-app-manifest-mock.js';
-
-/**
- * Configuration callback for {@link mockAppModules}.
- */
-export type AppMockConfigureFn<
-  TModules extends Array<AnyModule> | unknown = unknown,
-  TEnv extends AppEnv = AppEnv,
-> = (
-  configurator: AppMockConfigurator<TModules, Fusion['modules'], TEnv>,
-  args: { fusion: Fusion; env: TEnv },
-) => void | Promise<void>;
-
-/**
- * Runs an application's module pipeline with no real credentials required,
- * from either the parent framework or the app's own `http`/`msal`
- * registrations.
- *
- * @remarks
- * The real `AppConfigurator` pipeline is run — the real module set, the real
- * configuration pipeline and the real lifecycle. Only the boundaries that
- * would need credentials are substituted by default; the `http` module is
- * the real `HttpClientConfigurator`, so a registered client only avoids the
- * network for requests a middleware short-circuits with a response — a
- * client with no matching middleware, or a middleware that calls `next`,
- * still reaches the real network. A test exercises the wiring an
- * application actually depends on rather than a reimplementation of it.
- *
- * The configurator passed to `cb` is an {@link AppMockConfigurator}, which *is*
- * an `AppConfigurator`. `useFrameworkServiceClient`, `configureHttpClient` and
- * any callback written for a real app work against it unchanged.
- *
- * `fusion` defaults to a fresh {@link mockFramework} instance with a real `app`
- * module already enabled and this app's own manifest served at whatever URI
- * service discovery resolves `'apps'` to, so a test needs no parent Fusion
- * instance of its own — but an already-mocked (or real) instance can be passed
- * to compose with other framework-level setup. To point the parent's service
- * discovery at something else (e.g. a real local mock server) while keeping
- * the manifest served consistently, build that `fusion` with
- * {@link mockFramework} and call {@link enableAppManifestMock} yourself,
- * after customizing `serviceDiscovery`.
- *
- * @template TModules - Module descriptors beyond the default set. Supply this
- *   when a test registers application modules, so they are typed on the result.
- * @template TEnv - The application environment descriptor.
- * @param cb - Configuration callback invoked before module initialization, or `undefined` to skip it.
- * @param env - The application environment (manifest, config, basename).
- * @param fusion - The parent Fusion instance; defaults to a fresh {@link mockFramework} instance.
- * @returns The initialized application module instance.
- *
- * @example Zero configuration
- * ```typescript
- * const manifest = { appKey: 'my-app', displayName: 'My App', description: 'My app', type: 'standalone' } as const;
- * const modules = await mockAppModules(undefined, { manifest });
- * ```
- *
- * @example Register a client answered by the app's own mocked HTTP module
- * ```typescript
- * const manifest = { appKey: 'my-app', displayName: 'My App', description: 'My app', type: 'standalone' } as const;
- * const modules = await mockAppModules(
- *   (configurator) => {
- *     configurator.useFrameworkServiceClient('portal-api');
- *     configurator.http.addMiddleware(async (uri, init, next) =>
- *       uri === 'https://portal-api.fusion.test/items' ? Response.json([{ id: 1 }]) : next(uri, init),
- *     );
- *   },
- *   { manifest },
- * );
- *
- * const items = await modules.http.createClient('portal-api').json('/items');
- * ```
- */
-export async function mockAppModules<
-  TModules extends Array<AnyModule> | unknown = unknown,
-  TEnv extends AppEnv = AppEnv,
->(
-  cb: AppMockConfigureFn<TModules, TEnv> | undefined,
-  env: TEnv,
-  fusion?: Fusion,
-): Promise<AppModulesInstance<TModules>> {
-  // `await` is illegal in a parameter default, so an omitted fusion is resolved here instead.
-  // The default parent also carries a real `app` module, serving this app's own manifest at
-  // whatever URI service discovery is currently configured to resolve `'apps'` to, so a test
-  // exercises the same portal wiring a real parent framework would provide.
-  const resolvedFusion: Fusion =
-    fusion ??
-    (await mockFramework<[AppModule]>((configurator) => enableAppManifestMock(configurator, env)));
-  const configurator = new AppMockConfigurator<TModules, Fusion['modules'], TEnv>(env);
-  // Cast is safe: `initializeAppModules` returns the exact module instance produced by
-  // `configurator`, which was constructed with this same `TModules`. TypeScript widens
-  // `TModules` to its constraint (`AnyModule[]`) when inferring through the generic
-  // `TConfigurator` parameter, so the assignment needs an explicit assertion here.
-  return initializeAppModules(configurator, cb, {
-    fusion: resolvedFusion,
-    env,
-  }) as Promise<AppModulesInstance<TModules>>;
-}
-
-export default mockAppModules;

package/src/types.ts

@@ -1,145 +0,0 @@
-import type { Fusion } from '@equinor/fusion-framework';
-
-import type { AnyModule } from '@equinor/fusion-framework-module';
-
-import type {
-  AppConfig,
-  AppManifest,
-  AppModulesInstance,
-  ComponentRenderArgs,
-} from '@equinor/fusion-framework-module-app';
-
-import type { IAppConfigurator } from './AppConfigurator';
-import type { ConfigEnvironment } from '@equinor/fusion-framework-module-app';
-
-/**
- * Re-exported application module types from `@equinor/fusion-framework-module-app`.
- *
- * - `AppModules` — union of default application modules
- * - `AppManifest` — application manifest metadata (app key, version, etc.)
- * - `AppConfig` — environment-specific application configuration
- * - `AppModulesInstance` — resolved module instances after initialization
- */
-export type {
-  AppModules,
-  AppManifest,
-  AppConfig,
-  AppModulesInstance,
-} from '@equinor/fusion-framework-module-app';
-
-/**
- * Environment descriptor passed to the application during module initialization.
- *
- * Contains the application manifest, optional config (with endpoint definitions),
- * an optional base path for routing, and optional component props.
- *
- * @template TConfig - Shape of the environment-specific configuration object.
- * @template TProps - Additional properties forwarded to the application component (currently unused).
- */
-export type AppEnv<TConfig extends ConfigEnvironment = ConfigEnvironment, TProps = unknown> = {
-  /** Base routing path of the application (e.g. `/apps/my-app`). */
-  basename?: string;
-  /** Application manifest describing the app key, version, and build metadata. */
-  manifest: AppManifest;
-  /** Environment-specific configuration with optional endpoint definitions. */
-  config?: AppConfig<TConfig>;
-  /** Optional properties forwarded to the application component. */
-  props?: TProps;
-};
-
-/**
- * Configuration callback for setting up application modules.
- *
- * This is the function signature accepted by {@link configureModules}. Implement
- * this callback to register HTTP clients, enable bookmarks, and add custom modules
- * to the application’s module pipeline.
- *
- * @template TModules - Additional modules registered by the application.
- * @template TRef - The Fusion instance type used as a configuration reference.
- * @template TEnv - The application environment descriptor.
- *
- * @param configurator - The application configurator with HTTP and module helpers.
- * @param args - Object containing the Fusion instance and the application environment.
- * @returns `void` or a `Promise<void>` for async configuration steps.
- *
- * @example
- * ```ts
- * import type { AppModuleInitiator } from '@equinor/fusion-framework-app';
- *
- * const configure: AppModuleInitiator = (configurator, { fusion, env }) => {
- *   configurator.useFrameworkServiceClient('portal-api');
- * };
- * ```
- */
-export type AppModuleInitiator<
-  TModules extends Array<AnyModule> | unknown = unknown,
-  TRef extends Fusion = Fusion,
-  TEnv = AppEnv,
-> = (
-  configurator: IAppConfigurator<TModules, TRef['modules']>,
-  args: { fusion: TRef; env: TEnv },
-) => void | Promise<void>;
-
-/**
- * Factory type that wraps {@link AppModuleInitiator} into a complete initializer.
- *
- * Accepts a configuration callback and returns an async function that, given the
- * Fusion instance and environment, produces the initialized module instance.
- * This is the signature of the {@link configureModules} function itself.
- *
- * @template TModules - Additional modules registered by the application.
- * @template TRef - The Fusion instance type used as a configuration reference.
- * @template TEnv - The application environment descriptor.
- */
-export type AppModuleInit<
-  TModules extends Array<AnyModule> | unknown = [],
-  TRef extends Fusion = Fusion,
-  TEnv = AppEnv,
-> = (
-  cb: AppModuleInitiator<TModules, TRef, TEnv>,
-) => (args: AppModuleInitArgs<TRef, TEnv>) => Promise<AppModulesInstance<TModules>>;
-
-/**
- * Arguments passed to the async initializer returned by {@link configureModules}.
- *
- * @template TRef - The Fusion instance type.
- * @template TEnv - The application environment descriptor.
- */
-export type AppModuleInitArgs<TRef extends Fusion = Fusion, TEnv = AppEnv> = {
-  fusion: TRef;
-  env: TEnv;
-};
-
-/**
- * Render function signature for mounting a Fusion application into the DOM.
- *
- * Called by the Fusion portal or dev-server to render the application. The
- * function receives the root element and render arguments (Fusion instance,
- * environment, and modules) and optionally returns a cleanup function that
- * is invoked when the application is unmounted.
- *
- * @template TFusion - The Fusion instance type providing framework modules.
- * @template TEnv - The application environment descriptor.
- *
- * @param el - The root HTML element where the application will be rendered.
- * @param args - Render arguments including the Fusion instance, environment,
- *               and resolved modules.
- * @returns A cleanup / teardown function, or `void` if no cleanup is needed.
- *
- * @example
- * ```ts
- * import type { AppRenderFn } from '@equinor/fusion-framework-app';
- * import { createRoot } from 'react-dom/client';
- *
- * export const renderApp: AppRenderFn = (el, args) => {
- *   const root = createRoot(el);
- *   root.render(<App />);
- *   return () => root.unmount();
- * };
- * ```
- */
-export type AppRenderFn<TFusion extends Fusion = Fusion, TEnv = AppEnv> = (
-  el: HTMLHtmlElement,
-  args: ComponentRenderArgs<TFusion, TEnv>,
-  // biome-ignore lint/suspicious/noConfusingVoidType: `void` here relies on TypeScript's special-cased "void-returning callback accepts any return value" behavior \u2014 `undefined` would break assignability of render functions that return a cleanup function
-) => VoidFunction | void;

package/src/utils.ts

@@ -1,50 +0,0 @@
-export { default as deepClone } from 'lodash.clonedeep';
-
-/**
- * Utility type that makes all properties of an object deeply readonly.
- *
- * @typeParam T - The type to make deeply readonly.
- */
-export type DeepImmutable<T> = {
-  readonly [P in keyof T]: T[P] extends object ? DeepImmutable<T[P]> : T[P];
-};
-
-/**
- * Determines if the provided object is eligible to be frozen.
- *
- * Checks whether the input is a non-null object or array that is not already frozen.
- *
- * @param obj - The value to check for isMutable.
- * @returns True if the object is a non-null object or array and is not already frozen; otherwise, false.
- */
-function isMutable(obj: unknown): obj is Record<string, unknown> | Array<unknown> {
-  return typeof obj === 'object' && obj !== null && !Object.isFrozen(obj);
-}
-
-/**
- * Recursively applies Object.freeze to an object and all nested properties, making them immutable.
- *
- * @remarks
- * - Plain objects and arrays are deeply frozen.
- * - Does not handle circular references. Use with caution on complex object graphs.
- * - Symbol properties are not frozen.
- *
- * @template T - The type of the object to freeze.
- * @param obj - The object to deeply freeze.
- * @returns The deeply frozen (read-only) object.
- */
-export function deepFreeze<T>(source: T): DeepImmutable<T> {
-  // Skip primitives and objects already frozen to avoid unnecessary recursion.
-  if (isMutable(source)) {
-    // Arrays require traversing their values directly before freezing the container.
-    if (Array.isArray(source)) {
-      // Freeze every nested array value so the result is immutable at every depth.
-      source.forEach(deepFreeze);
-    } else {
-      // Freeze every nested object value so the result is immutable at every depth.
-      Object.values(source).forEach(deepFreeze);
-    }
-    Object.freeze(source);
-  }
-  return source;
-}

package/src/version.ts

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

package/tsconfig.json

@@ -1,42 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "dist/esm",
-    "rootDir": "src",
-    "declarationDir": "./dist/types"
-  },
-  "references": [
-    {
-      "path": "../modules/module"
-    },
-    {
-      "path": "../modules/http"
-    },
-    {
-      "path": "../modules/msal"
-    },
-    {
-      "path": "../modules/event"
-    },
-    {
-      "path": "../modules/telemetry"
-    },
-    {
-      "path": "../modules/bookmark"
-    },
-    {
-      "path": "../modules/state"
-    },
-    {
-      "path": "../modules/app"
-    },
-    {
-      "path": "../modules/feature-flag"
-    },
-    {
-      "path": "../framework"
-    }
-  ],
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "lib"]
-}

package/vitest.config.ts

@@ -1,10 +0,0 @@
-import { defineProject } from 'vitest/config';
-
-import { name, version } from './package.json' with { type: 'json' };
-
-export default defineProject({
-  test: {
-    include: ['src/__tests__/**'],
-    name: `${name}@${version}`,
-  },
-});