@equinor/fusion-framework-module-context 8.0.3 → 9.0.0-next.0

package/dist/types/{configurator.d.ts → ContextModuleConfig.d.ts}

@@ -1,21 +1,18 @@
+import type { AnyModuleInstance, ModuleInstance } from '@equinor/fusion-framework-module';
 import type { ObservableInput } from 'rxjs';
-import type { AnyModuleInstance, ModuleInitializerArgs, ModuleInstance } from '@equinor/fusion-framework-module';
-import type { ServicesModule, IApiProvider } from '@equinor/fusion-framework-module-services';
-import type { NavigationModule } from '@equinor/fusion-framework-module-navigation';
 import type { QueryCtorOptions } from '@equinor/fusion-query';
 import type { ContextFilterFn, ContextItem, QueryContextParameters, RelatedContextParameters } from './types';
 import type { GetContextParameters } from './client/ContextClient';
-import { type ContextConfigBuilderCallback } from './ContextConfigBuilder';
 import type { IContextProvider } from './ContextProvider';
 /**
  * Resolved configuration for the context module.
  *
  * Holds query clients, type filters, parent-connection settings, and
  * optional callbacks for validation, resolution, and path integration.
- * Produced by {@link ContextModuleConfigurator.createConfig} after all
- * {@link ContextConfigBuilder} callbacks have run.
+ * Produced by {@link ContextModuleConfigurator.createConfigAsync} after all
+ * registered config builders have run.
  *
- * @see ContextConfigBuilder — fluent API for populating this config.
+ * @see IContextModuleConfigurator — fluent API for populating this config.
  * @see ContextProvider — runtime consumer of this config.
  */
 export interface ContextModuleConfig {
@@ -123,60 +120,3 @@ export interface ContextModuleConfig {
         modules: ModuleInstance;
     }) => ObservableInput<ContextItem | void>;
 }
-/**
- * Public configurator contract for the context module.
- *
- * Consumers call {@link addConfigBuilder} to register one or more
- * {@link ContextConfigBuilderCallback} functions that will run during
- * module initialization to populate the {@link ContextModuleConfig}.
- */
-export interface IContextModuleConfigurator {
-    /**
-     * Registers a configuration callback that receives a {@link ContextConfigBuilder}.
-     *
-     * Multiple builders can be added; they execute sequentially and merge
-     * their results into a single {@link ContextModuleConfig}.
-     *
-     * @param init - Builder callback invoked during module initialization.
-     */
-    addConfigBuilder: (init: ContextConfigBuilderCallback) => void;
-}
-/**
- * Default implementation of {@link IContextModuleConfigurator}.
- *
- * Collects {@link ContextConfigBuilderCallback} registrations and, when
- * {@link createConfig} is called, runs them in order against a
- * {@link ContextConfigBuilder} to produce the final {@link ContextModuleConfig}.
- *
- * If no custom client is configured, the configurator falls back to
- * creating one from the {@link ServicesModule} API provider.
- */
-export declare class ContextModuleConfigurator implements IContextModuleConfigurator {
-    #private;
-    /** Default cache TTL (in ms) for context query results. */
-    defaultExpireTime: number;
-    /** @inheritdoc */
-    addConfigBuilder(init: ContextConfigBuilderCallback): void;
-    /**
-     * Resolves the services API provider, preferring the local module
-     * instance and falling back to the parent module.
-     *
-     * @param init - Module initializer arguments.
-     * @returns The resolved API provider.
-     * @throws Error if no services module is available.
-     */
-    protected _getServiceProvider(init: ModuleInitializerArgs<IContextModuleConfigurator, [ServicesModule]>): Promise<IApiProvider>;
-    /**
-     * Runs all registered config builders and produces the final
-     * {@link ContextModuleConfig}.
-     *
-     * If no `resolveInitialContext` was set, the default path + parent
-     * resolver is used. If no `client` was set, one is created from the
-     * {@link ServicesModule} API provider.
-     *
-     * @param init - Module initializer arguments including dependency instances.
-     * @returns The fully resolved context module configuration.
-     */
-    createConfig(init: ModuleInitializerArgs<IContextModuleConfigurator, [ServicesModule, NavigationModule]>): Promise<ContextModuleConfig>;
-}
-export default ContextModuleConfigurator;

