@equinor/fusion-framework-module-context 7.0.4-next.0 → 8.0.1

package/src/configurator.ts

@@ -8,7 +8,11 @@ import type {
 } 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 { getContextSelector, queryContextSelector, relatedContextSelector } from './selectors';
+import {
+  getContextSelector,
+  queryContextSelector,
+  relatedContextSelector,
+} from './get-context-selector';
 import type { QueryCtorOptions } from '@equinor/fusion-query';
 import type {
   ContextFilterFn,
@@ -21,87 +25,225 @@ import { ContextConfigBuilder, type ContextConfigBuilderCallback } from './Conte
 import type { IContextProvider } from './ContextProvider';
 import resolveInitialContext from './utils/resolve-initial-context';
 
+/**
+ * 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.
+ *
+ * @see ContextConfigBuilder — fluent API for populating this config.
+ * @see ContextProvider — runtime consumer of this config.
+ */
 export interface ContextModuleConfig {
+  /**
+   * Query client options used to fetch, search, and resolve related context items.
+   *
+   * - `get` — retrieves a single context item by ID.
+   * - `query` — searches context items by text and optional type filter.
+   * - `related` — fetches context items related to a given item (used during resolution).
+   */
   client: {
     get: QueryCtorOptions<ContextItem, GetContextParameters>;
     query: QueryCtorOptions<ContextItem[], QueryContextParameters>;
     related?: QueryCtorOptions<ContextItem[], RelatedContextParameters>;
   };
+
+  /**
+   * Allowed context type IDs (e.g. `['ProjectMaster', 'Facility']`).
+   *
+   * When set, {@link ContextProvider.validateContext} only accepts items
+   * whose `type.id` matches one of these values (case-insensitive).
+   */
   contextType?: string[];
+
+  /**
+   * Optional post-query filter applied to the result set returned by
+   * {@link ContextProvider.queryContext}.
+   */
   contextFilter?: ContextFilterFn;
 
   /**
-   * connect context module to paren context module.
+   * Whether to connect the context module to a parent context module.
+   *
+   * When `true` (the default), the provider subscribes to the parent's
+   * `currentContext$` and mirrors changes into its own state.
    *
-   * _default: `true`_
+   * @defaultValue `true`
    */
   connectParentContext?: boolean;
 
-  /** set initial context from parent, will await resolve */
+  /**
+   * When `true`, skips resolving an initial context from the path or parent
+   * during module post-initialization.
+   */
   skipInitialContext?: boolean;
 
+  /**
+   * Extracts a context ID from a URL path segment.
+   *
+   * Used during initial context resolution and deep-link support.
+   * If not provided, the default GUID-based extractor is used.
+   *
+   * @param path - The URL path to inspect.
+   * @returns The extracted context ID, or `undefined` if none is found.
+   */
   extractContextIdFromPath?: (path: string) => string | undefined;
+
+  /**
+   * Generates a URL path that embeds the given context item's ID.
+   *
+   * Used by navigation integrations to update the browser URL when
+   * the context changes.
+   *
+   * @param context - The active context item.
+   * @param path - The current URL path.
+   * @returns The updated path, or `undefined` to leave it unchanged.
+   */
   generatePathFromContext?: (context: ContextItem, path: string) => string | undefined;
 
   /**
-   * Method for generating context query parameters.
+   * Transforms a user search string and the configured context type into
+   * the query parameters sent to the context API.
+   *
+   * Override this to customise how free-text searches are mapped to the
+   * backend query contract.
    */
   contextParameterFn?: (args: {
     search: string;
     type: ContextModuleConfig['contextType'];
   }) => string | QueryContextParameters;
 
+  /**
+   * Custom context resolution strategy.
+   *
+   * Called with `this` bound to the {@link IContextProvider} when a context
+   * item fails validation and the caller requests resolution.
+   *
+   * @param item - The context item to resolve, or `null`.
+   * @returns An observable emitting the resolved context item.
+   */
   resolveContext?: (
     this: IContextProvider,
     item: ContextItem | null,
   ) => ReturnType<IContextProvider['resolveContext']>;
 
+  /**
+   * Custom context validation strategy.
+   *
+   * Called with `this` bound to the {@link IContextProvider} to decide
+   * whether a candidate context item is acceptable.
+   *
+   * @param item - The context item to validate, or `null`.
+   * @returns `true` if the item is valid.
+   */
   validateContext?: (
     this: IContextProvider,
     item: ContextItem | null,
   ) => ReturnType<IContextProvider['validateContext']>;
 
+  /**
+   * Resolves the initial context during module post-initialization.
+   *
+   * The default implementation tries to extract a context ID from the
+   * current navigation path, falling back to the parent provider's context.
+   *
+   * @param args - Module reference and instance map.
+   * @returns An observable input emitting the initial context item, or void.
+   */
   resolveInitialContext?: (args: {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // biome-ignore lint/suspicious/noExplicitAny: `AnyModuleInstance | any` intentionally widens to accept any module instance shape for `ref`
     ref?: AnyModuleInstance | any;
     modules: ModuleInstance;
+    // biome-ignore lint/suspicious/noConfusingVoidType: `void` here relies on TypeScript's special-cased "void-returning callback accepts any return value" behavior — `undefined` would break assignability of resolver functions that only conditionally emit a `ContextItem`
   }) => 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 class ContextModuleConfigurator implements IContextModuleConfigurator {
+  /** Default cache TTL (in ms) for context query results. */
   defaultExpireTime = 1 * 60 * 1000;
 
   #configBuilders: Array<ContextConfigBuilderCallback> = [];
 
+  /** @inheritdoc */
   addConfigBuilder(init: ContextConfigBuilderCallback): void {
     this.#configBuilders.push(init);
   }
 
+  /**
+   * 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 async _getServiceProvider(
     init: ModuleInitializerArgs<IContextModuleConfigurator, [ServicesModule]>,
   ): Promise<IApiProvider> {
+    // prefer the local services module instance if available
     if (init.hasModule('services')) {
       return init.requireInstance('services');
     }
     const parentServiceModule = (init.ref as ModulesInstanceType<[ServicesModule]>)?.services;
+    // fall back to the parent module's services instance
     if (!parentServiceModule) {
       throw Error('no service services provider configures [ServicesModule]');
     }
     return parentServiceModule;
   }
 
+  /**
+   * 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.
+   */
   public async createConfig(
     init: ModuleInitializerArgs<IContextModuleConfigurator, [ServicesModule, NavigationModule]>,
   ): Promise<ContextModuleConfig> {
+    // run each registered config builder in sequence, merging results into the accumulated config
     const config = await this.#configBuilders.reduce(
       async (cur, cb) => {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        // biome-ignore lint/suspicious/noExplicitAny: builder generics are erased here — `unknown` breaks assignability of the concrete `ContextConfigBuilder` instance passed to consumer callbacks
         const builder = new ContextConfigBuilder<any, any>(init, await cur);
         await Promise.resolve(cb(builder));
+        // Merge this builder's config into the accumulator for the next iteration.
         return Object.assign(cur, builder.config);
       },
       Promise.resolve({} as Partial<ContextModuleConfig>),
@@ -114,7 +256,7 @@ export class ContextModuleConfigurator implements IContextModuleConfigurator {
       },
     });
 
-    // TODO - make less lazy
+    // TODO(#5119) - make less lazy
     config.client ??= await (async (): Promise<ContextModuleConfig['client']> => {
       const apiProvider = await this._getServiceProvider(init);
       const contextClient = await apiProvider.createContextClient('json$');
@@ -130,7 +272,7 @@ export class ContextModuleConfigurator implements IContextModuleConfigurator {
           client: {
             fn: (query) => contextClient.query('v1', { query }, { selector: queryContextSelector }),
           },
-          // TODO - might cast to checksum
+          // TODO(#5118) - might cast to checksum
           key: (args) => JSON.stringify(args),
           expire: this.defaultExpireTime,
         },
@@ -144,7 +286,7 @@ export class ContextModuleConfigurator implements IContextModuleConfigurator {
               );
             },
           },
-          // TODO - might cast to checksum
+          // TODO(#5118) - might cast to checksum
           key: (args) => JSON.stringify(args),
           expire: this.defaultExpireTime,
         },

package/src/{errors.ts → errors/FusionContextSearchError.ts}

@@ -17,6 +17,7 @@ export class FusionContextSearchError extends Error {
 
   /**
    * The title of the error.
+   * @returns The error title.
    */
   get title(): string {
     return this.#details.title;
@@ -24,6 +25,7 @@ export class FusionContextSearchError extends Error {
 
   /**
    * 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;

package/src/errors/index.ts

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

package/src/get-context-selector.ts

@@ -0,0 +1,18 @@
+import type { GetContextResponse } from '@equinor/fusion-framework-module-services/context/get';
+
+import { parseContextItem } from './parse-context-item';
+import type { ContextItem } from './types';
+
+/**
+ * Parse the response from the GetContext API into a context item.
+ * @param response The response object containing the context item.
+ * @returns A promise that resolves to the context item.
+ */
+export const getContextSelector = async (response: Response): Promise<ContextItem> => {
+  const result = (await response.json()) as GetContextResponse<'v1'>;
+  return parseContextItem(result);
+};
+
+// Deliberately re-exported from here to preserve the package's existing selectors entry point
+export { queryContextSelector } from './query-context-selector';
+export { relatedContextSelector } from './related-context-selector';

package/src/index.ts

@@ -1,3 +1,16 @@
+/**
+ * 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,
   IContextModuleConfigurator,

package/src/module.ts

@@ -10,8 +10,19 @@ import { type IContextModuleConfigurator, ContextModuleConfigurator } from './co
 import { type IContextProvider, ContextProvider } from './ContextProvider';
 import type { ContextItem } from './types';
 
+/**
+ * Literal type identifying the context module within the Fusion Framework module system.
+ *
+ * Used as the key when registering or looking up the module in a `Modules` map.
+ */
 export type ContextModuleKey = 'context';
 
+/**
+ * Module registration key for the context module.
+ *
+ * Pass this value—or reference it as `contextModuleKey`—when you need to
+ * identify the context module by name at runtime (e.g., `hasModule(contextModuleKey)`).
+ */
 export const moduleKey: ContextModuleKey = 'context';
 
 /**

package/src/parse-context-item.ts

@@ -0,0 +1,39 @@
+import type {
+  ApiVersion,
+  ApiContextEntity,
+} from '@equinor/fusion-framework-module-services/context';
+import type { GetContextResponse } from '@equinor/fusion-framework-module-services/context/get';
+
+import type { ContextItem, ContextItemType } from './types';
+
+/**
+ * Parses the context type from the response of the GetContext API.
+ *
+ * @param type The type property from the GetContext response.
+ * @returns The parsed context item type.
+ */
+const parseContextType = (type: GetContextResponse<'v1'>['type']): ContextItemType => ({
+  id: type.id,
+  isChildType: type.isChildType,
+  parentTypeIds: type.parentTypeIds ?? [],
+});
+
+/**
+ * Parses an ApiContextEntity object into a ContextItem object.
+ * @param item The ApiContextEntity object to parse.
+ * @returns The parsed ContextItem object.
+ */
+export const parseContextItem = (item: ApiContextEntity<ApiVersion.v1>): ContextItem => {
+  return {
+    id: item.id,
+    externalId: item.externalId ?? undefined,
+    isActive: item.isActive,
+    isDeleted: item.isDeleted,
+    created: new Date(item.created),
+    source: item.source ?? undefined,
+    title: item.title ?? undefined,
+    type: parseContextType(item.type),
+    // TODO(#5115): parse and map the raw `value` payload into a typed context item value
+    value: item.value ?? {},
+  };
+};

package/src/query-context-selector.ts

@@ -0,0 +1,15 @@
+import type { QueryContextResponse } from '@equinor/fusion-framework-module-services/context/query';
+
+import { parseContextItem } from './parse-context-item';
+import type { ContextItem } from './types';
+
+/**
+ * Parse the response from the QueryContext API into an array of context items.
+ * @param response The response object.
+ * @returns A promise that resolves to an array of context items.
+ */
+export const queryContextSelector = async (response: Response): Promise<ContextItem[]> => {
+  const result = (await response.json()) as QueryContextResponse<'v1'>;
+  // parse each raw API entry into a ContextItem
+  return result.map(parseContextItem);
+};

package/src/related-context-selector.ts

@@ -0,0 +1,15 @@
+import type { RelatedContextResponse } from '@equinor/fusion-framework-module-services/context/related';
+
+import { parseContextItem } from './parse-context-item';
+import type { ContextItem } from './types';
+
+/**
+ * Parse the response from the RelatedContext API into an array of context items.
+ * @param response The response object containing the related context items.
+ * @returns A promise that resolves to an array of ContextItem objects.
+ */
+export const relatedContextSelector = async (response: Response): Promise<ContextItem[]> => {
+  const result = (await response.json()) as RelatedContextResponse<'v1'>;
+  // parse each raw API entry into a ContextItem
+  return result.map(parseContextItem);
+};

package/src/types.ts

@@ -16,7 +16,7 @@
  * @property graphic - Optional graphical representation, either as a string or an object containing type and content.
  * @property meta - Optional meta information, either as a string or an object containing type and content.
  *
- * @todo - convert to Zod schema for validation and type safety.
+ * @todo(#5122) - convert to Zod schema for validation and type safety.
  */
 export type ContextItem<TType extends Record<string, unknown> = Record<string, unknown>> = {
   id: string;
@@ -44,12 +44,34 @@ export type ContextItem<TType extends Record<string, unknown> = Record<string, u
       };
 };
 
+/**
+ * Describes the type classification of a {@link ContextItem}.
+ *
+ * Every context item carries a `type` that identifies what kind of
+ * entity it represents (e.g. `ProjectMaster`, `Facility`, `Contract`).
+ * The optional hierarchy fields indicate parent–child relationships
+ * between context types.
+ */
 export interface ContextItemType {
+  /** Unique identifier for the context type (e.g. `'ProjectMaster'`). */
   id: string;
+  /** Whether this type is a child of another context type. */
   isChildType?: boolean;
+  /** IDs of parent context types, when `isChildType` is `true`. */
   parentTypeIds?: string[];
 }
 
+/**
+ * Parameters for querying context items from the context API.
+ *
+ * Used by {@link ContextProvider.queryContext} and the underlying
+ * query client to search and filter context results.
+ *
+ * @property search - Free-text search term.
+ * @property filter - Optional structured filters.
+ * @property filter.type - Restrict results to specific context type IDs.
+ * @property filter.externalId - Filter by an external system identifier.
+ */
 export type QueryContextParameters = {
   search?: string;
   filter?: {

package/src/utils/extract-context-id-from-path.ts

@@ -0,0 +1,30 @@
+// GUID pattern
+const matchGUID =
+  /^(?:(?:[0-9a-fA-F]){8}-(?:[0-9a-fA-F]){4}-(?:[0-9a-fA-F]){4}-(?:[0-9a-fA-F]){4}-(?:[0-9a-fA-F]){12})$/;
+
+/**
+ * Method will try to extract a context id from a path.
+ * The default matcher is a GUID pattern.
+ * Will iterate over the path and return the first match.
+ *
+ * @example
+ * ```ts
+ * const path = '/apps/context/7fd97952-7fe6-409b-a6dc-292dbf0e50d7?dsadasdas#example';
+ * const contextId = extractContextIdFromPath(path); // '7fd97952-7fe6-409b-a6dc-292dbf0e50d7'
+ * ```
+ *
+ * @param path string - the path to extract the context id from
+ * @param matcher RegExp - the pattern to match against
+ * @returns string | undefined - the context id or undefined
+ */
+export const extractContextIdFromPath = (
+  path: string,
+  matcher: RegExp = matchGUID,
+): string | undefined =>
+  path
+    // remove leading slashes
+    .replace(/^\/+/, '')
+    // split path by slashes
+    .split('/')
+    // find the first path fragment that matches the matcher
+    .find((x) => x.match(matcher));

package/src/utils/index.ts

@@ -1,3 +1,13 @@
+/**
+ * Utility functions for context module configuration and initialization.
+ *
+ * - {@link enableContext} — register the context module on a configurator.
+ * - {@link resolveInitialContext} — default initial-context resolver (path → parent fallback).
+ * - {@link extractContextIdFromPath} — extract a GUID context ID from a URL path.
+ * - {@link resolveContextFromPath} — resolve a context item from a URL path.
+ *
+ * @packageDocumentation
+ */
 export { enableContext } from './enable-context';
 export { resolveInitialContext } from './resolve-initial-context';
 export { extractContextIdFromPath, resolveContextFromPath } from './resolve-context-from-path';

package/src/utils/resolve-context-from-path.ts

@@ -4,6 +4,9 @@ import type { ModuleType } from '@equinor/fusion-framework-module';
 
 import type { ContextModule } from '../module';
 import type { ContextItem } from '../types';
+import { extractContextIdFromPath } from './extract-context-id-from-path';
+
+export { extractContextIdFromPath } from './extract-context-id-from-path';
 
 /**
  * Arguments for resolving a context from a path.
@@ -23,37 +26,10 @@ export type ContextPathResolveArgs = {
   validate?: (contextId: string) => boolean;
 };
 
-// GUID pattern
+// GUID pattern, used as the default context id validator
 const matchGUID =
   /^(?:(?:[0-9a-fA-F]){8}-(?:[0-9a-fA-F]){4}-(?:[0-9a-fA-F]){4}-(?:[0-9a-fA-F]){4}-(?:[0-9a-fA-F]){12})$/;
 
-/**
- * Method will try to extract a context id from a path.
- * The default matcher is a GUID pattern.
- * Will iterate over the path and return the first match.
- *
- * @example
- * ```ts
- * const path = '/apps/context/7fd97952-7fe6-409b-a6dc-292dbf0e50d7?dsadasdas#example';
- * const contextId = extractContextIdFromPath(path); // '7fd97952-7fe6-409b-a6dc-292dbf0e50d7'
- * ```
- *
- * @param path string - the path to extract the context id from
- * @param matcher RegExp - the pattern to match against
- * @returns string | undefined - the context id or undefined
- */
-export const extractContextIdFromPath = (
-  path: string,
-  matcher: RegExp = matchGUID,
-): string | undefined =>
-  path
-    // remove leading slashes
-    .replace(/^\/+/, '')
-    // split path by slashes
-    .split('/')
-    // find the first path fragment that matches the matcher
-    .find((x) => x.match(matcher));
-
 const validateContextId = (contextId: string): boolean => !!contextId.match(matchGUID);
 
 /**
@@ -104,6 +80,13 @@ export function resolveContextFromPath(
   args?: ContextPathResolveArgs,
 ): (path: string) => Observable<ContextItem>;
 
+/**
+ * Resolves a context item from a path, using the provided extract/validate callbacks or the defaults.
+ * @param context The context module.
+ * @param args The arguments for resolving the path.
+ * @returns A function that takes a path and returns an Observable of the resolved context item.
+ * @throws Error if the extracted context id fails validation.
+ */
 export function resolveContextFromPath(
   context: ModuleType<ContextModule>,
   args?: ContextPathResolveArgs,
@@ -111,9 +94,11 @@ export function resolveContextFromPath(
   return (path: string) => {
     const { extract = extractContextIdFromPath, validate = validateContextId } = args ?? {};
     const contextId = extract(path);
+    // no context id found in the path, nothing to resolve
     if (!contextId) {
       return EMPTY;
     }
+    // only resolve the context if the extracted id passes validation
     if (validate(contextId)) {
       return context.contextClient.resolveContext(contextId);
     }

package/src/utils/resolve-initial-context.ts

@@ -30,6 +30,8 @@ export const resolveContextFromParent: ContextModuleConfig['resolveInitialContex
  * @param options - Optional configuration for resolving the context path.
  * @returns A function that accepts the module's reference and modules, and returns an Observable of the resolved initial context.
  */
+// Deliberately co-located with resolveContextFromParent, which it composes with
+// fusion-lint-disable-next-line single-export-per-file
 export const resolveInitialContext =
   (options?: {
     path?: ContextPathResolveArgs;

package/src/version.ts

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

package/dist/esm/errors.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,OAAO,wBAAyB,SAAQ,KAAK;IACjD,QAAQ,CAAC;IAET;;OAEG;IACH,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;IAC7B,CAAC;IAED;;OAEG;IACH,IAAI,WAAW;QACb,OAAO,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC;IACnC,CAAC;IAED;;;;OAIG;IACH,YACE,OASC,EACD,OAAsB;QAEtB,KAAK,CAAC,OAAO,CAAC,WAAW,IAAI,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACrD,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;QACxB,IAAI,CAAC,IAAI,GAAG,0BAA0B,CAAC;IACzC,CAAC;CACF"}

package/dist/esm/selectors.js

@@ -1,58 +0,0 @@
-/**
- * Parses the context type from the response of the GetContext API.
- *
- * @param type The type property from the GetContext response.
- * @returns The parsed context item type.
- */
-const parseContextType = (type) => ({
-    id: type.id,
-    isChildType: type.isChildType,
-    parentTypeIds: type.parentTypeIds ?? [],
-});
-/**
- * Parses an ApiContextEntity object into a ContextItem object.
- * @param item The ApiContextEntity object to parse.
- * @returns The parsed ContextItem object.
- */
-const parseContextItem = (item) => {
-    return {
-        id: item.id,
-        externalId: item.externalId ?? undefined,
-        isActive: item.isActive,
-        isDeleted: item.isDeleted,
-        created: new Date(item.created),
-        source: item.source ?? undefined,
-        title: item.title ?? undefined,
-        type: parseContextType(item.type),
-        // TODO
-        value: item.value ?? {},
-    };
-};
-/**
- * Parse the response from the GetContext API into a context item.
- * @param response The response object containing the context item.
- * @returns A promise that resolves to the context item.
- */
-export const getContextSelector = async (response) => {
-    const result = (await response.json());
-    return parseContextItem(result);
-};
-/**
- * Parse the response from the QueryContext API into an array of context items.
- * @param response The response object.
- * @returns A promise that resolves to an array of context items.
- */
-export const queryContextSelector = async (response) => {
-    const result = (await response.json());
-    return result.map(parseContextItem);
-};
-/**
- * Parse the response from the RelatedContext API into an array of context items.
- * @param response The response object containing the related context items.
- * @returns A promise that resolves to an array of ContextItem objects.
- */
-export const relatedContextSelector = async (response) => {
-    const result = (await response.json());
-    return result.map(parseContextItem);
-};
-//# sourceMappingURL=selectors.js.map

package/dist/esm/selectors.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"selectors.js","sourceRoot":"","sources":["../../src/selectors.ts"],"names":[],"mappings":"AASA;;;;;GAKG;AACH,MAAM,gBAAgB,GAAG,CAAC,IAAsC,EAAmB,EAAE,CAAC,CAAC;IACrF,EAAE,EAAE,IAAI,CAAC,EAAE;IACX,WAAW,EAAE,IAAI,CAAC,WAAW;IAC7B,aAAa,EAAE,IAAI,CAAC,aAAa,IAAI,EAAE;CACxC,CAAC,CAAC;AAEH;;;;GAIG;AACH,MAAM,gBAAgB,GAAG,CAAC,IAAqC,EAAe,EAAE;IAC9E,OAAO;QACL,EAAE,EAAE,IAAI,CAAC,EAAE;QACX,UAAU,EAAE,IAAI,CAAC,UAAU,IAAI,SAAS;QACxC,QAAQ,EAAE,IAAI,CAAC,QAAQ;QACvB,SAAS,EAAE,IAAI,CAAC,SAAS;QACzB,OAAO,EAAE,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC;QAC/B,MAAM,EAAE,IAAI,CAAC,MAAM,IAAI,SAAS;QAChC,KAAK,EAAE,IAAI,CAAC,KAAK,IAAI,SAAS;QAC9B,IAAI,EAAE,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC;QACjC,OAAO;QACP,KAAK,EAAE,IAAI,CAAC,KAAK,IAAI,EAAE;KACxB,CAAC;AACJ,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,KAAK,EAAE,QAAkB,EAAwB,EAAE;IACnF,MAAM,MAAM,GAAG,CAAC,MAAM,QAAQ,CAAC,IAAI,EAAE,CAA6B,CAAC;IACnE,OAAO,gBAAgB,CAAC,MAAM,CAAC,CAAC;AAClC,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,KAAK,EAAE,QAAkB,EAA0B,EAAE;IACvF,MAAM,MAAM,GAAG,CAAC,MAAM,QAAQ,CAAC,IAAI,EAAE,CAA+B,CAAC;IACrE,OAAO,MAAM,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;AACtC,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,KAAK,EAAE,QAAkB,EAA0B,EAAE;IACzF,MAAM,MAAM,GAAG,CAAC,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAiC,CAAC;IACvE,OAAO,MAAM,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;AACtC,CAAC,CAAC"}