@openmrs/esm-react-utils 6.3.1-pre.2965 → 6.3.1-pre.2986

package/.swcrc

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://swc.rs/schema.json",
+  "exclude": [".*\\.test\\..*", "setup-tests\\..*"],
+  "module": {
+    "type": "es6",
+    "resolveFully": true
+  },
+  "jsc": {
+    "parser": {
+      "syntax": "typescript",
+      "tsx": false
+    },
+    "target": "es2020",
+    "baseUrl": "src"
+  }
+}

package/.turbo/turbo-build.log

@@ -1,14 +1,3 @@
-asset openmrs-esm-react-utils.js 92.6 KiB [emitted] [minimized] (name: main) 2 related assets
-orphan modules 848 KiB [orphan] 693 modules
-runtime modules 937 bytes 4 modules
-built modules 310 KiB [built]
-  modules by path external "@openmrs/ 336 bytes
-    external "@openmrs/esm-navigation" 42 bytes [built] [code generated]
-    external "@openmrs/esm-extensions" 42 bytes [built] [code generated]
-    + 6 modules
-  cacheable modules 309 KiB
-    modules by path ../../../node_modules/ 3.11 KiB 4 modules
-    ./src/index.ts + 141 modules 298 KiB [built] [code generated]
-    ../esm-state/dist/openmrs-esm-state.js 8.12 KiB [built] [code generated]
-  + 5 modules
-webpack 5.88.0 compiled successfully in 10351 ms
+[0] Successfully compiled: 50 files with swc (174.78ms)
+[0] swc --strip-leading-paths src -d dist exited with code 0
+[1] tsc --project tsconfig.build.json exited with code 0

package/dist/ComponentContext.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+export interface ExtensionData {
+    extensionSlotName: string;
+    extensionSlotModuleName: string;
+    extensionId: string;
+}
+export interface ComponentConfig {
+    moduleName: string;
+    featureName: string;
+    extension?: ExtensionData;
+}
+/**
+ * Available to all components. Provided by `openmrsComponentDecorator`.
+ */
+export declare const ComponentContext: React.Context<ComponentConfig>;

package/dist/ComponentContext.js

@@ -0,0 +1,7 @@
+import React from "react";
+/**
+ * Available to all components. Provided by `openmrsComponentDecorator`.
+ */ export const ComponentContext = React.createContext({
+    moduleName: '',
+    featureName: ''
+});

package/dist/ConfigurableLink.d.ts

@@ -0,0 +1,21 @@
+/** @module @category Navigation */
+import React, { type MouseEvent, type AnchorHTMLAttributes, type PropsWithChildren } from 'react';
+import { type TemplateParams } from '@openmrs/esm-navigation';
+/**
+ * @noInheritDoc
+ */
+export interface ConfigurableLinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+    to: string;
+    templateParams?: TemplateParams;
+    onBeforeNavigate?: (event: MouseEvent) => void;
+}
+/**
+ * A React link component which calls [[navigate]] when clicked
+ *
+ * @param to The target path or URL. Supports interpolation. See [[navigate]]
+ * @param templateParams: A dictionary of values to interpolate into the URL, in addition to the default keys `openmrsBase` and `openmrsSpaBase`.
+ * @param onBeforeNavigate A callback to be called just before navigation occurs
+ * @param children Inline elements within the link
+ * @param otherProps Any other valid props for an <a> tag except `href` and `onClick`
+ */
+export declare function ConfigurableLink({ to, templateParams, onBeforeNavigate, children, ...otherProps }: PropsWithChildren<ConfigurableLinkProps>): React.JSX.Element;

package/dist/ConfigurableLink.js

