@equinor/fusion-framework-react-components-people-provider 1.0.1 → 1.1.0

package/dist/types/PeopleResolver.d.ts

@@ -1,4 +1,5 @@
 import { PersonResolver } from '@equinor/fusion-wc-person';
-export declare const PeopleResolver: (props: React.PropsWithChildren<{
+export { PersonResolver };
+export declare const PeopleResolverComponent: (props: React.PropsWithChildren<{
     resolver: PersonResolver;
 }>) => import("react/jsx-runtime").JSX.Element;

package/dist/types/PeopleResolverProvider.d.ts

@@ -1,4 +1,7 @@
-export declare const PeopleResolverProvider: ({ children }: {
-    readonly children?: React.ReactNode;
-}) => import("react/jsx-runtime").JSX.Element;
+import { PropsWithChildren } from 'react';
+import { PersonControllerOptions } from './PersonController';
+type PeopleResolverProviderProps = PropsWithChildren<{
+    readonly options?: PersonControllerOptions;
+}>;
+export declare const PeopleResolverProvider: (props: PeopleResolverProviderProps) => import("react/jsx-runtime").JSX.Element;
 export default PeopleResolverProvider;

package/dist/types/PersonController.d.ts

@@ -14,28 +14,41 @@ type MatcherArgs = {
     upn?: string;
     azureId: string;
 };
+type ResolverArgs<T> = T extends object ? {
+    [K in keyof T]: T[K];
+} & {
+    signal?: AbortSignal;
+} : {
+    signal?: AbortSignal;
+};
 export interface IPersonController {
-    getPerson(args: MatcherArgs): Observable<GetPersonResult>;
-    getPersonInfo(args: MatcherArgs): Observable<ApiPerson<'v2'>>;
-    getPhoto(args: MatcherArgs): Observable<string>;
-    search(args: {
+    getPerson(args: ResolverArgs<MatcherArgs>): Observable<GetPersonResult>;
+    getPersonInfo(args: ResolverArgs<MatcherArgs>): Observable<ApiPerson<'v2'>>;
+    getPhoto(args: ResolverArgs<MatcherArgs>): Observable<string>;
+    search(args: ResolverArgs<{
         search: string;
-    }): Observable<PersonSearchResult>;
+    }>): Observable<PersonSearchResult>;
 }
+export type PersonControllerOptions = {
+    fallbackImage?: Blob;
+};
 export declare class PersonController implements IPersonController {
     #private;
-    constructor(client: PeopleApiClient);
-    getPhoto(args: MatcherArgs): Observable<string>;
-    getPerson(args: MatcherArgs): Observable<GetPersonResult>;
-    getPersonInfo(args: MatcherArgs): Observable<ApiPerson<'v2'>>;
+    constructor(client: PeopleApiClient, options?: PersonControllerOptions);
     search(args: {
         search: string;
+        signal?: AbortSignal;
     }): Observable<PersonSearchResult>;
-    protected _getPersonById(azureId: string): Observable<GetPersonResult>;
-    protected _getPersonInfoById(azureId: string): Observable<ApiPerson<'v2'>>;
-    protected _getPersonByUpn(upn: string): Observable<GetPersonResult>;
-    protected _getPersonInfoByUpn(upn: string): Observable<ApiPerson<'v2'>>;
+    getPhoto(args: ResolverArgs<MatcherArgs>): Observable<string>;
+    getPerson(args: ResolverArgs<MatcherArgs>): Observable<GetPersonResult>;
+    getPersonInfo(args: ResolverArgs<MatcherArgs>): Observable<ApiPerson<'v2'>>;
+    protected _getPersonByUpn(upn: string, signal?: AbortSignal): Observable<GetPersonResult>;
+    _getPersonByAzureId(azureId: string, signal?: AbortSignal): Observable<GetPersonResult>;
+    protected _getPersonInfoById(azureId: string, signal?: AbortSignal): Observable<ApiPerson<'v2'>>;
+    protected _getPersonInfoByUpn(upn: string, signal?: AbortSignal): Observable<ApiPerson<'v2'>>;
+    protected _getPersonPhotoByAzureId(azureId: string, signal?: AbortSignal): Observable<string>;
+    protected _getPersonPhotoByUpn(upn: string, signal?: AbortSignal): Observable<string>;
     protected _personCache$(args: MatcherArgs): Observable<GetPersonResult>;
-    protected _queryCache$(args: MatcherArgs): Observable<import("@equinor/fusion-framework-module-services/people/api-models.v2").ApiPerson_v2>;
+    protected _queryCache$(args: MatcherArgs): Observable<ApiPerson<'v2'>>;
 }
 export {};

package/dist/types/makeResolver.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="react" />
+import { PersonControllerOptions } from './PersonController';
 import { IApiProvider } from '@equinor/fusion-framework-module-services';
-export declare const makeResolver: (services: IApiProvider) => import("react").LazyExoticComponent<({ children }: {
+export declare const makeResolver: (services: IApiProvider, options?: PersonControllerOptions) => import("react").LazyExoticComponent<({ children }: {
     readonly children?: React.ReactNode;
 }) => import("react/jsx-runtime").JSX.Element>;

package/dist/types/version.d.ts

@@ -1 +1 @@
-export declare const version = "1.0.1";
+export declare const version = "1.1.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@equinor/fusion-framework-react-components-people-provider",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "",
   "main": "dist/esm/index.js",
   "exports": {
@@ -20,20 +20,20 @@
   },
   "dependencies": {
     "rxjs": "^7.8.1",
-    "@equinor/fusion-framework-react": "^5.3.1",
+    "@equinor/fusion-framework-module-services": "^3.2.2",
+    "@equinor/fusion-framework-react": "^5.3.2",
     "@equinor/fusion-framework-react-module": "^3.0.6",
-    "@equinor/fusion-framework-react-module-bookmark": "^2.0.19",
-    "@equinor/fusion-query": "^4.0.1"
+    "@equinor/fusion-framework-react-module-bookmark": "^2.0.20",
+    "@equinor/fusion-query": "^4.0.2"
   },
   "devDependencies": {
-    "@equinor/fusion-wc-person": "1.0.0-next.5",
+    "@equinor/fusion-wc-person": "^2.0.1",
     "@types/react": "^18.2.20",
     "react": "^18.2.0",
     "typescript": "^5.1.3",
-    "@equinor/fusion-framework-module-app": "^5.2.6",
-    "@equinor/fusion-framework-module-bookmark": "^1.0.12",
-    "@equinor/fusion-framework-module-event": "^4.0.6",
-    "@equinor/fusion-framework-module-services": "^3.2.1"
+    "@equinor/fusion-framework-module-app": "^5.2.7",
+    "@equinor/fusion-framework-module-bookmark": "^1.0.13",
+    "@equinor/fusion-framework-module-event": "^4.0.6"
   },
   "peerDependencies": {
     "@types/react": "^17.0.0 || ^18.0.0",

package/src/PeopleResolver.tsx

@@ -6,19 +6,23 @@ import {
     PersonCardElement,
     PersonResolver,
     PersonListItemElement,
+    PersonSelectElement,
 } from '@equinor/fusion-wc-person';
 
 PersonProviderElement;
 PersonAvatarElement;
 PersonCardElement;
 PersonListItemElement;
+PersonSelectElement;
 
-export const PeopleResolver = (props: React.PropsWithChildren<{ resolver: PersonResolver }>) => {
+export { PersonResolver };
+
+export const PeopleResolverComponent = (props: React.PropsWithChildren<{ resolver: PersonResolver }>) => {
     const { resolver, children } = props;
     const ref = useRef<PersonProviderElement | null>(null);
     useEffect(() => {
         if (ref.current && resolver) {
-            ref.current.setResolver(resolver);
+            ref.current.resolver = resolver;
         }
     }, [ref, resolver]);
     return <fwc-person-provider ref={ref}>{children}</fwc-person-provider>;

package/src/PeopleResolverProvider.tsx

@@ -1,14 +1,20 @@
-import { Suspense, useMemo } from 'react';
+import { PropsWithChildren, Suspense, useMemo } from 'react';
 import { ServicesModule } from '@equinor/fusion-framework-module-services';
 import { useModule } from '@equinor/fusion-framework-react-module';
 import { makeResolver } from './makeResolver';
+import { PersonControllerOptions } from './PersonController';
 
-export const PeopleResolverProvider = ({ children }: { readonly children?: React.ReactNode }) => {
+type PeopleResolverProviderProps = PropsWithChildren<{
+    readonly options?: PersonControllerOptions;
+}>;
+
+export const PeopleResolverProvider = (props: PeopleResolverProviderProps) => {
+    const { children, options } = props;
     const services = useModule<ServicesModule>('services');
     if (!services) {
         throw Error('missing service module');
     }
-    const Component = useMemo(() => makeResolver(services), [services]);
+    const Component = useMemo(() => makeResolver(services, options), [services, options]);
     return (
         <Suspense fallback={<span>TODO</span>}>
             <Component>{children}</Component>

package/src/PersonController.ts

@@ -1,10 +1,14 @@
-import { Observable, concat, from } from 'rxjs';
-import { filter, find, map, raceWith, switchMap, take } from 'rxjs/operators';
+import { EMPTY, Observable, concat, from, fromEvent, of } from 'rxjs';
+import { catchError, filter, find, map, switchMap, take, takeUntil } from 'rxjs/operators';
 
 import type { ApiPerson, PeopleApiClient } from '@equinor/fusion-framework-module-services/people';
+import { isApiPerson } from '@equinor/fusion-framework-module-services/people/utils';
 import type { ApiResponse as GetPersonApiResponse } from '@equinor/fusion-framework-module-services/people/get';
 import type { ApiResponse as QueryPersonApiResponse } from '@equinor/fusion-framework-module-services/people/query';
-import Query from '@equinor/fusion-query';
+import { Query } from '@equinor/fusion-query';
+import { queryValue } from '@equinor/fusion-query/operators';
+
+import { ApiProviderError } from '@equinor/fusion-framework-module-services/provider';
 
 type GetPersonResult = GetPersonApiResponse<
     'v4',
@@ -15,6 +19,10 @@ type PersonSearchResult = QueryPersonApiResponse<'v2'>;
 
 type MatcherArgs = { upn: string; azureId?: string } | { upn?: string; azureId: string };
 
+type ResolverArgs<T> = T extends object
+    ? { [K in keyof T]: T[K] } & { signal?: AbortSignal }
+    : { signal?: AbortSignal };
+
 const personMatcher =
     (args: MatcherArgs) =>
     <T extends { azureUniqueId?: string; upn?: string }>(value: T): value is T => {
@@ -33,18 +41,22 @@ const personMatcher =
     };
 
 export interface IPersonController {
-    getPerson(args: MatcherArgs): Observable<GetPersonResult>;
-    getPersonInfo(args: MatcherArgs): Observable<ApiPerson<'v2'>>;
-    getPhoto(args: MatcherArgs): Observable<string>;
-    search(args: { search: string }): Observable<PersonSearchResult>;
+    getPerson(args: ResolverArgs<MatcherArgs>): Observable<GetPersonResult>;
+    getPersonInfo(args: ResolverArgs<MatcherArgs>): Observable<ApiPerson<'v2'>>;
+    getPhoto(args: ResolverArgs<MatcherArgs>): Observable<string>;
+    search(args: ResolverArgs<{ search: string }>): Observable<PersonSearchResult>;
 }
 
+export type PersonControllerOptions = {
+    fallbackImage?: Blob;
+};
+
 export class PersonController implements IPersonController {
-    #personQuery: Query<GetPersonResult, { azureId: string }>;
-    #personSearchQuery: Query<PersonSearchResult, { search: string }>;
-    #personPhotoQuery: Query<Blob, { azureId: string }>;
+    #personQuery: Query<GetPersonResult, ResolverArgs<{ azureId: string }>>;
+    #personSearchQuery: Query<PersonSearchResult, ResolverArgs<{ search: string }>>;
+    #personPhotoQuery: Query<Blob, ResolverArgs<{ azureId: string }>>;
 
-    constructor(client: PeopleApiClient) {
+    constructor(client: PeopleApiClient, options?: PersonControllerOptions) {
         const expire = 3 * 60 * 1000;
         this.#personQuery = new Query({
             expire,
@@ -77,137 +89,129 @@ export class PersonController implements IPersonController {
             key: ({ azureId }) => azureId,
             client: {
                 fn: ({ azureId }, signal) => {
-                    return client.photo('v2', 'blob$', { azureId }, { signal });
+                    return client.photo('v2', 'blob$', { azureId }, { signal }).pipe(
+                        catchError((err) => {
+                            const apiError = err as ApiProviderError;
+                            if (apiError.response.status === 404 && options?.fallbackImage) {
+                                return of(options?.fallbackImage);
+                            }
+                            return of(err);
+                        }),
+                    );
                 },
             },
         });
     }
 
-    /** TODO why does this need to have data?!? */
-    public getPhoto(args: MatcherArgs): Observable<string> {
-        const { azureId, upn } = args;
+    public search(args: { search: string; signal?: AbortSignal }): Observable<PersonSearchResult> {
+        const { search, signal } = args;
+        return this.#personSearchQuery.query({ search }, { signal }).pipe(queryValue);
+    }
 
-        const resolve = (azureId: string) =>
-            this.#personPhotoQuery
-                .query({ azureId })
-                .pipe(map((blob) => URL.createObjectURL(blob.value)));
+    /** TODO why does this need to have data?!? */
+    public getPhoto(args: ResolverArgs<MatcherArgs>): Observable<string> {
+        const { azureId, upn, signal } = args;
 
         if (azureId) {
-            return resolve(azureId);
-        }
-
-        if (!azureId && upn) {
-            const matcher = personMatcher({ upn });
-            const cache$ = this._personCache$(args).pipe(raceWith(this._queryCache$(args)));
-            return concat(
-                /** */
-                cache$.pipe(
-                    find(matcher),
-                    filter((x) => !!x),
-                ),
-                this.getPersonInfo({ upn }),
-            ).pipe(
-                /** */
-                filter((x): x is ApiPerson<'v2'> => {
-                    return !!x;
-                }),
-                switchMap((x) => resolve(x.azureUniqueId)),
-            );
+            return this._getPersonPhotoByAzureId(azureId, signal);
+        } else if (upn) {
+            return this._getPersonPhotoByUpn(upn, signal);
         }
         throw Error('invalid args provided');
     }
 
-    public getPerson(args: MatcherArgs): Observable<GetPersonResult> {
-        if (args.azureId) {
-            return this._getPersonById(args.azureId);
-        } else if (args.upn) {
-            return this._getPersonByUpn(args.upn);
+    public getPerson(args: ResolverArgs<MatcherArgs>): Observable<GetPersonResult> {
+        const { azureId, upn, signal } = args;
+        if (azureId) {
+            return this._getPersonByAzureId(azureId, signal);
+        } else if (upn) {
+            return this._getPersonByUpn(upn, signal);
         }
         throw Error('invalid args provided');
     }
 
-    public getPersonInfo(args: MatcherArgs): Observable<ApiPerson<'v2'>> {
-        if (args.azureId) {
-            return this._getPersonInfoById(args.azureId);
-        } else if (args.upn) {
-            return this._getPersonInfoByUpn(args.upn);
+    public getPersonInfo(args: ResolverArgs<MatcherArgs>): Observable<ApiPerson<'v2'>> {
+        const { azureId, upn, signal } = args;
+        if (azureId) {
+            return this._getPersonInfoById(azureId, signal);
+        } else if (upn) {
+            return this._getPersonInfoByUpn(upn, signal);
         }
         throw Error('invalid args provided');
     }
 
-    public search(args: { search: string }): Observable<PersonSearchResult> {
-        return this.#personSearchQuery.query(args).pipe(
-            /** extract value */
-            map((x) => x.value),
+    protected _getPersonByUpn(upn: string, signal?: AbortSignal): Observable<GetPersonResult> {
+        const abort$ = signal ? fromEvent(signal, 'abort') : EMPTY;
+        return concat(
+            this._personCache$({ upn }),
+            this._getPersonInfoByUpn(upn, signal).pipe(
+                filter(isApiPerson('v2')),
+                switchMap(({ azureUniqueId: azureId }) => {
+                    return this._getPersonByAzureId(azureId, signal);
+                }),
+            ),
+        ).pipe(
+            /** */
+            filter(isApiPerson('v4')),
+            takeUntil(abort$),
         );
     }
 
-    protected _getPersonById(azureId: string): Observable<GetPersonResult> {
-        return this.#personQuery.query({ azureId }).pipe(map((x) => x.value));
+    public _getPersonByAzureId(azureId: string, signal?: AbortSignal): Observable<GetPersonResult> {
+        return this.#personQuery.query({ azureId }, { signal }).pipe(queryValue);
     }
 
-    protected _getPersonInfoById(azureId: string): Observable<ApiPerson<'v2'>> {
+    protected _getPersonInfoById(
+        azureId: string,
+        signal?: AbortSignal,
+    ): Observable<ApiPerson<'v2'>> {
+        const abort$ = signal ? fromEvent(signal, 'abort') : EMPTY;
         return concat(
+            /** */
             this._personCache$({ azureId }),
-            concat(
-                this._queryCache$({ azureId }),
-                this.#personQuery.query({ azureId }).pipe(
-                    // TODO add mapper from v4 -> v2
-                    map((x) => x.value as ApiPerson<'v2'>),
-                ),
-            ).pipe(filter((x): x is ApiPerson<'v2'> => !!x)),
+            this._queryCache$({ azureId }),
+            this._getPersonByAzureId(azureId, signal),
         ).pipe(
-            map((x) => {
-                if (!x) {
-                    throw Error(`upn [${azureId}] not found`);
-                }
-                return x as ApiPerson<'v2'>;
-            }),
+            /** */
+            filter(isApiPerson('v2')),
+            takeUntil(abort$),
         );
     }
 
-    protected _getPersonByUpn(upn: string): Observable<GetPersonResult> {
+    protected _getPersonInfoByUpn(upn: string, signal?: AbortSignal): Observable<ApiPerson<'v2'>> {
+        const matcher = personMatcher({ upn });
+        const abort$ = signal ? fromEvent(signal, 'abort') : EMPTY;
         return concat(
             this._personCache$({ upn }),
-            this._getPersonInfoByUpn(upn).pipe(
-                filter((x): x is ApiPerson<'v2'> => !!x),
-                switchMap((x) =>
-                    this.#personQuery.query({ azureId: x!.azureUniqueId }).pipe(
-                        /** extract value */
-                        map((x) => x.value),
-                    ),
-                ),
+            this._queryCache$({ upn }),
+            this.#personSearchQuery.query({ search: upn }, { signal }).pipe(
+                /** extract first match, should only be 0 or 1 */
+                map((x) => x.value.find(matcher)),
+                /** type cast and end stream */
+                find(isApiPerson('v2')),
             ),
         ).pipe(
-            map((x) => {
-                if (!x) {
-                    throw Error(`upn [${upn}] not found`);
-                }
-                return x;
-            }),
+            /** */
+            find(isApiPerson('v2')),
+            filter(isApiPerson('v2')),
+            filter(isApiPerson('v2')),
+            takeUntil(abort$),
         );
     }
 
-    protected _getPersonInfoByUpn(upn: string): Observable<ApiPerson<'v2'>> {
-        const matcher = personMatcher({ upn });
-        return concat(
-            this._personCache$({ upn }),
-            concat(
-                this._queryCache$({ upn }),
-                this.#personSearchQuery.query({ search: upn }).pipe(
-                    /** extract first match, should only be 0 or 1 */
-                    map((x) => x.value.find(matcher)),
-                    /** type cast and end stream */
-                    find((x): x is ApiPerson<'v2'> => !!x),
-                ),
-            ).pipe(filter((x): x is ApiPerson<'v2'> => !!x)),
-        ).pipe(
-            map((x) => {
-                if (!x) {
-                    throw Error(`upn [${upn}] not found`);
-                }
-                return x as ApiPerson<'v2'>;
-            }),
+    protected _getPersonPhotoByAzureId(azureId: string, signal?: AbortSignal): Observable<string> {
+        return this.#personPhotoQuery.query({ azureId }, { signal }).pipe(
+            /** */
+            take(1),
+            map((result) => URL.createObjectURL(result.value)),
+        );
+    }
+
+    protected _getPersonPhotoByUpn(upn: string, signal?: AbortSignal) {
+        return this._getPersonInfoByUpn(upn, signal).pipe(
+            /** */
+            take(1),
+            switchMap((x) => this._getPersonPhotoByAzureId(x.azureUniqueId, signal)),
         );
     }
 
@@ -218,25 +222,27 @@ export class PersonController implements IPersonController {
             take(1),
             /** map out cached ApiPerson_v2 which matches upn  */
             map((x) => Object.values(x).find((x) => mather(x.value))?.value),
-            filter((x): x is GetPersonResult => !!x),
+            find(isApiPerson('v4')),
+            filter(isApiPerson('v4')),
         );
     }
 
-    protected _queryCache$(args: MatcherArgs) {
+    protected _queryCache$(args: MatcherArgs): Observable<ApiPerson<'v2'>> {
         const mather = personMatcher(args);
         return this.#personSearchQuery.cache.state$.pipe(
             /** make subscription cold */
             take(1),
-            switchMap((entry) =>
+            switchMap((entry) => {
                 /** expand cache records */
-                from(Object.values(entry)).pipe(
+                return from(Object.values(entry)).pipe(
                     /** find matching cache record item */
                     map((x) => x.value.find((x) => mather(x))),
                     /** type cast and end stream */
-                    find((x): x is ApiPerson<'v2'> => !!x),
-                ),
-            ),
-            filter((x): x is ApiPerson<'v2'> => !!x),
+                    find(isApiPerson('v2')),
+                );
+            }),
+            find(isApiPerson('v2')),
+            filter(isApiPerson('v2')),
         );
     }
 }

package/src/create-resolver.ts

@@ -16,7 +16,7 @@ export const createResolver = (controller: IPersonController): PersonResolver =>
         return firstValueFrom(
             controller.getPersonInfo(args).pipe(
                 /** TODO */
-                map((x) => ({ ...x, azureId: x.azureUniqueId }) as unknown as PersonDetails),
+                map((x) => ({ ...x, azureId: x.azureUniqueId }) as unknown as PersonInfo),
             ),
         );
     },

package/src/makeResolver.tsx

@@ -1,16 +1,16 @@
 import { lazy } from 'react';
-import { PeopleResolver } from './PeopleResolver';
-import { PersonController } from './PersonController';
+import { PeopleResolverComponent } from './PeopleResolver';
+import { PersonController, PersonControllerOptions } from './PersonController';
 import { createResolver } from './create-resolver';
 import { IApiProvider } from '@equinor/fusion-framework-module-services';
 
-export const makeResolver = (services: IApiProvider) => {
+export const makeResolver = (services: IApiProvider, options?: PersonControllerOptions) => {
     return lazy(async () => {
         const client = await services.createPeopleClient();
-        const controller = new PersonController(client);
+        const controller = new PersonController(client, options);
         const resolver = createResolver(controller);
         const Component = ({ children }: { readonly children?: React.ReactNode }) => (
-            <PeopleResolver resolver={resolver}>{children}</PeopleResolver>
+            <PeopleResolverComponent resolver={resolver}>{children}</PeopleResolverComponent>
         );
         return {
             default: Component,

package/src/version.ts

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