@medplum/react 2.0.0 → 2.0.1

package/dist/cjs/ReferenceRangeEditor/ReferenceRangeEditor.d.ts

@@ -1,13 +1,12 @@
 /// <reference types="react" />
 import { ObservationDefinition, ObservationDefinitionQualifiedInterval } from '@medplum/fhirtypes';
-declare const intervalFilters: readonly ["gender", "age", "gestationalAge", "context", "appliesTo"];
 export interface ReferenceRangeEditorProps {
     definition: ObservationDefinition;
     onSubmit: (result: ObservationDefinition) => void;
 }
 type IntervalGroup = {
     id: string;
-    filters: Record<typeof intervalFilters[number], any>;
+    filters: Record<string, any>;
     intervals: ObservationDefinitionQualifiedInterval[];
 };
 export declare function ReferenceRangeEditor(props: ReferenceRangeEditorProps): JSX.Element;

package/dist/cjs/ResourceTimeline/ResourceTimeline.d.ts

@@ -1,9 +1,9 @@
 /// <reference types="react" />
-import { ProfileResource } from '@medplum/core';
+import { MedplumClient, ProfileResource } from '@medplum/core';
 import { Attachment, Bundle, Communication, Media, Reference, Resource } from '@medplum/fhirtypes';
 export interface ResourceTimelineProps<T extends Resource> {
     value: T | Reference<T>;
-    buildSearchRequests: (resource: T) => Bundle;
+    loadTimelineResources: (medplum: MedplumClient, resource: T) => Promise<Bundle[]>;
     createCommunication?: (resource: T, sender: ProfileResource, text: string) => Communication;
     createMedia?: (resource: T, operator: ProfileResource, attachment: Attachment) => Media;
 }

package/dist/cjs/index.cjs

@@ -1244,7 +1244,7 @@
                 if (!property?.path) {
                     throw Error(`Displaying property of type ${props.propertyType} requires element definition path`);
                 }
-                return (React.createElement(BackboneElementDisplay, { value: { type: core.buildTypeName(property?.path?.split('.')), value }, compact: true, ignoreMissingValues: props.ignoreMissingValues }));
+                return (React.createElement(BackboneElementDisplay, { value: { type: core.getElementDefinitionTypeName(property), value }, compact: true, ignoreMissingValues: props.ignoreMissingValues }));
         }
     }
     /**
@@ -2241,7 +2241,7 @@
             case core.PropertyType.UsageContext:
                 return (React.createElement(BackboneElementInput, { typeName: propertyType, defaultValue: value, onChange: props.onChange, outcome: props.outcome }));
             default:
-                return (React.createElement(BackboneElementInput, { typeName: core.buildTypeName(property.path?.split('.')), defaultValue: value, onChange: props.onChange, outcome: props.outcome }));
+                return (React.createElement(BackboneElementInput, { typeName: core.getElementDefinitionTypeName(property), defaultValue: value, onChange: props.onChange, outcome: props.outcome }));
         }
     }
     function getTargetTypes(property) {
@@ -2799,7 +2799,7 @@
         const resource = useResource(props.value);
         const [history, setHistory] = React.useState();
         const [items, setItems] = React.useState([]);
-        const buildSearchRequests = props.buildSearchRequests;
+        const loadTimelineResources = props.loadTimelineResources;
         const itemsRef = React.useRef(items);
         itemsRef.current = items;
         const loadTimeline = React.useCallback(() => {
@@ -2808,8 +2808,8 @@
                 setHistory({});
                 return;
             }
-            medplum.executeBatch(buildSearchRequests(resource)).then(handleBatchResponse).catch(console.log);
-        }, [medplum, resource, buildSearchRequests]);
+            loadTimelineResources(medplum, resource).then(handleBatchResponse).catch(console.log);
+        }, [medplum, resource, loadTimelineResources]);
         React.useEffect(() => {
             loadTimeline();
         }, [loadTimeline]);
@@ -2817,29 +2817,24 @@
          * Handles a batch request response.
          * @param batchResponse The batch response.
          */
