@openmrs/esm-dynamic-loading 9.0.3-pre.4533 → 9.0.3-pre.4537

package/.turbo/turbo-build.log

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

package/dist/dynamic-loading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dynamic-loading.d.ts","sourceRoot":"","sources":["../src/dynamic-loading.ts"],"names":[],"mappings":"AAGA,OAAO,EAAsB,KAAK,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAG1E;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,UAEnC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,aAAa,CAAC,CAAC,GAAG,GAAG,EACzC,SAAS,EAAE,MAAM,EACjB,KAAK,GAAE,MAAkB,EACzB,OAAO,CAAC,EAAE;IACR,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,GACA,OAAO,CAAC,CAAC,CAAC,CAyCZ;AAuBD;;;;;;;;;;GAUG;AACH,wBAAsB,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,SAAS,iBAoD3E;AAED;;;;;;GAMG;AACH,wBAAsB,mBAAmB,uBAExC"}
+{"version":3,"file":"dynamic-loading.d.ts","sourceRoot":"","sources":["../src/dynamic-loading.ts"],"names":[],"mappings":"AAEA,OAAO,EAAsB,KAAK,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAI1E;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,UAEnC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,aAAa,CAAC,CAAC,GAAG,GAAG,EACzC,SAAS,EAAE,MAAM,EACjB,KAAK,GAAE,MAAkB,EACzB,OAAO,CAAC,EAAE;IACR,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,GACA,OAAO,CAAC,CAAC,CAAC,CAyCZ;AAuBD;;;;;;;;;;GAUG;AACH,wBAAsB,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,SAAS,iBAoD3E;AAED;;;;;;GAMG;AACH,wBAAsB,mBAAmB,uBAExC"}

package/dist/dynamic-loading.js

@@ -1,7 +1,7 @@
 /** @module @category Dynamic Loading */ 'use strict';
-// hack to make the types defined in esm-globals available here
 import { dispatchToastShown } from "@openmrs/esm-globals";
 import { getCoreTranslation } from "@openmrs/esm-translations";
