@medplum/core 0.2.0 → 0.4.0

package/dist/cjs/index.js

@@ -0,0 +1,1769 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.medplum = global.medplum || {}, global.medplum.core = {})));
+})(this, (function (exports) { 'use strict';
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+
+    function __awaiter(thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    }
+
+    /**
+     * LRU cache (least recently used)
+     * Source: https://stackoverflow.com/a/46432113
+     */
+    class LRUCache {
+        constructor(max = 10) {
+            this.max = max;
+            this.cache = new Map();
+        }
+        clear() {
+            this.cache.clear();
+        }
+        get(key) {
+            const item = this.cache.get(key);
+            if (item) {
+                this.cache.delete(key);
+                this.cache.set(key, item);
+            }
+            return item;
+        }
+        set(key, val) {
+            if (this.cache.has(key)) {
+                this.cache.delete(key);
+            }
+            else if (this.cache.size >= this.max) {
+                this.cache.delete(this.first());
+            }
+            this.cache.set(key, val);
+        }
+        first() {
+            // This works because the Map class maintains ordered keys.
+            return this.cache.keys().next().value;
+        }
+    }
+
+    function formatAddress(address, options) {
+        const builder = [];
+        if (address.line) {
+            builder.push(...address.line);
+        }
+        if (address.city) {
+            builder.push(address.city);
+        }
+        if (address.state) {
+            builder.push(address.state);
+        }
+        if (address.postalCode) {
+            builder.push(address.postalCode);
+        }
+        if (address.use && ((options === null || options === void 0 ? void 0 : options.all) || (options === null || options === void 0 ? void 0 : options.use))) {
+            builder.push('[' + address.use + ']');
+        }
+        return builder.join(', ').trim();
+    }
+    function formatHumanName(name, options) {
+        const builder = [];
+        if (name.prefix && ((options === null || options === void 0 ? void 0 : options.all) || (options === null || options === void 0 ? void 0 : options.prefix))) {
+            builder.push(...name.prefix);
+        }
+        if (name.given) {
+            builder.push(...name.given);
+        }
+        if (name.family) {
+            builder.push(name.family);
+        }
+        if (name.suffix && ((options === null || options === void 0 ? void 0 : options.all) || (options === null || options === void 0 ? void 0 : options.suffix))) {
+            builder.push(...name.suffix);
+        }
+        if (name.use && ((options === null || options === void 0 ? void 0 : options.all) || (options === null || options === void 0 ? void 0 : options.use))) {
+            builder.push('[' + name.use + ']');
+        }
+        return builder.join(' ').trim();
+    }
+    function formatGivenName(name) {
+        const builder = [];
+        if (name.given) {
+            builder.push(...name.given);
+        }
+        return builder.join(' ').trim();
+    }
+    function formatFamilyName(name) {
+        return name.family || '';
+    }
+
+    /**
+     * Creates a reference resource.
+     * @param resource The FHIR reesource.
+     * @returns A reference resource.
+     */
+    function createReference(resource) {
+        const reference = getReferenceString(resource);
+        const display = getDisplayString(resource);
+        return display === reference ? { reference } : { reference, display };
+    }
+    /**
+     * Returns a reference string for a resource.
+     * @param resource The FHIR resource.
+     * @returns A reference string of the form resourceType/id.
+     */
+    function getReferenceString(resource) {
+        return resource.resourceType + '/' + resource.id;
+    }
+    /**
+     * Returns true if the resource is a "ProfileResource".
+     * @param resource The FHIR resource.
+     * @returns True if the resource is a "ProfileResource".
+     */
+    function isProfileResource(resource) {
+        return (resource.resourceType === 'Patient' ||
+            resource.resourceType === 'Practitioner' ||
+            resource.resourceType === 'RelatedPerson');
+    }
+    /**
+     * Returns a display string for the resource.
+     * @param resource The input resource.
+     * @return Human friendly display string.
+     */
+    function getDisplayString(resource) {
+        if (isProfileResource(resource)) {
+            const profileName = getProfileResourceDisplayString(resource);
+            if (profileName) {
+                return profileName;
+            }
+        }
+        if (resource.resourceType === 'Device') {
+            const deviceName = getDeviceDisplayString(resource);
+            if (deviceName) {
+                return deviceName;
+            }
+        }
+        if (resource.resourceType === 'User') {
+            if (resource.email) {
+                return resource.email;
+            }
+        }
+        if ('name' in resource && resource.name && typeof resource.name === 'string') {
+            return resource.name;
+        }
+        return getReferenceString(resource);
+    }
+    /**
+     * Returns a display string for a profile resource if one is found.
+     * @param resource The profile resource.
+     * @returns The display name if one is found.
+     */
+    function getProfileResourceDisplayString(resource) {
+        const names = resource.name;
+        if (names && names.length > 0) {
+            return formatHumanName(names[0]);
+        }
+        return undefined;
+    }
+    /**
+     * Returns a display string for a device resource if one is found.
+     * @param device The device resource.
+     * @returns The display name if one is found.
+     */
+    function getDeviceDisplayString(device) {
+        const names = device.deviceName;
+        if (names && names.length > 0) {
+            return names[0].name;
+        }
+        return undefined;
+    }
+    /**
+     * Returns an image URL for the resource, if one is available.
+     * @param resource The input resource.
+     * @returns The image URL for the resource or undefined.
+     */
+    function getImageSrc(resource) {
+        if (isProfileResource(resource)) {
+            const photos = resource.photo;
+            if (photos) {
+                for (const photo of photos) {
+                    if (photo.url && photo.contentType && photo.contentType.startsWith('image/')) {
+                        return photo.url;
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Returns a Date property as a Date.
+     * When working with JSON objects, Dates are often serialized as ISO-8601 strings.
+     * When that happens, we need to safely convert to a proper Date object.
+     * @param date The date property value, which could be a string or a Date object.
+     * @returns A Date object.
+     */
+    function getDateProperty(date) {
+        return date ? new Date(date) : undefined;
+    }
+    /**
+     * FHIR JSON stringify.
+     * Removes properties with empty string values.
+     * Removes objects with zero properties.
+     * See: https://www.hl7.org/fhir/json.html
+     * @param value The input value.
+     * @param pretty Optional flag to pretty-print the JSON.
+     * @returns The resulting JSON string.
+     */
+    function stringify(value, pretty) {
+        return JSON.stringify(value, stringifyReplacer, pretty ? 2 : undefined);
+    }
+    /**
+     * Evaluates JSON key/value pairs for FHIR JSON stringify.
+     * Removes properties with empty string values.
+     * Removes objects with zero properties.
+     * @param {string} k Property key.
+     * @param {*} v Property value.
+     */
+    function stringifyReplacer(k, v) {
+        return isEmpty(v) ? undefined : v;
+    }
+    /**
+     * Returns true if the value is empty (null, undefined, empty string, or empty object).
+     * @param v Any value.
+     * @returns True if the value is an empty string or an empty object.
+     */
+    function isEmpty(v) {
+        if (v === null || v === undefined) {
+            return true;
+        }
+        const t = typeof v;
+        return (t === 'string' && v === '') || (t === 'object' && Object.keys(v).length === 0);
+    }
+    /**
+     * Resource equality.
+     * Ignores meta.versionId and meta.lastUpdated.
+     * See: https://dmitripavlutin.com/how-to-compare-objects-in-javascript/#4-deep-equality
+     * @param object1 The first object.
+     * @param object2 The second object.
+     * @returns True if the objects are equal.
+     */
+    function deepEquals(object1, object2, path) {
+        let keys1 = Object.keys(object1);
+        let keys2 = Object.keys(object2);
+        if (path === 'meta') {
+            keys1 = keys1.filter((k) => k !== 'versionId' && k !== 'lastUpdated' && k !== 'author');
+            keys2 = keys2.filter((k) => k !== 'versionId' && k !== 'lastUpdated' && k !== 'author');
+        }
+        if (keys1.length !== keys2.length) {
+            return false;
+        }
+        for (const key of keys1) {
+            const val1 = object1[key];
+            const val2 = object2[key];
+            if (isObject(val1) && isObject(val2)) {
+                if (!deepEquals(val1, val2, key)) {
+                    return false;
+                }
+            }
+            else {
+                if (val1 !== val2) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    function isObject(object) {
+        return object !== null && typeof object === 'object';
+    }
+    // Precompute hex octets
+    // See: https://stackoverflow.com/a/55200387
+    const byteToHex = [];
+    for (let n = 0; n < 256; n++) {
+        byteToHex.push(n.toString(16).padStart(2, '0'));
+    }
+    /**
+     * Converts an ArrayBuffer to hex string.
+     * See: https://stackoverflow.com/a/55200387
+     * @param arrayBuffer The input array buffer.
+     * @returns The resulting hex string.
+     */
+    function arrayBufferToHex(arrayBuffer) {
+        const bytes = new Uint8Array(arrayBuffer);
+        const result = new Array(bytes.length);
+        for (let i = 0; i < bytes.length; i++) {
+            result[i] = byteToHex[bytes[i]];
+        }
+        return result.join('');
+    }
+    /**
+     * Converts an ArrayBuffer to a base-64 encoded string.
+     * @param arrayBuffer The input array buffer.
+     * @returns The base-64 encoded string.
+     */
+    function arrayBufferToBase64(arrayBuffer) {
+        const bytes = new Uint8Array(arrayBuffer);
+        const result = [];
+        for (let i = 0; i < bytes.length; i++) {
+            result[i] = String.fromCharCode(bytes[i]);
+        }
+        return window.btoa(result.join(''));
+    }
+    function capitalize(word) {
+        return word.charAt(0).toUpperCase() + word.substr(1);
+    }
+    function isLowerCase(c) {
+        return c === c.toLowerCase();
+    }
+
+    /**
+     * Returns a cryptographically secure random string.
+     */
+    function getRandomString() {
+        const randomItems = new Uint32Array(28);
+        crypto.getRandomValues(randomItems);
+        return arrayBufferToHex(randomItems.buffer);
+    }
+    /**
+     * Encrypts a string with SHA256 encryption.
+     * @param str
+     */
+    function encryptSHA256(str) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return crypto.subtle.digest('SHA-256', new TextEncoder().encode(str));
+        });
+    }
+
+    /*
+     * Based on: https://developer.mozilla.org/en-US/docs/Web/API/EventTarget
+     */
+    class EventTarget {
+        constructor() {
+            this.listeners = {};
+        }
+        addEventListener(type, callback) {
+            if (!this.listeners[type]) {
+                this.listeners[type] = [];
+            }
+            this.listeners[type].push(callback);
+        }
+        removeEventListeneer(type, callback) {
+            const array = this.listeners[type];
+            if (!array) {
+                return;
+            }
+            for (let i = 0; i < array.length; i++) {
+                if (array[i] === callback) {
+                    array.splice(i, 1);
+                    return;
+                }
+            }
+        }
+        dispatchEvent(event) {
+            const array = this.listeners[event.type];
+            if (array) {
+                array.forEach((listener) => listener.call(this, event));
+            }
+            return !event.defaultPrevented;
+        }
+    }
+
+    /**
+     * Decodes a section of a JWT.
+     * See: https://tools.ietf.org/html/rfc7519
+     * @param payload
+     */
+    function decodePayload(payload) {
+        const cleanedPayload = payload.replace(/-/g, '+').replace(/_/g, '/');
+        const decodedPayload = window.atob(cleanedPayload);
+        const uriEncodedPayload = Array.from(decodedPayload).reduce((acc, char) => {
+            const uriEncodedChar = ('00' + char.charCodeAt(0).toString(16)).slice(-2);
+            return `${acc}%${uriEncodedChar}`;
+        }, '');
+        const jsonPayload = decodeURIComponent(uriEncodedPayload);
+        return JSON.parse(jsonPayload);
+    }
+    /**
+     * Parses the JWT payload.
+     * @param token JWT token
+     */
+    function parseJWTPayload(token) {
+        const [_header, payload, _signature] = token.split('.');
+        return decodePayload(payload);
+    }
+
+    const OK_ID = 'ok';
+    const CREATED_ID = 'created';
+    const GONE_ID = 'gone';
+    const NOT_MODIFIED_ID = 'not-modified';
+    const NOT_FOUND_ID = 'not-found';
+    const ACCESS_DENIED = 'access-denied';
+    const allOk = {
+        resourceType: 'OperationOutcome',
+        id: OK_ID,
+        issue: [
+            {
+                severity: 'information',
+                code: 'information',
+                details: {
+                    text: 'All OK',
+                },
+            },
+        ],
+    };
+    const created = {
+        resourceType: 'OperationOutcome',
+        id: CREATED_ID,
+        issue: [
+            {
+                severity: 'information',
+                code: 'information',
+                details: {
+                    text: 'Created',
+                },
+            },
+        ],
+    };
+    const notModified = {
+        resourceType: 'OperationOutcome',
+        id: NOT_MODIFIED_ID,
+        issue: [
+            {
+                severity: 'information',
+                code: 'information',
+                details: {
+                    text: 'Not Modified',
+                },
+            },
+        ],
+    };
+    const notFound = {
+        resourceType: 'OperationOutcome',
+        id: NOT_FOUND_ID,
+        issue: [
+            {
+                severity: 'error',
+                code: 'not-found',
+                details: {
+                    text: 'Not found',
+                },
+            },
+        ],
+    };
+    const gone = {
+        resourceType: 'OperationOutcome',
+        id: GONE_ID,
+        issue: [
+            {
+                severity: 'error',
+                code: 'gone',
+                details: {
+                    text: 'Gone',
+                },
+            },
+        ],
+    };
+    const accessDenied = {
+        resourceType: 'OperationOutcome',
+        id: ACCESS_DENIED,
+        issue: [
+            {
+                severity: 'error',
+                code: 'access-denied',
+                details: {
+                    text: 'Access Denied',
+                },
+            },
+        ],
+    };
+    function badRequest(details, expression) {
+        return {
+            resourceType: 'OperationOutcome',
+            issue: [
+                {
+                    severity: 'error',
+                    code: 'invalid',
+                    details: {
+                        text: details,
+                    },
+                    expression: expression ? [expression] : undefined,
+                },
+            ],
+        };
+    }
+    function isOk(outcome) {
+        return outcome.id === OK_ID || outcome.id === CREATED_ID || outcome.id === NOT_MODIFIED_ID;
+    }
+    function isNotFound(outcome) {
+        return outcome.id === NOT_FOUND_ID;
+    }
+    function isGone(outcome) {
+        return outcome.id === GONE_ID;
+    }
+    function getStatus(outcome) {
+        if (outcome.id === OK_ID) {
+            return 200;
+        }
+        else if (outcome.id === CREATED_ID) {
+            return 201;
+        }
+        else if (outcome.id === NOT_MODIFIED_ID) {
+            return 304;
+        }
+        else if (outcome.id === ACCESS_DENIED) {
+            return 403;
+        }
+        else if (outcome.id === NOT_FOUND_ID) {
+            return 404;
+        }
+        else if (outcome.id === GONE_ID) {
+            return 410;
+        }
+        else {
+            return 400;
+        }
+    }
+    /**
+     * Asserts that the operation completed successfully and that the resource is defined.
+     * @param outcome The operation outcome.
+     * @param resource The resource that may or may not have been returned.
+     */
+    function assertOk(outcome, resource) {
+        if (!isOk(outcome) || resource === undefined) {
+            throw new OperationOutcomeError(outcome);
+        }
+    }
+    class OperationOutcomeError extends Error {
+        constructor(outcome) {
+            var _a, _b;
+            super((_b = (_a = outcome === null || outcome === void 0 ? void 0 : outcome.issue) === null || _a === void 0 ? void 0 : _a[0].details) === null || _b === void 0 ? void 0 : _b.text);
+            this.outcome = outcome;
+        }
+    }
+
+    /**
+     * Search operators.
+     * These operators represent "modifiers" and "prefixes" in FHIR search.
+     * See: https://www.hl7.org/fhir/search.html
+     */
+    exports.Operator = void 0;
+    (function (Operator) {
+        Operator["EQUALS"] = "eq";
+        Operator["NOT_EQUALS"] = "ne";
+        // Numbers
+        Operator["GREATER_THAN"] = "gt";
+        Operator["LESS_THAN"] = "lt";
+        Operator["GREATER_THAN_OR_EQUALS"] = "ge";
+        Operator["LESS_THAN_OR_EQUALS"] = "le";
+        // Dates
+        Operator["STARTS_AFTER"] = "sa";
+        Operator["ENDS_BEFORE"] = "eb";
+        Operator["APPROXIMATELY"] = "ap";
+        // String
+        Operator["CONTAINS"] = "contains";
+        Operator["EXACT"] = "exact";
+        // Token
+        Operator["TEXT"] = "text";
+        Operator["ABOVE"] = "above";
+        Operator["BELOW"] = "below";
+        Operator["IN"] = "in";
+        Operator["NOT_IN"] = "not-in";
+        Operator["OF_TYPE"] = "of-type";
+    })(exports.Operator || (exports.Operator = {}));
+    const MODIFIER_OPERATORS = [
+        exports.Operator.CONTAINS,
+        exports.Operator.EXACT,
+        exports.Operator.TEXT,
+        exports.Operator.ABOVE,
+        exports.Operator.BELOW,
+        exports.Operator.IN,
+        exports.Operator.NOT_IN,
+        exports.Operator.OF_TYPE,
+    ];
+    const PREFIX_OPERATORS = [
+        exports.Operator.NOT_EQUALS,
+        exports.Operator.GREATER_THAN,
+        exports.Operator.LESS_THAN,
+        exports.Operator.GREATER_THAN_OR_EQUALS,
+        exports.Operator.LESS_THAN_OR_EQUALS,
+        exports.Operator.STARTS_AFTER,
+        exports.Operator.ENDS_BEFORE,
+        exports.Operator.APPROXIMATELY,
+    ];
+    /**
+     * Parses a URL into a SearchRequest.
+     *
+     * See the FHIR search spec: http://hl7.org/fhir/r4/search.html
+     *
+     * @param location The URL to parse.
+     * @returns Parsed search definition.
+     */
+    function parseSearchDefinition(location) {
+        const resourceType = location.pathname.split('/').pop();
+        const params = new URLSearchParams(location.search);
+        const filters = [];
+        const sortRules = [];
+        let fields;
+        let page = 0;
+        let count = 10;
+        params.forEach((value, key) => {
+            if (key === '_fields') {
+                fields = value.split(',');
+            }
+            else if (key === '_page') {
+                page = parseInt(value);
+            }
+            else if (key === '_count') {
+                count = parseInt(value);
+            }
+            else if (key === '_sort') {
+                sortRules.push(parseSortRule(value));
+            }
+            else {
+                filters.push(parseSearchFilter(key, value));
+            }
+        });
+        return {
+            resourceType,
+            filters,
+            fields,
+            page,
+            count,
+            sortRules,
+        };
+    }
+    /**
+     * Parses a URL query parameter into a sort rule.
+     *
+     * By default, the sort rule is the field name.
+     *
+     * Sort rules can be reversed into descending order by prefixing the field name with a minus sign.
+     *
+     * See sorting: http://hl7.org/fhir/r4/search.html#_sort
+     *
+     * @param value The URL parameter value.
+     * @returns The parsed sort rule.
+     */
+    function parseSortRule(value) {
+        if (value.startsWith('-')) {
+            return { code: value.substring(1), descending: true };
+        }
+        else {
+            return { code: value };
+        }
+    }
+    /**
+     * Parses a URL query parameter into a search filter.
+     *
+     * FHIR search filters can be specified as modifiers or prefixes.
+     *
+     * For string properties, modifiers are appended to the key, e.g. "name:contains=eve".
+     *
+     * For date and numeric properties, prefixes are prepended to the value, e.g. "birthdate=gt2000".
+     *
+     * See the FHIR search spec: http://hl7.org/fhir/r4/search.html
+     *
+     * @param key The URL parameter key.
+     * @param value The URL parameter value.
+     * @returns The parsed search filter.
+     */
+    function parseSearchFilter(key, value) {
+        let code = key;
+        let operator = exports.Operator.EQUALS;
+        for (const modifier of MODIFIER_OPERATORS) {
+            const modifierIndex = code.indexOf(':' + modifier);
+            if (modifierIndex !== -1) {
+                operator = modifier;
+                code = code.substring(0, modifierIndex);
+            }
+        }
+        for (const prefix of PREFIX_OPERATORS) {
+            if (value.match(new RegExp('^' + prefix + '\\d'))) {
+                operator = prefix;
+                value = value.substring(prefix.length);
+            }
+        }
+        return { code, operator, value };
+    }
+    /**
+     * Formats a search definition object into a query string.
+     * Note: The return value does not include the resource type.
+     * @param {!SearchRequest} definition The search definition.
+     * @returns Formatted URL.
+     */
+    function formatSearchQuery(definition) {
+        const params = [];
+        if (definition.fields) {
+            params.push('_fields=' + definition.fields.join(','));
+        }
+        if (definition.filters) {
+            definition.filters.forEach((filter) => {
+                const modifier = MODIFIER_OPERATORS.includes(filter.operator) ? ':' + filter.operator : '';
+                const prefix = PREFIX_OPERATORS.includes(filter.operator) ? filter.operator : '';
+                params.push(`${filter.code}${modifier}=${prefix}${encodeURIComponent(filter.value)}`);
+            });
+        }
+        if (definition.sortRules) {
+            params.push(formatSortRules(definition.sortRules));
+        }
+        if (definition.page && definition.page > 0) {
+            params.push('_page=' + definition.page);
+        }
+        if (definition.count && definition.count > 0) {
+            params.push('_count=' + definition.count);
+        }
+        if (params.length === 0) {
+            return '';
+        }
+        params.sort();
+        return '?' + params.join('&');
+    }
+    function formatSortRules(sortRules) {
+        if (!sortRules || sortRules.length === 0) {
+            return '';
+        }
+        return '_sort=' + sortRules.map((sr) => (sr.descending ? '-' + sr.code : sr.code)).join(',');
+    }
+
+    /**
+     * The ClientStorage class is a utility class for storing strings and objects.
+     *
+     * When using MedplumClient in the browser, it will be backed by browser localStorage.
+     *
+     * When Using MedplumClient in the server, it will be backed by the MemoryStorage class.
+     */
+    class ClientStorage {
+        constructor() {
+            this.storage = typeof localStorage !== 'undefined' ? localStorage : new MemoryStorage();
+        }
+        clear() {
+            this.storage.clear();
+        }
+        getString(key) {
+            return this.storage.getItem(key) || undefined;
+        }
+        setString(key, value) {
+            if (value) {
+                this.storage.setItem(key, value);
+            }
+            else {
+                this.storage.removeItem(key);
+            }
+        }
+        getObject(key) {
+            const str = this.getString(key);
+            return str ? JSON.parse(str) : undefined;
+        }
+        setObject(key, value) {
+            this.setString(key, value ? stringify(value) : undefined);
+        }
+    }
+    /**
+     * The MemoryStorage class is a minimal in-memory implementation of the Storage interface.
+     */
+    class MemoryStorage {
+        constructor() {
+            this.data = new Map();
+        }
+        /**
+         * Returns the number of key/value pairs.
+         */
+        get length() {
+            return this.data.size;
+        }
+        /**
+         * Removes all key/value pairs, if there are any.
+         */
+        clear() {
+            this.data.clear();
+        }
+        /**
+         * Returns the current value associated with the given key, or null if the given key does not exist.
+         */
+        getItem(key) {
+            var _a;
+            return (_a = this.data.get(key)) !== null && _a !== void 0 ? _a : null;
+        }
+        /**
+         * Sets the value of the pair identified by key to value, creating a new key/value pair if none existed for key previously.
+         */
+        setItem(key, value) {
+            if (value) {
+                this.data.set(key, value);
+            }
+            else {
+                this.data.delete(key);
+            }
+        }
+        /**
+         * Removes the key/value pair with the given key, if a key/value pair with the given key exists.
+         */
+        removeItem(key) {
+            this.data.delete(key);
+        }
+        /**
+         * Returns the name of the nth key, or null if n is greater than or equal to the number of key/value pairs.
+         */
+        key(index) {
+            return Array.from(this.data.keys())[index];
+        }
+    }
+
+    /**
+     * List of property types.
+     * http://www.hl7.org/fhir/valueset-defined-types.html
+     * The list here includes additions found from StructureDefinition resources.
+     */
+    exports.PropertyType = void 0;
+    (function (PropertyType) {
+        PropertyType["Address"] = "Address";
+        PropertyType["Age"] = "Age";
+        PropertyType["Annotation"] = "Annotation";
+        PropertyType["Attachment"] = "Attachment";
+        PropertyType["BackboneElement"] = "BackboneElement";
+        PropertyType["CodeableConcept"] = "CodeableConcept";
+        PropertyType["Coding"] = "Coding";
+        PropertyType["ContactDetail"] = "ContactDetail";
+        PropertyType["ContactPoint"] = "ContactPoint";
+        PropertyType["Contributor"] = "Contributor";
+        PropertyType["Count"] = "Count";
+        PropertyType["DataRequirement"] = "DataRequirement";
+        PropertyType["Distance"] = "Distance";
+        PropertyType["Dosage"] = "Dosage";
+        PropertyType["Duration"] = "Duration";
+        PropertyType["Expression"] = "Expression";
+        PropertyType["Extension"] = "Extension";
+        PropertyType["HumanName"] = "HumanName";
+        PropertyType["Identifier"] = "Identifier";
+        PropertyType["MarketingStatus"] = "MarketingStatus";
+        PropertyType["Meta"] = "Meta";
+        PropertyType["Money"] = "Money";
+        PropertyType["Narrative"] = "Narrative";
+        PropertyType["ParameterDefinition"] = "ParameterDefinition";
+        PropertyType["Period"] = "Period";
+        PropertyType["Population"] = "Population";
+        PropertyType["ProdCharacteristic"] = "ProdCharacteristic";
+        PropertyType["ProductShelfLife"] = "ProductShelfLife";
+        PropertyType["Quantity"] = "Quantity";
+        PropertyType["Range"] = "Range";
+        PropertyType["Ratio"] = "Ratio";
+        PropertyType["Reference"] = "Reference";
+        PropertyType["RelatedArtifact"] = "RelatedArtifact";
+        PropertyType["Resource"] = "Resource";
+        PropertyType["SampledData"] = "SampledData";
+        PropertyType["Signature"] = "Signature";
+        PropertyType["SubstanceAmount"] = "SubstanceAmount";
+        PropertyType["SystemString"] = "http://hl7.org/fhirpath/System.String";
+        PropertyType["Timing"] = "Timing";
+        PropertyType["TriggerDefinition"] = "TriggerDefinition";
+        PropertyType["UsageContext"] = "UsageContext";
+        PropertyType["base64Binary"] = "base64Binary";
+        PropertyType["boolean"] = "boolean";
+        PropertyType["canonical"] = "canonical";
+        PropertyType["code"] = "code";
+        PropertyType["date"] = "date";
+        PropertyType["dateTime"] = "dateTime";
+        PropertyType["decimal"] = "decimal";
+        PropertyType["id"] = "id";
+        PropertyType["instant"] = "instant";
+        PropertyType["integer"] = "integer";
+        PropertyType["markdown"] = "markdown";
+        PropertyType["oid"] = "oid";
+        PropertyType["positiveInt"] = "positiveInt";
+        PropertyType["string"] = "string";
+        PropertyType["time"] = "time";
+        PropertyType["unsignedInt"] = "unsignedInt";
+        PropertyType["uri"] = "uri";
+        PropertyType["url"] = "url";
+        PropertyType["uuid"] = "uuid";
+    })(exports.PropertyType || (exports.PropertyType = {}));
+    /**
+     * Creates a new empty IndexedStructureDefinition.
+     * @returns The empty IndexedStructureDefinition.
+     */
+    function createSchema() {
+        return { types: {} };
+    }
+    /**
+     * Indexes a StructureDefinition for fast lookup.
+     * See comments on IndexedStructureDefinition for more details.
+     * @param schema The output IndexedStructureDefinition.
+     * @param structureDefinition The original StructureDefinition.
+     */
+    function indexStructureDefinition(schema, structureDefinition) {
+        var _a;
+        const typeName = structureDefinition.name;
+        if (!typeName) {
+            return;
+        }
+        schema.types[typeName] = {
+            display: typeName,
+            description: structureDefinition.description,
+            properties: {},
+        };
+        const elements = (_a = structureDefinition.snapshot) === null || _a === void 0 ? void 0 : _a.element;
+        if (elements) {
+            // Filter out any elements missing path or type
+            const filtered = elements.filter((e) => e.path !== typeName && e.path);
+            // First pass, build types
+            filtered.forEach((element) => indexType(schema, element));
+            // Second pass, build properties
+            filtered.forEach((element) => indexProperty(schema, element));
+        }
+    }
+    /**
+     * Indexes TypeSchema from an ElementDefinition.
+     * In the common case, there will be many ElementDefinition instances per TypeSchema.
+     * Only the first occurrence is saved.
+     * @param schema The output IndexedStructureDefinition.
+     * @param element The input ElementDefinition.
+     */
+    function indexType(schema, element) {
+        var _a, _b;
+        const path = element.path;
+        const typeCode = (_b = (_a = element.type) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.code;
+        if (typeCode !== 'Element' && typeCode !== 'BackboneElement') {
+            return;
+        }
+        const parts = path.split('.');
+        const typeName = buildTypeName(parts);
+        if (!(typeName in schema.types)) {
+            schema.types[typeName] = {
+                display: typeName,
+                description: element.definition,
+                parentType: buildTypeName(parts.slice(0, parts.length - 1)),
+                properties: {},
+            };
+        }
+    }
+    /**
+     * Indexes PropertySchema from an ElementDefinition.
+     * @param schema The output IndexedStructureDefinition.
+     * @param element The input ElementDefinition.
+     */
+    function indexProperty(schema, element) {
+        const path = element.path;
+        const parts = path.split('.');
+        if (parts.length === 1) {
+            return;
+        }
+        const typeName = buildTypeName(parts.slice(0, parts.length - 1));
+        const typeSchema = schema.types[typeName];
+        const key = parts[parts.length - 1];
+        typeSchema.properties[key] = element;
+    }
+    /**
+     * Indexes a SearchParameter resource for fast lookup.
+     * Indexes by SearchParameter.code, which is the query string parameter name.
+     * @param schema The output IndexedStructureDefinition.
+     * @param searchParam The SearchParameter resource.
+     */
+    function indexSearchParameter(schema, searchParam) {
+        if (!searchParam.base) {
+            return;
+        }
+        for (const resourceType of searchParam.base) {
+            const typeSchema = schema.types[resourceType];
+            if (!typeSchema) {
+                continue;
+            }
+            if (!typeSchema.searchParams) {
+                typeSchema.searchParams = {};
+            }
+            typeSchema.searchParams[searchParam.code] = searchParam;
+        }
+    }
+    function buildTypeName(components) {
+        return components.map(capitalize).join('');
+    }
+    function getPropertyDisplayName(property) {
+        // Get the property name, which is the remainder after the last period
+        // For example, for path "Patient.birthDate"
+        // the property name is "birthDate"
+        const propertyName = property.path.replaceAll('[x]', '').split('.').pop();
+        // Split by capital letters
+        // Capitalize the first letter of each word
+        // Join together with spaces in between
+        // Then normalize whitespace to single space character
+        // For example, for property name "birthDate",
+        // the display name is "Birth Date".
+        return propertyName
+            .split(/(?=[A-Z])/)
+            .map(capitalize)
+            .join(' ')
+            .replace('_', ' ')
+            .replace(/\s+/g, ' ');
+    }
+
+    // PKCE auth ased on:
+    const DEFAULT_BASE_URL = 'https://api.medplum.com/';
+    const DEFAULT_SCOPE = 'launch/patient openid fhirUser offline_access user/*.*';
+    const DEFAULT_RESOURCE_CACHE_SIZE = 1000;
+    const JSON_CONTENT_TYPE = 'application/json';
+    const FHIR_CONTENT_TYPE = 'application/fhir+json';
+    const PATCH_CONTENT_TYPE = 'application/json-patch+json';
+    class MedplumClient extends EventTarget {
+        constructor(options) {
+            var _a;
+            super();
+            if (options === null || options === void 0 ? void 0 : options.baseUrl) {
+                if (!options.baseUrl.startsWith('http')) {
+                    throw new Error('Base URL must start with http or https');
+                }
+                if (!options.baseUrl.endsWith('/')) {
+                    throw new Error('Base URL must end with a trailing slash');
+                }
+            }
+            this.fetch = (options === null || options === void 0 ? void 0 : options.fetch) || window.fetch.bind(window);
+            this.storage = new ClientStorage();
+            this.schema = createSchema();
+            this.resourceCache = new LRUCache((_a = options === null || options === void 0 ? void 0 : options.resourceCacheSize) !== null && _a !== void 0 ? _a : DEFAULT_RESOURCE_CACHE_SIZE);
+            this.baseUrl = (options === null || options === void 0 ? void 0 : options.baseUrl) || DEFAULT_BASE_URL;
+            this.clientId = (options === null || options === void 0 ? void 0 : options.clientId) || '';
+            this.authorizeUrl = (options === null || options === void 0 ? void 0 : options.authorizeUrl) || this.baseUrl + 'oauth2/authorize';
+            this.tokenUrl = (options === null || options === void 0 ? void 0 : options.tokenUrl) || this.baseUrl + 'oauth2/token';
+            this.logoutUrl = (options === null || options === void 0 ? void 0 : options.logoutUrl) || this.baseUrl + 'oauth2/logout';
+            this.onUnauthenticated = options === null || options === void 0 ? void 0 : options.onUnauthenticated;
+            this.loading = false;
+            this.refreshProfile().catch(console.log);
+            this.setupStorageListener();
+        }
+        /**
+         * Clears all auth state including local storage and session storage.
+         */
+        clear() {
+            this.storage.clear();
+            this.resourceCache.clear();
+            this.dispatchEvent({ type: 'change' });
+        }
+        get(url) {
+            return this.request('GET', url);
+        }
+        post(url, body, contentType) {
+            return this.request('POST', url, contentType, body);
+        }
+        put(url, body, contentType) {
+            return this.request('PUT', url, contentType, body);
+        }
+        delete(url) {
+            return this.request('DELETE', url);
+        }
+        /**
+         * Tries to register a new user.
+         * @param request The registration request.
+         * @returns Promise to the authentication response.
+         */
+        register(request) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const response = yield this.post('auth/register', request);
+                yield this.setActiveLogin(response);
+            });
+        }
+        /**
+         * Initiates a user login flow.
+         * @param email The email address of the user.
+         * @param password The password of the user.
+         * @param remember Optional flag to remember the user.
+         * @returns Promise to the authentication response.
+         */
+        startLogin(email, password, remember) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield this.startPkce();
+                return this.post('auth/login', {
+                    clientId: this.clientId,
+                    scope: DEFAULT_SCOPE,
+                    codeChallengeMethod: 'S256',
+                    codeChallenge: this.storage.getString('codeChallenge'),
+                    email,
+                    password,
+                    remember: !!remember,
+                });
+            });
+        }
+        /**
+         * Tries to sign in with Google authentication.
+         * The response parameter is the result of a Google authentication.
+         * See: https://developers.google.com/identity/gsi/web/guides/handle-credential-responses-js-functions
+         * @param googleResponse The Google credential response.
+         * @returns Promise to the authentication response.
+         */
+        startGoogleLogin(googleResponse) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield this.startPkce();
+                return this.post('auth/google', googleResponse);
+            });
+        }
+        /**
+         * Signs out locally.
+         * Does not invalidate tokens with the server.
+         */
+        signOut() {
+            this.clear();
+            return Promise.resolve();
+        }
+        /**
+         * Tries to sign in the user.
+         * Returns true if the user is signed in.
+         * This may result in navigating away to the sign in page.
+         */
+        signInWithRedirect() {
+            const urlParams = new URLSearchParams(window.location.search);
+            const code = urlParams.get('code');
+            if (!code) {
+                this.requestAuthorization();
+                return undefined;
+            }
+            else {
+                return this.processCode(code);
+            }
+        }
+        /**
+         * Tries to sign out the user.
+         * See: https://docs.aws.amazon.com/cognito/latest/developerguide/logout-endpoint.html
+         */
+        signOutWithRedirect() {
+            window.location.assign(this.logoutUrl);
+        }
+        /**
+         * Builds a FHIR URL from a collection of URL path components.
+         * For example, `buildUrl('/Patient', '123')` returns `fhir/R4/Patient/123`.
+         * @param path The path component of the URL.
+         * @returns The well-formed FHIR URL.
+         */
+        fhirUrl(...path) {
+            const builder = [this.baseUrl, 'fhir/R4'];
+            path.forEach((p) => builder.push('/', encodeURIComponent(p)));
+            return builder.join('');
+        }
+        /**
+         * Sends a FHIR search request.
+         * @param search The search query.
+         * @returns Promise to the search result bundle.
+         */
+        search(search) {
+            return this.get(this.fhirUrl(search.resourceType) + formatSearchQuery(search));
+        }
+        /**
+         * Searches a ValueSet resource using the "expand" operation.
+         * See: https://www.hl7.org/fhir/operation-valueset-expand.html
+         * @param system The ValueSet system url.
+         * @param filter The search string.
+         * @returns Promise to expanded ValueSet.
+         */
+        searchValueSet(system, filter) {
+            return this.get(this.fhirUrl('ValueSet', '$expand') +
+                `?url=${encodeURIComponent(system)}` +
+                `&filter=${encodeURIComponent(filter)}`);
+        }
+        /**
+         * Returns a cached resource if it is available.
+         * @param resourceType The FHIR resource type.
+         * @param id The FHIR resource ID.
+         * @returns The resource if it is available in the cache; undefined otherwise.
+         */
+        getCached(resourceType, id) {
+            const cached = this.resourceCache.get(resourceType + '/' + id);
+            if (cached && !('then' in cached)) {
+                return cached;
+            }
+            return undefined;
+        }
+        /**
+         * Returns a cached resource if it is available.
+         * @param resourceType The FHIR resource type.
+         * @param id The FHIR resource ID.
+         * @returns The resource if it is available in the cache; undefined otherwise.
+         */
+        getCachedReference(reference) {
+            const cached = this.resourceCache.get(reference.reference);
+            if (cached && !('then' in cached)) {
+                return cached;
+            }
+            return undefined;
+        }
+        read(resourceType, id) {
+            const cacheKey = resourceType + '/' + id;
+            const promise = this.get(this.fhirUrl(resourceType, id)).then((resource) => {
+                this.resourceCache.set(cacheKey, resource);
+                return resource;
+            });
+            this.resourceCache.set(cacheKey, promise);
+            return promise;
+        }
+        readCached(resourceType, id) {
+            const cached = this.resourceCache.get(resourceType + '/' + id);
+            return cached ? Promise.resolve(cached) : this.read(resourceType, id);
+        }
+        readReference(reference) {
+            const refString = reference === null || reference === void 0 ? void 0 : reference.reference;
+            if (!refString) {
+                return Promise.reject('Missing reference');
+            }
+            const [resourceType, id] = refString.split('/');
+            return this.read(resourceType, id);
+        }
+        readCachedReference(reference) {
+            const refString = reference === null || reference === void 0 ? void 0 : reference.reference;
+            if (!refString) {
+                return Promise.reject('Missing reference');
+            }
+            const [resourceType, id] = refString.split('/');
+            return this.readCached(resourceType, id);
+        }
+        /**
+         * Returns a cached schema for a resource type.
+         * If the schema is not cached, returns undefined.
+         * It is assumed that a client will call requestSchema before using this method.
+         * @param resourceType The FHIR resource type.
+         * @returns The schema if immediately available, undefined otherwise.
+         */
+        getSchema() {
+            return this.schema;
+        }
+        /**
+         * Requests the schema for a resource type.
+         * If the schema is already cached, the promise is resolved immediately.
+         * @param resourceType The FHIR resource type.
+         * @returns Promise to a schema with the requested resource type.
+         */
+        requestSchema(resourceType) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (resourceType in this.schema.types) {
+                    return Promise.resolve(this.schema);
+                }
+                const query = `{
+      StructureDefinitionList(name: "${encodeURIComponent(resourceType)}") {
+        name,
+        description,
+        snapshot {
+          element {
+            id,
+            path,
+            min,
+            max,
+            type {
+              code,
+              targetProfile
+            },
+            binding {
+              valueSet
+            },
+            definition
+          }
+        }
+      }
+      SearchParameterList(base: "${encodeURIComponent(resourceType)}") {
+        base,
+        code,
+        type
+      }
+    }`.replace(/\s+/g, ' ');
+                const response = (yield this.graphql(query));
+                for (const structureDefinition of response.data.StructureDefinitionList) {
+                    indexStructureDefinition(this.schema, structureDefinition);
+                }
+                for (const searchParameter of response.data.SearchParameterList) {
+                    indexSearchParameter(this.schema, searchParameter);
+                }
+                return this.schema;
+            });
+        }
+        readHistory(resourceType, id) {
+            return this.get(this.fhirUrl(resourceType, id, '_history'));
+        }
+        readPatientEverything(id) {
+            return this.get(this.fhirUrl('Patient', id, '$everything'));
+        }
+        create(resource) {
+            if (!resource.resourceType) {
+                throw new Error('Missing resourceType');
+            }
+            return this.post(this.fhirUrl(resource.resourceType), resource);
+        }
+        createBinary(data, filename, contentType) {
+            return this.post(this.fhirUrl('Binary') + '?_filename=' + encodeURIComponent(filename), data, contentType);
+        }
+        update(resource) {
+            if (!resource.resourceType) {
+                throw new Error('Missing resourceType');
+            }
+            if (!resource.id) {
+                throw new Error('Missing id');
+            }
+            return this.put(this.fhirUrl(resource.resourceType, resource.id), resource);
+        }
+        patch(resourceType, id, operations) {
+            return this.request('PATCH', this.fhirUrl(resourceType, id), PATCH_CONTENT_TYPE, operations);
+        }
+        deleteResource(resourceType, id) {
+            return this.delete(this.fhirUrl(resourceType, id));
+        }
+        graphql(query) {
+            return this.post(this.fhirUrl('$graphql'), { query }, JSON_CONTENT_TYPE);
+        }
+        getActiveLogin() {
+            return this.storage.getObject('activeLogin');
+        }
+        setActiveLogin(login) {
+            return __awaiter(this, void 0, void 0, function* () {
+                this.storage.setObject('activeLogin', login);
+                this.addLogin(login);
+                this.resourceCache.clear();
+                this.refreshPromise = undefined;
+                yield this.refreshProfile();
+            });
+        }
+        getLogins() {
+            var _a;
+            return (_a = this.storage.getObject('logins')) !== null && _a !== void 0 ? _a : [];
+        }
+        addLogin(newLogin) {
+            const logins = this.getLogins().filter((login) => { var _a, _b; return ((_a = login.profile) === null || _a === void 0 ? void 0 : _a.reference) !== ((_b = newLogin.profile) === null || _b === void 0 ? void 0 : _b.reference); });
+            logins.push(newLogin);
+            this.storage.setObject('logins', logins);
+        }
+        refreshProfile() {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                const reference = (_a = this.getActiveLogin()) === null || _a === void 0 ? void 0 : _a.profile;
+                if (reference === null || reference === void 0 ? void 0 : reference.reference) {
+                    this.loading = true;
+                    this.storage.setObject('profile', yield this.readCachedReference(reference));
+                    this.loading = false;
+                    this.dispatchEvent({ type: 'change' });
+                }
+                return this.getProfile();
+            });
+        }
+        getProfile() {
+            return this.storage.getObject('profile');
+        }
+        isLoading() {
+            return this.loading;
+        }
+        /**
+         * Makes an HTTP request.
+         * @param {string} method
+         * @param {string} url
+         * @param {string=} contentType
+         * @param {Object=} body
+         */
+        request(method, url, contentType, body) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                if (this.refreshPromise) {
+                    yield this.refreshPromise;
+                }
+                if (!url.startsWith('http')) {
+                    url = this.baseUrl + url;
+                }
+                const headers = {
+                    'Content-Type': contentType || FHIR_CONTENT_TYPE,
+                };
+                const accessToken = (_a = this.getActiveLogin()) === null || _a === void 0 ? void 0 : _a.accessToken;
+                if (accessToken) {
+                    headers['Authorization'] = 'Bearer ' + accessToken;
+                }
+                const options = {
+                    method: method,
+                    cache: 'no-cache',
+                    credentials: 'include',
+                    headers,
+                };
+                if (body) {
+                    if (typeof body === 'string' || (typeof File !== 'undefined' && body instanceof File)) {
+                        options.body = body;
+                    }
+                    else {
+                        options.body = stringify(body);
+                    }
+                }
+                const response = yield this.fetch(url, options);
+                if (response.status === 401) {
+                    // Refresh and try again
+                    return this.handleUnauthenticated(method, url, contentType, body);
+                }
+                if (response.status === 204 || response.status === 304) {
+                    // No content or change
+                    return undefined;
+                }
+                const obj = yield response.json();
+                if (obj.resourceType === 'OperationOutcome' && !isOk(obj)) {
+                    return Promise.reject(obj);
+                }
+                return obj;
+            });
+        }
+        /**
+         * Handles an unauthenticated response from the server.
+         * First, tries to refresh the access token and retry the request.
+         * Otherwise, calls unauthenticated callbacks and rejects.
+         * @param method The HTTP method of the original request.
+         * @param url The URL of the original request.
+         * @param contentType The content type of the original request.
+         * @param body The body of the original request.
+         */
+        handleUnauthenticated(method, url, contentType, body) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return this.refresh()
+                    .then(() => this.request(method, url, contentType, body))
+                    .catch((error) => {
+                    this.clear();
+                    if (this.onUnauthenticated) {
+                        this.onUnauthenticated();
+                    }
+                    return Promise.reject(error);
+                });
+            });
+        }
+        /**
+         * Starts a new PKCE flow.
+         * These PKCE values are stateful, and must survive redirects and page refreshes.
+         */
+        startPkce() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const pkceState = getRandomString();
+                this.storage.setString('pkceState', pkceState);
+                const codeVerifier = getRandomString();
+                this.storage.setString('codeVerifier', codeVerifier);
+                const arrayHash = yield encryptSHA256(codeVerifier);
+                const codeChallenge = arrayBufferToBase64(arrayHash).replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
+                this.storage.setString('codeChallenge', codeChallenge);
+            });
+        }
+        /**
+         * Redirects the user to the login screen for authorization.
+         * Clears all auth state including local storage and session storage.
+         * See: https://openid.net/specs/openid-connect-core-1_0.html#AuthorizationEndpoint
+         */
+        requestAuthorization() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!this.authorizeUrl) {
+                    throw new Error('Missing authorize URL');
+                }
+                this.startPkce();
+                window.location.assign(this.authorizeUrl +
+                    '?response_type=code' +
+                    '&state=' +
+                    encodeURIComponent(this.storage.getString('pkceState')) +
+                    '&client_id=' +
+                    encodeURIComponent(this.clientId) +
+                    '&redirect_uri=' +
+                    encodeURIComponent(getBaseUrl()) +
+                    '&scope=' +
+                    encodeURIComponent(DEFAULT_SCOPE) +
+                    '&code_challenge_method=S256' +
+                    '&code_challenge=' +
+                    encodeURIComponent(this.storage.getString('codeChallenge')));
+            });
+        }
+        /**
+         * Processes an OAuth authorization code.
+         * See: https://openid.net/specs/openid-connect-core-1_0.html#TokenRequest
+         * @param code The authorization code received by URL parameter.
+         */
+        processCode(code) {
+            const pkceState = this.storage.getString('pkceState');
+            if (!pkceState) {
+                this.clear();
+                throw new Error('Invalid PCKE state');
+            }
+            const codeVerifier = this.storage.getString('codeVerifier');
+            if (!codeVerifier) {
+                this.clear();
+                throw new Error('Invalid PCKE code verifier');
+            }
+            return this.fetchTokens('grant_type=authorization_code' +
+                (this.clientId ? '&client_id=' + encodeURIComponent(this.clientId) : '') +
+                '&code_verifier=' +
+                encodeURIComponent(codeVerifier) +
+                '&redirect_uri=' +
+                encodeURIComponent(getBaseUrl()) +
+                '&code=' +
+                encodeURIComponent(code));
+        }
+        /**
+         * Tries to refresh the auth tokens.
+         * See: https://openid.net/specs/openid-connect-core-1_0.html#RefreshTokens
+         */
+        refresh() {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                if (this.refreshPromise) {
+                    return this.refreshPromise;
+                }
+                const refreshToken = (_a = this.getActiveLogin()) === null || _a === void 0 ? void 0 : _a.refreshToken;
+                if (!refreshToken) {
+                    this.clear();
+                    return Promise.reject('Invalid refresh token');
+                }
+                this.refreshPromise = this.fetchTokens('grant_type=refresh_token' +
+                    '&client_id=' +
+                    encodeURIComponent(this.clientId) +
+                    '&refresh_token=' +
+                    encodeURIComponent(refreshToken));
+                yield this.refreshPromise;
+            });
+        }
+        /**
+         * Makes a POST request to the tokens endpoint.
+         * See: https://openid.net/specs/openid-connect-core-1_0.html#TokenEndpoint
+         * @param formBody Token parameters in URL encoded format.
+         */
+        fetchTokens(formBody) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!this.tokenUrl) {
+                    return Promise.reject('Missing token URL');
+                }
+                return this.fetch(this.tokenUrl, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+                    body: formBody,
+                })
+                    .then((response) => {
+                    if (!response.ok) {
+                        return Promise.reject('Failed to fetch tokens');
+                    }
+                    return response.json();
+                })
+                    .then((tokens) => this.verifyTokens(tokens))
+                    .then(() => this.getProfile());
+            });
+        }
+        /**
+         * Verifies the tokens received from the auth server.
+         * Validates the JWT against the JWKS.
+         * See: https://openid.net/specs/openid-connect-core-1_0.html#TokenEndpoint
+         * @param tokens
+         */
+        verifyTokens(tokens) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const token = tokens.access_token;
+                // Verify token has not expired
+                const tokenPayload = parseJWTPayload(token);
+                if (Date.now() >= tokenPayload.exp * 1000) {
+                    this.clear();
+                    return Promise.reject('Token expired');
+                }
+                // Verify app_client_id
+                if (this.clientId && tokenPayload.client_id !== this.clientId) {
+                    this.clear();
+                    return Promise.reject('Token was not issued for this audience');
+                }
+                yield this.setActiveLogin({
+                    accessToken: token,
+                    refreshToken: tokens.refresh_token,
+                    project: tokens.project,
+                    profile: tokens.profile,
+                });
+            });
+        }
+        /**
+         * Sets up a listener for window storage events.
+         * This synchronizes state across browser windows and browser tabs.
+         */
+        setupStorageListener() {
+            try {
+                window.addEventListener('storage', (e) => {
+                    if (e.key === null || e.key === 'activeLogin') {
+                        // Storage events fire when different tabs make changes.
+                        // On storage clear (key === null) or activeLogin change (key === 'activeLogin')
+                        // Refresh the page to ensure the active login is up to date.
+                        window.location.reload();
+                    }
+                });
+            }
+            catch (err) {
+                // Silently ignore if this environment does not support storage events
+            }
+        }
+    }
+    /**
+     * Returns the base URL for the current page.
+     */
+    function getBaseUrl() {
+        return window.location.protocol + '//' + window.location.host + '/';
+    }
+
+    exports.SearchParameterType = void 0;
+    (function (SearchParameterType) {
+        SearchParameterType["BOOLEAN"] = "BOOLEAN";
+        SearchParameterType["NUMBER"] = "NUMBER";
+        SearchParameterType["QUANTITY"] = "QUANTITY";
+        SearchParameterType["TEXT"] = "TEXT";
+        SearchParameterType["REFERENCE"] = "REFERENCE";
+        SearchParameterType["DATE"] = "DATE";
+        SearchParameterType["DATETIME"] = "DATETIME";
+        SearchParameterType["PERIOD"] = "PERIOD";
+    })(exports.SearchParameterType || (exports.SearchParameterType = {}));
+    /**
+     * Returns the type details of a SearchParameter.
+     *
+     * The SearchParameter resource has a "type" parameter, but that is missing some critical information.
+     *
+     * For example:
+     *   1) The "date" type includes "date", "datetime", and "period".
+     *   2) The "token" type includes enums and booleans.
+     *   3) Arrays/multiple values are not reflected at all.
+     *
+     * @param structureDefinitions Collection of StructureDefinition resources indexed by name.
+     * @param resourceType The root resource type.
+     * @param searchParam The search parameter.
+     * @returns The search parameter type details.
+     */
+    function getSearchParameterDetails(structureDefinitions, resourceType, searchParam) {
+        var _a, _b, _c, _d;
+        const columnName = convertCodeToColumnName(searchParam.code);
+        const expression = (_a = getExpressionForResourceType(resourceType, searchParam.expression)) === null || _a === void 0 ? void 0 : _a.split('.');
+        if (!expression) {
+            // This happens on compound types
+            // In the future, explore returning multiple column definitions
+            return { columnName, type: exports.SearchParameterType.TEXT };
+        }
+        let baseType = resourceType;
+        let propertyType = undefined;
+        let array = false;
+        for (let i = 1; i < expression.length; i++) {
+            const propertyName = expression[i];
+            const propertyDef = (_c = (_b = structureDefinitions.types[baseType]) === null || _b === void 0 ? void 0 : _b.properties) === null || _c === void 0 ? void 0 : _c[propertyName];
+            if (!propertyDef) {
+                // This happens on complex properties such as "collected[x]"/"collectedDateTime"/"collectedPeriod"
+                // In the future, explore returning multiple column definitions
+                return { columnName, type: exports.SearchParameterType.TEXT, array };
+            }
+            if (propertyDef.max === '*') {
+                array = true;
+            }
+            propertyType = (_d = propertyDef.type) === null || _d === void 0 ? void 0 : _d[0].code;
+            if (!propertyType) {
+                // This happens when one of parent properties uses contentReference
+                // In the future, explore following the reference
+                return { columnName, type: exports.SearchParameterType.TEXT, array };
+            }
+            if (i < expression.length - 1) {
+                if (propertyType === 'Element' || propertyType === 'BackboneElement') {
+                    baseType = baseType + capitalize(propertyName);
+                }
+                else {
+                    baseType = propertyType;
+                }
+            }
+        }
+        const type = getSearchParameterType(searchParam, propertyType);
+        return { columnName, type, array };
+    }
+    /**
+     * Converts a hyphen-delimited code to camelCase string.
+     * @param code The search parameter code.
+     * @returns The SQL column name.
+     */
+    function convertCodeToColumnName(code) {
+        return code.split('-').reduce((result, word, index) => result + (index ? capitalize(word) : word), '');
+    }
+    function getSearchParameterType(searchParam, propertyType) {
+        let type = exports.SearchParameterType.TEXT;
+        switch (searchParam.type) {
+            case 'date':
+                type = exports.SearchParameterType.DATE;
+                break;
+            case 'number':
+                type = exports.SearchParameterType.NUMBER;
+                break;
+            case 'quantity':
+                type = exports.SearchParameterType.QUANTITY;
+                break;
+            case 'reference':
+                type = exports.SearchParameterType.REFERENCE;
+                break;
+            case 'token':
+                if (propertyType === 'boolean') {
+                    type = exports.SearchParameterType.BOOLEAN;
+                }
+                break;
+        }
+        return type;
+    }
+    function getExpressionForResourceType(resourceType, expression) {
+        const expressions = expression.split(' | ');
+        for (const e of expressions) {
+            const simplified = simplifyExpression(e);
+            if (simplified.startsWith(resourceType + '.')) {
+                return simplified;
+            }
+        }
+        return undefined;
+    }
+    function simplifyExpression(input) {
+        let result = input.trim();
+        if (result.startsWith('(') && result.endsWith(')')) {
+            result = result.substring(1, result.length - 1);
+        }
+        if (result.includes(' as ')) {
+            result = result.substring(0, result.indexOf(' as '));
+        }
+        if (result.includes('.where(')) {
+            result = result.substring(0, result.indexOf('.where('));
+        }
+        return result;
+    }
+
+    exports.MedplumClient = MedplumClient;
+    exports.OperationOutcomeError = OperationOutcomeError;
+    exports.accessDenied = accessDenied;
+    exports.allOk = allOk;
+    exports.arrayBufferToBase64 = arrayBufferToBase64;
+    exports.arrayBufferToHex = arrayBufferToHex;
+    exports.assertOk = assertOk;
+    exports.badRequest = badRequest;
+    exports.buildTypeName = buildTypeName;
+    exports.capitalize = capitalize;
+    exports.createReference = createReference;
+    exports.createSchema = createSchema;
+    exports.created = created;
+    exports.deepEquals = deepEquals;
+    exports.formatAddress = formatAddress;
+    exports.formatFamilyName = formatFamilyName;
+    exports.formatGivenName = formatGivenName;
+    exports.formatHumanName = formatHumanName;
+    exports.formatSearchQuery = formatSearchQuery;
+    exports.getDateProperty = getDateProperty;
+    exports.getDisplayString = getDisplayString;
+    exports.getExpressionForResourceType = getExpressionForResourceType;
+    exports.getImageSrc = getImageSrc;
+    exports.getPropertyDisplayName = getPropertyDisplayName;
+    exports.getReferenceString = getReferenceString;
+    exports.getSearchParameterDetails = getSearchParameterDetails;
+    exports.getStatus = getStatus;
+    exports.gone = gone;
+    exports.indexSearchParameter = indexSearchParameter;
+    exports.indexStructureDefinition = indexStructureDefinition;
+    exports.isGone = isGone;
+    exports.isLowerCase = isLowerCase;
+    exports.isNotFound = isNotFound;
+    exports.isOk = isOk;
+    exports.isProfileResource = isProfileResource;
+    exports.notFound = notFound;
+    exports.notModified = notModified;
+    exports.parseSearchDefinition = parseSearchDefinition;
+    exports.stringify = stringify;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=index.js.map