@@ -0,0 +1,48 @@
+/** @module @category Navigation */ import React, { useEffect } from "react";
+import { navigate, interpolateUrl } from "@openmrs/esm-navigation";
+function handleClick(event, to, templateParams, onBeforeNavigate) {
+    // Left click without modifiers (normal navigation)
+    if (event.button === 0 && !event.ctrlKey && !event.shiftKey && !event.altKey && !event.metaKey) {
+        event.preventDefault();
+        onBeforeNavigate?.(event);
+        navigate({
+            to,
+            templateParams
+        });
+    }
+    // Left click with Ctrl key (or Cmd key on Mac) - Open in new tab
+    if (event.button === 0 && (event.ctrlKey || event.metaKey)) {
+        onBeforeNavigate?.(event);
+    }
+    // Left click with Shift key - Open in new window
+    if (event.button === 0 && event.shiftKey) {
+        onBeforeNavigate?.(event);
+    }
+    // Middle click - Open in new background tab
+    if (event.button === 1) {
+        onBeforeNavigate?.(event);
+    }
+}
+/**
+ * A React link component which calls [[navigate]] when clicked
+ *
+ * @param to The target path or URL. Supports interpolation. See [[navigate]]
+ * @param templateParams: A dictionary of values to interpolate into the URL, in addition to the default keys `openmrsBase` and `openmrsSpaBase`.
+ * @param onBeforeNavigate A callback to be called just before navigation occurs
+ * @param children Inline elements within the link
+ * @param otherProps Any other valid props for an <a> tag except `href` and `onClick`
+ */ export function ConfigurableLink({ to, templateParams, onBeforeNavigate, children, ...otherProps }) {
+    useEffect(()=>{
+        if (otherProps.href) {
+            console.warn(`ConfigurableLink does not support the href prop. Use the 'to' prop instead. The provided href value is '${otherProps.href}'`);
+        }
+        if (otherProps.onClick) {
+            console.warn(`ConfigurableLink does not support the onClick prop. Use the 'onBeforeNavigate' prop instead. The 'to' prop of the offending link is ${to}`);
+        }
+    }, []);
+    return /*#__PURE__*/ React.createElement("a", {
+        onClick: (event)=>handleClick(event, to, templateParams, onBeforeNavigate),
+        href: interpolateUrl(to, templateParams),
+        ...otherProps
+    }, children);
+}

package/dist/Extension.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+export type ExtensionProps = React.HTMLAttributes<HTMLDivElement> & {
+    state?: Record<string, unknown>;
+};
+/**
+ * Represents the position in the DOM where each extension within
+ * an extension slot is rendered.
+ *
+ * Renders once for each extension attached to that extension slot.
+ *
+ * Usage of this component *must* have an ancestor `<ExtensionSlot>`,
+ * and *must* only be used once within that `<ExtensionSlot>`.
+ */
+export declare const Extension: React.FC<ExtensionProps>;

package/dist/Extension.js

