aidbox-react 1.5.0 → 1.7.0

package/dist/cjs/libs/remoteData.d.ts

@@ -0,0 +1,35 @@
+declare enum Status {
+    Success = "Success",
+    Failure = "Failure",
+    Loading = "Loading",
+    NotAsked = "NotAsked"
+}
+interface RemoteDataNotAsked {
+    status: Status.NotAsked;
+}
+export declare const notAsked: RemoteDataNotAsked;
+interface RemoteDataLoading {
+    status: Status.Loading;
+}
+export declare const loading: RemoteDataLoading;
+interface RemoteDataSuccess<s> {
+    status: Status.Success;
+    data: s;
+}
+export declare function success<S = any>(data: S): RemoteDataSuccess<S>;
+interface RemoteDataFailure<F> {
+    status: Status.Failure;
+    error: F;
+}
+export declare function failure<F = any>(error: F): RemoteDataFailure<F>;
+export type RemoteDataResult<S = any, F = any> = RemoteDataSuccess<S> | RemoteDataFailure<F>;
+export type RemoteData<S = any, F = any> = RemoteDataNotAsked | RemoteDataLoading | RemoteDataResult<S, F>;
+export declare function isNotAsked(remoteData: RemoteData): remoteData is RemoteDataNotAsked;
+export declare function isLoading(remoteData: RemoteData): remoteData is RemoteDataLoading;
+export declare function isSuccess<S>(remoteData: RemoteData<S>): remoteData is RemoteDataSuccess<S>;
+export declare function isSuccessAll<S>(responses: Array<RemoteData<S>>): responses is Array<RemoteDataSuccess<S>>;
+export declare function isFailure<F>(remoteData: RemoteData<any, F>): remoteData is RemoteDataFailure<F>;
+export declare function isFailureAny<F>(responses: Array<RemoteData<any, F>>): responses is Array<RemoteDataFailure<F>>;
+export declare function isLoadingAny(responses: Array<RemoteData>): responses is Array<RemoteDataLoading>;
+export declare function isNotAskedAny(responses: Array<RemoteData>): responses is Array<RemoteDataNotAsked>;
+export {};

package/dist/cjs/services/fhir.d.ts