package/dist/types/ContextModuleConfigurator.d.ts

@@ -0,0 +1,97 @@
+import { BaseConfigBuilder, type ModuleInitializerArgs, type Modules, type ModuleType } from '@equinor/fusion-framework-module';
+import type { ServicesModule, IApiProvider } from '@equinor/fusion-framework-module-services';
+import type { NavigationModule } from '@equinor/fusion-framework-module-navigation';
+import type { QueryCtorOptions, QueryFn } from '@equinor/fusion-query';
+import type { ContextItem, QueryContextParameters, RelatedContextParameters } from './types';
+import type { GetContextParameters } from './client/ContextClient';
+import type { ContextModuleConfig } from './ContextModuleConfig';
+import type { ContextConfigBuilderCallback, IContextModuleConfigurator } from './ContextModuleConfigurator.interface';
+export type { ContextModuleConfig } from './ContextModuleConfig';
+export type { ContextConfigBuilderCallback, IContextModuleConfigurator, } from './ContextModuleConfigurator.interface';
+/**
+ * Default implementation of {@link IContextModuleConfigurator}.
+ *
+ * Collects {@link ContextConfigBuilderCallback} registrations and, when
+ * {@link createConfigAsync} is called, runs them in order — each callback
+ * receives this configurator itself and populates the config through its
+ * setter methods, which register into {@link BaseConfigBuilder._set} — to
+ * produce the final {@link ContextModuleConfig}.
+ *
+ * If no custom client is configured, the configurator falls back to
+ * creating one from the {@link ServicesModule} API provider.
+ *
+ * @remarks
+ * Extends {@link BaseConfigBuilder} and fully reuses its `_set`/`_buildConfig`
+ * machinery. Setters always pass an `async () => value` callback to `_set`,
+ * never the raw value directly — `_set` decides whether it received a value
+ * or a deferred callback by checking `typeof value_or_cb === 'function'`, so
+ * fields that are themselves functions (e.g. `validateContext`) would
+ * otherwise be misread as callbacks and invoked instead of stored.
+ */
+export declare class ContextModuleConfigurator extends BaseConfigBuilder<ContextModuleConfig> implements IContextModuleConfigurator {
+    #private;
+    /** Default cache TTL (in ms) for context query results. */
+    defaultExpireTime: number;
+    /** @inheritdoc */
+    addConfigBuilder(init: ContextConfigBuilderCallback): void;
+    /** @inheritdoc */
+    requireInstance<TKey extends string = Extract<keyof Modules, string>>(module: TKey): Promise<ModuleType<Modules[TKey]>>;
+    /** @inheritdoc */
+    requireInstance<T>(module: string): Promise<T>;
+    /** @inheritdoc */
+    setContextType(type: ContextModuleConfig['contextType']): void;
+    /** @inheritdoc */
+    setContextFilter(filter: ContextModuleConfig['contextFilter']): void;
+    /** @inheritdoc */
+    connectParentContext(connect: ContextModuleConfig['connectParentContext']): void;
+    /** @inheritdoc */
+    setContextParameterFn(fn: ContextModuleConfig['contextParameterFn']): void;
+    /** @inheritdoc */
+    setValidateContext(fn: ContextModuleConfig['validateContext']): void;
+    /** @inheritdoc */
+    setResolveContext(fn: ContextModuleConfig['resolveContext']): void;
+    /** @inheritdoc */
+    setContextPathExtractor(fn: ContextModuleConfig['extractContextIdFromPath']): void;
+    /** @inheritdoc */
+    setContextPathGenerator(fn: ContextModuleConfig['generatePathFromContext']): void;
+    /** @inheritdoc */
+    setResolveInitialContext(fn: ContextModuleConfig['resolveInitialContext']): void;
+    /** @inheritdoc */
+    setContextClient(client: {
+        get: QueryFn<ContextItem, GetContextParameters> | QueryCtorOptions<ContextItem, GetContextParameters>;
+        query: QueryFn<ContextItem[], QueryContextParameters> | QueryCtorOptions<ContextItem[], QueryContextParameters>;
+        related?: QueryFn<ContextItem[], RelatedContextParameters> | QueryCtorOptions<ContextItem[], RelatedContextParameters>;
+    }, expire?: number): void;
+    /**
+     * Resolves the services API provider, preferring the local module
+     * instance and falling back to the parent module.
+     *
+     * @param init - Module initializer arguments.
+     * @returns The resolved API provider.
+     * @throws Error if no services module is available.
+     */
+    protected _getServiceProvider(init: ModuleInitializerArgs<IContextModuleConfigurator, [ServicesModule]>): Promise<IApiProvider>;
+    /**
+     * Runs all registered config builders, then resolves the accumulated
+     * `_set` registrations into the final {@link ContextModuleConfig}.
+     *
+     * @param init - Module initializer arguments including dependency instances.
+     * @param initial - Optional partial config inherited from a parent module.
+     * @returns The fully resolved context module configuration.
+     */
+    protected _createConfig(init: ModuleInitializerArgs<IContextModuleConfigurator, [ServicesModule, NavigationModule]>, initial?: Partial<ContextModuleConfig>): Promise<ContextModuleConfig>;
+    /**
+     * Defaults `resolveInitialContext` and `client` when a builder callback
+     * didn't set them.
+     *
+     * If no `resolveInitialContext` was set, the default path + parent
+     * resolver is used. If no `client` was set, one is created from the
+     * {@link ServicesModule} API provider.
+     *
+     * @param config - The config accumulated from registered builder callbacks.
+     * @param init - Module initializer arguments including dependency instances.
+     * @returns The fully resolved context module configuration.
+     */
+    protected _processConfig(config: Partial<ContextModuleConfig>, init: ModuleInitializerArgs<IContextModuleConfigurator, [ServicesModule, NavigationModule]>): Promise<ContextModuleConfig>;
+}
+export default ContextModuleConfigurator;

