@openmrs/esm-extensions 10.0.1-pre.5263 → 10.0.1-pre.5299

package/.turbo/turbo-build.log

@@ -1,3 +1,3 @@
-[0] Successfully compiled: 11 files with swc (123.7ms)
+[0] Successfully compiled: 11 files with swc (154.25ms)
 [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

@@ -61,29 +61,38 @@ export declare function detach(extensionSlotName: string, extensionId: string):
  */
 export declare function detachAll(extensionSlotName: string): void;
 /**
- * Gets the list of extensions assigned to a given slot
+ * Gets the extensions a given rendering of a slot should display, in order. This is the supported
+ * way to ask what belongs in a slot; reading the extension store directly skips display conditions.
  *
- * @param slotName The slot to load the assigned extensions for
- * @returns An array of extensions assigned to the named slot
+ * Display conditions are evaluated against `state`, so pass whatever the slot is being rendered
+ * for. The same slot can be rendered many times with different state — once per row of a table,
+ * say — and each rendering can resolve to a different set of extensions. Omitting `state` hides
+ * every extension whose condition refers to it, since the condition cannot be evaluated.
+ *
+ * @param slotName The slot to load the extensions for
+ * @param state The state of the rendering of the slot the extensions will be displayed in
+ * @returns Those extensions assigned to the slot whose display conditions hold
  */
-export declare function getAssignedExtensions(slotName: string): Array<AssignedExtension>;
+export declare function getAssignedExtensions(slotName: string, state?: ExtensionSlotCustomState): Array<AssignedExtension>;
 /**
- * Used by by extension slots at mount time.
+ * Gets everything assigned to a slot without evaluating any display condition, which
+ * {@link getAssignedExtensions} cannot do without knowing the state of a particular rendering.
+ *
+ * This exists for tools that present a slot's configuration rather than render it — the UI editor
+ * has to list an extension in order to let an implementer reorder or remove it, even where no
+ * rendering would display it. Anything deciding what to render wants `getAssignedExtensions()`.
  *
- * @param moduleName The name of the module that contains the extension slot
- * @param slotName The extension slot name that is actually used
- * @param state Optional custom state for the slot, which will be stored in the extension store.
  * @internal
  */
-export declare const registerExtensionSlot: (moduleName: string, slotName: string, state?: ExtensionSlotCustomState) => void;
+export declare function getCandidateExtensions(slotName: string): Array<AssignedExtension>;
 /**
- * Used by extension slots to update the copy of the state for the extension slot
+ * Used by by extension slots at mount time.
  *
- * @param slotName The name of the slot with state to update
- * @param state A copy of the new state
- * @param partial Whether this should be applied as a partial
+ * @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 function updateExtensionSlotState(slotName: string, state: ExtensionSlotCustomState, partial?: boolean): void;
+export declare const registerExtensionSlot: (moduleName: string, slotName: string) => void;
 /**
  * @internal
  * Just for testing.

package/dist/extensions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extensions.d.ts","sourceRoot":"","sources":["../src/extensions.ts"],"names":[],"mappings":"AAAA,kCAAkC;AA4BlC,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,EAM9B,MAAM,SAAS,CAAC;AAsHjB;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,MAAM,UAGzD;AAED,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,sBAAsB,EAC7B,WAAW,EAAE,MAAM,GAClB,qBAAqB,GAAG,SAAS,CAGnC;AAED,wBAAgB,wBAAwB,CAAC,WAAW,EAAE,MAAM,GAAG,qBAAqB,GAAG,SAAS,CAG/F;AAED;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,EAAE,CAAC,qBAAqB,EAAE,qBAAqB,KAAK,IAO9E,CAAC;AAEL;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,QA4B3D;AAED;;;;;;;GAOG;AACH,wBAAgB,MAAM,CAAC,iBAAiB,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,QAmBpE;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,iBAAiB,EAAE,MAAM,QAmBlD;AAqHD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,KAAK,CAAC,iBAAiB,CAAC,CAoBhF;AAwBD;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,wBAAwB,KAAK,IA2C5G,CAAC;AAEL;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,wBAAwB,EAAE,OAAO,GAAE,OAAe,QAcnH;AAED;;;GAGG;AACH,eAAO,MAAM,KAAK,EAAE,MAAM,IAMtB,CAAC"}
+{"version":3,"file":"extensions.d.ts","sourceRoot":"","sources":["../src/extensions.ts"],"names":[],"mappings":"AAAA,kCAAkC;AA2BlC,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,EAQ9B,MAAM,SAAS,CAAC;AA4MjB;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,MAAM,UAGzD;AAED,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,sBAAsB,EAC7B,WAAW,EAAE,MAAM,GAClB,qBAAqB,GAAG,SAAS,CAGnC;AAED,wBAAgB,wBAAwB,CAAC,WAAW,EAAE,MAAM,GAAG,qBAAqB,GAAG,SAAS,CAG/F;AAED;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,EAAE,CAAC,qBAAqB,EAAE,qBAAqB,KAAK,IAO7E,CAAC;AAEN;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,QA4B3D;AAED;;;;;;;GAOG;AACH,wBAAgB,MAAM,CAAC,iBAAiB,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,QAmBpE;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,iBAAiB,EAAE,MAAM,QAmBlD;AAmJD;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,wBAAwB,GAAG,KAAK,CAAC,iBAAiB,CAAC,CAOlH;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,KAAK,CAAC,iBAAiB,CAAC,CAEjF;AAqBD;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,IAsC1E,CAAC;AAEL;;;GAGG;AACH,eAAO,MAAM,KAAK,EAAE,MAAM,IAOzB,CAAC"}

package/dist/extensions.js

@@ -4,66 +4,157 @@
  * - 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)
+ * - displayed (computed from assigned)
  */ import { sessionStore, userHasAccess } from "@openmrs/esm-api";
-import { getExtensionConfigFromExtensionSlotStore, getExtensionConfigFromStore, getExtensionSlotConfig, getExtensionSlotConfigFromStore, getExtensionSlotsConfigStore, getExtensionsConfigStore } from "@openmrs/esm-config";
+import { getExtensionConfigFromExtensionSlotStore, getExtensionConfigFromStore, getExtensionSlotConfigFromStore, getExtensionSlotsConfigStore, getExtensionsConfigStore } 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, merge } from "lodash-es";
 import { checkStatusFor } from "./helpers.js";