@@ -0,0 +1,44 @@
+import { AxiosRequestConfig } from 'axios';
+import { AidboxReference, AidboxResource, ValueSet, Bundle, BundleEntry, id } from 'shared/src/contrib/aidbox';
+import { RemoteDataResult } from '../libs/remoteData';
+import { SearchParams } from './search';
+export type WithId<T extends AidboxResource> = T & Required<Pick<T, 'id'>>;
+export declare function createFHIRResource<R extends AidboxResource>(resource: R, searchParams?: SearchParams): Promise<RemoteDataResult<WithId<R>>>;
+export declare function create<R extends AidboxResource>(resource: R, searchParams?: SearchParams): AxiosRequestConfig;
+export declare function updateFHIRResource<R extends AidboxResource>(resource: R, searchParams?: SearchParams): Promise<RemoteDataResult<WithId<R>>>;
+export declare function update<R extends AidboxResource>(resource: R, searchParams?: SearchParams): AxiosRequestConfig;
+export declare function getFHIRResource<R extends AidboxResource>(reference: AidboxReference<R>): Promise<RemoteDataResult<WithId<R>>>;
+export declare function get<R extends AidboxResource>(reference: AidboxReference<R>): AxiosRequestConfig;
+export declare function getFHIRResources<R extends AidboxResource>(resourceType: R['resourceType'], searchParams: SearchParams, extraPath?: string): Promise<RemoteDataResult<Bundle<WithId<R>>>>;
+export declare function getAllFHIRResources<R extends AidboxResource>(resourceType: string, params: SearchParams, extraPath?: string): Promise<RemoteDataResult<Bundle<WithId<R>>>>;
+export declare function list<R extends AidboxResource>(resourceType: R['resourceType'], searchParams: SearchParams, extraPath?: string): AxiosRequestConfig;
+export declare function findFHIRResource<R extends AidboxResource>(resourceType: R['resourceType'], params: SearchParams, extraPath?: string): Promise<RemoteDataResult<WithId<R>>>;
+export declare function saveFHIRResource<R extends AidboxResource>(resource: R): Promise<RemoteDataResult<WithId<R>>>;
+export declare function save<R extends AidboxResource>(resource: R): AxiosRequestConfig;
+export declare function saveFHIRResources<R extends AidboxResource>(resources: R[], bundleType: 'transaction' | 'batch'): Promise<RemoteDataResult<Bundle<WithId<R>>>>;
+type NullableRecursivePartial<T> = {
+    [P in keyof T]?: NullableRecursivePartial<T[P]> | null;
+};
+export declare function patchFHIRResource<R extends AidboxResource>(resource: NullableRecursivePartial<R> & Required<Pick<R, 'id' | 'resourceType'>>, searchParams?: SearchParams): Promise<RemoteDataResult<WithId<R>>>;
+export declare function patch<R extends AidboxResource>(resource: NullableRecursivePartial<R> & Required<Pick<R, 'resourceType'>>, searchParams?: SearchParams): AxiosRequestConfig;
+export declare function deleteFHIRResource<R extends AidboxResource>(resource: AidboxReference<R>): Promise<RemoteDataResult<WithId<R>>>;
+export declare function markAsDeleted<R extends AidboxResource>(resource: AidboxReference<R>): AxiosRequestConfig;
+export declare function forceDeleteFHIRResource<R extends AidboxResource>(resource: AidboxReference<R>): Promise<RemoteDataResult<WithId<R>>>;
+export declare function forceDelete<R extends AidboxResource>(resourceType: R['resourceType'], idOrSearchParams: id | SearchParams): AxiosRequestConfig;
+export declare function getReference<T extends AidboxResource>(resource: T, display?: string): AidboxReference<T>;
+export declare function makeReference<T extends AidboxResource>(resourceType: string, id: string, display?: string): AidboxReference<T>;
+export declare function isReference<T extends AidboxResource>(resource: T | AidboxReference<T>): resource is AidboxReference<T>;
+export type ResourcesMap<T extends AidboxResource> = {
+    [P in T['resourceType']]: T extends {
+        resourceType: P;
+    } ? T[] : never;
+};
+export declare function extractBundleResources<T extends AidboxResource>(bundle: Bundle<T>): ResourcesMap<T>;
+export declare function getIncludedResource<T extends AidboxResource>(resources: ResourcesMap<T | any>, reference: AidboxReference<T>): T | undefined;
+export declare function getIncludedResources<T extends AidboxResource>(resources: ResourcesMap<T | any>, resourceType: T['resourceType']): T[];
+export declare function getMainResources<T extends AidboxResource>(bundle: Bundle<T>, resourceType: T['resourceType']): T[];
+export declare function getConcepts(valueSetId: string, params?: SearchParams): Promise<RemoteDataResult<ValueSet>>;
+export declare function applyFHIRService<T extends AidboxResource, F = any>(request: AxiosRequestConfig): Promise<RemoteDataResult<WithId<T>, F>>;
+export declare function transformToBundleEntry<R extends AidboxResource>(config: AxiosRequestConfig): BundleEntry<R> | null;
+export declare function applyFHIRServices<T extends AidboxResource, F = any>(requests: Array<AxiosRequestConfig>, type?: 'transaction' | 'batch'): Promise<RemoteDataResult<Bundle<WithId<T>>, F>>;
+export {};

package/dist/cjs/services/instance.d.ts

@@ -0,0 +1,6 @@
+import { Token } from './token';
+export declare function buildQueryParams(params: Record<string, any>): string;
+export declare const axiosInstance: import("axios").AxiosInstance;
+export declare function setInstanceBaseURL(baseURL: string): void;
+export declare function setInstanceToken(token: Token): void;
+export declare function resetInstanceToken(): void;

package/dist/cjs/services/search.d.ts

@@ -0,0 +1,4 @@
+export type SearchParam<T> = T | T[] | undefined;
+export interface SearchParams {
+    [key: string]: SearchParam<string | number | boolean>;
+}