package/dist/types/{ContextConfigBuilder.d.ts → ContextModuleConfigurator.interface.d.ts}

@@ -1,65 +1,45 @@
-import type { AnyModule, ModuleInitializerArgs, Modules, ModuleType } from '@equinor/fusion-framework-module';
+import type { Modules, ModuleType } from '@equinor/fusion-framework-module';
 import type { QueryCtorOptions, QueryFn } from '@equinor/fusion-query';
-import type { GetContextParameters } from './client/ContextClient';
-import type { ContextModuleConfig, ContextModuleConfigurator, IContextModuleConfigurator } from './configurator';
+import type { ContextModuleConfig } from './ContextModuleConfig';
 import type { ContextItem, QueryContextParameters, RelatedContextParameters } from './types';
+import type { GetContextParameters } from './client/ContextClient';
 /**
  * Callback passed to {@link IContextModuleConfigurator.addConfigBuilder}.
  *
- * Receives a {@link ContextConfigBuilder} and may use its setter methods
- * to populate the context module configuration. The callback may be async.
- *
- * @typeParam TDeps - Module dependency array inferred from the configurator.
+ * Receives the {@link IContextModuleConfigurator} itself and may use its
+ * setter methods to populate the context module configuration. The
+ * callback may be async.
  */
-export type ContextConfigBuilderCallback = <TDeps extends Array<AnyModule> = []>(builder: ContextConfigBuilder<TDeps, ModuleInitializerArgs<IContextModuleConfigurator, TDeps>>) => void | Promise<void>;
+export type ContextConfigBuilderCallback = (builder: IContextModuleConfigurator) => void | Promise<void>;
 /**
- * A builder class for configuring and customizing context module behavior within the Fusion Framework.
- *
- * `ContextConfigBuilder` provides a fluent API for setting up various aspects of context management,
- * including context type, filtering, parent context connection, parameter resolution, validation,
- * path extraction/generation, and client configuration for fetching context items.
- *
- * @typeParam TModules - An array of modules that extend `AnyModule`. Defaults to an empty array.
- * @typeParam TInit - The initializer arguments for the module, extending `ModuleInitializerArgs`.
- *
- * @example
- * ```typescript
- * const builder = new ContextConfigBuilder(init);
- * builder.setContextType(['ProjectMaster']);
- * builder.setContextFilter(items => items.filter(ctx => ctx.isActive));
- * builder.setContextClient({ get: fetchContextItem, query: fetchContextItems });
- * ```
- *
- * @remarks
- * - Use the provided setter methods to customize context behavior as needed.
- * - The builder pattern allows chaining configuration methods for clarity and convenience.
- * - The `requireInstance` method enables asynchronous retrieval of module instances by name.
- *
- * @todo(#5120) - this should extend the BaseConfigBuilder
+ * Public configurator contract for the context module.
  *
- * @see ContextModuleConfig
- * @see ModuleInitializerArgs
+ * Consumers call {@link addConfigBuilder} to register one or more
+ * {@link ContextConfigBuilderCallback} functions that will run during
+ * module initialization to populate the {@link ContextModuleConfig}, using
+ * the fluent setter methods declared below.
  */
