@openmrs/esm-extensions 6.3.1-pre.2965 → 6.3.1-pre.2997

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,16 +1,3 @@
-asset openmrs-esm-extensions.js 92 KiB [emitted] [minimized] (name: main) 1 related asset
-orphan modules 779 KiB [orphan] 666 modules
-runtime modules 670 bytes 3 modules
-built modules 234 KiB [built]
-  modules by path external "@openmrs/ 252 bytes
-    external "@openmrs/esm-config" 42 bytes [built] [code generated]
-    external "@openmrs/esm-state" 42 bytes [built] [code generated]
-    external "@openmrs/esm-api" 42 bytes [built] [code generated]
-    external "@openmrs/esm-expression-evaluator" 42 bytes [built] [code generated]
-    external "@openmrs/esm-feature-flags" 42 bytes [built] [code generated]
-    external "@openmrs/esm-utils" 42 bytes [built] [code generated]
-  cacheable modules 234 KiB
-    ./src/index.ts + 115 modules 227 KiB [built] [code generated]
-    ../esm-globals/dist/openmrs-esm-globals.js 6.29 KiB [built] [code generated]
-  external "single-spa" 42 bytes [built] [code generated]
-webpack 5.88.0 compiled successfully in 10431 ms
+[0] Successfully compiled: 8 files with swc (123.88ms)
+[0] swc --strip-leading-paths src -d dist exited with code 0
+[1] tsc --project tsconfig.build.json exited with code 0

package/dist/extensions.d.ts

@@ -0,0 +1,74 @@
+/** @module @category Extension */
+import { type AssignedExtension } from '.';
+import { type ExtensionRegistration, type ExtensionInternalStore } from './store';
+/**
+ * Given an extension ID, which is a string uniquely identifying
+ * an instance of an extension within an extension slot, this
+ * returns the extension name.
+ *
+ * @example
+ * ```js
+ * getExtensionNameFromId("foo#bar")
+ *  --> "foo"
+ * getExtensionNameFromId("baz")
+ *  --> "baz"
+ * ```
+ */
+export declare function getExtensionNameFromId(extensionId: string): string;
+export declare function getExtensionRegistrationFrom(state: ExtensionInternalStore, extensionId: string): ExtensionRegistration | undefined;
+export declare function getExtensionRegistration(extensionId: string): ExtensionRegistration | undefined;
+/**
+ * Extensions must be registered in order to be rendered.
+ * This is handled by the app shell, when extensions are provided
+ * via the `setupOpenMRS` return object.
+ * @internal
+ */
+export declare const registerExtension: (extensionRegistration: ExtensionRegistration) => void;
+/**
+ * Attach an extension to an extension slot.
+ *
+ * This will cause the extension to be rendered into the specified
+ * extension slot, unless it is removed by configuration. Using
+ * `attach` is an alternative to specifying the `slot` or `slots`
+ * in the extension declaration.
+ *
+ * It is particularly useful when creating a slot into which
+ * you want to render an existing extension. This enables you
+ * to do so without modifying the extension's declaration, which
+ * may be impractical or inappropriate, for example if you are
+ * writing a module for a specific implementation.
+ *
+ * @param slotName a name uniquely identifying the slot
+ * @param extensionId an extension name, with an optional #-suffix
+ *    to distinguish it from other instances of the same extension
+ *    attached to the same slot.
+ */
+export declare function attach(slotName: string, extensionId: string): void;
+/**
+ * @deprecated Avoid using this. Extension attachments should be considered declarative.
+ */
+export declare function detach(extensionSlotName: string, extensionId: string): void;
+/**
+ * @deprecated Avoid using this. Extension attachments should be considered declarative.
+ */
+export declare function detachAll(extensionSlotName: string): void;
+/**
+ * Gets the list of extensions assigned to a given slot
+ *
+ * @param slotName The slot to load the assigned extensions for
+ * @returns An array of extensions assigned to the named slot
+ */
+export declare function getAssignedExtensions(slotName: string): Array<AssignedExtension>;
+/**
+ * Used by by extension slots at mount time.
+ *
+ * @param moduleName The name of the module that contains the extension slot
+ * @param slotName The extension slot name that is actually used
+ * @internal
+ */
+export declare const registerExtensionSlot: (moduleName: string, slotName: string) => void;
+/**
+ * @internal
+ * Just for testing.
+ */
+export declare const reset: () => void;

