@equinor/fusion-framework-module-context 0.0.0-context-error-20240131144633

package/dist/types/ContextProvider.d.ts

@@ -0,0 +1,99 @@
+import { Observable, Subscription } from 'rxjs';
+import { ContextModuleConfig } from './configurator';
+import { ContextClient } from './client/ContextClient';
+import { ContextItem, QueryContextParameters, RelatedContextParameters } from './types';
+import { ModuleType } from '@equinor/fusion-framework-module';
+import { EventModule, FrameworkEvent, FrameworkEventInit } from '@equinor/fusion-framework-module-event';
+import Query from '@equinor/fusion-query';
+export interface IContextProvider {
+    readonly contextClient: ContextClient;
+    readonly queryClient: Query<ContextItem[], QueryContextParameters>;
+    readonly currentContext$: Observable<ContextItem | null | undefined>;
+    currentContext: ContextItem | null | undefined;
+    queryContext(search: string): Observable<Array<ContextItem>>;
+    queryContextAsync(search: string): Promise<Array<ContextItem>>;
+    validateContext(item: ContextItem<Record<string, unknown>>): boolean;
+    resolveContext: (current: ContextItem) => Observable<ContextItem>;
+    resolveContextAsync: (current: ContextItem) => Promise<ContextItem>;
+    relatedContexts: (args: RelatedContextParameters) => Observable<Array<ContextItem<Record<string, unknown>>>>;
+    relatedContextsAsync: (args: RelatedContextParameters) => Promise<Array<ContextItem<Record<string, unknown>>>>;
+    clearCurrentContext: VoidFunction;
+    setCurrentContextById(id: string): Observable<ContextItem<Record<string, unknown>>>;
+    setCurrentContextByIdAsync(id: string): Promise<ContextItem<Record<string, unknown>>>;
+    setCurrentContext(context: ContextItem<Record<string, unknown>> | null, opt?: {
+        validate?: boolean;
+        resolve?: boolean;
+    }): Observable<ContextItem<Record<string, unknown>> | null>;
+    setCurrentContextAsync(context: ContextItem<Record<string, unknown>> | null, opt?: {
+        validate?: boolean;
+        resolve?: boolean;
+    }): Promise<ContextItem<Record<string, unknown>> | null>;
+}
+export declare class ContextProvider implements IContextProvider {
+    #private;
+    get contextClient(): ContextClient;
+    get queryClient(): Query<ContextItem[], QueryContextParameters>;
+    get currentContext$(): Observable<ContextItem | null | undefined>;
+    get currentContext(): ContextItem | undefined | null;
+    set currentContext(context: ContextItem | null | undefined);
+    constructor(args: {
+        config: ContextModuleConfig;
+        event?: ModuleType<EventModule>;
+        parentContext?: IContextProvider;
+    });
+    connectParentContext(provider: IContextProvider, opt?: {
+        skipFirst: boolean;
+    }): Subscription;
+    setCurrentContextById(id: string): Observable<ContextItem<Record<string, unknown>>>;
+    setCurrentContextByIdAsync(id: string): Promise<ContextItem<Record<string, unknown>>>;
+    setCurrentContext<T extends ContextItem<Record<string, unknown>> | null>(context: T, opt?: {
+        validate?: boolean;
+        resolve?: boolean;
+    }): Observable<T>;
+    protected _setCurrentContext<T extends ContextItem<Record<string, unknown>> | null>(context: T, opt?: {
+        validate?: boolean;
+        resolve?: boolean;
+    }): Observable<T>;
+    setCurrentContextAsync<T extends ContextItem<Record<string, unknown>> | null>(context: T, opt?: {
+        validate?: boolean;
+        resolve?: boolean;
+    }): Promise<T>;
+    queryContext(search: string): Observable<Array<ContextItem>>;
+    queryContextAsync(search: string): Promise<Array<ContextItem>>;
+    validateContext(item: ContextItem<Record<string, unknown>>): boolean;
+    resolveContext(item: ContextItem<Record<string, unknown>>): Observable<ContextItem<Record<string, unknown>>>;
+    resolveContextAsync(item: ContextItem<Record<string, unknown>>): Promise<ContextItem<Record<string, unknown>>>;
+    relatedContexts(args: RelatedContextParameters): Observable<Array<ContextItem<Record<string, unknown>>>>;
+    relatedContextsAsync(args: RelatedContextParameters): Promise<Array<ContextItem<Record<string, unknown>>>>;
+    clearCurrentContext(): void;
+    dispose(): void;
+}
+export default ContextProvider;
+declare module '@equinor/fusion-framework-module-event' {
+    interface FrameworkEventMap {
+        onCurrentContextChange: FrameworkEvent<FrameworkEventInit<{
+            context: ContextItem | null;
+        }, IContextProvider>>;
+        onCurrentContextChanged: FrameworkEvent<FrameworkEventInit<{
+            next: ContextItem | null;
+            previous?: ContextItem | null;
+        }, IContextProvider>>;
+        onParentContextChanged: FrameworkEvent<FrameworkEventInit<{
+            context: ContextItem | null;
+        }, IContextProvider>>;
+        onSetContextResolve: FrameworkEvent<FrameworkEventInit<{
+            context: ContextItem;
+        }, IContextProvider>>;
+        onSetContextResolved: FrameworkEvent<FrameworkEventInit<{
+            context: ContextItem;
+            resolved?: ContextItem | null;
+        }, IContextProvider>>;
+        onSetContextValidationFailed: FrameworkEvent<FrameworkEventInit<{
+            context: ContextItem;
+        }, IContextProvider>>;
+        onSetContextResolveFailed: FrameworkEvent<FrameworkEventInit<{
+            context: ContextItem;
+            error: unknown;
+        }, IContextProvider>>;
+    }
+}