package/dist/cjs/services/service.d.ts

@@ -0,0 +1,33 @@
+import { AxiosRequestConfig } from 'axios';
+import { RemoteDataResult, RemoteData } from '../libs/remoteData';
+export declare function service<S = any, F = any>(config: AxiosRequestConfig): Promise<RemoteDataResult<S, F>>;
+export declare function applyDataTransformer<S = any, F = any, R = any>(servicePromise: Promise<RemoteDataResult<S, F>>, transformer: (data: S) => R): Promise<RemoteDataResult<R, F>>;
+export declare function applyDataTransformer<S = any, F = any, R = any>(servicePromise: Promise<RemoteData<S, F>>, transformer: (data: S) => R): Promise<RemoteData<R, F>>;
+export declare function applyErrorTransformer<S = any, F = any, R = any>(servicePromise: Promise<RemoteDataResult<S, F>>, transformer: (error: F) => R): Promise<RemoteDataResult<S, R>>;
+export declare function applyErrorTransformer<S = any, F = any, R = any>(servicePromise: Promise<RemoteData<S, F>>, transformer: (error: F) => R): Promise<RemoteData<S, R>>;
+export declare function mapSuccess<S = any, F = any, R = any>(remoteData: RemoteDataResult<S, F>, transformer: (data: S) => R): RemoteDataResult<R, F>;
+export declare function mapSuccess<S = any, F = any, R = any>(remoteData: RemoteData<S, F>, transformer: (data: S) => R): RemoteData<R, F>;
+export declare function mapFailure<S = any, F = any, R = any>(remoteData: RemoteDataResult<S, F>, transformer: (error: F) => R): RemoteDataResult<S, R>;
+export declare function mapFailure<S = any, F = any, R = any>(remoteData: RemoteData<S, F>, transformer: (error: F) => R): RemoteData<S, R>;
+export type PromiseRemoteDataResultMap<T, F> = {
+    [P in keyof T]: Promise<RemoteDataResult<T[P], F>>;
+};
+export type RemoteDataResultMap<T, F> = {
+    [P in keyof T]: RemoteDataResult<T[P], F>;
+};
+export type PromiseRemoteDataMap<T, F> = {
+    [P in keyof T]: Promise<RemoteData<T[P], F>>;
+};
+export type RemoteDataMap<T, F> = {
+    [P in keyof T]: RemoteData<T[P], F>;
+};
+export declare function sequenceArray<T, F>(remoteDataArray: Array<RemoteDataResult<T, F>>): RemoteDataResult<T[], F[]>;
+export declare function sequenceArray<T, F>(remoteDataArray: Array<RemoteData<T, F>>): RemoteData<T[], F[]>;
+export declare function sequenceMap<I, F>(remoteDataMap: RemoteDataResultMap<I, F>): RemoteDataResult<I, F[]>;
+export declare function sequenceMap<I, F>(remoteDataMap: RemoteDataMap<I, F>): RemoteData<I, F[]>;
+export declare function resolveArray<T, F>(promiseArray: Array<Promise<RemoteDataResult<T, F>>>): Promise<RemoteDataResult<T[], F[]>>;
+export declare function resolveArray<T, F>(promiseArray: Array<Promise<RemoteData<T, F>>>): Promise<RemoteData<T[], F[]>>;
+export declare function resolveMap<I, F>(promiseMap: PromiseRemoteDataResultMap<I, F>): Promise<RemoteDataResult<I, F[]>>;
+export declare function resolveMap<I, F>(promiseMap: PromiseRemoteDataMap<I, F>): Promise<RemoteData<I, F[]>>;
+export declare function resolveServiceMap<I, F>(promiseMap: PromiseRemoteDataResultMap<I, F>): Promise<RemoteDataResult<I, F[]>>;
+export declare function resolveServiceMap<I, F>(promiseMap: PromiseRemoteDataMap<I, F>): Promise<RemoteData<I, F[]>>;

package/dist/cjs/services/token.d.ts