package/dist/extensions.js

@@ -0,0 +1,351 @@
+/** @module @category Extension */ /*
+ * We have the following extension modes:
+ *
+ * - attached (set via code in form of: attach, detach, ...)
+ * - configured (set via configuration in form of: added, removed, ...)
+ * - assigned (computed from attached and configured)
+ * - connected (computed from assigned using connectivity and online / offline)
+ */ import { sessionStore, userHasAccess } from "@openmrs/esm-api";
+import { getExtensionConfigFromStore, getExtensionsConfigStore, getExtensionSlotConfig, getExtensionSlotConfigFromStore, getExtensionSlotsConfigStore } from "@openmrs/esm-config";
+import { evaluateAsBoolean } from "@openmrs/esm-expression-evaluator";
+import { featureFlagsStore } from "@openmrs/esm-feature-flags";
+import { subscribeConnectivityChanged } from "@openmrs/esm-globals";
+import { isOnline as isOnlineFn } from "@openmrs/esm-utils";
+import { isEqual } from "lodash-es";
+import { checkStatusFor, getExtensionInternalStore } from "./index.js";
+import { getExtensionStore, updateInternalExtensionStore } from "./store.js";
+const extensionInternalStore = getExtensionInternalStore();
+const extensionStore = getExtensionStore();
+const slotsConfigStore = getExtensionSlotsConfigStore();
+const extensionsConfigStore = getExtensionsConfigStore();
+// Keep the output store updated
+function updateExtensionOutputStore(internalState, extensionSlotConfigs, extensionsConfigStore, featureFlagStore, sessionStore) {
+    const slots = {};
+    const isOnline = isOnlineFn();
+    const enabledFeatureFlags = Object.entries(featureFlagStore.flags).filter(([, { enabled }])=>enabled).map(([name])=>name);
+    for (let [slotName, slot] of Object.entries(internalState.slots)){
+        const { config } = getExtensionSlotConfigFromStore(extensionSlotConfigs, slot.name);
+        const assignedExtensions = getAssignedExtensionsFromSlotData(slotName, internalState, config, extensionsConfigStore, enabledFeatureFlags, isOnline, sessionStore.session);
+        slots[slotName] = {
+            moduleName: slot.moduleName,
+            assignedExtensions
+        };
+    }
+    if (!isEqual(extensionStore.getState().slots, slots)) {
+        extensionStore.setState({
+            slots
+        });
+    }
+}
+extensionInternalStore.subscribe((internalStore)=>{
+    updateExtensionOutputStore(internalStore, slotsConfigStore.getState(), extensionsConfigStore.getState(), featureFlagsStore.getState(), sessionStore.getState());
+});
+slotsConfigStore.subscribe((slotConfigs)=>{
+    updateExtensionOutputStore(extensionInternalStore.getState(), slotConfigs, extensionsConfigStore.getState(), featureFlagsStore.getState(), sessionStore.getState());
+});
+extensionsConfigStore.subscribe((extensionConfigs)=>{
+    updateExtensionOutputStore(extensionInternalStore.getState(), slotsConfigStore.getState(), extensionConfigs, featureFlagsStore.getState(), sessionStore.getState());
+});
+featureFlagsStore.subscribe((featureFlagStore)=>{
+    updateExtensionOutputStore(extensionInternalStore.getState(), slotsConfigStore.getState(), extensionsConfigStore.getState(), featureFlagStore, sessionStore.getState());
+});
+sessionStore.subscribe((session)=>{
+    updateExtensionOutputStore(extensionInternalStore.getState(), slotsConfigStore.getState(), extensionsConfigStore.getState(), featureFlagsStore.getState(), session);
+});
+function updateOutputStoreToCurrent() {
+    updateExtensionOutputStore(extensionInternalStore.getState(), slotsConfigStore.getState(), extensionsConfigStore.getState(), featureFlagsStore.getState(), sessionStore.getState());
+}
+updateOutputStoreToCurrent();
+subscribeConnectivityChanged(updateOutputStoreToCurrent);
+function createNewExtensionSlotInfo(slotName, moduleName) {
+    return {
+        moduleName,
+        name: slotName,
+        attachedIds: [],
+        config: null
+    };
+}
+/**
+ * Given an extension ID, which is a string uniquely identifying
+ * an instance of an extension within an extension slot, this
+ * returns the extension name.
+ *
+ * @example
+ * ```js
+ * getExtensionNameFromId("foo#bar")
+ *  --> "foo"
+ * getExtensionNameFromId("baz")
+ *  --> "baz"
+ * ```
+ */ export function getExtensionNameFromId(extensionId) {
+    const [extensionName] = extensionId.split('#');
+    return extensionName;
+}
+export function getExtensionRegistrationFrom(state, extensionId) {
+    const name = getExtensionNameFromId(extensionId);
+    return state.extensions[name];
+}
+export function getExtensionRegistration(extensionId) {
+    const state = extensionInternalStore.getState();
+    return getExtensionRegistrationFrom(state, extensionId);
+}
+/**
+ * Extensions must be registered in order to be rendered.
+ * This is handled by the app shell, when extensions are provided
+ * via the `setupOpenMRS` return object.
+ * @internal
+ */ export const registerExtension = (extensionRegistration)=>extensionInternalStore.setState((state)=>{
+        state.extensions[extensionRegistration.name] = {
+            ...extensionRegistration,
+            instances: []
+        };
+        return state;
+    });
+/**
+ * Attach an extension to an extension slot.
+ *
+ * This will cause the extension to be rendered into the specified
+ * extension slot, unless it is removed by configuration. Using
+ * `attach` is an alternative to specifying the `slot` or `slots`
+ * in the extension declaration.
+ *
+ * It is particularly useful when creating a slot into which
+ * you want to render an existing extension. This enables you
+ * to do so without modifying the extension's declaration, which
+ * may be impractical or inappropriate, for example if you are
+ * writing a module for a specific implementation.
+ *
+ * @param slotName a name uniquely identifying the slot
+ * @param extensionId an extension name, with an optional #-suffix
+ *    to distinguish it from other instances of the same extension
+ *    attached to the same slot.
+ */ export function attach(slotName, extensionId) {
+    updateInternalExtensionStore((state)=>{
+        const existingSlot = state.slots[slotName];
+        if (!existingSlot) {
+            return {
+                ...state,
+                slots: {
+                    ...state.slots,
+                    [slotName]: {
+                        ...createNewExtensionSlotInfo(slotName),
+                        attachedIds: [
+                            extensionId
+                        ]
+                    }
+                }
+            };
+        } else {
+            return {
+                ...state,
+                slots: {
+                    ...state.slots,
+                    [slotName]: {
+                        ...existingSlot,
+                        attachedIds: [
+                            ...existingSlot.attachedIds,
+                            extensionId
+                        ]
+                    }
+                }
+            };
+        }
+    });
+}
+/**
+ * @deprecated Avoid using this. Extension attachments should be considered declarative.
+ */ export function detach(extensionSlotName, extensionId) {
+    updateInternalExtensionStore((state)=>{
+        const existingSlot = state.slots[extensionSlotName];
+        if (existingSlot && existingSlot.attachedIds.includes(extensionId)) {
+            return {
+                ...state,
+                slots: {
+                    ...state.slots,
+                    [extensionSlotName]: {
+                        ...existingSlot,
+                        attachedIds: existingSlot.attachedIds.filter((id)=>id !== extensionId)
+                    }
+                }
+            };
+        } else {
+            return state;
+        }
+    });
+}
+/**
+ * @deprecated Avoid using this. Extension attachments should be considered declarative.
+ */ export function detachAll(extensionSlotName) {
+    updateInternalExtensionStore((state)=>{
+        const existingSlot = state.slots[extensionSlotName];
+        if (existingSlot) {
+            return {
+                ...state,
+                slots: {
+                    ...state.slots,
+                    [extensionSlotName]: {
+                        ...existingSlot,
+                        attachedIds: []
+                    }
+                }
+            };
+        } else {
+            return state;
+        }
+    });
+}
+/**
+ * Get an order index for the extension. This will
+ * come from either its configured order, its registered order
+ * parameter, or the order in which it happened to be attached.
+ */ function getOrder(extensionId, configuredOrder, registeredOrderIndex, attachedOrder) {
+    const configuredIndex = configuredOrder.indexOf(extensionId);
+    if (configuredIndex !== -1) {
+        return configuredIndex;
+    } else if (registeredOrderIndex !== undefined) {
+        // extensions that don't have a configured order should appear after those that do
+        return 1000 + registeredOrderIndex;
+    } else {
+        const assignedIndex = attachedOrder.indexOf(extensionId);
+        if (assignedIndex !== -1) {
+            // extensions that have neither a configured nor registered order should appear
+            // after all others
+            return 2000 + assignedIndex;
+        } else {
+            return -1;
+        }
+    }
+}
+function getAssignedExtensionsFromSlotData(slotName, internalState, config, extensionConfigStoreState, enabledFeatureFlags, isOnline, session) {
+    const attachedIds = internalState.slots[slotName].attachedIds;
+    const assignedIds = calculateAssignedIds(config, attachedIds);
+    const extensions = [];
+    for (let id of assignedIds){
+        const { config: extensionConfig } = getExtensionConfigFromStore(extensionConfigStoreState, slotName, id);
+        const name = getExtensionNameFromId(id);
+        const extension = internalState.extensions[name];
+        // if the extension has not been registered yet, do not include it
+        if (extension) {
+            const requiredPrivileges = extensionConfig?.['Display conditions']?.privileges ?? extension.privileges ?? [];
+            if (requiredPrivileges && (typeof requiredPrivileges === 'string' || Array.isArray(requiredPrivileges) && requiredPrivileges.length > 0)) {
+                if (!session?.user) {
+                    continue;
+                }
+                if (!userHasAccess(requiredPrivileges, session.user)) {
+                    continue;
+                }
+            }
+            const displayConditionExpression = extensionConfig?.['Display conditions']?.expression ?? null;
+            if (displayConditionExpression !== null) {
+                try {
+                    if (!evaluateAsBoolean(displayConditionExpression, {
+                        session
+                    })) {
+                        continue;
+                    }
+                } catch (e) {
+                    console.error(`Error while evaluating expression ${displayConditionExpression}`, e);
+                    continue;
+                }
+            }
+            if (extension.featureFlag && !enabledFeatureFlags.includes(extension.featureFlag)) {
+                continue;
+            }
+            if (window.offlineEnabled && !checkStatusFor(isOnline, extension.online, extension.offline)) {
+                continue;
+            }
+            extensions.push({
+                id,
+                name,
+                moduleName: extension.moduleName,
+                config: extensionConfig,
+                featureFlag: extension.featureFlag,
+                meta: extension.meta,
+                online: extensionConfig?.['Display conditions']?.online ?? extension.online ?? true,
+                offline: extensionConfig?.['Display conditions']?.offline ?? extension.offline ?? false
+            });
+        }
+    }
+    return extensions;
+}
+/**
+ * Gets the list of extensions assigned to a given slot
+ *
+ * @param slotName The slot to load the assigned extensions for
+ * @returns An array of extensions assigned to the named slot
+ */ export function getAssignedExtensions(slotName) {
+    const internalState = extensionInternalStore.getState();
+    const { config: slotConfig } = getExtensionSlotConfig(slotName);
+    const extensionStoreState = extensionsConfigStore.getState();
+    const featureFlagState = featureFlagsStore.getState();
+    const sessionState = sessionStore.getState();
+    const isOnline = isOnlineFn();
+    const enabledFeatureFlags = Object.entries(featureFlagState.flags).filter(([, { enabled }])=>enabled).map(([name])=>name);
+    return getAssignedExtensionsFromSlotData(slotName, internalState, slotConfig, extensionStoreState, enabledFeatureFlags, isOnline, sessionState.session);
+}
+function calculateAssignedIds(config, attachedIds) {
+    const addedIds = config.add || [];
+    const removedIds = config.remove || [];
+    const idOrder = config.order || [];
+    const { extensions } = extensionInternalStore.getState();
+    return [
+        ...attachedIds,
+        ...addedIds
+    ].filter((id)=>!removedIds.includes(id)).sort((idA, idB)=>{
+        const ai = getOrder(idA, idOrder, extensions[getExtensionNameFromId(idA)]?.order, attachedIds);
+        const bi = getOrder(idB, idOrder, extensions[getExtensionNameFromId(idB)]?.order, attachedIds);
+        if (bi === -1) {
+            return -1;
+        } else if (ai === -1) {
+            return 1;
+        } else {
+            return ai - bi;
+        }
+    });
+}
+/**
+ * Used by by extension slots at mount time.
+ *
+ * @param moduleName The name of the module that contains the extension slot
+ * @param slotName The extension slot name that is actually used
+ * @internal
+ */ export const registerExtensionSlot = (moduleName, slotName)=>extensionInternalStore.setState((state)=>{
+        const existingModuleName = state.slots[slotName]?.moduleName;
+        if (existingModuleName && existingModuleName != moduleName) {
+            console.warn(`An extension slot with the name '${slotName}' already exists. Refusing to register the same slot name twice (in "registerExtensionSlot"). The existing one is from module ${existingModuleName}.`);
+            return state;
+        }
+        if (existingModuleName && existingModuleName == moduleName) {
+            // Re-rendering an existing slot
+            return state;
+        }
+        if (state.slots[slotName]) {
+            return {
+                ...state,
+                slots: {
+                    ...state.slots,
+                    [slotName]: {
+                        ...state.slots[slotName],
+                        moduleName
+                    }
+                }
+            };
+        }
+        const slot = createNewExtensionSlotInfo(slotName, moduleName);
+        return {
+            ...state,
+            slots: {
+                ...state.slots,
+                [slotName]: slot
+            }
+        };
+    });
+/**
+ * @internal
+ * Just for testing.
+ */ export const reset = ()=>extensionStore.setState(()=>{
+        return {
+            slots: {},
+            extensions: {}
+        };
+    });