@@ -0,0 +1,83 @@
+/** @module @category Extension */ import { renderExtension } from "@openmrs/esm-extensions";
+import React, { useCallback, useContext, useEffect, useRef } from "react";
+import { ComponentContext } from "./index.js";
+/**
+ * Represents the position in the DOM where each extension within
+ * an extension slot is rendered.
+ *
+ * Renders once for each extension attached to that extension slot.
+ *
+ * Usage of this component *must* have an ancestor `<ExtensionSlot>`,
+ * and *must* only be used once within that `<ExtensionSlot>`.
+ */ export const Extension = ({ state, children, ...divProps })=>{
+    const { extension } = useContext(ComponentContext);
+    const parcel = useRef(null);
+    const updatePromise = useRef(Promise.resolve());
+    const ref = useCallback((node)=>{
+        if (extension?.extensionSlotName && extension.extensionSlotModuleName && extension.extensionSlotModuleName && !parcel.current) {
+            renderExtension(node, extension.extensionSlotName, extension.extensionSlotModuleName, extension.extensionId, undefined, state).then((newParcel)=>{
+                parcel.current = newParcel;
+            });
+        }
+    }, []);
+    useEffect(()=>{
+        return ()=>{
+            if (parcel && parcel.current) {
+                const status = parcel.current.getStatus();
+                switch(status){
+                    case 'MOUNTING':
+                        parcel.current.mountPromise.then(()=>{
+                            if (parcel.current?.getStatus() === 'MOUNTED') {
+                                parcel.current.unmount();
+                            }
+                        });
+                        break;
+                    case 'MOUNTED':
+                        parcel.current.unmount();
+                        break;
+                    case 'UPDATING':
+                        if (updatePromise.current) {
+                            updatePromise.current.then(()=>{
+                                if (parcel.current?.getStatus() === 'MOUNTED') {
+                                    parcel.current.unmount();
+                                }
+                            });
+                        }
+                }
+            }
+        };
+    }, []);
+    useEffect(()=>{
+        if (parcel.current && parcel.current.update && parcel.current.getStatus() !== 'UNMOUNTING') {
+            Promise.all([
+                parcel.current.mountPromise,
+                updatePromise.current
+            ]).then(()=>{
+                if (parcel?.current?.getStatus() === 'MOUNTED' && parcel.current.update) {
+                    updatePromise.current = parcel.current.update({
+                        ...state
+                    }).catch((err)=>{
+                        // if we were trying to update but the component was unmounted
+                        // while this was happening, ignore the error
+                        if (!(err instanceof Error) || !err.message.includes('minified message #32') || parcel.current?.getStatus() === 'MOUNTED') {
+                            throw err;
+                        }
+                    });
+                }
+            });
+        }
+    }, [
+        state
+    ]);
+    // The extension is rendered into the `<div>`. The `<div>` has relative
+    // positioning in order to allow the UI Editor to absolutely position
+    // elements within it.
+    return extension ? /*#__PURE__*/ React.createElement("div", {
+        ref: ref,
+        "data-extension-id": extension?.extensionId,
+        style: {
+            position: 'relative'
+        },
+        ...divProps
+    }) : null;
+};

package/dist/ExtensionSlot.d.ts

@@ -0,0 +1,69 @@
+/** @module @category Extension */
+import React from 'react';
+import { type AssignedExtension } from '@openmrs/esm-extensions';
+export interface ExtensionSlotBaseProps {
+    name: string;
+    /** @deprecated Use `name` */
+    extensionSlotName?: string;
+    select?: (extensions: Array<AssignedExtension>) => Array<AssignedExtension>;
+    state?: Record<string, unknown>;
+}
+export interface OldExtensionSlotBaseProps {
+    name?: string;
+    /** @deprecated Use `name` */
+    extensionSlotName: string;
+    select?: (extensions: Array<AssignedExtension>) => Array<AssignedExtension>;
+    state?: Record<string, unknown>;
+}
+export type ExtensionSlotProps = (OldExtensionSlotBaseProps | ExtensionSlotBaseProps) & Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> & {
+    children?: React.ReactNode | ((extension: AssignedExtension, state?: Record<string, unknown>) => React.ReactNode);
+};
+/**
+ * An [extension slot](https://o3-docs.openmrs.org/docs/extension-system).
+ * A place with a name. Extensions that get connected to that name
+ * will be rendered into this.
+ *
+ * @param props.name The name of the extension slot
+ * @param props.select An optional function for filtering or otherwise modifying
+ *   the list of extensions that will be rendered.
+ * @param props.state *Only works if no children are provided*. Passes data
+ *   through as props to the extensions that are mounted here. If `ExtensionSlot`
+ *   has children, you must pass the state through the `state` param of the
+ *   `Extension` component.
+ * @param props.children There are two different ways to use `ExtensionSlot`
+ *   children.
+ *  - Passing a `ReactNode`, the "normal" way. The child must contain the component
+ *     `Extension`. Whatever is passed as the child will be rendered once per extension.
+ *     See the first example below.
+ *  - Passing a function, the "render props" way. The child must be a function
+ *     which takes a [[ConnectedExtension]] as argument and returns a `ReactNode`.
+ *     the resulting react node must contain the component `Extension`. It will
+ *     be run for each extension. See the second example below.
+ *
+ * @example
+ * Passing a react node as children
+ *
+ * ```tsx
+ * <ExtensionSlot name="Foo">
+ *   <div style={{ width: 10rem }}>
+ *     <Extension />
+ *   </div>
+ * </ExtensionSlot>
+ * ```
+ *
+ * @example
+ * Passing a function as children
+ *
+ * ```tsx
+ * <ExtensionSlot name="Bar">
+ *   {(extension) => (
+ *     <h1>{extension.name}</h1>
+ *     <div style={{ color: extension.meta.color }}>
+ *       <Extension />
+ *     </div>
+ *   )}
+ * </ExtensionSlot>
+ * ```
+ *
+ */
+export declare function ExtensionSlot({ name: extensionSlotName, extensionSlotName: legacyExtensionSlotName, select, children, state, style, ...divProps }: ExtensionSlotProps): React.JSX.Element;