package/dist/types/client/ContextClient.d.ts

@@ -0,0 +1,22 @@
+import { Observable } from 'rxjs';
+import { Query, QueryCtorOptions } from '@equinor/fusion-query';
+import { ContextItem } from '../types';
+export type GetContextParameters = {
+    id: string;
+};
+export declare class ContextClient extends Observable<ContextItem | null> {
+    #private;
+    get currentContext(): ContextItem | null | undefined;
+    get currentContext$(): Observable<ContextItem | null | undefined>;
+    get client(): Query<ContextItem, {
+        id: string;
+    }>;
+    constructor(options: QueryCtorOptions<ContextItem, GetContextParameters>);
+    setCurrentContext(idOrItem?: string | ContextItem | null): void;
+    resolveContext(id: string): Observable<ContextItem>;
+    resolveContextAsync(id: string, opt?: {
+        awaitResolve: boolean;
+    }): Promise<ContextItem>;
+    dispose(): void;
+}
+export default ContextClient;

package/dist/types/configurator.d.ts

@@ -0,0 +1,41 @@
+import { ObservableInput } from 'rxjs';
+import { AnyModuleInstance, ModuleInitializerArgs, ModuleInstance } from '@equinor/fusion-framework-module';
+import { ServicesModule, IApiProvider } from '@equinor/fusion-framework-module-services';
+import { NavigationModule } from '@equinor/fusion-framework-module-navigation';
+import { QueryCtorOptions } from '@equinor/fusion-query';
+import { ContextFilterFn, ContextItem, QueryContextParameters, RelatedContextParameters } from './types';
+import { GetContextParameters } from './client/ContextClient';
+import { ContextConfigBuilderCallback } from './ContextConfigBuilder';
+import { type IContextProvider } from './ContextProvider';
+export interface ContextModuleConfig {
+    client: {
+        get: QueryCtorOptions<ContextItem, GetContextParameters>;
+        query: QueryCtorOptions<ContextItem[], QueryContextParameters>;
+        related?: QueryCtorOptions<ContextItem[], RelatedContextParameters>;
+    };
+    contextType?: string[];
+    contextFilter?: ContextFilterFn;
+    connectParentContext?: boolean;
+    skipInitialContext?: boolean;
+    contextParameterFn?: (args: {
+        search: string;
+        type: ContextModuleConfig['contextType'];
+    }) => string | QueryContextParameters;
+    resolveContext?: (this: IContextProvider, item: ContextItem | null) => ReturnType<IContextProvider['resolveContext']>;
+    validateContext?: (this: IContextProvider, item: ContextItem | null) => ReturnType<IContextProvider['validateContext']>;
+    resolveInitialContext?: (args: {
+        ref?: AnyModuleInstance | any;
+        modules: ModuleInstance;
+    }) => ObservableInput<ContextItem | void>;
+}
+export interface IContextModuleConfigurator {
+    addConfigBuilder: (init: ContextConfigBuilderCallback) => void;
+}
+export declare class ContextModuleConfigurator implements IContextModuleConfigurator {
+    #private;
+    defaultExpireTime: number;
+    addConfigBuilder(init: ContextConfigBuilderCallback): void;
+    protected _getServiceProvider(init: ModuleInitializerArgs<IContextModuleConfigurator, [ServicesModule]>): Promise<IApiProvider>;
+    createConfig(init: ModuleInitializerArgs<IContextModuleConfigurator, [ServicesModule, NavigationModule]>): Promise<ContextModuleConfig>;
+}
+export default ContextModuleConfigurator;