-import { getExtensionInternalStore, getExtensionStore, updateInternalExtensionStore } from "./store.js";
+import { getExtensionRenderingsStore, getExtensionInternalStore, getExtensionStore, scheduleRecomputation, 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) {
+/**
+ * Slots whose derived state may have changed since the output store was last updated. `null`
+ * stands for "every slot", and is used when an input changes that isn't scoped to one slot —
+ * the session, a feature flag, connectivity, or a new extension registration.
+ */ let dirtySlots = new Set();
+let isRecomputingOutputStore = false;
+function markSlotsDirty(slots) {
+    if (slots === null) {
+        dirtySlots = null;
+    } else if (dirtySlots !== null) {
+        for (const slotName of slots){
+            dirtySlots.add(slotName);
+        }
+    }
+    scheduleRecomputation(recomputeExtensionOutputStore);
+}
+/**
+ * A subscriber that dirties a slot every time the output store is published would loop here for
+ * ever, so the drain gives up after this many passes and leaves the rest for the next write. Any
+ * real cascade settles in two or three.
+ */ const maxRecomputationPasses = 20;
+function recomputeExtensionOutputStore() {
+    // Publishing notifies subscribers synchronously, so one that dirties a slot re-enters here. The
+    // loop below picks that work up; recursing instead would nest without bound.
+    if (isRecomputingOutputStore) {
+        return;
+    }
+    isRecomputingOutputStore = true;
+    try {
+        for(let pass = 1;; pass++){
+            const slots = dirtySlots;
+            if (slots !== null && slots.size === 0) {
+                return;
+            }
+            // Taken before the work so that anything dirtied while it runs accumulates for the next pass
+            // rather than being discarded when this one finishes.
+            dirtySlots = new Set();
+            try {
+                updateExtensionOutputStore(extensionInternalStore.getState(), slotsConfigStore.getState(), extensionsConfigStore.getState(), featureFlagsStore.getState(), sessionStore.getState(), slots);
+            } catch (e) {
+                // Fold the work back in, so a failure leaves these slots marked for the next recomputation
+                // instead of stranding them stale.
+                dirtySlots = slots === null || dirtySlots === null ? null : new Set([
+                    ...slots,
+                    ...dirtySlots
+                ]);
+                throw e;
+            }
+            if (pass >= maxRecomputationPasses) {
+                console.error(`The extension system stopped recomputing after ${maxRecomputationPasses} passes because ` + `something keeps invalidating slots in response to the extension store being written. ` + `Some slots are left stale until the next write.`);
+                return;
+            }
+        }
+    } finally{
+        isRecomputingOutputStore = false;
+    }
+}
+/**
+ * Re-derives the output store from the extension system's inputs.
+ *
+ * Two things keep this cheap. `dirtySlotNames` limits which slots are recomputed at all; passing
+ * `null` recomputes every slot. And slots whose derived value hasn't changed keep their existing
+ * object, so that components subscribed to one slot don't re-render because a different slot
+ * changed.
+ */ function updateExtensionOutputStore(internalState, extensionSlotConfigs, extensionsConfigState, featureFlagState, sessionState, dirtySlotNames = null) {
+    const previousSlots = extensionStore.getState().slots;
     const slots = {};
+    let changed = false;
     const isOnline = isOnlineFn();
-    const enabledFeatureFlags = Object.entries(featureFlagStore.flags).filter(([, { enabled }])=>enabled).map(([name])=>name);
+    const enabledFeatureFlags = Object.entries(featureFlagState.flags).filter(([, { enabled }])=>enabled).map(([name])=>name);
     for (let [slotName, slot] of Object.entries(internalState.slots)){
+        const previous = previousSlots[slotName];
+        if (previous && dirtySlotNames && !dirtySlotNames.has(slotName)) {
+            slots[slotName] = previous;
+            continue;
+        }
         const { config } = getExtensionSlotConfigFromStore(extensionSlotConfigs, slot.name);
-        const assignedExtensions = getAssignedExtensionsFromSlotData(slotName, internalState, config, extensionsConfigStore, enabledFeatureFlags, isOnline, sessionStore.session);
-        slots[slotName] = {
-            moduleName: slot.moduleName,
-            assignedExtensions
-        };
+        const candidateExtensions = getAssignedExtensionsFromSlotData(slotName, internalState, config, extensionsConfigState, enabledFeatureFlags, isOnline, sessionState.session);
+        if (previous && previous.moduleName === slot.moduleName && isEqual(previous.candidateExtensions, candidateExtensions)) {
+            slots[slotName] = previous;
+        } else {
+            slots[slotName] = {
+                moduleName: slot.moduleName,
+                candidateExtensions
+            };
+            changed = true;
+        }
     }
-    if (!isEqual(extensionStore.getState().slots, slots)) {
+    if (changed || Object.keys(previousSlots).length !== Object.keys(slots).length) {
         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());
+/**
+ * Returns the keys whose values differ between two records, including keys present in only one.
+ */ function changedKeys(next, previous) {
+    const changed = new Set();
+    for (const key of Object.keys(next)){
+        if (next[key] !== previous[key]) {
+            changed.add(key);
+        }
+    }
+    for (const key of Object.keys(previous)){
+        if (!(key in next)) {
+            changed.add(key);
+        }
+    }
+    return changed;
+}
+extensionInternalStore.subscribe((state, previousState)=>{
+    // A new or changed registration can affect any slot the extension might be assigned to. Every
+    // other kind of change here — attaching, registering a slot — is scoped to the slots whose
+    // entries actually changed.
+    markSlotsDirty(state.extensions !== previousState.extensions ? null : changedKeys(state.slots, previousState.slots));
 });
-featureFlagsStore.subscribe((featureFlagStore)=>{
-    updateExtensionOutputStore(extensionInternalStore.getState(), slotsConfigStore.getState(), extensionsConfigStore.getState(), featureFlagStore, sessionStore.getState());
+// Slot configs are per-slot, so a config change invalidates only the slots it names.
+slotsConfigStore.subscribe((state, previousState)=>{
+    markSlotsDirty(changedKeys(state.slots, previousState.slots));
 });
-sessionStore.subscribe((session)=>{
-    updateExtensionOutputStore(extensionInternalStore.getState(), slotsConfigStore.getState(), extensionsConfigStore.getState(), featureFlagsStore.getState(), session);
+// Extension configs are keyed by slot too, and the config system hands back the same per-slot
+// object when nothing under it changed, so only the slots whose configs actually moved are dirtied.
+extensionsConfigStore.subscribe((state, previousState)=>{
+    markSlotsDirty(changedKeys(state.configs, previousState.configs));
 });
+featureFlagsStore.subscribe(()=>markSlotsDirty(null));
+sessionStore.subscribe(()=>markSlotsDirty(null));
 function updateOutputStoreToCurrent() {
-    updateExtensionOutputStore(extensionInternalStore.getState(), slotsConfigStore.getState(), extensionsConfigStore.getState(), featureFlagsStore.getState(), sessionStore.getState());
+    markSlotsDirty(null);
 }
 updateOutputStoreToCurrent();
 subscribeConnectivityChanged(updateOutputStoreToCurrent);
-function createNewExtensionSlotInfo(slotName, moduleName, state) {
+function createNewExtensionSlotInfo(slotName, moduleName) {
     return {
         moduleName,
         name: slotName,
-        attachedIds: [],
-        config: null,
-        state
+        attachedIds: []
     };
 }
 /**
@@ -95,13 +186,15 @@ export function getExtensionRegistration(extensionId) {
  * This is handled by the app shell, when extensions are provided
  * via the `routes.json` file and registered through `registerApp()`.
  * @internal
- */ export const registerExtension = (extensionRegistration)=>extensionInternalStore.setState((state)=>{
-        state.extensions[extensionRegistration.name] = {
-            ...extensionRegistration,
-            instances: []
-        };
-        return state;
-    });
+ */ export const registerExtension = (extensionRegistration)=>updateInternalExtensionStore((state)=>({
+            ...state,
+            extensions: {
+                ...state.extensions,
+                [extensionRegistration.name]: {
+                    ...extensionRegistration
+                }
+            }
+        }));
 /**
  * Attach an extension to an extension slot.
  *
@@ -208,6 +301,10 @@ export function getExtensionRegistration(extensionId) {
  * 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.
+ *
+ * The four bands below keep the comparison a total order: every extension lands in exactly one, and
+ * those with no ordering information share the last band rather than taking a sentinel that can't be
+ * compared against itself.
  */ function getOrder(extensionId, configuredOrder, registeredOrderIndex, attachedOrder) {
     const configuredIndex = configuredOrder.indexOf(extensionId);
     if (configuredIndex !== -1) {
@@ -222,7 +319,9 @@ export function getExtensionRegistration(extensionId) {
             // after all others
             return 2000 + assignedIndex;
         } else {
-            return -1;
+            // Added by configuration with no order of any kind — after everything else, and among
+            // themselves in the order the configuration lists them.
+            return 3000;
         }
     }
 }
@@ -230,18 +329,12 @@ function getAssignedExtensionsFromSlotData(slotName, internalState, config, exte
     const attachedIds = internalState.slots[slotName].attachedIds;
     const assignedIds = calculateAssignedIds(config, attachedIds);
     const extensions = [];
-    // Create context once for all extensions in this slot
-    const slotState = internalState.slots[slotName]?.state;
-    const expressionContext = slotState && typeof slotState === 'object' ? {
-        session,
-        ...slotState
-    } : {
-        session
-    };
     for (let id of assignedIds){
         const { config: rawExtensionConfig } = getExtensionConfigFromStore(extensionConfigStoreState, slotName, id);
         const rawExtensionSlotExtensionConfig = getExtensionConfigFromExtensionSlotStore(config, slotName, id);
-        const extensionConfig = merge(rawExtensionConfig, rawExtensionSlotExtensionConfig);
+        // `merge` mutates its first argument, and `rawExtensionConfig` belongs to the config store,
+        // so never merge into it.
+        const extensionConfig = rawExtensionSlotExtensionConfig ? merge({}, rawExtensionConfig, rawExtensionSlotExtensionConfig) : rawExtensionConfig;
         const name = getExtensionNameFromId(id);
         const extension = internalState.extensions[name];
         // if the extension has not been registered yet, do not include it
@@ -255,17 +348,6 @@ function getAssignedExtensionsFromSlotData(slotName, internalState, config, exte
                     continue;
                 }
             }
-            const displayConditionExpression = extensionConfig?.['Display conditions']?.expression || extension.displayExpression;
-            if (displayConditionExpression !== undefined && typeof displayConditionExpression === 'string' && displayConditionExpression.trim().length > 0) {
-                try {
-                    if (!evaluateAsBoolean(displayConditionExpression, expressionContext)) {
-                        continue;
-                    }
-                } catch (e) {
-                    console.error(`Error while evaluating expression '${displayConditionExpression}' for extension ${name} in slot ${slotName}`, e);
-                    continue;
-                }
-            }
             if (extension.featureFlag && !enabledFeatureFlags.includes(extension.featureFlag)) {
                 continue;
             }
@@ -280,26 +362,74 @@ function getAssignedExtensionsFromSlotData(slotName, internalState, config, exte
                 featureFlag: extension.featureFlag,
                 meta: extension.meta,
                 online: extensionConfig?.['Display conditions']?.online ?? extension.online ?? true,
-                offline: extensionConfig?.['Display conditions']?.offline ?? extension.offline ?? false
+                offline: extensionConfig?.['Display conditions']?.offline ?? extension.offline ?? false,
+                displayConditionExpression: extensionConfig?.['Display conditions']?.expression || extension.displayExpression
             });
         }
     }
     return extensions;
 }
 /**
- * Gets the list of extensions assigned to a given slot
+ * Narrows `extensions` to those whose display condition holds for one particular rendering of a
+ * slot, evaluating each condition against `state`.
  *
- * @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);
+ * An extension whose display condition throws is left out, on the grounds that a condition that cannot be
+ * evaluated has not been met.
+ *
+ * @param extensions The extensions assigned to the slot, as the extension store holds them
+ * @param state The state of this rendering of the slot
+ * @param session The current session, which conditions may refer to as `session`
+ * @param slotName The slot these were assigned to, used only to identify them if a condition throws
+ * @returns Those of `extensions` that should be displayed, in the same order. Always a new array.
+ */ function filterExtensionsByDisplayConditions(extensions, state, session = null, slotName) {
+    // Built once for the whole slot rather than per extension: the context is the same for all of
+    // them, and most slots have no conditions at all.
+    let expressionContext;
+    return extensions.filter((extension)=>{
+        const expression = extension.displayConditionExpression;
+        if (typeof expression !== 'string' || expression.trim().length === 0) {
+            return true;
+        }
+        expressionContext ?? (expressionContext = state && typeof state === 'object' ? {
+            session,
+            ...state
+        } : {
+            session
+        });
+        try {
+            return Boolean(evaluateAsBoolean(expression, expressionContext));
+        } catch (e) {
+            console.error(`Error while evaluating expression '${expression}' for ${extension.id}` + (slotName ? ` in ${slotName}` : ''), e);
+            return false;
+        }
+    });
+}
+/**
+ * Gets the extensions a given rendering of a slot should display, in order. This is the supported
+ * way to ask what belongs in a slot; reading the extension store directly skips display conditions.
+ *
+ * Display conditions are evaluated against `state`, so pass whatever the slot is being rendered
+ * for. The same slot can be rendered many times with different state — once per row of a table,
+ * say — and each rendering can resolve to a different set of extensions. Omitting `state` hides
+ * every extension whose condition refers to it, since the condition cannot be evaluated.
+ *
+ * @param slotName The slot to load the extensions for
+ * @param state The state of the rendering of the slot the extensions will be displayed in
+ * @returns Those extensions assigned to the slot whose display conditions hold
+ */ export function getAssignedExtensions(slotName, state) {
+    return filterExtensionsByDisplayConditions(getCandidateExtensions(slotName), state, sessionStore.getState().session, slotName);
+}
+/**
+ * Gets everything assigned to a slot without evaluating any display condition, which
+ * {@link getAssignedExtensions} cannot do without knowing the state of a particular rendering.
+ *
+ * This exists for tools that present a slot's configuration rather than render it — the UI editor
+ * has to list an extension in order to let an implementer reorder or remove it, even where no
+ * rendering would display it. Anything deciding what to render wants `getAssignedExtensions()`.
+ *
+ * @internal
+ */ export function getCandidateExtensions(slotName) {
+    return extensionStore.getState().slots[slotName]?.candidateExtensions ?? [];
 }
 function calculateAssignedIds(config, attachedIds) {
     const addedIds = config.add || [];
@@ -312,13 +442,10 @@ function calculateAssignedIds(config, attachedIds) {
     ].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;
-        }
+        // Ties keep their input order — `Array.prototype.sort` is stable, and the input is
+        // `[...attachedIds, ...addedIds]`, so two extensions the ordering rules can't separate
+        // come out in the order the code and the configuration declared them.
+        return ai - bi;
     });
 }
 /**
@@ -326,9 +453,8 @@ function calculateAssignedIds(config, attachedIds) {
  *
  * @param moduleName The name of the module that contains the extension slot
  * @param slotName The extension slot name that is actually used
- * @param state Optional custom state for the slot, which will be stored in the extension store.
  * @internal
- */ export const registerExtensionSlot = (moduleName, slotName, state)=>extensionInternalStore.setState((currentState)=>{
+ */ export const registerExtensionSlot = (moduleName, slotName)=>extensionInternalStore.setState((currentState)=>{
         const existingModuleName = currentState.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}.`);
@@ -345,13 +471,12 @@ function calculateAssignedIds(config, attachedIds) {
                     ...currentState.slots,
                     [slotName]: {
                         ...currentState.slots[slotName],
-                        moduleName,
-                        state
+                        moduleName
                     }
                 }
             };
         }
-        const slot = createNewExtensionSlotInfo(slotName, moduleName, state);
+        const slot = createNewExtensionSlotInfo(slotName, moduleName);
         return {
             ...currentState,
             slots: {
@@ -362,33 +487,21 @@ function calculateAssignedIds(config, attachedIds) {
             }
         };
     });
-/**
- * Used by extension slots to update the copy of the state for the extension slot
- *
- * @param slotName The name of the slot with state to update
- * @param state A copy of the new state
- * @param partial Whether this should be applied as a partial
- */ export function updateExtensionSlotState(slotName, state, partial = false) {
-    extensionInternalStore.setState((currentState)=>{
-        const newState = partial ? merge(currentState.slots[slotName].state, state) : state;
-        return {
-            ...currentState,
-            slots: {
-                ...currentState.slots,
-                [slotName]: {
-                    ...currentState.slots[slotName],
-                    state: newState
-                }
-            }
-        };
-    });
-}
 /**
  * @internal
  * Just for testing.
- */ export const reset = ()=>extensionStore.setState(()=>{
-        return {
+ */ export const reset = ()=>{
+    // Invalidation is carried in module state, so it has to be reset too or it bleeds into the
+    // next test as either a stale dirty set or a missing one.
+    dirtySlots = null;
+    updateInternalExtensionStore(()=>({
             slots: {},
             extensions: {}
-        };
+        }));
+    getExtensionRenderingsStore().setState({
+        renderings: new Map()
+    });
+    extensionStore.setState({
+        slots: {}
     });
+};

package/dist/public.d.ts

@@ -1,7 +1,7 @@
 export { getExtensionNameFromId, registerExtension, attach, detach, detachAll, getAssignedExtensions, registerExtensionSlot, } from './extensions';
 export { type LeftNavStore, setLeftNav, unsetLeftNav, type SetLeftNavParams } from './left-nav';
 export { type CancelLoading, renderExtension } from './render';
-export { type ExtensionMeta, type ExtensionRegistration, type ExtensionStore, type AssignedExtension, type ConnectedExtension, type ExtensionSlotState, getExtensionStore, } from './store';
+export { type ExtensionMeta, type ExtensionRegistration, type ExtensionStore, type AssignedExtension, type ConnectedExtension, type ExtensionSlotCustomState, type ExtensionSlotState, getExtensionStore, } from './store';
 export { type WorkspaceRegistration } from './workspaces';
 export { type ExtensionData, type ComponentConfig } from './types';
 //# sourceMappingURL=public.d.ts.map

package/dist/public.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../src/public.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,iBAAiB,EACjB,MAAM,EACN,MAAM,EACN,SAAS,EACT,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,KAAK,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,KAAK,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAChG,OAAO,EAAE,KAAK,aAAa,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAC/D,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,qBAAqB,EAC1B,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,iBAAiB,GAClB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAC1D,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,eAAe,EAAE,MAAM,SAAS,CAAC"}
+{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../src/public.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,iBAAiB,EACjB,MAAM,EACN,MAAM,EACN,SAAS,EACT,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,KAAK,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,KAAK,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAChG,OAAO,EAAE,KAAK,aAAa,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAC/D,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,qBAAqB,EAC1B,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,kBAAkB,EACvB,iBAAiB,GAClB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAC1D,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,eAAe,EAAE,MAAM,SAAS,CAAC"}

package/dist/render.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../src/render.ts"],"names":[],"mappings":"AAAA,kCAAkC;AAClC,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,WAAW,EAChB,KAAK,MAAM,EACX,KAAK,YAAY,EACjB,KAAK,WAAW,EACjB,MAAM,YAAY,CAAC;AAKpB,MAAM,WAAW,aAAa;IAC5B,IAAI,IAAI,CAAC;CACV;AAED,KAAK,WAAW,GAAG,QAAQ,CAAC,aAAa,CAAC,CAAC;AAgD3C;;;;;;;;GAQG;AACH,wBAAsB,YAAY,CAAC,CAAC,GAAG,WAAW,EAChD,YAAY,EAAE,YAAY,EAC1B,WAAW,EAAE,WAAW,GAAG,CAAC,GAC3B,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,CAGlC;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,IAAI,WAAW,CAEjD;AAoCD;;;;GAIG;AACH,wBAAsB,eAAe,CACnC,UAAU,EAAE,WAAW,EACvB,iBAAiB,EAAE,MAAM,EACzB,uBAAuB,EAAE,MAAM,EAC/B,WAAW,EAAE,MAAM,EACnB,cAAc,GAAE,CAAC,WAAW,EAAE,YAAY,KAAK,YAAuB,EACtE,eAAe,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,GACxC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAyDxB"}
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../src/render.ts"],"names":[],"mappings":"AAAA,kCAAkC;AAClC,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,WAAW,EAEhB,KAAK,MAAM,EACX,KAAK,YAAY,EACjB,KAAK,WAAW,EACjB,MAAM,YAAY,CAAC;AAKpB,MAAM,WAAW,aAAa;IAC5B,IAAI,IAAI,CAAC;CACV;AAED,KAAK,WAAW,GAAG,QAAQ,CAAC,aAAa,CAAC,CAAC;AA2E3C;;;;;;;;GAQG;AACH,wBAAsB,YAAY,CAAC,CAAC,GAAG,WAAW,EAChD,YAAY,EAAE,YAAY,EAC1B,WAAW,EAAE,WAAW,GAAG,CAAC,GAC3B,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,CAGlC;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,IAAI,WAAW,CAEjD;AAoCD;;;;GAIG;AACH,wBAAsB,eAAe,CACnC,UAAU,EAAE,WAAW,EACvB,iBAAiB,EAAE,MAAM,EACzB,uBAAuB,EAAE,MAAM,EAC/B,WAAW,EAAE,MAAM,EACnB,cAAc,GAAE,CAAC,WAAW,EAAE,YAAY,KAAK,YAAuB,EACtE,eAAe,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,GACxC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAsGxB"}