package/dist/ExtensionSlot.js

@@ -0,0 +1,97 @@
+/** @module @category Extension */ import React, { useRef, useMemo } from "react";
+import { ComponentContext } from "./ComponentContext.js";
+import { Extension } from "./Extension.js";
+import { useExtensionSlot } from "./useExtensionSlot.js";
+function defaultSelect(extensions) {
+    return extensions;
+}
+/**
+ * An [extension slot](https://o3-docs.openmrs.org/docs/extension-system).
+ * A place with a name. Extensions that get connected to that name
+ * will be rendered into this.
+ *
+ * @param props.name The name of the extension slot
+ * @param props.select An optional function for filtering or otherwise modifying
+ *   the list of extensions that will be rendered.
+ * @param props.state *Only works if no children are provided*. Passes data
+ *   through as props to the extensions that are mounted here. If `ExtensionSlot`
+ *   has children, you must pass the state through the `state` param of the
+ *   `Extension` component.
+ * @param props.children There are two different ways to use `ExtensionSlot`
+ *   children.
+ *  - Passing a `ReactNode`, the "normal" way. The child must contain the component
+ *     `Extension`. Whatever is passed as the child will be rendered once per extension.
+ *     See the first example below.
+ *  - Passing a function, the "render props" way. The child must be a function
+ *     which takes a [[ConnectedExtension]] as argument and returns a `ReactNode`.
+ *     the resulting react node must contain the component `Extension`. It will
+ *     be run for each extension. See the second example below.
+ *
+ * @example
+ * Passing a react node as children
+ *
+ * ```tsx
+ * <ExtensionSlot name="Foo">
+ *   <div style={{ width: 10rem }}>
+ *     <Extension />
+ *   </div>
+ * </ExtensionSlot>
+ * ```
+ *
+ * @example
+ * Passing a function as children
+ *
+ * ```tsx
+ * <ExtensionSlot name="Bar">
+ *   {(extension) => (
+ *     <h1>{extension.name}</h1>
+ *     <div style={{ color: extension.meta.color }}>
+ *       <Extension />
+ *     </div>
+ *   )}
+ * </ExtensionSlot>
+ * ```
+ *
+ */ export function ExtensionSlot({ name: extensionSlotName, extensionSlotName: legacyExtensionSlotName, select = defaultSelect, children, state, style, ...divProps }) {
+    if (children && state) {
+        throw new Error('Both children and state have been provided. If children are provided, the state must be passed as a prop to the `Extension` component.');
+    }
+    const name = extensionSlotName ?? legacyExtensionSlotName;
+    const slotRef = useRef(null);
+    const { extensions, extensionSlotModuleName } = useExtensionSlot(name);
+    const extensionsToRender = useMemo(()=>select(extensions), [
+        select,
+        extensions
+    ]);
+    const extensionsFromChildrenFunction = useMemo(()=>{
+        if (typeof children == 'function' && !/*#__PURE__*/ React.isValidElement(children)) {
+            return extensionsToRender.map((extension)=>children(extension, state));
+        }
+    }, [
+        children,
+        extensionsToRender
+    ]);
+    return /*#__PURE__*/ React.createElement("div", {
+        ref: slotRef,
+        "data-extension-slot-name": name,
+        "data-extension-slot-module-name": extensionSlotModuleName,
+        style: {
+            ...style,
+            position: 'relative'
+        },
+        ...divProps
+    }, name && extensionsToRender?.map((extension, i)=>/*#__PURE__*/ React.createElement(ComponentContext.Provider, {
+            key: extension.id,
+            value: {
+                moduleName: extensionSlotModuleName,
+                featureName: '',
+                extension: {
+                    extensionId: extension.id,
+                    extensionSlotName: name,
+                    extensionSlotModuleName
+                }
+            }
+        }, extensionsFromChildrenFunction?.[i] ?? (typeof children !== 'function' ? children : null) ?? /*#__PURE__*/ React.createElement(Extension, {
+            state: state
+        }))));
+}

