@openmrs/esm-react-utils 8.0.1-pre.3935 → 8.0.1-pre.3942

package/.turbo/turbo-build.log

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

package/dist/useDefineAppContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDefineAppContext.d.ts","sourceRoot":"","sources":["../src/useDefineAppContext.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,WAAW,CAAC,MAAM,CAAC,GAAG,WAAW,CAAC,MAAM,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,CAAC,YAE5E,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,UAmBvD"}
+{"version":3,"file":"useDefineAppContext.d.ts","sourceRoot":"","sources":["../src/useDefineAppContext.ts"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,WAAW,CAAC,MAAM,CAAC,GAAG,WAAW,CAAC,MAAM,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,CAAC,YAE5E,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,UA2CvD"}

package/dist/useDefineAppContext.js

@@ -1,6 +1,10 @@
 /** @module @category Context */ import { useEffect, useRef } from "react";
-import { registerContext, unregisterContext, updateContext } from "@openmrs/esm-context";
+import { getContext, registerContext, unregisterContext, updateContext } from "@openmrs/esm-context";
 import { shallowEqual } from "@openmrs/esm-utils";
+/**
+ * Tracks the current owner of each namespace so that a stale cleanup from a
+ * previous instance does not unregister a namespace that a newer instance now owns.
+ */ const namespaceOwners = new Map();
 /**
  * This hook is used to register a namespace in the AppContext. The component that registers the
  * namespace is responsible for updating the value associated with the namespace. The namespace
@@ -34,11 +38,28 @@ import { shallowEqual } from "@openmrs/esm-utils";
  */ export function useDefineAppContext(namespace, value) {
     const previousValue = useRef(value ?? {});
     const updateFunction = useRef((update)=>updateContext(namespace, update));
+    const ownerToken = useRef(Symbol());
     // effect hook for registration and unregistration
     useEffect(()=>{
-        registerContext(namespace, value ?? {});
+        const initialValue = value ?? {};
+        const token = ownerToken.current;
+        if (getContext(namespace) === null) {
+            registerContext(namespace, initialValue);
+        } else {
+            // The previous instance's cleanup effect hasn't run before this new instance
+            // mounts (e.g., during navigation when extensions unmount/remount across
+            // separate single-spa lifecycles). Update the existing context instead.
+            console.warn(`Namespace ${namespace} is already registered in the app context. ` + `This is likely a race condition during navigation, but may indicate two components ` + `are trying to own the same namespace. Updating the existing context.`);
+            updateContext(namespace, ()=>initialValue);
+        }
+        namespaceOwners.set(namespace, token);
         return ()=>{
-            unregisterContext(namespace);
+            // Only unregister if this instance is still the current owner.
+            // A newer instance may have taken ownership during a lifecycle race.
+            if (namespaceOwners.get(namespace) === token) {
+                unregisterContext(namespace);
+                namespaceOwners.delete(namespace);
+            }
         };
     }, [
         namespace

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openmrs/esm-react-utils",
-  "version": "8.0.1-pre.3935",
+  "version": "8.0.1-pre.3942",
   "license": "MPL-2.0",
   "description": "React utilities for OpenMRS.",
   "type": "module",
@@ -79,17 +79,17 @@
     "swr": "2.x"
   },
   "devDependencies": {
-    "@openmrs/esm-api": "8.0.1-pre.3935",
-    "@openmrs/esm-config": "8.0.1-pre.3935",
-    "@openmrs/esm-context": "8.0.1-pre.3935",
-    "@openmrs/esm-emr-api": "8.0.1-pre.3935",
-    "@openmrs/esm-error-handling": "8.0.1-pre.3935",
-    "@openmrs/esm-extensions": "8.0.1-pre.3935",
-    "@openmrs/esm-feature-flags": "8.0.1-pre.3935",
-    "@openmrs/esm-globals": "8.0.1-pre.3935",
-    "@openmrs/esm-navigation": "8.0.1-pre.3935",
-    "@openmrs/esm-state": "8.0.1-pre.3935",
-    "@openmrs/esm-utils": "8.0.1-pre.3935",
+    "@openmrs/esm-api": "8.0.1-pre.3942",
+    "@openmrs/esm-config": "8.0.1-pre.3942",
+    "@openmrs/esm-context": "8.0.1-pre.3942",
+    "@openmrs/esm-emr-api": "8.0.1-pre.3942",
+    "@openmrs/esm-error-handling": "8.0.1-pre.3942",
+    "@openmrs/esm-extensions": "8.0.1-pre.3942",
+    "@openmrs/esm-feature-flags": "8.0.1-pre.3942",
+    "@openmrs/esm-globals": "8.0.1-pre.3942",
+    "@openmrs/esm-navigation": "8.0.1-pre.3942",
+    "@openmrs/esm-state": "8.0.1-pre.3942",
+    "@openmrs/esm-utils": "8.0.1-pre.3942",
     "@swc/cli": "^0.7.7",
     "@swc/core": "^1.11.29",
     "@vitest/coverage-v8": "^4.0.18",

package/src/useDefineAppContext.test.tsx

@@ -0,0 +1,67 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { renderHook } from '@testing-library/react';
+import { getContext, unregisterContext } from '@openmrs/esm-context';
+import { useDefineAppContext } from './useDefineAppContext';
+
+const namespace = 'test-context';
+
+afterEach(() => {
+  // Clean up any registered context between tests
+  unregisterContext(namespace);
+});
+
+describe('useDefineAppContext', () => {
+  it('registers the namespace on mount and unregisters on unmount', () => {
+    const { unmount } = renderHook(() => useDefineAppContext(namespace, { value: 1 }));
+
+    expect(getContext(namespace)).toEqual({ value: 1 });
+
+    unmount();
+
+    expect(getContext(namespace)).toBeNull();
+  });
+
+  it('updates the context when the value changes', () => {
+    const { rerender } = renderHook(({ value }) => useDefineAppContext(namespace, value), {
+      initialProps: { value: { count: 1 } },
+    });
+
+    expect(getContext(namespace)).toEqual({ count: 1 });
+
+    rerender({ value: { count: 2 } });
+
+    expect(getContext(namespace)).toEqual({ count: 2 });
+  });
+
+  it('recovers when a new instance mounts before the previous cleanup runs', () => {
+    const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    // First instance registers the context
+    const { unmount: unmountFirst } = renderHook(() => useDefineAppContext(namespace, { version: 'old' }));
+
+    expect(getContext(namespace)).toEqual({ version: 'old' });
+
+    // Simulate the race: mount a second instance WITHOUT unmounting the first.
+    // This is what happens when a new single-spa lifecycle mounts before the
+    // old one's cleanup effect has run.
+    const { unmount: unmountSecond } = renderHook(() => useDefineAppContext(namespace, { version: 'new' }));
+
+    // The second instance should have updated the context, not crashed
+    expect(getContext(namespace)).toEqual({ version: 'new' });
+    expect(consoleWarnSpy).toHaveBeenCalledWith(
+      expect.stringContaining(`Namespace ${namespace} is already registered`),
+    );
+
+    // The stale cleanup from the old instance must NOT remove the new instance's context
+    unmountFirst();
+
+    expect(getContext(namespace)).toEqual({ version: 'new' });
+
+    // Only the current owner's cleanup should unregister the context
+    unmountSecond();
+
+    expect(getContext(namespace)).toBeNull();
+
+    consoleWarnSpy.mockRestore();
+  });
+});

package/src/useDefineAppContext.ts

@@ -1,8 +1,14 @@
 /** @module @category Context */
 import { useEffect, useRef } from 'react';
-import { registerContext, unregisterContext, updateContext } from '@openmrs/esm-context';
+import { getContext, registerContext, unregisterContext, updateContext } from '@openmrs/esm-context';
 import { shallowEqual } from '@openmrs/esm-utils';
 
+/**
+ * Tracks the current owner of each namespace so that a stale cleanup from a
+ * previous instance does not unregister a namespace that a newer instance now owns.
+ */
+const namespaceOwners = new Map<string, symbol>();
+
 /**
  * This hook is used to register a namespace in the AppContext. The component that registers the
  * namespace is responsible for updating the value associated with the namespace. The namespace
@@ -37,12 +43,36 @@ import { shallowEqual } from '@openmrs/esm-utils';
 export function useDefineAppContext<T extends NonNullable<object> = NonNullable<object>>(namespace: string, value?: T) {
   const previousValue = useRef<T>(value ?? ({} as T));
   const updateFunction = useRef((update: (state: T) => T) => updateContext<T>(namespace, update));
+  const ownerToken = useRef(Symbol());
 
   // effect hook for registration and unregistration
   useEffect(() => {
-    registerContext(namespace, value ?? ({} as T));
+    const initialValue = value ?? ({} as T);
+    const token = ownerToken.current;
+
+    if (getContext(namespace) === null) {
+      registerContext(namespace, initialValue);
+    } else {
+      // The previous instance's cleanup effect hasn't run before this new instance
+      // mounts (e.g., during navigation when extensions unmount/remount across
+      // separate single-spa lifecycles). Update the existing context instead.
+      console.warn(
+        `Namespace ${namespace} is already registered in the app context. ` +
+          `This is likely a race condition during navigation, but may indicate two components ` +
+          `are trying to own the same namespace. Updating the existing context.`,
+      );
+      updateContext<T>(namespace, () => initialValue);
+    }
+
+    namespaceOwners.set(namespace, token);
+
     return () => {
-      unregisterContext(namespace);
+      // Only unregister if this instance is still the current owner.
+      // A newer instance may have taken ownership during a lifecycle race.
+      if (namespaceOwners.get(namespace) === token) {
+        unregisterContext(namespace);
+        namespaceOwners.delete(namespace);
+      }
     };
   }, [namespace]);