-        function handleBatchResponse(batchResponse) {
+        function handleBatchResponse(bundles) {
             const newItems = [];
-            if (batchResponse.entry) {
-                for (const batchEntry of batchResponse.entry) {
-                    const bundle = batchEntry.resource;
-                    if (!bundle) {
-                        // User may not have access to all resource types
-                        continue;
-                    }
-                    if (bundle.type === 'history') {
-                        setHistory(bundle);
-                    }
-                    if (bundle.entry) {
-                        for (const entry of bundle.entry) {
-                            if (entry.resource) {
-                                newItems.push(entry.resource);
-                            }
-                        }
+            for (const bundle of bundles) {
+                if (!bundle) {
+                    // User may not have access to all resource types
+                    continue;
+                }
+                if (bundle.type === 'history') {
+                    setHistory(bundle);
+                }
+                if (bundle.entry) {
+                    for (const entry of bundle.entry) {
+                        newItems.push(entry.resource);
                     }
                 }
-                sortByDateAndPriority(newItems);
-                newItems.reverse();
             }
+            sortByDateAndPriority(newItems);
+            newItems.reverse();
             setItems(newItems);
         }
         /**
@@ -2960,10 +2955,10 @@
                         React.createElement(AttachmentButton, { onUpload: createMedia, onUploadStart: onUploadStart, onUploadProgress: onUploadProgress }, (props) => (React.createElement(core$1.ActionIcon, { ...props, radius: "xl", color: "blue", variant: "filled" },
                             React.createElement(icons.IconCloudUpload, { size: 16 })))))))),
             items.map((item) => {
+                const key = `${item.resourceType}/${item.id}/${item.meta?.versionId}`;
                 if (item.resourceType === resource.resourceType && item.id === resource.id) {
-                    return (React.createElement(HistoryTimelineItem, { key: item.meta?.versionId, history: history, resource: item, onDetails: onVersionDetails }));
+                    return (React.createElement(HistoryTimelineItem, { key: key, history: history, resource: item, onDetails: onVersionDetails }));
                 }
-                const key = `${item.resourceType}/${item.id}`;
                 switch (item.resourceType) {
                     case 'AuditEvent':
                         return React.createElement(AuditEventTimelineItem, { key: key, resource: item, onDetails: onDetails });
@@ -3052,51 +3047,22 @@
     }
 
     function DefaultResourceTimeline(props) {
-        return (React.createElement(ResourceTimeline, { value: props.resource, buildSearchRequests: (resource) => ({
-                resourceType: 'Bundle',
-                type: 'batch',
-                entry: [
-                    {
-                        request: {
-                            method: 'GET',
-                            url: `${core.getReferenceString(resource)}/_history`,
-                        },
-                    },
-                    {
-                        request: {
-                            method: 'GET',
-                            url: `AuditEvent?entity=${core.getReferenceString(resource)}&_sort=-_lastUpdated`,
-                        },
-                    },
-                ],
-            }) }));
+        return (React.createElement(ResourceTimeline, { value: props.resource, loadTimelineResources: async (medplum, resource) => {
+                return Promise.all([
+                    medplum.readHistory(resource.resourceType, resource.id),
+                    medplum.search('AuditEvent', '_sort=-_lastUpdated&entity=' + core.getReferenceString(resource)),
+                ]);
+            } }));
     }
 
     function EncounterTimeline(props) {
-        return (React.createElement(ResourceTimeline, { value: props.encounter, buildSearchRequests: (resource) => ({
-                resourceType: 'Bundle',
-                type: 'batch',
-                entry: [
-                    {
-                        request: {
-                            method: 'GET',
-                            url: `${core.getReferenceString(resource)}/_history`,
-                        },
-                    },
-                    {
-                        request: {
-                            method: 'GET',
-                            url: `Communication?encounter=${core.getReferenceString(resource)}`,
-                        },
-                    },
-                    {
-                        request: {
-                            method: 'GET',
-                            url: `Media?encounter=${core.getReferenceString(resource)}`,
-                        },
-                    },
-                ],
-            }), createCommunication: (resource, sender, text) => ({
+        return (React.createElement(ResourceTimeline, { value: props.encounter, loadTimelineResources: async (medplum, resource) => {
+                return Promise.all([
+                    medplum.readHistory('Encounter', resource.id),
+                    medplum.search('Communication', 'encounter=' + core.getReferenceString(resource)),
+                    medplum.search('Media', 'encounter=' + core.getReferenceString(resource)),
+                ]);
+            }, createCommunication: (resource, sender, text) => ({
                 resourceType: 'Communication',
                 status: 'completed',
                 encounter: core.createReference(resource),
@@ -4569,26 +4535,19 @@
     }
     const MemoizedFhirPathTable = React.memo(FhirPathTable);
 
-    const searches = [
-        '$/_history',
-        'Communication?subject=$',
-        'Device?patient=$',
-        'DeviceRequest?patient=$',
-        'DiagnosticReport?subject=$',
-        'Media?subject=$',
-        'ServiceRequest?subject=$',
-    ];
     function PatientTimeline(props) {
-        return (React.createElement(ResourceTimeline, { value: props.patient, buildSearchRequests: (resource) => ({
-                resourceType: 'Bundle',
-                type: 'batch',
-                entry: searches.map((search) => ({
-                    request: {
-                        method: 'GET',
-                        url: search.replaceAll('$', core.getReferenceString(resource)),
-                    },
-                })),
-            }), createCommunication: (resource, sender, text) => ({
+        const loadTimelineResources = React.useCallback((medplum, resource) => {
+            return Promise.all([
+                medplum.readHistory('Patient', resource.id),
+                medplum.search('Communication', 'subject=' + core.getReferenceString(resource)),
+                medplum.search('Device', 'patient=' + core.getReferenceString(resource)),
+                medplum.search('DeviceRequest', 'patient=' + core.getReferenceString(resource)),
+                medplum.search('DiagnosticReport', 'subject=' + core.getReferenceString(resource)),
+                medplum.search('Media', 'subject=' + core.getReferenceString(resource)),
+                medplum.search('ServiceRequest', 'subject=' + core.getReferenceString(resource)),
+            ]);
+        }, []);
+        return (React.createElement(ResourceTimeline, { value: props.patient, loadTimelineResources: loadTimelineResources, createCommunication: (resource, sender, text) => ({
                 resourceType: 'Communication',
                 status: 'completed',
                 subject: core.createReference(resource),
@@ -6175,36 +6134,14 @@
     }
 
     function ServiceRequestTimeline(props) {
-        return (React.createElement(ResourceTimeline, { value: props.serviceRequest, buildSearchRequests: (resource) => ({
-                resourceType: 'Bundle',
-                type: 'batch',
-                entry: [
-                    {
-                        request: {
-                            method: 'GET',
-                            url: `${core.getReferenceString(resource)}/_history`,
-                        },
-                    },
-                    {
-                        request: {
-                            method: 'GET',
-                            url: `Communication?based-on=${core.getReferenceString(resource)}&_sort=-_lastUpdated`,
-                        },
-                    },
-                    {
-                        request: {
-                            method: 'GET',
-                            url: `Media?_count=100&based-on=${core.getReferenceString(resource)}&_sort=-_lastUpdated`,
-                        },
-                    },
-                    {
-                        request: {
-                            method: 'GET',
-                            url: `DiagnosticReport?based-on=${core.getReferenceString(resource)}&_sort=-_lastUpdated`,
-                        },
-                    },
-                ],
-            }), createCommunication: (resource, sender, text) => ({
+        return (React.createElement(ResourceTimeline, { value: props.serviceRequest, loadTimelineResources: async (medplum, resource) => {
+                return Promise.all([
+                    medplum.readHistory('ServiceRequest', resource.id),
+                    medplum.search('Communication', 'based-on=' + core.getReferenceString(resource)),
+                    medplum.search('Media', '_count=100&based-on=' + core.getReferenceString(resource)),
+                    medplum.search('DiagnosticReport', 'based-on=' + core.getReferenceString(resource)),
+                ]);
+            }, createCommunication: (resource, sender, text) => ({
                 resourceType: 'Communication',
                 status: 'completed',
                 basedOn: [core.createReference(resource)],