package/dist/OpenmrsContext.d.ts

@@ -0,0 +1,20 @@
+export interface OpenmrsAppContextProps<T = unknown> {
+    /** the namespace that this component defines */
+    namespace: string;
+    /** used to control the value associated with the namespace */
+    value?: T;
+}
+/**
+ * OpenmrsAppContext is a simple React component meant to function similarly to React's Context,
+ * but built on top of the OpenmrsAppContext.
+ *
+ * @example
+ * ```ts
+ *    <OpenmrsAppContext namespace="something" value={{ key: "1234" }} />
+ * ```
+ *
+ * **Notes on usage:** Unlike a proper React context where the value is limited to the subtree under the
+ * context component, the `OpenmrsAppContext` is inherently global in scope. That means that _all applications_
+ * will see the values that you set for the namespace if they load the value of the namespace.
+ */
+export declare function OpenmrsAppContext<T extends {}>({ namespace, value }: OpenmrsAppContextProps<T>): null;

package/dist/OpenmrsContext.js

@@ -0,0 +1,17 @@
+/** @module @category Context */ import { useDefineAppContext } from "./useDefineAppContext.js";
+/**
+ * OpenmrsAppContext is a simple React component meant to function similarly to React's Context,
+ * but built on top of the OpenmrsAppContext.
+ *
+ * @example
+ * ```ts
+ *    <OpenmrsAppContext namespace="something" value={{ key: "1234" }} />
+ * ```
+ *
+ * **Notes on usage:** Unlike a proper React context where the value is limited to the subtree under the
+ * context component, the `OpenmrsAppContext` is inherently global in scope. That means that _all applications_
+ * will see the values that you set for the namespace if they load the value of the namespace.
+ */ export function OpenmrsAppContext({ namespace, value }) {
+    useDefineAppContext(namespace, value);
+    return null;
+}

package/dist/RenderIfValueIsTruthy.d.ts

@@ -0,0 +1,19 @@
+import React, { type PropsWithChildren } from 'react';
+/**
+ * A really simple component that renders its children if the prop named `value` has a truthy value
+ *
+ * @example
+ * ```tsx
+ * <RenderIfValueIsTruthy value={variable}>
+ *  <Component value={variable} />
+ * </RenderIfValueIsTruthy>
+ * ````
+ *
+ * @param props.value The value to check whether or not its truthy
+ * @param props.fallback What to render if the value is not truthy. If not specified, nothing will be rendered
+ * @param props.children The components to render if the `value` is truthy
+ */
+export declare const RenderIfValueIsTruthy: React.FC<PropsWithChildren<{
+    value: unknown;
+    fallback?: React.ReactNode;
+}>>;

package/dist/RenderIfValueIsTruthy.js

@@ -0,0 +1,20 @@
+import React from "react";
+/**
+ * A really simple component that renders its children if the prop named `value` has a truthy value
+ *
+ * @example
+ * ```tsx
+ * <RenderIfValueIsTruthy value={variable}>
+ *  <Component value={variable} />
+ * </RenderIfValueIsTruthy>
+ * ````
+ *
+ * @param props.value The value to check whether or not its truthy
+ * @param props.fallback What to render if the value is not truthy. If not specified, nothing will be rendered
+ * @param props.children The components to render if the `value` is truthy
+ */ export const RenderIfValueIsTruthy = ({ children, value, fallback })=>{
+    if (Boolean(value)) {
+        return /*#__PURE__*/ React.createElement(React.Fragment, null, children);
+    }
+    return fallback ? /*#__PURE__*/ React.createElement(React.Fragment, null, fallback) : null;
+};