-export declare class ContextConfigBuilder<TModules extends Array<AnyModule> = [], TInit extends ModuleInitializerArgs<any, any> = ModuleInitializerArgs<ContextModuleConfigurator, TModules>> {
-    #private;
-    config: Partial<ContextModuleConfig>;
+export interface IContextModuleConfigurator {
     /**
-     * Creates a new `ContextConfigBuilder`.
-     * @param init - Module initializer arguments used to resolve module instances.
-     * @param config - The partial context module config to build upon.
+     * Registers a configuration callback that receives this configurator.
+     *
+     * Multiple builders can be added; they execute sequentially against the
+     * same configurator instance, so later calls win when they touch the
+     * same field.
+     *
+     * @param init - Builder callback invoked during module initialization.
      */
-    constructor(init: TInit, config?: Partial<ContextModuleConfig>);
+    addConfigBuilder: (init: ContextConfigBuilderCallback) => void;
     /**
-     * Requires a module instance by its registered key.
-     * @param module - The key of the module to resolve.
+     * Requires a module instance by its registered key or name.
+     *
+     * Only resolvable from within a {@link ContextConfigBuilderCallback} —
+     * throws if called before module initialization has started.
+     *
+     * @param module - The key or name of the module to resolve.
      * @returns A promise that resolves to the requested module instance.
      */
     requireInstance<TKey extends string = Extract<keyof Modules, string>>(module: TKey): Promise<ModuleType<Modules[TKey]>>;
-    /**
-     * Requires a module instance by name.
-     * @param module - The name of the module to resolve.
-     * @returns A promise that resolves to the requested module instance.
-     */
     requireInstance<T>(module: string): Promise<T>;
     /**
      * Sets the context type for the current configuration.

package/dist/types/ContextProvider.d.ts

@@ -1,5 +1,5 @@
 import { Observable, Subscription } from 'rxjs';
-import type { ContextModuleConfig } from './configurator';
+import type { ContextModuleConfig } from './ContextModuleConfig';
 import { BaseModuleProvider } from '@equinor/fusion-framework-module/provider';
 import { ContextClient } from './client/ContextClient';
 import type { ContextItem, QueryContextParameters, RelatedContextParameters } from './types';

package/dist/types/__tests__/ContextModuleConfigurator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/__tests__/mock/context-mock.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/__tests__/mock/create-context-item-factory.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/__tests__/mock/create-context-items.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -10,7 +10,9 @@
  *
  * @packageDocumentation
  */
-export { ContextModuleConfigurator, IContextModuleConfigurator, ContextModuleConfig, } from './configurator';
+export { ContextModuleConfigurator } from './ContextModuleConfigurator';
+export type { IContextModuleConfigurator } from './ContextModuleConfigurator.interface';
+export type { ContextModuleConfig } from './ContextModuleConfig';
 export { IContextProvider, ContextProvider } from './ContextProvider';
 export { default, ContextModule, module as contextModule, moduleKey as contextModuleKey, } from './module';
 export { enableContext } from './utils/enable-context';

package/dist/types/mock/ContextMockConfigurator.d.ts

@@ -0,0 +1,155 @@
+import type { ModuleInitializerArgs } from '@equinor/fusion-framework-module';
+import type { NavigationModule } from '@equinor/fusion-framework-module-navigation';
+import type { ServicesModule } from '@equinor/fusion-framework-module-services';
+import { ContextModuleConfigurator } from '../ContextModuleConfigurator';
+import type { ContextModuleConfig } from '../ContextModuleConfig';
+import type { IContextModuleConfigurator } from '../ContextModuleConfigurator.interface';
+import type { ContextItem } from '../types';
+/**
+ * Resolves a context item by id, or `undefined` if none matches.
+ *
+ * @remarks
+ * The escape hatch for {@link ContextMockConfigurator.setResolver} — anything
+ * the friendly seeding methods did not anticipate can be expressed here instead.
+ */
+export type ContextResolverFn = (id: string) => ContextItem | undefined;
+/**
+ * A {@link ContextModuleConfigurator} backed by in-memory context items instead
+ * of a real context API, for seeding context in tests.
+ *
+ * @remarks
+ * Two layers cover different needs, both running through the real
+ * `ContextProvider` logic underneath — only the data source is substituted,
+ * never `validateContext`, `resolveContext`, or parent-context propagation:
+ *
+ * - **Friendly layer** — {@link setCurrentContext}, {@link setContexts},
+ *   {@link addContext}, {@link setRelatedContexts} — a small, context-domain
+ *   vocabulary for the common case: seed a known item, get it back.
+ * - **Escape hatch** — {@link setResolver} — a raw id-lookup function for a
+ *   custom id-based resolution strategy or a shape the friendly layer did not
+ *   cover. Only replaces id-based lookup (used by `setCurrentContextById` and
+ *   the initial context); it does not affect related-context resolution by
+ *   item, which always goes through {@link setRelatedContexts} instead.
+ *
+ * Seeding the initial context (via {@link setCurrentContext}) overrides
+ * `resolveInitialContext` directly with the seeded item, so a test never needs
+ * to construct a fake navigation module or parent framework instance to make an
+ * app start up with a known context selected. Resolving a context id from a URL
+ * path on startup is not covered — that needs a fake router, which is separate,
+ * not-yet-built work.
+ *
+ * Seeded ids are never generated for you — every item is looked up and
+ * returned exactly by the id it was seeded with, so a test never sees a
+ * different id than the one it wrote. Use `createContextItemFactory` or
+ * `createContextItems` for fixtures needing ids of their own, rather than a
+ * random generator that would change on every run.
+ *
+ * Related-context resolution defaults to the same seeded pool, filtered to
+ * whichever type(s) the query asked for — related context is the same
+ * context, just a different type, exactly as `ContextProvider.resolveContext`
+ * uses it to resolve an item of an unexpected type into one of the configured
+ * type. Seed items of both types and resolution works with no extra wiring;
+ * {@link setRelatedContexts} overrides that default for one specific item.
+ *
+ * @example Seed and select a known context item
+ * ```ts
+ * enableContextMock(configurator, (mock) => {
+ *   mock.setCurrentContext({ id: 'my-ctx', type: { id: 'ProjectMaster' }, value: {} });
+ * });
+ * ```
+ *
+ * @example Resolve a child-typed item into its parent type
+ * ```ts
+ * enableContextMock(configurator, (mock) => {
+ *   // no explicit wiring needed — relatedContexts filters this same pool by type
+ *   mock.setContexts([project, facility]);
+ * });
+ * ```
+ *
+ * @example Override related contexts for one specific item
+ * ```ts
+ * enableContextMock(configurator, (mock) => {
+ *   mock.addContext(project);
+ *   mock.setRelatedContexts(project.id, [facilityA, facilityB]);
+ * });
+ * ```
+ *
+ * @example Escape hatch for a custom resolution need
+ * ```ts
+ * enableContextMock(configurator, (mock) => {
+ *   mock.setResolver((id) => (id === 'special' ? specialContextItem : undefined));
+ * });
+ * ```
+ */
+export declare class ContextMockConfigurator extends ContextModuleConfigurator {
+    #private;
+    /**
+     * Registers the in-memory client up front, so `createConfig` never falls
+     * back to building one from a real `ServicesModule` — a mock needs neither
+     * an API provider nor a network to answer `get`/`query`/`related`.
+     */
+    constructor();
+    /**
+     * Seeds a context item and selects it as the context the app resolves on startup.
+     *
+     * @param item - The context item to seed and select.
+     * @returns This configurator, for chaining.
+     */
+    setCurrentContext(item: ContextItem): this;
+    /**
+     * Seeds multiple context items, making each resolvable by id.
+     *
+     * @remarks
+     * Does not select any of them as current — pair with {@link setCurrentContext}
+     * for that.
+     *
+     * @param items - The context items to seed.
+     * @returns This configurator, for chaining.
+     */
+    setContexts(items: ContextItem[]): this;
+    /**
+     * Seeds a single context item, making it resolvable by id.
+     *
+     * @param item - The context item to seed.
+     * @returns This configurator, for chaining.
+     */
+    addContext(item: ContextItem): this;
+    /**
+     * Overrides related-context resolution for one specific source item.
+     *
+     * @remarks
+     * Without this, `relatedContexts` filters the seeded pool by the requested
+     * type(s) — this is only needed when a test wants a specific item to resolve
+     * something other than that default (e.g. no related items at all).
+     *
+     * @param itemId - The id of the item relations are being overridden for.
+     * @param items - The context items to return from `relatedContexts` for that item.
+     * @returns This configurator, for chaining.
+     */
+    setRelatedContexts(itemId: string, items: ContextItem[]): this;
+    /**
+     * Escape hatch: overrides id-based context resolution directly.
+     *
+     * @remarks
+     * For a custom id-lookup strategy or a shape the friendly seeding methods
+     * above did not cover — reaching for this means they were already tried
+     * and did not fit. Only replaces lookup by id (used by
+     * `setCurrentContextById` and the seeded initial context) — related-context
+     * resolution by item always goes through {@link setRelatedContexts} instead,
+     * regardless of this setting.
+     *
+     * @param fn - Resolves a context item by id, or returns `undefined` if none matches.
+     * @returns This configurator, for chaining.
+     */
+    setResolver(fn: ContextResolverFn): this;
+    /**
+     * Defaults `resolveInitialContext` from the seeded/resolved state, once the
+     * real config has been assembled.
+     *
+     * @param config - The context module config assembled by the base configurator.
+     * @param init - Module initializer arguments.
+     * @returns The context module configuration, backed by seeded/resolved data.
+     */
+    protected _processConfig(config: Partial<ContextModuleConfig>, init: ModuleInitializerArgs<IContextModuleConfigurator, [ServicesModule, NavigationModule]>): Promise<ContextModuleConfig>;
+}
+export default ContextMockConfigurator;

package/dist/types/mock/fixtures/create-context-item-factory.d.ts

@@ -0,0 +1,40 @@
+import type { ContextItem } from '../../types';
+/**
+ * Creates one {@link ContextItem} fixture per call, for a single factory instance.
+ *
+ * @param overrides - Fields to override on the generated item. Supplying `id`
+ * skips the sequential generator for that one item.
+ * @returns A fully-formed {@link ContextItem}.
+ */
+export type MockContextItemFactory = (overrides?: Partial<ContextItem>) => ContextItem;
+/**
+ * Builds a {@link MockContextItemFactory} producing deterministic, sequential
+ * ids of the form `<prefix>-<n>`, with a realistic `title` filled in by
+ * {@link https://fakerjs.dev/ | faker} (`@faker-js/faker`, a peer dependency —
+ * only required if this factory is imported).
+ *
+ * @remarks
+ * Ids are scoped to the returned factory, not shared globally, so two tests
+ * creating their own factory each start counting from `1` — a random id (e.g.
+ * `crypto.randomUUID()`) would change on every run and break any assertion
+ * that seeds one item and expects to see that same id again. The faker seed
+ * is derived from that same id, so the generated `title` is just as
+ * deterministic. For fixtures spanning several context types (e.g. a
+ * parent/child type hierarchy), use `createContextItems` instead — it
+ * assigns ids per type and wires the type hierarchy for you.
+ *
+ * @param prefix - The id prefix. Defaults to `'ctx'`.
+ * @returns A function creating one {@link ContextItem} fixture per call.
+ *
+ * @example
+ * ```ts
+ * const createContextItem = createContextItemFactory();
+ *
+ * const project = createContextItem(); // id: 'ctx-1', title: a deterministic faker company name
+ * const facility = createContextItem({ title: 'Facility A' }); // id: 'ctx-2', title overridden
+ *
+ * mock.setContexts([project, facility]);
+ * ```
+ */
+export declare const createContextItemFactory: (prefix?: string) => MockContextItemFactory;
+export default createContextItemFactory;

package/dist/types/mock/fixtures/create-context-items.d.ts

@@ -0,0 +1,59 @@
+import type { ContextItem } from '../../types';
+/** Overridable {@link ContextItem} fields. `id` and `type` are always assigned by the type seed itself. */
+export type ContextItemOverrides = Partial<Omit<ContextItem, 'id' | 'type'>>;
+/**
+ * Describes one context type to generate fixtures for.
+ *
+ * @param type - The context type id (e.g. `'ProjectMaster'`, `'Contract'`).
+ * @param count - Number of items to generate for this type. Defaults to `1`.
+ * @param parentTypeIds - Parent type ids, when this type is a child in the
+ * type hierarchy — sets `type.isChildType`/`type.parentTypeIds` on every
+ * generated item of this type.
+ * @param item - Per-item overrides, called with the item's 1-based index
+ * within this type.
+ */
+export interface ContextTypeSeed {
+    type: string;
+    count?: number;
+    parentTypeIds?: string[];
+    item?: (index: number) => ContextItemOverrides;
+}
+/**
+ * Generates a batch of {@link ContextItem} fixtures across one or more
+ * context types, with deterministic ids, a realistic `title` from
+ * {@link https://fakerjs.dev/ | faker} (`@faker-js/faker`, a peer dependency —
+ * only required if this factory is imported), and a consistent type hierarchy.
+ *
+ * @remarks
+ * Ids are `<type>-<n>` (lowercased type, 1-based per type), so results are
+ * stable across runs and readable in test failures. `title` is filled in from
+ * a faker instance seeded by that same id, so it's just as deterministic.
+ * Feeding the result to `ContextMockConfigurator.setContexts` is enough to
+ * make related-context resolution work across types — the mock's
+ * `relatedContexts` filters this same seeded pool by type, so a child-typed
+ * item resolves into a parent of its `parentTypeIds` without any per-item
+ * wiring. That default is a simplification: the real context API resolves
+ * relations per specific instance (a `Contract` belongs to one particular
+ * `ProjectMaster`, not every `ProjectMaster` in the system) — seed only one
+ * instance per type when that distinction doesn't matter to the test, or use
+ * `ContextMockConfigurator.setRelatedContexts` to pin a specific item's
+ * relations when it does.
+ *
+ * @param types - The context types, and how many items to generate for each.
+ * @returns The generated context items, in the order the type seeds were given.
+ *
+ * @example Seed a project type and a child contract type
+ * ```ts
+ * const [project] = createContextItems([{ type: 'ProjectMaster' }]);
+ * const [contract] = createContextItems([
+ *   { type: 'Contract', parentTypeIds: ['ProjectMaster'] },
+ * ]);
+ *
+ * enableContextMock(configurator, (mock) => {
+ *   mock.setContexts([project, contract]);
+ *   // relatedContexts({ item: contract, filter: { type: ['ProjectMaster'] } }) now resolves `project`
+ * });
+ * ```
+ */
+export declare const createContextItems: (types: ContextTypeSeed[]) => ContextItem[];
+export default createContextItems;

package/dist/types/mock/fixtures/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Fixture generators for {@link ContextMockConfigurator} test data.
+ *
+ * @remarks
+ * A separate entry point from `@equinor/fusion-framework-module-context/mock`
+ * because these factories use {@link https://fakerjs.dev/ | faker}
+ * (`@faker-js/faker`) for realistic values — an optional peer dependency, only
+ * required if this entry point is imported. `enableContextMock` and
+ * `ContextMockConfigurator` on the main `/mock` entry point never require it.
+ *
+ * @example
+ * ```typescript
+ * import { createContextItems } from '@equinor/fusion-framework-module-context/mock/fixtures';
+ *
+ * const [project] = createContextItems([{ type: 'ProjectMaster' }]);
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { createContextItemFactory, type MockContextItemFactory, } from './create-context-item-factory';
+export { createContextItems, type ContextTypeSeed, type ContextItemOverrides, } from './create-context-items';

package/dist/types/mock/fixtures/string-to-seed.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Derives a numeric seed from a string, for a deterministic {@link https://fakerjs.dev/ | faker} instance.
+ *
+ * @remarks
+ * A pure-JS hash (no `node:crypto`) so fixtures stay usable in browser-like test
+ * environments, not just Node. Same id in, same seed out, every run.
+ *
+ * @param value - The string to derive a seed from (typically a generated item id).
+ * @returns A 32-bit unsigned integer seed.
+ */
+export declare const stringToSeed: (value: string) => number;
+export default stringToSeed;

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

@@ -0,0 +1,30 @@
+/**
+ * Mock context module for tests: real provider, real configurator, in-memory data.
+ *
+ * @remarks
+ * Substituting the data source is the smallest change that removes the context
+ * API, HTTP mocking, and service-discovery mocking from a test. Everything
+ * above it — validation, resolution, parent-context propagation, initial-context
+ * selection — is the production code path.
+ *
+ * This is one of two ways to mock context data in tests: a small, static,
+ * in-memory pool (this module — no HTTP layer involved at all). The other is
+ * mocking the context API's HTTP responses directly (e.g. with MSW), which
+ * exercises the real `ContextModuleConfigurator`/services/HTTP pipeline —
+ * reach for that instead when the test needs to cover that pipeline itself.
+ * For fixture generators with realistic fake data, see
+ * `@equinor/fusion-framework-module-context/mock/fixtures`.
+ *
+ * @example
+ * ```typescript
+ * import { enableContextMock } from '@equinor/fusion-framework-module-context/mock';
+ *
+ * enableContextMock(configurator, (mock) => {
+ *   mock.setCurrentContext({ id: 'my-ctx', type: { id: 'ProjectMaster' }, value: {} });
+ * });
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { ContextMockConfigurator, type ContextResolverFn, } from './ContextMockConfigurator';
+export { enableContextMock, contextMockModule, type ContextMockConfigFn } from './module';