package/dist/types/errors.d.ts

@@ -0,0 +1,8 @@
+export declare class FusionContextSearchError extends Error {
+    #private;
+    get title(): string;
+    constructor(details: {
+        title: string;
+        description?: string;
+    }, options?: ErrorOptions);
+}

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export { ContextModuleConfigurator, IContextModuleConfigurator, ContextModuleConfig, } from './configurator';
+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/dist/types/module.d.ts

@@ -0,0 +1,20 @@
+import { Module } from '@equinor/fusion-framework-module';
+import { EventModule } from '@equinor/fusion-framework-module-event';
+import { ServicesModule } from '@equinor/fusion-framework-module-services';
+import { NavigationModule } from '@equinor/fusion-framework-module-navigation';
+import { IContextModuleConfigurator } from './configurator';
+import { IContextProvider } from './ContextProvider';
+export type ContextModuleKey = 'context';
+export declare const moduleKey: ContextModuleKey;
+export type ContextModule = Module<ContextModuleKey, IContextProvider, IContextModuleConfigurator, [
+    ServicesModule,
+    EventModule,
+    NavigationModule
+]>;
+export declare const module: ContextModule;
+declare module '@equinor/fusion-framework-module' {
+    interface Modules {
+        context: ContextModule;
+    }
+}
+export default module;

package/dist/types/selectors.d.ts

@@ -0,0 +1,4 @@
+import type { ContextItem } from './types';
+export declare const getContextSelector: (response: Response) => Promise<ContextItem>;
+export declare const queryContextSelector: (response: Response) => Promise<ContextItem[]>;
+export declare const relatedContextSelector: (response: Response) => Promise<ContextItem[]>;

package/dist/types/types.d.ts

@@ -0,0 +1,34 @@
+export type ContextItem<TType extends Record<string, unknown> = Record<string, unknown>> = {
+    id: string;
+    externalId?: string;
+    source?: string;
+    type: ContextItemType;
+    value: TType;
+    title?: string;
+    subTitle?: string;
+    isActive?: boolean;
+    isDeleted?: boolean;
+    created?: Date;
+    updated?: Date;
+    graphic?: string;
+    meta?: string;
+};
+export interface ContextItemType {
+    id: string;
+    isChildType?: boolean;
+    parentTypeIds?: string[];
+}
+export type QueryContextParameters = {
+    search?: string;
+    filter?: {
+        type?: string[];
+        externalId?: string;
+    };
+};
+export type RelatedContextParameters = {
+    item: ContextItem;
+    filter?: {
+        type?: string[];
+    };
+};
+export type ContextFilterFn = (items: ContextItem[]) => ContextItem[];