package/dist/helpers.d.ts

@@ -0,0 +1,2 @@
+export declare function checkStatus(online?: boolean | object, offline?: boolean | object): boolean;
+export declare function checkStatusFor(status: boolean, online?: boolean | object, offline?: boolean | object): boolean;

package/dist/helpers.js

@@ -0,0 +1,7 @@
+import { isOnline } from "@openmrs/esm-utils";
+export function checkStatus(online = true, offline = false) {
+    return checkStatusFor(isOnline(), online, offline);
+}
+export function checkStatusFor(status, online = true, offline = false) {
+    return Boolean(status ? online : offline);
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './store';
+export * from './extensions';
+export * from './modals';
+export * from './workspaces';
+export * from './helpers';
+export * from './render';
+/** @deprecated Use `getExtensionStore`. The structure of this store has also changed. */
+declare const internalStore: import("zustand").StoreApi<import("./store").ExtensionInternalStore>;
+export { internalStore as extensionStore };

package/dist/index.js

@@ -0,0 +1,12 @@
+export * from "./store.js";
+export * from "./extensions.js";
+export * from "./modals.js";
+export * from "./workspaces.js";
+export * from "./helpers.js";
+export * from "./render.js";
+// Temporary compatibility hack
+// What is now `extensionInternalStore` used to be exposed
+// and used as `extensionStore`.
+import { getExtensionInternalStore } from "./store.js";
+/** @deprecated Use `getExtensionStore`. The structure of this store has also changed. */ const internalStore = getExtensionInternalStore();
+export { internalStore as extensionStore };

package/dist/modals.d.ts

@@ -0,0 +1,13 @@
+import type { LifeCycles } from 'single-spa';
+/** @internal */
+export interface ModalRegistration {
+    name: string;
+    load(): Promise<{
+        default?: LifeCycles;
+    } & LifeCycles>;
+    moduleName: string;
+}
+/** @internal */
+export declare function registerModal(modalRegistration: ModalRegistration): void;
+/** @internal */
+export declare function getModalRegistration(modalName: string): ModalRegistration | undefined;

package/dist/modals.js

@@ -0,0 +1,28 @@
+import { createGlobalStore } from "@openmrs/esm-state";
+import { getExtensionRegistration } from "./index.js";
+const modalRegistryStore = createGlobalStore('modalRegistry', {
+    modals: {}
+});
+/** @internal */ export function registerModal(modalRegistration) {
+    modalRegistryStore.setState((state)=>{
+        state.modals[modalRegistration.name] = modalRegistration;
+        return state;
+    });
+}
+/** @internal */ export function getModalRegistration(modalName) {
+    let modalRegistration = modalRegistryStore.getState().modals[modalName];
+    if (!modalRegistration) {
+        const extensionRegistration = getExtensionRegistration(modalName);
+        if (extensionRegistration) {
+            modalRegistration = {
+                name: modalName,
+                load: extensionRegistration.load,
+                moduleName: extensionRegistration.moduleName
+            };
+            console.warn(`Modal ${modalName} was registered as an extension. This is deprecated and will be removed in the future. Please register it in the "modals" section of routes.json instead of the "extensions" section.`);
+            // Register it so the warning only appears once
+            registerModal(modalRegistration);
+        }
+    }
+    return modalRegistration;
+}

package/dist/public.d.ts

@@ -0,0 +1,4 @@
+export { getExtensionNameFromId, registerExtension, attach, detach, detachAll, getAssignedExtensions, registerExtensionSlot, } from './extensions';
+export { type CancelLoading, renderExtension } from './render';
+export { type ExtensionMeta, type ExtensionRegistration, type ExtensionStore, type AssignedExtension, type ConnectedExtension, type ExtensionSlotState, getExtensionStore, } from './store';
+export { type WorkspaceRegistration } from './workspaces';

package/dist/public.js

@@ -0,0 +1,3 @@
+export { getExtensionNameFromId, registerExtension, attach, detach, detachAll, getAssignedExtensions, registerExtensionSlot } from "./extensions.js";
+export { renderExtension } from "./render.js";
+export { getExtensionStore } from "./store.js";

package/dist/render.d.ts

@@ -0,0 +1,11 @@
+/** @module @category Extension */
+import { type Parcel, type ParcelConfig } from 'single-spa';
+export interface CancelLoading {
+    (): void;
+}
+/**
+ * Mounts into a DOM node (representing an extension slot)
+ * a lazy-loaded component from *any* frontend module
+ * that registered an extension component for this slot.
+ */
+export declare function renderExtension(domElement: HTMLElement, extensionSlotName: string, extensionSlotModuleName: string, extensionId: string, renderFunction?: (application: ParcelConfig) => ParcelConfig, additionalProps?: Record<string, any>): Promise<Parcel | null>;

package/dist/render.js

@@ -0,0 +1,62 @@
+/** @module @category Extension */ import { mountRootParcel } from "single-spa";
+import { getExtensionNameFromId, getExtensionRegistration } from "./extensions.js";
+import { checkStatus } from "./helpers.js";
+import { updateInternalExtensionStore } from "./store.js";
+let parcelCount = 0;
+/**
+ * Mounts into a DOM node (representing an extension slot)
+ * a lazy-loaded component from *any* frontend module
+ * that registered an extension component for this slot.
+ */ export async function renderExtension(domElement, extensionSlotName, extensionSlotModuleName, extensionId, renderFunction = (x)=>x, additionalProps = {}) {
+    const extensionName = getExtensionNameFromId(extensionId);
+    const extensionRegistration = getExtensionRegistration(extensionId);
+    let parcel = null;
+    if (domElement) {
+        if (!extensionRegistration) {
+            throw Error(`Couldn't find extension '${extensionName}' to attach to '${extensionSlotName}'`);
+        }
+        const { load, meta, moduleName, online, offline } = extensionRegistration;
+        if (checkStatus(online, offline)) {
+            updateInternalExtensionStore((state)=>{
+                const instance = {
+                    domElement,
+                    id: extensionId,
+                    slotName: extensionSlotName,
+                    slotModuleName: extensionSlotModuleName
+                };
+                return {
+                    ...state,
+                    extensions: {
+                        ...state.extensions,
+                        [extensionName]: {
+                            ...state.extensions[extensionName],
+                            instances: [
+                                ...state.extensions[extensionName].instances,
+                                instance
+                            ]
+                        }
+                    }
+                };
+            });
+            const { default: result, ...lifecycle } = await load();
+            const id = parcelCount++;
+            parcel = mountRootParcel(renderFunction({
+                ...result ?? lifecycle,
+                name: `${extensionSlotName}/${extensionName}-${id}`
+            }), {
+                ...additionalProps,
+                _meta: meta,
+                _extensionContext: {
+                    extensionId,
+                    extensionSlotName,
+                    extensionSlotModuleName,
+                    extensionModuleName: moduleName
+                },
+                domElement
+            });
+        }
+    } else {
+        console.warn(`Tried to render ${extensionId} into ${extensionSlotName} but no DOM element was available.`);
+    }
+    return parcel;
+}