@@ -0,0 +1,4 @@
+export interface Token {
+    access_token: string;
+    token_type: string;
+}

package/dist/cjs/utils/date.d.ts

@@ -0,0 +1,14 @@
+import moment from 'moment';
+export declare const FHIRDateFormat = "YYYY-MM-DD";
+export declare const FHIRTimeFormat = "HH:mm:ss";
+export declare const FHIRDateTimeFormat = "YYYY-MM-DDTHH:mm:ss[Z]";
+export declare const formatFHIRTime: (date: Date | moment.Moment) => string;
+export declare const formatFHIRDate: (date: Date | moment.Moment) => string;
+export declare const formatFHIRDateTime: (date: Date | moment.Moment) => string;
+export declare const parseFHIRTime: (date: string) => moment.Moment;
+export declare const parseFHIRDate: (date: string) => moment.Moment;
+export declare const parseFHIRDateTime: (date: string) => moment.Moment;
+export declare const makeFHIRDateTime: (date: string, time?: string) => string;
+export declare const extractFHIRDate: (date: string) => string;
+export declare const extractFHIRTime: (date: string) => string;
+export declare const isFHIRDateEqual: (date1: string, date2: string) => boolean;

package/dist/cjs/utils/error.d.ts

@@ -0,0 +1,30 @@
+import { OperationOutcome } from 'shared/src/contrib/aidbox';
+interface BackendError {
+    error: string;
+    error_description: string;
+}
+interface ErrorMapping {
+    [code: string]: string;
+}
+interface FormatErrorConfig {
+    mapping?: ErrorMapping;
+    format?: (errorCode: string, errorDescription: string) => string;
+}
+/**
+ * Returns formatted error (when you need to display human-friendly error message)
+ *
+ * formatError(
+ *     error,
+ *     {
+ *         mapping: {'conflict': 'Please reload page'},
+ *         format: (errorCode, errorDescription) =>
+ *             `An error occurred: ${errorDescription} (${errorCode}). Please reach tech support`
+ *     }
+ * )
+ */
+export declare function formatError(error: any, config?: FormatErrorConfig): any;
+export declare function extractErrorDescription(error: any): any;
+export declare function extractErrorCode(error: any): string;
+export declare function isOperationOutcome(error: any): error is OperationOutcome;
+export declare function isBackendError(error: any): error is BackendError;
+export {};

package/dist/cjs/utils/tests.d.ts

@@ -0,0 +1,10 @@
+import { User } from 'shared/src/contrib/aidbox';
+import { RemoteData } from '../libs/remoteData';
+import { Token } from '../services/token';
+export type LoginService = (user: User) => Promise<RemoteData<Token>>;
+export declare function withRootAccess<R>(fn: () => Promise<R>): Promise<R>;
+export declare function ensure<R>(result: RemoteData<R>): R;
+export declare function investigate<R = any>(result: RemoteData<unknown, R>): R;
+export declare function getToken(user: User, loginService: LoginService): Promise<Token>;
+export declare function login(user: User, loginService: LoginService): Promise<Token>;
+export declare function getUserInfo(): Promise<User>;

package/dist/cjs/utils/uuid.d.ts

@@ -0,0 +1 @@
+export declare function uuid4(): string;

package/dist/esm/components/RenderRemoteData/index.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { RemoteData } from '../../libs/remoteData';
+interface RenderConfig<E = any> {
+    renderFailure?: (error: E) => React.ReactElement;
+    renderLoading?: () => React.ReactElement;
+    renderNotAsked?: () => React.ReactElement;
+}
+interface RenderRemoteDataBasicProps<S, E = any> {
+    remoteData: RemoteData<S, E>;
+    children: (data: S) => React.ReactElement;
+}
+type RenderRemoteDataProps<S, E = any> = RenderRemoteDataBasicProps<S> & RenderConfig<E>;
+export declare function RenderRemoteData<S, E = any>(props: RenderRemoteDataProps<S, E>): JSX.Element | null;
+export declare function withRender<E = any>(config: RenderConfig<E>): <S>(props: RenderRemoteDataProps<S, E>) => JSX.Element;
+export {};