package/dist/UserHasAccess.d.ts

@@ -0,0 +1,35 @@
+import React from 'react';
+export interface UserHasAccessProps {
+    privilege: string | string[];
+    fallback?: React.ReactNode;
+    children?: React.ReactNode;
+}
+/**
+ * A React component that renders its children only if the current user exists and has the privilege(s)
+ * specified by the `privilege` prop. This can be used not to render certain components when the user
+ * doesn't have the permission to use this.
+ *
+ * Note that for top-level extensions (i.e., the component that's the root of the extension), you don't
+ * need to use this component. Instead, when registering the extension, declare the required privileges
+ * as part of the extension registration. This is for use deeper in extensions or other components where
+ * a separate permission check might be needed.
+ *
+ * This can also be used to hide components when the current user is not logged in.
+ *
+ * @example
+ * ```ts
+ * <Form>
+ *   <UserHasAccess privilege='Form Finallizer'>
+ *     <Checkbox id="finalize-form" value={formFinalized} onChange={handleChange} />
+ *   </UserHasAccess>
+ * </Form>
+ * ````
+ *
+ * @param props.privilege Either a string for a single required privilege or an array of strings for a
+ *   set of required privileges. Note that sets of required privileges must all be matched.
+ * @param props.fallback What to render if the user does not have access or if the user is not currently
+ *   logged in. If not provided, nothing will be rendered
+ * @param props.children The children to be rendered only if the user is logged in and has the required
+ *   privileges.
+ */
+export declare const UserHasAccess: React.FC<UserHasAccessProps>;

package/dist/UserHasAccess.js

@@ -0,0 +1,43 @@
+/** @module @category API */ import { getCurrentUser, userHasAccess } from "@openmrs/esm-api";
+import React, { useEffect, useState } from "react";
+/**
+ * A React component that renders its children only if the current user exists and has the privilege(s)
+ * specified by the `privilege` prop. This can be used not to render certain components when the user
+ * doesn't have the permission to use this.
+ *
+ * Note that for top-level extensions (i.e., the component that's the root of the extension), you don't
+ * need to use this component. Instead, when registering the extension, declare the required privileges
+ * as part of the extension registration. This is for use deeper in extensions or other components where
+ * a separate permission check might be needed.
+ *
+ * This can also be used to hide components when the current user is not logged in.
+ *
+ * @example
+ * ```ts
+ * <Form>
+ *   <UserHasAccess privilege='Form Finallizer'>
+ *     <Checkbox id="finalize-form" value={formFinalized} onChange={handleChange} />
+ *   </UserHasAccess>
+ * </Form>
+ * ````
+ *
+ * @param props.privilege Either a string for a single required privilege or an array of strings for a
+ *   set of required privileges. Note that sets of required privileges must all be matched.
+ * @param props.fallback What to render if the user does not have access or if the user is not currently
+ *   logged in. If not provided, nothing will be rendered
+ * @param props.children The children to be rendered only if the user is logged in and has the required
+ *   privileges.
+ */ export const UserHasAccess = ({ privilege, fallback, children })=>{
+    const [user, setUser] = useState(null);
+    useEffect(()=>{
+        const subscription = getCurrentUser({
+            includeAuthStatus: false
+        }).subscribe(setUser);
+        return ()=>subscription.unsubscribe();
+    }, []);
+    if (user && userHasAccess(privilege, user)) {
+        return /*#__PURE__*/ React.createElement(React.Fragment, null, children);
+    } else {
+        return fallback ? /*#__PURE__*/ React.createElement(React.Fragment, null, fallback) : null;
+    }
+};

package/dist/getLifecycle.d.ts

