@openmrs/esm-config 8.0.1-pre.3439 → 8.0.1-pre.3457

package/.turbo/turbo-build.log

@@ -1,3 +1,3 @@
-[0] Successfully compiled: 8 files with swc (194.74ms)
+[0] Successfully compiled: 8 files with swc (148.75ms)
 [0] swc --strip-leading-paths src -d dist exited with code 0
 [1] tsc --project tsconfig.build.json exited with code 0

package/dist/module-config/module-config.d.ts

@@ -90,3 +90,12 @@ export declare function processConfig(schema: ConfigSchema, providedConfig: Conf
  * @internal
  */
 export declare function clearConfigErrors(keyPath?: string): void;
+/**
+ * Cleans up all config store subscriptions and re-establishes them. This is primarily
+ * useful for testing, where subscriptions set up at module load time need to be cleared
+ * between tests to prevent infinite update loops. After clearing, subscriptions are
+ * re-established so the config system continues to work normally.
+ *
+ * @internal
+ */
+export declare function resetConfigSystem(): void;

package/dist/module-config/module-config.js

@@ -1,8 +1,8 @@
-/** @module @category Config */ import { clone, reduce, mergeDeepRight, equals, omit } from "ramda";
+/** @module @category Config */ import { clone, equals, reduce, mergeDeepRight, omit } from "ramda";
 import { Type } from "../types.js";
 import { isArray, isBoolean, isUuid, isNumber, isObject, isString } from "../validators/type-validators.js";
 import { validator } from "../validators/validator.js";
-import { configInternalStore, configExtensionStore, getConfigStore, getExtensionConfig, getExtensionsConfigStore, implementerToolsConfigStore, temporaryConfigStore, getExtensionSlotsConfigStore } from "./state.js";
+import { configExtensionStore, configInternalStore, getConfigStore, getExtensionConfig, getExtensionSlotsConfigStore, getExtensionsConfigStore, implementerToolsConfigStore, temporaryConfigStore } from "./state.js";
 /**
  * Store setup
  *
@@ -22,25 +22,31 @@ import { configInternalStore, configExtensionStore, getConfigStore, getExtension
  * (or are supposed to be), other than the fact that they all `setState`
  * store values at the end. `computeExtensionConfigs` calls `getGlobalStore`,
  * which creates stores.
- */ computeModuleConfig(configInternalStore.getState(), temporaryConfigStore.getState());
-configInternalStore.subscribe((configState)=>computeModuleConfig(configState, temporaryConfigStore.getState()));
-temporaryConfigStore.subscribe((tempConfigState)=>computeModuleConfig(configInternalStore.getState(), tempConfigState));
-computeImplementerToolsConfig(configInternalStore.getState(), temporaryConfigStore.getState());
-configInternalStore.subscribe((configState)=>computeImplementerToolsConfig(configState, temporaryConfigStore.getState()));
-temporaryConfigStore.subscribe((tempConfigState)=>computeImplementerToolsConfig(configInternalStore.getState(), tempConfigState));
-computeExtensionSlotConfigs(configInternalStore.getState(), temporaryConfigStore.getState());
-configInternalStore.subscribe((configState)=>computeExtensionSlotConfigs(configState, temporaryConfigStore.getState()));
-temporaryConfigStore.subscribe((tempConfigState)=>computeExtensionSlotConfigs(configInternalStore.getState(), tempConfigState));
-computeExtensionConfigs(configInternalStore.getState(), configExtensionStore.getState(), temporaryConfigStore.getState());
-configInternalStore.subscribe((configState)=>{
-    computeExtensionConfigs(configState, configExtensionStore.getState(), temporaryConfigStore.getState());
-});
-configExtensionStore.subscribe((extensionState)=>{
-    computeExtensionConfigs(configInternalStore.getState(), extensionState, temporaryConfigStore.getState());
-});
-temporaryConfigStore.subscribe((tempConfigState)=>{
-    computeExtensionConfigs(configInternalStore.getState(), configExtensionStore.getState(), tempConfigState);
-});
+ */ // Store unsubscribe functions to allow cleanup (e.g., in tests or hot module reloading)
+const configSubscriptions = [];
+/**
+ * Recomputes all configuration derived stores based on current state of input stores.
+ * Called whenever any input store (configInternalStore, temporaryConfigStore, configExtensionStore) changes.
+ */ function recomputeAllConfigs() {
+    const configState = configInternalStore.getState();
+    const tempConfigState = temporaryConfigStore.getState();
+    const extensionState = configExtensionStore.getState();
+    computeModuleConfig(configState, tempConfigState);
+    computeImplementerToolsConfig(configState, tempConfigState);
+    computeExtensionSlotConfigs(configState, tempConfigState);
+    computeExtensionConfigs(configState, extensionState, tempConfigState);
+}
+function setupConfigSubscriptions() {
+    // Initial computation
+    recomputeAllConfigs();
+    // Subscribe to all input stores with a single handler
+    // This ensures we only recompute once even if multiple stores change simultaneously
+    configSubscriptions.push(configInternalStore.subscribe(recomputeAllConfigs));
+    configSubscriptions.push(temporaryConfigStore.subscribe(recomputeAllConfigs));
+    configSubscriptions.push(configExtensionStore.subscribe(recomputeAllConfigs));
+}
+// Set up subscriptions at module load time
+setupConfigSubscriptions();
 function computeModuleConfig(state, tempState) {
     for (let moduleName of Object.keys(state.schemas)){
         // At this point the schema could be either just the implicit schema or the actually
@@ -50,21 +56,23 @@ function computeModuleConfig(state, tempState) {
         // available, which as of this writing blocks the schema definition from occurring
         // for modules loaded based on their extensions.
         const moduleStore = getConfigStore(moduleName);
+        let newState;
         if (state.moduleLoaded[moduleName]) {
             const config = getConfigForModule(moduleName, state, tempState);
-            moduleStore.setState({
+            newState = {
                 translationOverridesLoaded: true,
                 loaded: true,
                 config
-            });
+            };
         } else {
             const config = getConfigForModuleImplicitSchema(moduleName, state, tempState);
-            moduleStore.setState({
+            newState = {
                 translationOverridesLoaded: true,
                 loaded: false,
                 config
-            });
+            };
         }
+        moduleStore.setState(newState);
     }
 }
 function computeExtensionSlotConfigs(state, tempState) {
@@ -84,15 +92,20 @@ function computeExtensionSlotConfigs(state, tempState) {
             ...newSlotStoreEntries
         }
     };
-    if (!equals(oldState, newState)) {
+    if (!equals(oldState.slots, newState.slots)) {
         slotStore.setState(newState);
     }
 }
 function computeImplementerToolsConfig(state, tempConfigState) {
+    const oldState = implementerToolsConfigStore.getState();
     const config = getImplementerToolsConfig(state, tempConfigState);
-    implementerToolsConfigStore.setState({
+    const newState = {
         config
-    });
+    };
+    // Use deep equality on the actual config content, not the wrapper object
+    if (!equals(oldState.config, newState.config)) {
+        implementerToolsConfigStore.setState(newState);
+    }
 }
 function computeExtensionConfigs(configState, extensionState, tempConfigState) {
     const configs = {};
@@ -100,17 +113,23 @@ function computeExtensionConfigs(configState, extensionState, tempConfigState) {
     // it contains is mounted.
     for (let extension of extensionState.mountedExtensions){
         const config = computeExtensionConfig(extension.slotModuleName, extension.extensionModuleName, extension.slotName, extension.extensionId, configState, tempConfigState);
-        configs[extension.slotName] = {
-            ...configs[extension.slotName],
-            [extension.extensionId]: {
-                config,
-                loaded: true
-            }
+        if (!configs[extension.slotName]) {
+            configs[extension.slotName] = {};
+        }
+        configs[extension.slotName][extension.extensionId] = {
+            config,
+            loaded: true
         };
     }
-    getExtensionsConfigStore().setState({
+    const extensionsConfigStore = getExtensionsConfigStore();
+    const oldState = extensionsConfigStore.getState();
+    const newState = {
         configs
-    });
+    };
+    // Use deep equality to only update if configs actually changed
+    if (!equals(oldState.configs, newState.configs)) {
+        extensionsConfigStore.setState(newState);
+    }
 }
 /*
  * API
@@ -751,6 +770,18 @@ function logError(keyPath, message) {
         displayedValidationMessages.clear();
     }
 }
+/**
+ * Cleans up all config store subscriptions and re-establishes them. This is primarily
+ * useful for testing, where subscriptions set up at module load time need to be cleared
+ * between tests to prevent infinite update loops. After clearing, subscriptions are
+ * re-established so the config system continues to work normally.
+ *
+ * @internal
+ */ export function resetConfigSystem() {
+    configSubscriptions.forEach((unsubscribe)=>unsubscribe());
+    configSubscriptions.length = 0;
+    setupConfigSubscriptions();
+}
 /**
  * Copied over from esm-extensions. It rightly belongs to that module, but esm-config
  * cannot depend on esm-extensions.
@@ -782,6 +813,11 @@ function logError(keyPath, message) {
             _description: 'The privilege(s) the user must have to use this extension',
             _type: Type.Array,
             _default: []
+        },
+        expression: {
+            _description: 'The expression that determines whether the extension is displayed',
+            _type: Type.String,
+            _default: undefined
         }
     },
     ...translationOverridesSchema

package/dist/module-config/state.js

@@ -35,7 +35,7 @@ function initializeConfigStore() {
     };
 }
 /** @internal */ export function getConfigStore(moduleName) {
-    // We use a store for each module's config, named `config-${moduleName}`
+    // We use a store for each module's config, named `config-module-${moduleName}`
     return getGlobalStore(`config-module-${moduleName}`, initializeConfigStore());
 }
 /** @internal */ export function getExtensionSlotsConfigStore() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openmrs/esm-config",
-  "version": "8.0.1-pre.3439",
+  "version": "8.0.1-pre.3457",
   "license": "MPL-2.0",
   "description": "A configuration library for the OpenMRS Single-Spa framework.",
   "type": "module",
@@ -61,9 +61,9 @@
     "single-spa": "6.x"
   },
   "devDependencies": {
-    "@openmrs/esm-globals": "8.0.1-pre.3439",
-    "@openmrs/esm-state": "8.0.1-pre.3439",
-    "@openmrs/esm-utils": "8.0.1-pre.3439",
+    "@openmrs/esm-globals": "8.0.1-pre.3457",
+    "@openmrs/esm-state": "8.0.1-pre.3457",
+    "@openmrs/esm-utils": "8.0.1-pre.3457",
     "@swc/cli": "^0.7.7",
     "@swc/core": "^1.11.29",
     "@types/ramda": "^0.26.44",

package/src/module-config/module-config.test.ts

@@ -1031,6 +1031,13 @@ describe('implementer tools config', () => {
         _type: Type.Array,
         _value: [],
       },
+      expression: {
+        _default: undefined,
+        _description: expect.any(String),
+        _source: 'default',
+        _type: Type.String,
+        _value: undefined,
+      },
     },
     'Translation overrides': {
       _default: {},
@@ -1261,7 +1268,7 @@ describe('extension config', () => {
     expect(result).toStrictEqual({
       bar: 'qux',
       baz: 'bazzy',
-      'Display conditions': { privileges: [] },
+      'Display conditions': { expression: undefined, privileges: [] },
       'Translation overrides': {},
     });
     expect(console.error).not.toHaveBeenCalled();
@@ -1284,7 +1291,7 @@ describe('extension config', () => {
     expect(result).toStrictEqual({
       bar: 'qux',
       baz: 'quiz',
-      'Display conditions': { privileges: [] },
+      'Display conditions': { expression: undefined, privileges: [] },
       'Translation overrides': {},
     });
     expect(console.error).not.toHaveBeenCalled();
@@ -1317,10 +1324,9 @@ describe('extension config', () => {
     const result = getExtensionConfig('barSlot', 'fooExt').getState().config;
     expect(result).toStrictEqual({
       qux: 'quxolotl',
-      'Display conditions': { privileges: [] },
+      'Display conditions': { expression: undefined, privileges: [] },
       'Translation overrides': {},
     });
-    expect(console.error).not.toHaveBeenCalled();
   });
 
   it("uses the 'configure' config if one is present, with extension config schema", () => {
@@ -1343,7 +1349,7 @@ describe('extension config', () => {
     const result = getExtensionConfig('barSlot', 'fooExt#id2').getState().config;
     expect(result).toStrictEqual({
       qux: 'quxotic',
-      'Display conditions': { privileges: [] },
+      'Display conditions': { expression: undefined, privileges: [] },
       'Translation overrides': {},
     });
   });

package/src/module-config/module-config.ts

@@ -1,19 +1,19 @@
 /** @module @category Config */
-import { clone, reduce, mergeDeepRight, equals, omit } from 'ramda';
+import { clone, equals, reduce, mergeDeepRight, omit } from 'ramda';
 import type { Config, ConfigObject, ConfigSchema, ExtensionSlotConfig } from '../types';
 import { Type } from '../types';
 import { isArray, isBoolean, isUuid, isNumber, isObject, isString } from '../validators/type-validators';
 import { validator } from '../validators/validator';
 import { type ConfigExtensionStore, type ConfigInternalStore, type ConfigStore } from './state';
 import {
-  configInternalStore,
   configExtensionStore,
+  configInternalStore,
   getConfigStore,
   getExtensionConfig,
+  getExtensionSlotsConfigStore,
   getExtensionsConfigStore,
   implementerToolsConfigStore,
   temporaryConfigStore,
-  getExtensionSlotsConfigStore,
 } from './state';
 import { type TemporaryConfigStore } from '..';
 
@@ -37,42 +37,37 @@ import { type TemporaryConfigStore } from '..';
  * store values at the end. `computeExtensionConfigs` calls `getGlobalStore`,
  * which creates stores.
  */
-computeModuleConfig(configInternalStore.getState(), temporaryConfigStore.getState());
-configInternalStore.subscribe((configState) => computeModuleConfig(configState, temporaryConfigStore.getState()));
-temporaryConfigStore.subscribe((tempConfigState) =>
-  computeModuleConfig(configInternalStore.getState(), tempConfigState),
-);
-
-computeImplementerToolsConfig(configInternalStore.getState(), temporaryConfigStore.getState());
-configInternalStore.subscribe((configState) =>
-  computeImplementerToolsConfig(configState, temporaryConfigStore.getState()),
-);
-temporaryConfigStore.subscribe((tempConfigState) =>
-  computeImplementerToolsConfig(configInternalStore.getState(), tempConfigState),
-);
-
-computeExtensionSlotConfigs(configInternalStore.getState(), temporaryConfigStore.getState());
-configInternalStore.subscribe((configState) =>
-  computeExtensionSlotConfigs(configState, temporaryConfigStore.getState()),
-);
-temporaryConfigStore.subscribe((tempConfigState) =>
-  computeExtensionSlotConfigs(configInternalStore.getState(), tempConfigState),
-);
-
-computeExtensionConfigs(
-  configInternalStore.getState(),
-  configExtensionStore.getState(),
-  temporaryConfigStore.getState(),
-);
-configInternalStore.subscribe((configState) => {
-  computeExtensionConfigs(configState, configExtensionStore.getState(), temporaryConfigStore.getState());
-});
-configExtensionStore.subscribe((extensionState) => {
-  computeExtensionConfigs(configInternalStore.getState(), extensionState, temporaryConfigStore.getState());
-});
-temporaryConfigStore.subscribe((tempConfigState) => {
-  computeExtensionConfigs(configInternalStore.getState(), configExtensionStore.getState(), tempConfigState);
-});
+// Store unsubscribe functions to allow cleanup (e.g., in tests or hot module reloading)
+const configSubscriptions: Array<() => void> = [];
+
+/**
+ * Recomputes all configuration derived stores based on current state of input stores.
+ * Called whenever any input store (configInternalStore, temporaryConfigStore, configExtensionStore) changes.
+ */
+function recomputeAllConfigs() {
+  const configState = configInternalStore.getState();
+  const tempConfigState = temporaryConfigStore.getState();
+  const extensionState = configExtensionStore.getState();
+
+  computeModuleConfig(configState, tempConfigState);
+  computeImplementerToolsConfig(configState, tempConfigState);
+  computeExtensionSlotConfigs(configState, tempConfigState);
+  computeExtensionConfigs(configState, extensionState, tempConfigState);
+}
+
+function setupConfigSubscriptions() {
+  // Initial computation
+  recomputeAllConfigs();
+
+  // Subscribe to all input stores with a single handler
+  // This ensures we only recompute once even if multiple stores change simultaneously
+  configSubscriptions.push(configInternalStore.subscribe(recomputeAllConfigs));
+  configSubscriptions.push(temporaryConfigStore.subscribe(recomputeAllConfigs));
+  configSubscriptions.push(configExtensionStore.subscribe(recomputeAllConfigs));
+}
+
+// Set up subscriptions at module load time
+setupConfigSubscriptions();
 
 function computeModuleConfig(state: ConfigInternalStore, tempState: TemporaryConfigStore) {
   for (let moduleName of Object.keys(state.schemas)) {
@@ -83,21 +78,24 @@ function computeModuleConfig(state: ConfigInternalStore, tempState: TemporaryCon
     // available, which as of this writing blocks the schema definition from occurring
     // for modules loaded based on their extensions.
     const moduleStore = getConfigStore(moduleName);
+    let newState;
     if (state.moduleLoaded[moduleName]) {
       const config = getConfigForModule(moduleName, state, tempState);
-      moduleStore.setState({
+      newState = {
         translationOverridesLoaded: true,
         loaded: true,
         config,
-      });
+      };
     } else {
       const config = getConfigForModuleImplicitSchema(moduleName, state, tempState);
-      moduleStore.setState({
+      newState = {
         translationOverridesLoaded: true,
         loaded: false,
         config,
-      });
+      };
     }
+
+    moduleStore.setState(newState);
   }
 }
 
@@ -109,14 +107,21 @@ function computeExtensionSlotConfigs(state: ConfigInternalStore, tempState: Temp
   const slotStore = getExtensionSlotsConfigStore();
   const oldState = slotStore.getState();
   const newState = { slots: { ...oldState.slots, ...newSlotStoreEntries } };
-  if (!equals(oldState, newState)) {
+
+  if (!equals(oldState.slots, newState.slots)) {
     slotStore.setState(newState);
   }
 }
 
 function computeImplementerToolsConfig(state: ConfigInternalStore, tempConfigState: TemporaryConfigStore) {
+  const oldState = implementerToolsConfigStore.getState();
   const config = getImplementerToolsConfig(state, tempConfigState);
-  implementerToolsConfigStore.setState({ config });
+  const newState = { config };
+
+  // Use deep equality on the actual config content, not the wrapper object
+  if (!equals(oldState.config, newState.config)) {
+    implementerToolsConfigStore.setState(newState);
+  }
 }
 
 function computeExtensionConfigs(
@@ -137,12 +142,19 @@ function computeExtensionConfigs(
       tempConfigState,
     );
 
-    configs[extension.slotName] = {
-      ...configs[extension.slotName],
-      [extension.extensionId]: { config, loaded: true },
-    };
+    if (!configs[extension.slotName]) {
+      configs[extension.slotName] = {};
+    }
+    configs[extension.slotName][extension.extensionId] = { config, loaded: true };
+  }
+  const extensionsConfigStore = getExtensionsConfigStore();
+  const oldState = extensionsConfigStore.getState();
+  const newState = { configs };
+
+  // Use deep equality to only update if configs actually changed
+  if (!equals(oldState.configs, newState.configs)) {
+    extensionsConfigStore.setState(newState);
   }
-  getExtensionsConfigStore().setState({ configs });
 }
 
 /*
@@ -862,6 +874,20 @@ export function clearConfigErrors(keyPath?: string) {
   }
 }
 
+/**
+ * Cleans up all config store subscriptions and re-establishes them. This is primarily
+ * useful for testing, where subscriptions set up at module load time need to be cleared
+ * between tests to prevent infinite update loops. After clearing, subscriptions are
+ * re-established so the config system continues to work normally.
+ *
+ * @internal
+ */
+export function resetConfigSystem() {
+  configSubscriptions.forEach((unsubscribe) => unsubscribe());
+  configSubscriptions.length = 0;
+  setupConfigSubscriptions();
+}
+
 /**
  * Copied over from esm-extensions. It rightly belongs to that module, but esm-config
  * cannot depend on esm-extensions.
@@ -905,6 +931,11 @@ const implicitConfigSchema: ConfigSchema = {
       _type: Type.Array,
       _default: [],
     },
+    expression: {
+      _description: 'The expression that determines whether the extension is displayed',
+      _type: Type.String,
+      _default: undefined,
+    },
   },
   ...translationOverridesSchema,
 };

package/src/module-config/state.ts

@@ -111,7 +111,7 @@ function initializeConfigStore() {
 
 /** @internal */
 export function getConfigStore(moduleName: string) {
-  // We use a store for each module's config, named `config-${moduleName}`
+  // We use a store for each module's config, named `config-module-${moduleName}`
   return getGlobalStore<ConfigStore>(`config-module-${moduleName}`, initializeConfigStore());
 }