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

package/src/client/ContextClient.ts

@@ -1,149 +0,0 @@
-import { Observable, BehaviorSubject, EMPTY, lastValueFrom, firstValueFrom } from 'rxjs';
-import { catchError, map } from 'rxjs/operators';
-
-import equal from 'fast-deep-equal';
-
-import { Query, type QueryCtorOptions } from '@equinor/fusion-query';
-
-import type { ContextItem } from '../types';
-
-export type GetContextParameters = { id: string };
-
-/**
- * `ContextClient` is an observable client for managing and retrieving context items.
- *
- * This class extends `Observable<ContextItem | null | undefined>`, allowing consumers to subscribe to context changes.
- * It encapsulates a `Query` instance for fetching context items by ID and maintains the current context state using a `BehaviorSubject`.
- *
- * ### Features
- * - Exposes the current context synchronously and as an observable stream.
- * - Provides methods to set the current context by ID or item, resolving and updating as needed.
- * - Supports asynchronous context resolution with optional await behavior.
- * - Handles errors during context resolution, unwrapping nested causes.
- * - Implements a `dispose` method to clean up internal subscriptions.
- *
- * @template ContextItem The type of the context item managed by the client.
- * @extends Observable<ContextItem | null | undefined>
- *
- * @todo(#5116) - should this have `undefined` as a valid value?
- *
- * @example
- * ```typescript
- * const client = new ContextClient(options);
- * client.setCurrentContext('context-id');
- * client.currentContext$.subscribe(ctx => { ... });
- * ```
- */
-export class ContextClient extends Observable<ContextItem | null | undefined> {
-  #client: Query<ContextItem, { id: string }>;
-  /** might change to reactive state, for comparing state with reducer */
-  #currentContext$: BehaviorSubject<ContextItem | null | undefined>;
-
-  /**
-   * Gets the current context item.
-   *
-   * @returns The current {@link ContextItem}, or `null` if no context is set, or `undefined` if the context has not been initialized.
-   */
-  get currentContext(): ContextItem | null | undefined {
-    return this.#currentContext$.value;
-  }
-
-  /**
-   * An observable stream that emits the current context item.
-   *
-   * @remarks
-   * This observable emits the current `ContextItem` whenever it changes.
-   * It can emit `null` or `undefined` if there is no current context.
-   *
-   * @returns Observable that emits the current `ContextItem`, `null`, or `undefined`.
-   */
-  get currentContext$(): Observable<ContextItem | null | undefined> {
-    return this.#currentContext$.asObservable();
-  }
-
-  /**
-   * Gets the query client for retrieving a specific `ContextItem` by its ID.
-   *
-   * @returns A `Query` instance configured to fetch a `ContextItem` using an object containing an `id` property.
-   */
-  get client(): Query<ContextItem, { id: string }> {
-    return this.#client;
-  }
-
-  /**
-   * Creates a new `ContextClient`.
-   * @param options - Query constructor options used to fetch a `ContextItem` by its ID.
-   */
-  constructor(options: QueryCtorOptions<ContextItem, GetContextParameters>) {
-    super((observer) => this.#currentContext$.subscribe(observer));
-    this.#client = new Query(options);
-    this.#currentContext$ = new BehaviorSubject<ContextItem | null | undefined>(undefined);
-  }
-
-  /**
-   * Sets the current context based on the provided identifier or context item.
-   *
-   * If a string identifier is provided, attempts to resolve the corresponding context asynchronously.
-   * If a `ContextItem` or `null` is provided, updates the current context only if it differs from the existing one.
-   *
-   * @param idOrItem - The context identifier (string), a `ContextItem`, or `null`. If omitted, the current context may be cleared.
-   */
-  public setCurrentContext(idOrItem?: string | ContextItem | null): void {
-    // resolve string identifiers to a context item before setting
-    if (typeof idOrItem === 'string') {
-      // TODO(#5117) - compare context
-      // TODO(#5117) should this catch error?
-      this.resolveContext(idOrItem)
-        .pipe(catchError(() => EMPTY))
-        .subscribe((value) => this.setCurrentContext(value));
-      /** only add context if not match */
-    } else if (!equal(idOrItem, this.#currentContext$.value)) {
-      this.#currentContext$.next(idOrItem);
-    }
-  }
-
-  /**
-   * Resolves a context item by its unique identifier.
-   *
-   * @param id - The unique identifier of the context item to resolve.
-   * @returns An Observable that emits the resolved {@link ContextItem}.
-   * @throws Rethrows the underlying error cause if present, otherwise throws the original error.
-   */
-  public resolveContext(id: string): Observable<ContextItem> {
-    // unwrap the query result into the resolved context item
-    return this.#client.query({ id }).pipe(
-      map((x) => x.value),
-      // unwrap error
-      catchError((err) => {
-        // unwrap the underlying cause so callers see the original error
-        if (err.cause) {
-          throw err.cause;
-        }
-        throw err;
-      }),
-    );
-  }
-
-  /**
-   * Resolves a context item asynchronously by its ID.
-   *
-   * @param id - The unique identifier of the context item to resolve.
-   * @param opt - Optional settings for resolution.
-   * @param opt.awaitResolve - If true, waits for the observable to complete and returns the last emitted value;
-   * otherwise, returns the first emitted value.
-   * @returns A promise that resolves to the requested {@link ContextItem}.
-   */
-  public resolveContextAsync(id: string, opt?: { awaitResolve: boolean }): Promise<ContextItem> {
-    const fn = opt?.awaitResolve ? lastValueFrom : firstValueFrom;
-    return fn(this.resolveContext(id));
-  }
-
-  /**
-   * Disposes of the client, completing the internal current-context subject.
-   */
-  public dispose(): void {
-    this.#currentContext$.complete();
-  }
-}
-
-export default ContextClient;

package/src/errors/FusionContextSearchError.ts

@@ -1,56 +0,0 @@
-/**
- * Represents an error that occurs during a Fusion context search operation.
- *
- * This error provides a title and an optional description to give more context
- * about the failure. It extends the built-in `Error` class and sets the error
- * name to `'FusionContextSearchError'`.
- *
- * @example
- * ```typescript
- * throw new FusionContextSearchError({ title: 'Search failed', description: 'No results found.' });
- * ```
- *
- * @public
- */
-export class FusionContextSearchError extends Error {
-  #details;
-
-  /**
-   * The title of the error.
-   * @returns The error title.
-   */
-  get title(): string {
-    return this.#details.title;
-  }
-
-  /**
-   * The description of the error, if available.
-   * @returns The error description, or `undefined` if none was provided.
-   */
-  get description(): string | undefined {
-    return this.#details.description;
-  }
-
-  /**
-   * Creates a new instance of FusionContextSearchError.
-   * @param details - The details of the error.
-   * @param options - Optional parameters for the error.
-   */
-  constructor(
-    details: {
-      /**
-       * The title of the error.
-       */
-      title: string;
-      /**
-       * The description of the error, if available.
-       */
-      description?: string;
-    },
-    options?: ErrorOptions,
-  ) {
-    super(details.description ?? details.title, options);
-    this.#details = details;
-    this.name = 'FusionContextSearchError';
-  }
-}

package/src/errors/index.ts

@@ -1 +0,0 @@
-export * from './FusionContextSearchError';

package/src/index.ts

@@ -1,29 +0,0 @@
-/**
- * Context module for the Fusion Framework.
- *
- * Provides context management for Fusion-based applications and portals,
- * including setting, querying, validating, and resolving context items.
- *
- * Use {@link enableContext} to register the module in a configurator,
- * then access the {@link IContextProvider} from the module instance
- * to interact with context state.
- *
- * @packageDocumentation
- */
-
-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';
-
-export * from './types';

package/src/mock/ContextMockConfigurator.ts

@@ -1,244 +0,0 @@
-import { EMPTY, from, lastValueFrom, of, throwError } from 'rxjs';
-
-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 class ContextMockConfigurator extends ContextModuleConfigurator {
-  #contexts = new Map<string, ContextItem>();
-  #related = new Map<string, ContextItem[]>();
-  #resolver?: ContextResolverFn;
-  #pendingCurrentId?: string;
-
-  /**
-   * 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() {
-    super();
-    this.addConfigBuilder((builder) => {
-      builder.setContextClient({
-        get: (args) => {
-          const item = this.#resolve(args.id);
-          // a caller asking for an unseeded id gets a clear error, not a silent miss
-          return item
-            ? of(item)
-            : throwError(
-                () =>
-                  new Error(
-                    `ContextMockConfigurator: no context item resolves for id "${args.id}" — seed it with setCurrentContext/setContexts/addContext, or provide setResolver.`,
-                  ),
-              );
-        },
-        query: () => of([...this.#contexts.values()]),
-        related: (args) => {
-          const override = this.#related.get(args.item.id);
-          // an explicit override for this exact item always wins
-          if (override) return of(override);
-          const types = args.filter?.type;
-          // otherwise: related context is the same seeded pool, filtered to the requested type(s)
-          return of(
-            [...this.#contexts.values()].filter(
-              (item) => item.id !== args.item.id && (!types || types.includes(item.type.id)),
-            ),
-          );
-        },
-      });
-    });
-  }
-
-  /**
-   * 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.
-   */
-  public setCurrentContext(item: ContextItem): this {
-    this.#contexts.set(item.id, item);
-    this.#pendingCurrentId = item.id;
-    return 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.
-   */
-  public setContexts(items: ContextItem[]): this {
-    // seed every item so each is individually resolvable by id
-    for (const item of items) this.#contexts.set(item.id, item);
-    return this;
-  }
-
-  /**
-   * Seeds a single context item, making it resolvable by id.
-   *
-   * @param item - The context item to seed.
-   * @returns This configurator, for chaining.
-   */
-  public addContext(item: ContextItem): this {
-    this.#contexts.set(item.id, item);
-    return 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.
-   */
-  public setRelatedContexts(itemId: string, items: ContextItem[]): this {
-    this.#related.set(itemId, items);
-    return 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.
-   */
-  public setResolver(fn: ContextResolverFn): this {
-    this.#resolver = fn;
-    return this;
-  }
-
-  /**
-   * Resolves an id through the escape hatch if one is set, otherwise the seeded map.
-   *
-   * @param id - The context id to resolve.
-   * @returns The matching context item, or `undefined`.
-   */
-  #resolve(id: string): ContextItem | undefined {
-    // the escape hatch, when set, replaces the seeded map entirely
-    return this.#resolver ? this.#resolver(id) : this.#contexts.get(id);
-  }
-
-  /**
-   * 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 override async _processConfig(
-    config: Partial<ContextModuleConfig>,
-    init: ModuleInitializerArgs<IContextModuleConfigurator, [ServicesModule, NavigationModule]>,
-  ): Promise<ContextModuleConfig> {
-    // the base default is a plain Observable (`of(...)`), not a thenable — unwrap it explicitly
-    const resolved = await lastValueFrom(from(super._processConfig(config, init)));
-    const id = this.#pendingCurrentId;
-
-    // The base default resolves from the URL path or a parent framework, and
-    // throws when neither is present — the common case for an isolated mock.
-    // Resolve the seeded item when one was selected, otherwise resolve none.
-    resolved.resolveInitialContext = id ? () => of(this.#resolve(id)) : () => EMPTY;
-
-    return resolved;
-  }
-}
-
-export default ContextMockConfigurator;

package/src/mock/fixtures/create-context-item-factory.ts

@@ -1,62 +0,0 @@
-import { Faker, en } from '@faker-js/faker';
-
-import type { ContextItem } from '../../types';
-import { stringToSeed } from './string-to-seed';
-
-/**
- * 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 const createContextItemFactory = (prefix = 'ctx'): MockContextItemFactory => {
-  const created: ContextItem[] = [];
-  return (overrides: Partial<ContextItem> = {}): ContextItem => {
-    // overrides.id, when supplied, always wins over the sequential generator
-    const id = overrides.id ?? `${prefix}-${created.length + 1}`;
-    const faker = new Faker({ seed: stringToSeed(id), locale: en });
-    const item: ContextItem = {
-      type: { id: 'Mock' },
-      value: {},
-      title: faker.company.name(),
-      ...overrides,
-      id,
-    };
-    created.push(item);
-    return item;
-  };
-};
-
-export default createContextItemFactory;

package/src/mock/fixtures/create-context-items.ts

@@ -1,80 +0,0 @@
-import { Faker, en } from '@faker-js/faker';
-
-import type { ContextItem } from '../../types';
-import { stringToSeed } from './string-to-seed';
-
-/** 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 const createContextItems = (types: ContextTypeSeed[]): ContextItem[] =>
-  types.flatMap(({ type, count = 1, parentTypeIds, item }) =>
-    Array.from({ length: count }, (_, i): ContextItem => {
-      const index = i + 1;
-      const id = `${type.toLowerCase()}-${index}`;
-      const faker = new Faker({ seed: stringToSeed(id), locale: en });
-      return {
-        value: {},
-        title: faker.company.name(),
-        ...item?.(index),
-        id,
-        type: parentTypeIds ? { id: type, isChildType: true, parentTypeIds } : { id: type },
-      };
-    }),
-  );
-
-export default createContextItems;

package/src/mock/fixtures/index.ts

@@ -1,28 +0,0 @@
-/**
- * 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/src/mock/fixtures/string-to-seed.ts

@@ -1,18 +0,0 @@
-/**
- * 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 const stringToSeed = (value: string): number =>
-  // FNV-1a-style hash: fold each char in, keep the running hash unsigned 32-bit
-  [...value].reduce(
-    (hash, char) => Math.imul(hash ^ char.charCodeAt(0), 16777619) >>> 0,
-    2166136261,
-  );
-
-export default stringToSeed;