@@ -0,0 +1,13 @@
+/** @module @category Framework */
+import type { ComponentType } from 'react';
+import singleSpaReact from 'single-spa-react';
+import type { ComponentDecoratorOptions } from './openmrsComponentDecorator';
+export declare function getLifecycle<T>(Component: ComponentType<T>, options: ComponentDecoratorOptions): singleSpaReact.ReactAppOrParcel<T>;
+export declare function getAsyncLifecycle<T>(lazy: () => Promise<{
+    default: ComponentType<T>;
+}>, options: ComponentDecoratorOptions): () => Promise<singleSpaReact.ReactAppOrParcel<T>>;
+export declare function getSyncLifecycle<T>(Component: ComponentType<T>, options: ComponentDecoratorOptions): () => Promise<singleSpaReact.ReactAppOrParcel<T>>;
+/**
+ * @deprecated Use getAsyncLifecycle instead.
+ */
+export declare const getAsyncExtensionLifecycle: typeof getAsyncLifecycle;

package/dist/getLifecycle.js

@@ -0,0 +1,20 @@
+/** @module @category Framework */ import React from "react";
+import ReactDOMClient from "react-dom/client";
+import singleSpaReact from "single-spa-react";
+import { openmrsComponentDecorator } from "./openmrsComponentDecorator.js";
+export function getLifecycle(Component, options) {
+    return singleSpaReact({
+        React,
+        ReactDOMClient,
+        rootComponent: openmrsComponentDecorator(options)(Component)
+    });
+}
+export function getAsyncLifecycle(lazy, options) {
+    return ()=>lazy().then(({ default: Component })=>getLifecycle(Component, options));
+}
+export function getSyncLifecycle(Component, options) {
+    return ()=>Promise.resolve(getLifecycle(Component, options));
+}
+/**
+ * @deprecated Use getAsyncLifecycle instead.
+ */ export const getAsyncExtensionLifecycle = getAsyncLifecycle;

package/dist/index.d.ts

@@ -0,0 +1,48 @@
+export * from './ComponentContext';
+export * from './ConfigurableLink';
+export * from './Extension';
+export * from './ExtensionSlot';
+export * from './OpenmrsContext';
+export * from './RenderIfValueIsTruthy';
+export * from './UserHasAccess';
+export * from './getLifecycle';
+export * from './openmrsComponentDecorator';
+export * from './useAbortController';
+export * from './useAppContext';
+export * from './useAssignedExtensionIds';
+export * from './useAssignedExtensions';
+export * from './useAttachments';
+export * from './useBodyScrollLock';
+export * from './useConfig';
+export * from './useConnectedExtensions';
+export * from './useConnectivity';
+export * from './useDebounce';
+export * from './useDefineAppContext';
+export * from './useEmrConfiguration';
+export * from './useExtensionInternalStore';
+export * from './useExtensionSlot';
+export * from './useExtensionSlotMeta';
+export * from './useExtensionSlotStore';
+export * from './useExtensionStore';
+export * from './useFeatureFlag';
+export * from './useForceUpdate';
+export * from './useFhirFetchAll';
+export * from './useFhirInfinite';
+export * from './useFhirPagination';
+export * from './useLayoutType';
+export * from './useLocations';
+export * from './useOnClickOutside';
+export * from './useOnVisible';
+export * from './useOpenmrsSWR';
+export * from './usePagination';
+export * from './usePatient';
+export * from './usePrimaryIdentifierResource';
+export * from './useRenderableExtensions';
+export * from './useStore';
+export * from './useVisit';
+export * from './useVisitContextStore';
+export * from './useVisitTypes';
+export { useOpenmrsFetchAll, type UseServerFetchAllOptions } from './useOpenmrsFetchAll';
+export { useOpenmrsInfinite, type UseServerInfiniteOptions } from './useOpenmrsInfinite';
+export { useOpenmrsPagination, type UseServerPaginationOptions } from './useOpenmrsPagination';
+export { useSession } from './useSession';