+import { getCurrentPageMap, getImportMapOverrideMap, resetImportMapOverrides } from "./import-maps.js";
 /**
  * @internal
  *
@@ -108,7 +108,7 @@ import { getCoreTranslation } from "@openmrs/esm-translations";
         if (url.startsWith('./')) {
             url = window.spaBase + url.substring(1);
         }
-        const isOverridden = !!window.localStorage.getItem(`import-map-override:${jsPackage}`);
+        const isOverridden = jsPackage in getImportMapOverrideMap().imports;
         try {
             return await new Promise((resolve, reject)=>{
                 loadScript(url, resolve, reject);
@@ -123,7 +123,7 @@ import { getCoreTranslation } from "@openmrs/esm-translations";
                     }),
                     actionButtonLabel: getCoreTranslation('resetOverrides', 'Reset overrides'),
                     onActionButtonClick () {
-                        window.importMapOverrides.resetOverrides();
+                        resetImportMapOverrides();
                         window.location.reload();
                     }
                 });
@@ -140,7 +140,7 @@ import { getCoreTranslation } from "@openmrs/esm-translations";
  *
  * @returns The current import map.
  */ export async function getCurrentImportMap() {
-    return window.importMapOverrides.getCurrentPageMap();
+    return getCurrentPageMap();
 }
 function isFederatedModule(a) {
     return typeof a === 'object' && a !== null && 'init' in a && typeof a['init'] === 'function' && 'get' in a && typeof a['get'] === 'function';

package/dist/import-maps.d.ts

@@ -0,0 +1,50 @@
+/** @module @category Import Map */
+import type { ImportMap } from '@openmrs/esm-globals';
+/**
+ * Returns the import map for the current page. In dev mode, this merges
+ * the base map with the override snapshot captured at page load.
+ */
+export declare function getCurrentPageMap(): Promise<ImportMap>;
+/**
+ * Returns the base import map from the DOM without any overrides applied.
+ */
+export declare function getImportMapDefaultMap(): Promise<ImportMap>;
+/**
+ * Returns what the import map will look like on the next page load, including
+ * any overrides that have been added/removed since the page loaded.
+ * In production, this is the same as the base map.
+ */
+export declare function getImportMapNextPageMap(): Promise<ImportMap>;
+/**
+ * Returns the current override map. In production, returns empty imports.
+ * @param includeDisabled If true, includes disabled overrides.
+ */
+export declare function getImportMapOverrideMap(includeDisabled?: boolean): ImportMap;
+/**
+ * Returns the list of module names whose overrides are disabled.
+ * In production, returns an empty array.
+ */
+export declare function getImportMapDisabledOverrides(): string[];
+/**
+ * Returns whether the given module's override is disabled.
+ * In production, returns false.
+ */
+export declare function isImportMapOverrideDisabled(moduleName: string): boolean;
+/**
+ * Adds an import map override. In production, this is a no-op.
+ */
+export declare function addImportMapOverride(name: string, url: string): void;
+/**
+ * Removes an import map override. In production, this is a no-op.
+ */
+export declare function removeImportMapOverride(name: string): void;
+/**
+ * Clears all import map overrides. In production, this is a no-op.
+ */
+export declare function resetImportMapOverrides(): void;
+/**
+ * Re-enables a previously disabled import map override. In production, this is a no-op.
+ */
+export declare function enableImportMapOverride(name: string): void;
+export declare function setupImportMapOverrides(): void;
+//# sourceMappingURL=import-maps.d.ts.map

package/dist/import-maps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-maps.d.ts","sourceRoot":"","sources":["../src/import-maps.ts"],"names":[],"mappings":"AAAA,mCAAmC;AACnC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AA2EtD;;;GAGG;AACH,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,SAAS,CAAC,CAO5D;AAED;;GAEG;AACH,wBAAsB,sBAAsB,IAAI,OAAO,CAAC,SAAS,CAAC,CAEjE;AAED;;;;GAIG;AACH,wBAAsB,uBAAuB,IAAI,OAAO,CAAC,SAAS,CAAC,CAMlE;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,eAAe,CAAC,EAAE,OAAO,GAAG,SAAS,CAmB5E;AAED;;;GAGG;AACH,wBAAgB,6BAA6B,IAAI,MAAM,EAAE,CAiBxD;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAKvE;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAWpE;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAiB1D;AAED;;GAEG;AACH,wBAAgB,uBAAuB,IAAI,IAAI,CAmB9C;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAgB1D;AAaD,wBAAgB,uBAAuB,SAWtC"}

package/dist/import-maps.js

@@ -0,0 +1,246 @@
+/** @module @category Import Map */ const OVERRIDE_PREFIX = 'import-map-override:';
+const DISABLED_KEY = 'import-map-overrides-disabled';
+const CHANGE_EVENT = 'import-map-overrides:change';
+// Set by setupImportMapOverrides(); controls whether override functionality is active.
+let devMode = false;
+// Snapshot of overrides at setup time (matches import-map-overrides library behavior:
+// getCurrentPageMap returns the overrides as they were when the page loaded).
+let initialOverrideSnapshot = null;
+/**
+ * Reads all `<script type="systemjs-importmap">` tags from the DOM and merges
+ * them into a single {@link ImportMap}. Tags with a `src` attribute are fetched;
+ * inline tags have their `textContent` parsed as JSON.
+ */ async function readBaseMap() {
+    const scripts = document.querySelectorAll('script[type="systemjs-importmap"]');
+    const maps = [];
+    for(let i = 0; i < scripts.length; i++){
+        const script = scripts[i];
+        try {
+            if (script.src) {
+                const response = await fetch(script.src);
+                maps.push(await response.json());
+            } else if (script.textContent) {
+                maps.push(JSON.parse(script.textContent));
+            }
+        } catch (e) {
+            console.warn(`[import-maps] Failed to parse import map from script tag at index ${i}`, e);
+        }
+    }
+    return mergeMaps(maps);
+}
+function mergeMaps(maps) {
+    const merged = {
+        imports: {}
+    };
+    for (const map of maps){
+        if (map?.imports) {
+            Object.assign(merged.imports, map.imports);
+        }
+    }
+    return merged;
+}
+/** Returns all `import-map-override:*` entries from localStorage as an {@link ImportMap}. */ function readOverrideMap() {
+    const imports = {};
+    try {
+        const disabled = getImportMapDisabledOverrides();
+        for(let i = 0; i < localStorage.length; i++){
+            const key = localStorage.key(i);
+            if (key?.startsWith(OVERRIDE_PREFIX)) {
+                const moduleName = key.slice(OVERRIDE_PREFIX.length);
+                if (!disabled.includes(moduleName)) {
+                    const url = localStorage.getItem(key);
+                    if (url) {
+                        imports[moduleName] = url;
+                    }
+                }
+            }
+        }
+    } catch (e) {
+        console.warn('[import-maps] Failed to read import-map overrides from localStorage', e);
+    }
+    return {
+        imports
+    };
+}
+/**
+ * Returns the import map for the current page. In dev mode, this merges
+ * the base map with the override snapshot captured at page load.
+ */ export async function getCurrentPageMap() {
+    const base = await readBaseMap();
+    if (!devMode) {
+        return base;
+    }
+    const overrides = initialOverrideSnapshot ?? readOverrideMap();
+    return mergeMaps([
+        base,
+        overrides
+    ]);
+}
+/**
+ * Returns the base import map from the DOM without any overrides applied.
+ */ export async function getImportMapDefaultMap() {
+    return readBaseMap();
+}
+/**
+ * Returns what the import map will look like on the next page load, including
+ * any overrides that have been added/removed since the page loaded.
+ * In production, this is the same as the base map.
+ */ export async function getImportMapNextPageMap() {
+    if (!devMode) {
+        return readBaseMap();
+    }
+    const base = await readBaseMap();
+    return mergeMaps([
+        base,
+        readOverrideMap()
+    ]);
+}
+/**
+ * Returns the current override map. In production, returns empty imports.
+ * @param includeDisabled If true, includes disabled overrides.
+ */ export function getImportMapOverrideMap(includeDisabled) {
+    if (!devMode) {
+        return {
+            imports: {}
+        };
+    }
+    if (includeDisabled) {
+        const imports = {};
+        for(let i = 0; i < localStorage.length; i++){
+            const key = localStorage.key(i);
+            if (key?.startsWith(OVERRIDE_PREFIX)) {
+                const url = localStorage.getItem(key);
+                if (url) {
+                    imports[key.slice(OVERRIDE_PREFIX.length)] = url;
+                }
+            }
+        }
+        return {
+            imports
+        };
+    }
+    return readOverrideMap();
+}
+/**
+ * Returns the list of module names whose overrides are disabled.
+ * In production, returns an empty array.
+ */ export function getImportMapDisabledOverrides() {
+    if (!devMode) {
+        return [];
+    }
+    try {
+        const raw = localStorage.getItem(DISABLED_KEY);
+        if (raw) {
+            const parsed = JSON.parse(raw);
+            if (Array.isArray(parsed)) {
+                return parsed;
+            }
+        }
+    } catch  {
+    // ignore malformed data
+    }
+    return [];
+}
+/**
+ * Returns whether the given module's override is disabled.
+ * In production, returns false.
+ */ export function isImportMapOverrideDisabled(moduleName) {
+    if (!devMode) {
+        return false;
+    }
+    return getImportMapDisabledOverrides().includes(moduleName);
+}
+/**
+ * Adds an import map override. In production, this is a no-op.
+ */ export function addImportMapOverride(name, url) {
+    if (!devMode) {
+        console.warn('[Security] Import map overrides are disabled in production mode.');
+        return;
+    }
+    try {
+        localStorage.setItem(OVERRIDE_PREFIX + name, url);
+        window.dispatchEvent(new CustomEvent(CHANGE_EVENT));
+    } catch (e) {
+        console.warn('[import-maps] Failed to write import-map override to localStorage', e);
+    }
+}
+/**
+ * Removes an import map override. In production, this is a no-op.
+ */ export function removeImportMapOverride(name) {
+    if (!devMode) {
+        console.warn('[Security] Import map overrides are disabled in production mode.');
+        return;
+    }
+    try {
+        localStorage.removeItem(OVERRIDE_PREFIX + name);
+        const disabled = getImportMapDisabledOverrides().filter((n)=>n !== name);
+        if (disabled.length > 0) {
+            localStorage.setItem(DISABLED_KEY, JSON.stringify(disabled));
+        } else {
+            localStorage.removeItem(DISABLED_KEY);
+        }
+        window.dispatchEvent(new CustomEvent(CHANGE_EVENT));
+    } catch (e) {
+        console.warn('[import-maps] Failed to update import-map overrides in localStorage', e);
+    }
+}
+/**
+ * Clears all import map overrides. In production, this is a no-op.
+ */ export function resetImportMapOverrides() {
+    if (!devMode) {
+        console.warn('[Security] Import map overrides are disabled in production mode.');
+        return;
+    }
+    try {
+        const keysToRemove = [];
+        for(let i = 0; i < localStorage.length; i++){
+            const key = localStorage.key(i);
+            if (key?.startsWith(OVERRIDE_PREFIX)) {
+                keysToRemove.push(key);
+            }
+        }
+        keysToRemove.forEach((key)=>localStorage.removeItem(key));
+        localStorage.removeItem(DISABLED_KEY);
+        window.dispatchEvent(new CustomEvent(CHANGE_EVENT));
+    } catch (e) {
+        console.warn('[import-maps] Failed to clear import-map overrides from localStorage', e);
+    }
+}
+/**
+ * Re-enables a previously disabled import map override. In production, this is a no-op.
+ */ export function enableImportMapOverride(name) {
+    if (!devMode) {
+        console.warn('[Security] Import map overrides are disabled in production mode.');
+        return;
+    }
+    try {
+        const disabled = getImportMapDisabledOverrides().filter((n)=>n !== name);
+        if (disabled.length > 0) {
+            localStorage.setItem(DISABLED_KEY, JSON.stringify(disabled));
+        } else {
+            localStorage.removeItem(DISABLED_KEY);
+        }
+        window.dispatchEvent(new CustomEvent(CHANGE_EVENT));
+    } catch (e) {
+        console.warn('[import-maps] Failed to update import-map overrides in localStorage', e);
+    }
+}
+/**
+ * Initializes the import map override system with mode-aware behavior.
+ *
+ * In production (`window.spaEnv !== 'development'`), mutation functions are
+ * no-ops and localStorage overrides are never consulted. In development, the
+ * full override workflow is available.
+ *
+ * Must be called before any code that depends on the import map functions.
+ */ let initialized = false;
+export function setupImportMapOverrides() {
+    if (initialized) {
+        return;
+    }
+    initialized = true;
+    devMode = window.spaEnv === 'development';
+    if (devMode) {
+        initialOverrideSnapshot = readOverrideMap();
+    }
+}

package/dist/index.d.ts

@@ -1,2 +1,4 @@
 export * from './dynamic-loading';
+export * from './import-maps';
+export * from './route-maps';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC"}

package/dist/index.js

@@ -1 +1,3 @@
 export * from "./dynamic-loading.js";
+export * from "./import-maps.js";
+export * from "./route-maps.js";

package/dist/route-maps.d.ts

@@ -0,0 +1,46 @@
+/** @module @category Route Map */
+import { type OpenmrsAppRoutes, type OpenmrsRoutes } from '@openmrs/esm-globals';
+/**
+ * Returns the route map for the current page. In dev mode, this merges
+ * the base map with the override snapshot captured at page load.
+ */
+export declare function getCurrentRouteMap(): Promise<OpenmrsRoutes>;
+/**
+ * Returns the base route map from the DOM without any overrides applied.
+ */
+export declare function getRouteMapDefaultMap(): Promise<OpenmrsRoutes>;
+/**
+ * Returns what the route map will look like on the next page load, including
+ * any overrides that have been added/removed since the page loaded.
+ * In production, this is the same as the base map.
+ */
+export declare function getRouteMapNextPageMap(): Promise<OpenmrsRoutes>;
+/**
+ * Returns the current raw override entries from localStorage.
+ * In production, returns an empty object.
+ */
+export declare function getRouteMapOverrideMap(): Record<string, string>;
+/**
+ * Adds a route override. In production, this is a no-op.
+ * The app must be reloaded for overrides to take effect.
+ *
+ * @param moduleName The name of the module the routes are for
+ * @param routes Either an {@link OpenmrsAppRoutes} object, a string that represents a JSON
+ *  version of an {@link OpenmrsAppRoutes} object, or a string or URL that resolves to a
+ *  JSON document that represents an {@link OpenmrsAppRoutes} object
+ */
+export declare function addRouteMapOverride(moduleName: string, routes: OpenmrsAppRoutes | string | URL): void;
+/**
+ * Removes a route override. In production, this is a no-op.
+ * The app must be reloaded for the removal to take effect.
+ *
+ * @param moduleName The module to remove the overrides for
+ */
+export declare function removeRouteMapOverride(moduleName: string): void;
+/**
+ * Clears all route overrides. In production, this is a no-op.
+ * The app must be reloaded for the removal to take effect.
+ */
+export declare function resetRouteMapOverrides(): void;
+export declare function setupRouteMapOverrides(): Promise<void>;
+//# sourceMappingURL=route-maps.d.ts.map

package/dist/route-maps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-maps.d.ts","sourceRoot":"","sources":["../src/route-maps.ts"],"names":[],"mappings":"AAAA,kCAAkC;AAClC,OAAO,EAAuC,KAAK,gBAAgB,EAAE,KAAK,aAAa,EAAE,MAAM,sBAAsB,CAAC;AA2GtH;;;GAGG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,aAAa,CAAC,CAOjE;AAED;;GAEG;AACH,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,aAAa,CAAC,CAEpE;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,IAAI,OAAO,CAAC,aAAa,CAAC,CAMrE;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAoB/D;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,gBAAgB,GAAG,MAAM,GAAG,GAAG,QAkC9F;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,MAAM,QAYxD;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,SAmBrC;AAaD,wBAAgB,sBAAsB,IAAI,OAAO,CAAC,IAAI,CAAC,CAgBtD"}

package/dist/route-maps.js

@@ -0,0 +1,252 @@
+/** @module @category Route Map */ import { isOpenmrsAppRoutes, isOpenmrsRoutes } from "@openmrs/esm-globals";
+const OVERRIDE_PREFIX = 'openmrs-routes:';
+const CHANGE_EVENT = 'openmrs-routes:change';
+// Set by setupRouteMapOverrides(); controls whether override functionality is active.
+let devMode = false;
+// Snapshot of overrides at setup time (mirrors the import-map-overrides pattern:
+// getCurrentRouteMap returns the overrides as they were when the page loaded).
+let initialOverrideSnapshot = null;
+/**
+ * Reads all `<script type="openmrs-routes">` tags from the DOM and merges
+ * them into a single {@link OpenmrsRoutes} object. Tags with a `src` attribute
+ * are fetched; inline tags have their `textContent` parsed as JSON.
+ */ async function readBaseMap() {
+    const scripts = document.querySelectorAll("script[type='openmrs-routes']");
+    const maps = [];
+    for(let i = 0; i < scripts.length; i++){
+        const script = scripts[i];
+        try {
+            let parsed;
+            if (script.src) {
+                const response = await fetch(script.src);
+                parsed = await response.json();
+            } else if (script.textContent) {
+                parsed = JSON.parse(script.textContent);
+            }
+            if (parsed && isOpenmrsRoutes(parsed)) {
+                maps.push(parsed);
+            }
+        } catch (e) {
+            console.warn(`[route-maps] Failed to parse routes from script tag at index ${i}`, e);
+        }
+    }
+    return mergeRouteMaps(maps);
+}
+function mergeRouteMaps(maps) {
+    const merged = {};
+    for (const map of maps){
+        if (map && typeof map === 'object') {
+            Object.assign(merged, map);
+        }
+    }
+    return merged;
+}
+/**
+ * Reads all `openmrs-routes:*` entries from localStorage as an {@link OpenmrsRoutes}.
+ * This is async because URL-valued overrides need to be fetched.
+ */ async function readOverrideMap() {
+    const result = {};
+    try {
+        const entries = [];
+        for(let i = 0; i < localStorage.length; i++){
+            const key = localStorage.key(i);
+            if (key?.startsWith(OVERRIDE_PREFIX)) {
+                const raw = localStorage.getItem(key);
+                if (raw) {
+                    entries.push({
+                        moduleName: key.slice(OVERRIDE_PREFIX.length),
+                        raw
+                    });
+                }
+            }
+        }
+        const settled = await Promise.allSettled(entries.map(async ({ moduleName, raw })=>{
+            const parsed = JSON.parse(raw);
+            if (isOpenmrsAppRoutes(parsed)) {
+                return {
+                    moduleName,
+                    routes: parsed
+                };
+            }
+            if (typeof parsed === 'string' && parsed.startsWith('http')) {
+                const response = await fetch(parsed);
+                const fetched = await response.json();
+                if (isOpenmrsAppRoutes(fetched)) {
+                    return {
+                        moduleName,
+                        routes: fetched
+                    };
+                }
+                throw new Error(`${parsed} did not resolve to a valid OpenmrsAppRoutes object`);
+            }
+            throw new Error(`Override for ${moduleName} is neither a valid routes object nor a URL`);
+        }));
+        for (const entry of settled){
+            if (entry.status === 'fulfilled') {
+                result[entry.value.moduleName] = entry.value.routes;
+            } else {
+                console.warn('[route-maps] Failed to load route override', entry.reason);
+            }
+        }
+    } catch (e) {
+        console.warn('[route-maps] Failed to read route overrides from localStorage', e);
+    }
+    return result;
+}
+/**
+ * Returns the route map for the current page. In dev mode, this merges
+ * the base map with the override snapshot captured at page load.
+ */ export async function getCurrentRouteMap() {
+    const base = await readBaseMap();
+    if (!devMode) {
+        return base;
+    }
+    const overrides = initialOverrideSnapshot ?? await readOverrideMap();
+    return mergeRouteMaps([
+        base,
+        overrides
+    ]);
+}
+/**
+ * Returns the base route map from the DOM without any overrides applied.
+ */ export async function getRouteMapDefaultMap() {
+    return readBaseMap();
+}
+/**
+ * Returns what the route map will look like on the next page load, including
+ * any overrides that have been added/removed since the page loaded.
+ * In production, this is the same as the base map.
+ */ export async function getRouteMapNextPageMap() {
+    if (!devMode) {
+        return readBaseMap();
+    }
+    const base = await readBaseMap();
+    return mergeRouteMaps([
+        base,
+        await readOverrideMap()
+    ]);
+}
+/**
+ * Returns the current raw override entries from localStorage.
+ * In production, returns an empty object.
+ */ export function getRouteMapOverrideMap() {
+    if (!devMode) {
+        return {};
+    }
+    const result = {};
+    try {
+        for(let i = 0; i < localStorage.length; i++){
+            const key = localStorage.key(i);
+            if (key?.startsWith(OVERRIDE_PREFIX)) {
+                const value = localStorage.getItem(key);
+                if (value) {
+                    result[key.slice(OVERRIDE_PREFIX.length)] = value;
+                }
+            }
+        }
+    } catch (e) {
+        console.warn('[route-maps] Failed to read route overrides from localStorage', e);
+    }
+    return result;
+}
+/**
+ * Adds a route override. In production, this is a no-op.
+ * The app must be reloaded for overrides to take effect.
+ *
+ * @param moduleName The name of the module the routes are for
+ * @param routes Either an {@link OpenmrsAppRoutes} object, a string that represents a JSON
+ *  version of an {@link OpenmrsAppRoutes} object, or a string or URL that resolves to a
+ *  JSON document that represents an {@link OpenmrsAppRoutes} object
+ */ export function addRouteMapOverride(moduleName, routes) {
+    if (!devMode) {
+        console.warn('[Security] Route overrides are disabled outside development mode.');
+        return;
+    }
+    try {
+        if (typeof routes === 'string') {
+            if (routes.startsWith('http')) {
+                localStorage.setItem(OVERRIDE_PREFIX + moduleName, JSON.stringify(routes));
+            } else {
+                const maybeRoutes = JSON.parse(routes);
+                if (isOpenmrsAppRoutes(maybeRoutes)) {
+                    localStorage.setItem(OVERRIDE_PREFIX + moduleName, JSON.stringify(maybeRoutes));
+                } else {
+                    console.error(`The supplied routes for ${moduleName} is not a valid OpenmrsAppRoutes object`, routes);
+                    return;
+                }
+            }
+        } else if (routes instanceof URL) {
+            localStorage.setItem(OVERRIDE_PREFIX + moduleName, JSON.stringify(routes.toString()));
+        } else if (isOpenmrsAppRoutes(routes)) {
+            localStorage.setItem(OVERRIDE_PREFIX + moduleName, JSON.stringify(routes));
+        } else {
+            console.error(`Override for ${moduleName} is not in a valid format. Expected either a Javascript Object, a JSON string of a Javascript object, or a URL`, routes);
+            return;
+        }
+        window.dispatchEvent(new CustomEvent(CHANGE_EVENT));
+    } catch (e) {
+        console.warn('[route-maps] Failed to write route override to localStorage', e);
+    }
+}
+/**
+ * Removes a route override. In production, this is a no-op.
+ * The app must be reloaded for the removal to take effect.
+ *
+ * @param moduleName The module to remove the overrides for
+ */ export function removeRouteMapOverride(moduleName) {
+    if (!devMode) {
+        console.warn('[Security] Route overrides are disabled outside development mode.');
+        return;
+    }
+    try {
+        localStorage.removeItem(OVERRIDE_PREFIX + moduleName);
+        window.dispatchEvent(new CustomEvent(CHANGE_EVENT));
+    } catch (e) {
+        console.warn('[route-maps] Failed to remove route override from localStorage', e);
+    }
+}
+/**
+ * Clears all route overrides. In production, this is a no-op.
+ * The app must be reloaded for the removal to take effect.
+ */ export function resetRouteMapOverrides() {
+    if (!devMode) {
+        console.warn('[Security] Route overrides are disabled outside development mode.');
+        return;
+    }
+    try {
+        const keysToRemove = [];
+        for(let i = 0; i < localStorage.length; i++){
+            const key = localStorage.key(i);
+            if (key?.startsWith(OVERRIDE_PREFIX)) {
+                keysToRemove.push(key);
+            }
+        }
+        keysToRemove.forEach((key)=>localStorage.removeItem(key));
+        window.dispatchEvent(new CustomEvent(CHANGE_EVENT));
+    } catch (e) {
+        console.warn('[route-maps] Failed to clear route overrides from localStorage', e);
+    }
+}
+/**
+ * Initializes the route map override system with mode-aware behavior.
+ *
+ * In production (`window.spaEnv !== 'development'`), mutation functions are
+ * no-ops and localStorage overrides are never consulted. In development, the
+ * full override workflow is available.
+ *
+ * Must be called before any code that depends on the route map functions.
+ */ let setupPromise = null;
+export function setupRouteMapOverrides() {
+    if (setupPromise) {
+        return setupPromise;
+    }
+    devMode = window.spaEnv === 'development';
+    if (devMode) {
+        setupPromise = readOverrideMap().then((snapshot)=>{
+            initialOverrideSnapshot = snapshot;
+        });
+    } else {
+        setupPromise = Promise.resolve();
+    }
+    return setupPromise;
+}