package/dist/types/utils/enable-context.d.ts

@@ -0,0 +1,4 @@
+import type { IModulesConfigurator, AnyModule, ModuleInitializerArgs } from '@equinor/fusion-framework-module';
+import type { IContextModuleConfigurator } from '../configurator';
+import type { ContextConfigBuilder } from '../ContextConfigBuilder';
+export declare const enableContext: (configurator: IModulesConfigurator<any, any>, builder?: (<TDeps extends AnyModule[] = []>(builder: ContextConfigBuilder<TDeps, ModuleInitializerArgs<IContextModuleConfigurator, TDeps>>) => void | Promise<void>) | undefined) => void;

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

@@ -0,0 +1,2 @@
+export { enableContext } from './enable-context';
+export { resolveInitialContext } from './resolve-initial-context';

package/dist/types/utils/resolve-context-from-path.d.ts

@@ -0,0 +1,8 @@
+import { ModuleType } from '@equinor/fusion-framework-module';
+import { type ContextModule } from '../module';
+export type ContextPathResolveArgs = {
+    extract?: (path: string) => string | undefined;
+    validate?: (contextId: string) => boolean;
+};
+export declare const resolveContextFromPath: (context: ModuleType<ContextModule>, args?: ContextPathResolveArgs) => (path: string) => import("rxjs").Observable<import("..").ContextItem>;
+export default resolveContextFromPath;

package/dist/types/utils/resolve-initial-context.d.ts

@@ -0,0 +1,7 @@
+import { type ContextModuleConfig } from '../configurator';
+import { ContextPathResolveArgs } from './resolve-context-from-path';
+export declare const resolveContextFromParent: ContextModuleConfig['resolveInitialContext'];
+export declare const resolveInitialContext: (options?: {
+    path?: ContextPathResolveArgs;
+}) => Required<ContextModuleConfig>['resolveInitialContext'];
+export default resolveInitialContext;

package/dist/types/version.d.ts

@@ -0,0 +1 @@
+export declare const version = "4.0.19";

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@equinor/fusion-framework-module-context",
+  "version": "0.0.0-context-error-20240131144633",
+  "description": "",
+  "main": "./dist/esm/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "types": "./dist/types/index.d.ts"
+    },
+    "./errors.js": {
+      "import": "./dist/esm/errors.js",
+      "types": "./dist/types/errors.d.ts"
+    },
+    "./package.json": "./package.json",
+    "./utils": {
+      "import": "./dist/esm/utils/index.js",
+      "types": "./dist/types/utils/index.d.ts"
+    }
+  },
+  "types": "index.d.ts",
+  "typesVersions": {
+    ">=4.2": {
+      "*": [
+        "dist/types/*"
+      ],
+      "utils": [
+        "dist/types/utils/index.d.ts"
+      ],
+      "./errors.js": [
+        ".dist/types/errors.d.ts"
+      ]
+    }
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/equinor/fusion-framework.git",
+    "directory": "packages/modules/context"
+  },
+  "dependencies": {
+    "fast-deep-equal": "^3.1.3",
+    "@equinor/fusion-query": "^4.0.5"
+  },
+  "devDependencies": {
+    "rxjs": "^7.8.1",
+    "typescript": "^5.1.3",
+    "@equinor/fusion-framework-module": "^4.2.6",
+    "@equinor/fusion-framework-module-event": "^4.0.7",
+    "@equinor/fusion-framework-module-navigation": "^3.1.3",
+    "@equinor/fusion-framework-module-services": "^3.2.3"
+  },
+  "peerDependencies": {
+    "rxjs": "^7.8.1",
+    "@equinor/fusion-framework-module": "^4.2.6"
+  },
+  "scripts": {
+    "build": "tsc -b"
+  }
+}