package/dist/esm/hooks/bus.d.ts

@@ -0,0 +1,17 @@
+interface BaseAction {
+    type: unknown;
+}
+type ExactlyOne<T, TKey = keyof T> = TKey extends keyof T ? {
+    [key in Exclude<keyof T, TKey>]?: never;
+} & {
+    [key in TKey]: T[key];
+} : never;
+type GetOnlyBaseActions<T> = T extends ExactlyOne<T, 'type'> ? T : never;
+type Callback<T extends BaseAction> = (e: T) => void;
+type Dispatch<T extends BaseAction> = (action: T | GetOnlyBaseActions<T>['type']) => void;
+type UseBus<T extends BaseAction> = (type: T['type'], callback: Callback<T>, deps: Array<any>) => Dispatch<T>;
+export declare function createBus<T extends BaseAction = never>(): {
+    useBus: UseBus<T>;
+    dispatch: Dispatch<T>;
+};
+export {};

package/dist/esm/hooks/crud.d.ts

@@ -0,0 +1,7 @@
+import { AidboxResource } from 'shared/src/contrib/aidbox';
+import { RemoteData } from '../libs/remoteData';
+export interface CRUDManager<T> {
+    handleSave: (updatedResource: T, relatedResources?: AidboxResource[]) => Promise<RemoteData<T>>;
+    handleDelete: (resourceToDelete: T) => void;
+}
+export declare function useCRUD<T extends AidboxResource>(resourceType: T['resourceType'], id?: string, getOrCreate?: boolean, defaultResource?: Partial<T>): [RemoteData<T>, CRUDManager<T>];

package/dist/esm/hooks/pager.d.ts

@@ -0,0 +1,13 @@
+import { AidboxResource, Bundle } from 'shared/src/contrib/aidbox';
+import { RemoteData } from '../libs/remoteData';
+import { SearchParams } from '../services/search';
+export interface PagerManager {
+    loadNext: () => void;
+    loadPrevious: () => void;
+    loadPage: (page: number) => void;
+    reload: () => void;
+    hasNext: boolean;
+    hasPrevious: boolean;
+    currentPage: number;
+}
+export declare function usePager<T extends AidboxResource>(resourceType: T['resourceType'], resourcesOnPage?: number, searchParams?: SearchParams): [RemoteData<Bundle<T>>, PagerManager];

package/dist/esm/hooks/service.d.ts

@@ -0,0 +1,8 @@
+import { RemoteData, RemoteDataResult } from '../libs/remoteData';
+export interface ServiceManager<S, F> {
+    reload: () => void;
+    reloadAsync: () => Promise<RemoteDataResult<S, F>>;
+    softReloadAsync: () => Promise<RemoteDataResult<S, F>>;
+    set: (dataOrFn: S | ((data: S) => S)) => void;
+}
+export declare function useService<S = any, F = any>(asyncFunction: () => Promise<RemoteDataResult<S, F>>, deps?: ReadonlyArray<any>): [RemoteData<S, F>, ServiceManager<S, F>];

package/dist/esm/hooks/shared-state.d.ts

@@ -0,0 +1,9 @@
+export interface StateManager<S> {
+    getSharedState: () => S;
+    setSharedState: (s: S) => void;
+    useSharedState: () => [S, (s: S) => void];
+}
+export declare class SharedStateInitializationError extends Error {
+    constructor(message?: string);
+}
+export declare function createSharedState<S>(initial?: S): StateManager<S>;

package/dist/esm/index.d.ts

@@ -0,0 +1,16 @@
+export * from './libs/remoteData';
+export * from './services/token';
+export * from './services/instance';
+export * from './services/search';
+export * from './services/service';
+export * from './services/fhir';
+export * from './utils/date';
+export * from './utils/error';
+export * from './utils/tests';
+export * from './utils/uuid';
+export * from './hooks/bus';
+export * from './hooks/service';
+export * from './hooks/crud';
+export * from './hooks/shared-state';
+export * from './hooks/pager';
+export * from './components/RenderRemoteData';