package/src/ContextConfigBuilder.ts

@@ -0,0 +1,131 @@
+import type {
+    AnyModule,
+    ModuleInitializerArgs,
+    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 { ContextItem, QueryContextParameters, RelatedContextParameters } from './types';
+
+export type ContextConfigBuilderCallback = <TDeps extends Array<AnyModule> = []>(
+    builder: ContextConfigBuilder<TDeps, ModuleInitializerArgs<IContextModuleConfigurator, TDeps>>,
+) => void | Promise<void>;
+
+export class ContextConfigBuilder<
+    TModules extends Array<AnyModule> = [],
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    TInit extends ModuleInitializerArgs<any, any> = ModuleInitializerArgs<
+        ContextModuleConfigurator,
+        TModules
+    >,
+> {
+    #init: TInit;
+    constructor(
+        init: TInit,
+        public config: Partial<ContextModuleConfig> = {},
+    ) {
+        this.#init = init;
+    }
+
+    requireInstance<TKey extends string = Extract<keyof Modules, string>>(
+        module: TKey,
+    ): Promise<ModuleType<Modules[TKey]>>;
+
+    requireInstance<T>(module: string): Promise<T>;
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    requireInstance(module: string): Promise<any> {
+        return this.#init.requireInstance(module);
+    }
+
+    setContextType(type: ContextModuleConfig['contextType']) {
+        this.config.contextType = type;
+    }
+
+    setContextFilter(filter: ContextModuleConfig['contextFilter']) {
+        this.config.contextFilter = filter;
+    }
+
+    connectParentContext(connect: ContextModuleConfig['connectParentContext']) {
+        this.config.connectParentContext = connect;
+    }
+
+    setContextParameterFn(fn: ContextModuleConfig['contextParameterFn']) {
+        this.config.contextParameterFn = fn;
+    }
+
+    setValidateContext(fn: ContextModuleConfig['validateContext']) {
+        this.config.validateContext = fn;
+    }
+
+    setResolveContext(fn: ContextModuleConfig['resolveContext']) {
+        this.config.resolveContext = fn;
+    }
+
+    setResolveInitialContext(fn: ContextModuleConfig['resolveInitialContext']) {
+        this.config.resolveInitialContext = fn;
+    }
+
+    setContextClient(
+        client: {
+            get:
+                | QueryFn<ContextItem, GetContextParameters>
+                | QueryCtorOptions<ContextItem, GetContextParameters>;
+            query:
+                | QueryFn<ContextItem[], QueryContextParameters>
+                | QueryCtorOptions<ContextItem[], QueryContextParameters>;
+            related?:
+                | QueryFn<ContextItem[], RelatedContextParameters>
+                | QueryCtorOptions<ContextItem[], RelatedContextParameters>;
+        },
+        expire = 1 * 60 * 1000,
+    ): void {
+        this.config.client = {
+            get:
+                typeof client.get === 'function'
+                    ? {
+                          key: ({ id }) => id,
+                          client: {
+                              fn: client.get,
+                          },
+                          expire,
+                      }
+                    : client.get,
+            query:
+                typeof client.query === 'function'
+                    ? {
+                          // TODO - might cast to checksum
+                          key: (args) => JSON.stringify(args),
+                          client: {
+                              fn: client.query,
+                          },
+                          expire,
+                      }
+                    : client.query,
+        };
+        if (client.related) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            this.config.client!.related =
+                typeof client.related === 'function'
+                    ? {
+                          // TODO - might cast to checksum
+                          key: (args) => JSON.stringify(args),
+                          client: {
+                              fn: client.related,
+                          },
+                          expire,
+                      }
+                    : client.related;
+        }
+    }
+}