@squide/firefly 9.2.1 → 9.3.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @squide/firefly
 
+## 9.3.0
+
+### Minor Changes
+
+- [#219](https://github.com/gsoft-inc/wl-squide/pull/219) [`25cb482`](https://github.com/gsoft-inc/wl-squide/commit/25cb482779ee280f3f7109de4607b92dcfeef7f3) Thanks [@patricklafrance](https://github.com/patricklafrance)! - Now dispatching events to enable instrumentation packages for observability platforms.
+
+### Patch Changes
+
+- Updated dependencies [[`25cb482`](https://github.com/gsoft-inc/wl-squide/commit/25cb482779ee280f3f7109de4607b92dcfeef7f3)]:
+  - @squide/module-federation@6.2.0
+  - @squide/react-router@6.4.0
+  - @squide/core@5.4.0
+  - @squide/msw@3.2.0
+
 ## 9.2.1
 
 ### Patch Changes

package/dist/AppRouter.js

@@ -1,6 +1,8 @@
-export { AppRouter } from './chunk-36U4TTNR.js';
+export { AppRouter } from './chunk-L44KFU57.js';
 import './chunk-WOPD33CM.js';
-import './chunk-ENUCXEMN.js';
-import './chunk-MZG2PJJG.js';
+import './chunk-JFMSLZ74.js';
+import './chunk-TURKCH7J.js';
+import './chunk-H2ILEMPE.js';
+import './chunk-PMVN3U47.js';
 import './chunk-PP3MRMJJ.js';
 import './chunk-G32YX2KR.js';

package/dist/AppRouterReducer.d.ts

@@ -1,5 +1,6 @@
 import { Dispatch } from 'react';
 
+type ActiveRouteVisiblity = "unknown" | "public" | "protected";
 interface AppRouterState {
     waitForMsw: boolean;
     waitForPublicData: boolean;
@@ -12,10 +13,19 @@ interface AppRouterState {
     publicDataUpdatedAt?: number;
     protectedDataUpdatedAt?: number;
     deferredRegistrationsUpdatedAt?: number;
-    isActiveRouteProtected: boolean;
+    activeRouteVisibility: ActiveRouteVisiblity;
     isUnauthorized: boolean;
 }
-type AppRouterActionType = "modules-registered" | "modules-ready" | "msw-ready" | "public-data-ready" | "protected-data-ready" | "public-data-updated" | "protected-data-updated" | "deferred-registrations-updated" | "active-route-is-protected" | "is-unauthorized";
+type AppRouterActionType = "modules-registered" | "modules-ready" | "msw-ready" | "public-data-ready" | "protected-data-ready" | "public-data-updated" | "protected-data-updated" | "deferred-registrations-updated" | "active-route-is-public" | "active-route-is-protected" | "is-unauthorized";
+declare const ModulesRegisteredEvent = "squide-modules-registered";
+declare const ModulesReadyEvent = "squide-modules-ready";
+declare const MswReadyEvent = "squide-msw-ready";
+declare const PublicDataReadyEvent = "squide-public-data-ready";
+declare const ProtectedDataReadyEvent = "squide-protected-data-ready";
+declare const PublicDataUpdatedEvent = "squide-public-data-updated";
+declare const ProtectedDataUpdatedEvent = "squide-protected-data-updated";
+declare const DeferredRegistrationsUpdatedEvent = "squide-deferred-registrations-updated";
+declare const ApplicationBoostrappedEvent = "squide-app-boostrapped";
 interface AppRouterAction {
     type: AppRouterActionType;
 }
@@ -24,8 +34,9 @@ declare function getAreModulesRegistered(): boolean;
 declare function getAreModulesReady(): boolean;
 declare function useModuleRegistrationStatusDispatcher(areModulesRegisteredValue: boolean, areModulesReadyValue: boolean, dispatch: AppRouterDispatch): void;
 declare function useMswStatusDispatcher(isMswReadyValue: boolean, dispatch: AppRouterDispatch): void;
+declare function useBootstrappingCompletedDispatcher(state: AppRouterState): void;
 declare function __setAppReducerDispatchProxyFactory(factory: (reactDispatch: AppRouterDispatch) => AppRouterDispatch): void;
 declare function __clearAppReducerDispatchProxy(): void;
 declare function useAppRouterReducer(waitForMsw: boolean, waitForPublicData: boolean, waitForProtectedData: boolean): [AppRouterState, AppRouterDispatch];
 
-export { type AppRouterAction, type AppRouterActionType, type AppRouterDispatch, type AppRouterState, __clearAppReducerDispatchProxy, __setAppReducerDispatchProxyFactory, getAreModulesReady, getAreModulesRegistered, useAppRouterReducer, useModuleRegistrationStatusDispatcher, useMswStatusDispatcher };
+export { type ActiveRouteVisiblity, type AppRouterAction, type AppRouterActionType, type AppRouterDispatch, type AppRouterState, ApplicationBoostrappedEvent, DeferredRegistrationsUpdatedEvent, ModulesReadyEvent, ModulesRegisteredEvent, MswReadyEvent, ProtectedDataReadyEvent, ProtectedDataUpdatedEvent, PublicDataReadyEvent, PublicDataUpdatedEvent, __clearAppReducerDispatchProxy, __setAppReducerDispatchProxyFactory, getAreModulesReady, getAreModulesRegistered, useAppRouterReducer, useBootstrappingCompletedDispatcher, useModuleRegistrationStatusDispatcher, useMswStatusDispatcher };

package/dist/AppRouterReducer.js

@@ -1 +1,4 @@
-export { __clearAppReducerDispatchProxy, __setAppReducerDispatchProxyFactory, getAreModulesReady, getAreModulesRegistered, useAppRouterReducer, useModuleRegistrationStatusDispatcher, useMswStatusDispatcher } from './chunk-ENUCXEMN.js';
+export { ApplicationBoostrappedEvent, DeferredRegistrationsUpdatedEvent, ModulesReadyEvent, ModulesRegisteredEvent, MswReadyEvent, ProtectedDataReadyEvent, ProtectedDataUpdatedEvent, PublicDataReadyEvent, PublicDataUpdatedEvent, __clearAppReducerDispatchProxy, __setAppReducerDispatchProxyFactory, getAreModulesReady, getAreModulesRegistered, useAppRouterReducer, useBootstrappingCompletedDispatcher, useModuleRegistrationStatusDispatcher, useMswStatusDispatcher } from './chunk-JFMSLZ74.js';
+import './chunk-TURKCH7J.js';
+import './chunk-H2ILEMPE.js';
+import './chunk-G32YX2KR.js';

package/dist/FireflyRuntime.js

@@ -1,2 +1,5 @@
-export { FireflyRuntime } from './chunk-FKQ7XQEU.js';
-import './chunk-ENUCXEMN.js';
+export { FireflyRuntime } from './chunk-CFNKNPS3.js';
+import './chunk-JFMSLZ74.js';
+import './chunk-TURKCH7J.js';
+import './chunk-H2ILEMPE.js';
+import './chunk-G32YX2KR.js';

package/dist/RootRoute.js

@@ -1,3 +1,3 @@
-export { RootRoute } from './chunk-MZG2PJJG.js';
+export { RootRoute } from './chunk-PMVN3U47.js';
 import './chunk-PP3MRMJJ.js';
 import './chunk-G32YX2KR.js';

package/dist/boostrap.d.ts

@@ -0,0 +1,20 @@
+import { RegisterModulesOptions, ModuleRegisterFunction, ModuleRegistrationError } from '@squide/core';
+import { RemoteDefinition, RemoteModuleRegistrationError } from '@squide/module-federation';
+import { FireflyRuntime } from './FireflyRuntime.js';
+import '@squide/react-router';
+import 'msw';
+
+declare const ApplicationBootstrappingStartedEvent = "squide-app-bootstrapping-started";
+type StartMswFunction<TRuntime = FireflyRuntime> = (runtime: TRuntime) => Promise<void>;
+interface BootstrapAppOptions<TRuntime extends FireflyRuntime = FireflyRuntime, TContext = unknown, TData = unknown> extends RegisterModulesOptions<TContext> {
+    localModules?: ModuleRegisterFunction<TRuntime, TContext, TData>[];
+    remotes?: RemoteDefinition[];
+    startMsw?: StartMswFunction<TRuntime>;
+}
+declare function bootstrap<TRuntime extends FireflyRuntime = FireflyRuntime, TContext = unknown, TData = unknown>(runtime: TRuntime, options?: BootstrapAppOptions<TRuntime, TContext, TData>): Promise<{
+    localModuleErrors: ModuleRegistrationError[];
+    remoteModuleErrors: RemoteModuleRegistrationError[];
+}>;
+declare function __resetBootstrapGuard(): void;
+
+export { ApplicationBootstrappingStartedEvent, type BootstrapAppOptions, type StartMswFunction, __resetBootstrapGuard, bootstrap };

package/dist/boostrap.js

@@ -0,0 +1 @@
+export { ApplicationBootstrappingStartedEvent, __resetBootstrapGuard, bootstrap } from './chunk-IGJHKH2A.js';

package/dist/{chunk-PU7MASPN.js → chunk-4RUCDAUT.js}

@@ -9,10 +9,10 @@ function useCanRegisterDeferredRegistrations() {
     areModulesRegistered,
     isPublicDataReady,
     isProtectedDataReady,
-    isActiveRouteProtected,
+    activeRouteVisibility,
     isUnauthorized
   } = useAppRouterState();
-  return !isUnauthorized && areModulesRegistered && !areModulesReady && (!waitForPublicData || isPublicDataReady) && (!waitForProtectedData || !isActiveRouteProtected || isProtectedDataReady);
+  return !isUnauthorized && areModulesRegistered && !areModulesReady && (!waitForPublicData || isPublicDataReady) && (!waitForProtectedData || activeRouteVisibility === "public" || isProtectedDataReady);
 }
 
 export { useCanRegisterDeferredRegistrations };

package/dist/{chunk-2E76JVV7.js → chunk-BFHHJOJT.js}

@@ -1,6 +1,6 @@
 import { useRegisterDeferredRegistrations } from './chunk-YRWFYWK4.js';
 import { useUpdateDeferredRegistrations } from './chunk-N2GOIQ5E.js';
-import { useCanRegisterDeferredRegistrations } from './chunk-PU7MASPN.js';
+import { useCanRegisterDeferredRegistrations } from './chunk-4RUCDAUT.js';
 import { useCanUpdateDeferredRegistrations } from './chunk-WVRMJZV6.js';
 import { useRuntime } from '@squide/core';
 import { useEffect } from 'react';

package/dist/{chunk-FKQ7XQEU.js → chunk-CFNKNPS3.js}

@@ -1,4 +1,4 @@
-import { getAreModulesRegistered } from './chunk-ENUCXEMN.js';
+import { getAreModulesRegistered } from './chunk-JFMSLZ74.js';
 import { MswPlugin } from '@squide/msw';
 import { ReactRouterRuntime } from '@squide/react-router';
 

package/dist/{chunk-VUMBZ5BP.js → chunk-CTLPFYLM.js}

@@ -1,21 +1,27 @@
 import { useCanFetchPublicData } from './chunk-IOMSOUAL.js';
+import { useExecuteOnce } from './chunk-TURKCH7J.js';
 import { GlobalDataQueriesError } from './chunk-HE5HKFL3.js';
 import { useAppRouterDispatcher } from './chunk-G32YX2KR.js';
+import { useEventBus } from '@squide/core';
 import { useQueries } from '@tanstack/react-query';
-import { useCallback, useEffect, useRef } from 'react';
+import { useCallback, useRef, useEffect } from 'react';
 
+var PublicDataFetchStartedEvent = "squide-public-data-fetch-started";
+var PublicDataFetchFailedEvent = "squide-public-data-fetch-failed";
 function usePublicDataQueries(queries) {
   const canFetchPublicData = useCanFetchPublicData();
+  const eventBus = useEventBus();
   const dispatch = useAppRouterDispatcher();
   const combineResults = useCallback((results) => {
     const errors = results.filter((x) => x.error).map((x) => x.error);
+    const hasErrors2 = errors.length > 0;
     return {
       data: results.map((x) => x.data),
       errors,
-      hasErrors: errors.length > 0,
-      isReady: results.length === queries.length && results.every((x) => x.data)
+      hasErrors: hasErrors2,
+      isReady: !hasErrors2 && !results.some((x) => x.isPending)
     };
-  }, [queries.length]);
+  }, []);
   const { data, errors: queriesErrors, hasErrors, isReady } = useQueries({
     queries: queries.map((x) => ({
       enabled: canFetchPublicData,
@@ -23,24 +29,37 @@ function usePublicDataQueries(queries) {
     })),
     combine: combineResults
   });
-  useEffect(() => {
-    if (hasErrors) {
-      throw new GlobalDataQueriesError("[squide] Global public data queries failed.", queriesErrors);
+  useExecuteOnce(useCallback(() => {
+    if (canFetchPublicData) {
+      eventBus.dispatch(PublicDataFetchStartedEvent);
+      return true;
     }
-  }, [hasErrors, queriesErrors]);
+    return false;
+  }, [canFetchPublicData, eventBus]), true);
   const isReadyRef = useRef(false);
+  const dispatchReady = useExecuteOnce(useCallback(() => {
+    if (isReady) {
+      isReadyRef.current = true;
+      dispatch({ type: "public-data-ready" });
+      return true;
+    }
+    return false;
+  }, [isReady, dispatch]));
+  useEffect(() => {
+    dispatchReady();
+  }, [dispatchReady]);
   useEffect(() => {
     if (isReadyRef.current && data) {
       dispatch({ type: "public-data-updated" });
     }
   }, [data, dispatch]);
   useEffect(() => {
-    if (isReady) {
-      isReadyRef.current = true;
-      dispatch({ type: "public-data-ready" });
+    if (hasErrors) {
+      eventBus.dispatch(PublicDataFetchFailedEvent, queriesErrors);
+      throw new GlobalDataQueriesError("[squide] Global public data queries failed.", queriesErrors);
     }
-  }, [isReady, dispatch]);
+  }, [hasErrors, queriesErrors, eventBus]);
   return data;
 }
 
-export { usePublicDataQueries };
+export { PublicDataFetchFailedEvent, PublicDataFetchStartedEvent, usePublicDataQueries };

package/dist/{chunk-I6L3AYOB.js → chunk-H2ILEMPE.js}

@@ -2,6 +2,10 @@ import { useAppRouterState } from './chunk-G32YX2KR.js';
 
 // src/useIsBootstrapping.ts
 function useIsBootstrapping() {
+  const state = useAppRouterState();
+  return isApplicationBootstrapping(state);
+}
+function isApplicationBootstrapping(state) {
   const {
     waitForMsw,
     waitForPublicData,
@@ -10,10 +14,10 @@ function useIsBootstrapping() {
     isMswReady,
     isPublicDataReady,
     isProtectedDataReady,
-    isActiveRouteProtected,
+    activeRouteVisibility,
     isUnauthorized
-  } = useAppRouterState();
-  const isAppReady = !isUnauthorized && areModulesReady && (!waitForMsw || isMswReady) && (!waitForPublicData || isPublicDataReady) && (!waitForProtectedData || !isActiveRouteProtected || isProtectedDataReady);
+  } = state;
+  const isAppReady = !isUnauthorized && areModulesReady && (!waitForMsw || isMswReady) && (!waitForPublicData || isPublicDataReady) && (!waitForProtectedData || activeRouteVisibility === "public" || isProtectedDataReady);
   const flush = (
     // Only applicable when there's a unauthorized request while fetching the initial data.
     isUnauthorized && (!waitForMsw || isMswReady) && (!waitForPublicData || isPublicDataReady)
@@ -21,4 +25,4 @@ function useIsBootstrapping() {
   return !isAppReady && !flush;
 }
 
-export { useIsBootstrapping };
+export { isApplicationBootstrapping, useIsBootstrapping };

package/dist/chunk-IGJHKH2A.js

@@ -0,0 +1,48 @@
+import { registerLocalModules, isFunction } from '@squide/core';
+import { registerRemoteModules } from '@squide/module-federation';
+import { setMswAsReady } from '@squide/msw';
+
+// src/boostrap.ts
+var ApplicationBootstrappingStartedEvent = "squide-app-bootstrapping-started";
+var isBootstrapped = false;
+async function bootstrap(runtime, options = {}) {
+  const {
+    localModules,
+    remotes,
+    context,
+    startMsw
+  } = options;
+  if (isBootstrapped) {
+    throw new Error('[squide] A squide application can only be bootstrapped once. Did you call the "bootstrap" function twice?');
+  }
+  runtime.eventBus.dispatch(ApplicationBootstrappingStartedEvent);
+  let localModuleErrors = [];
+  let remoteModuleErrors = [];
+  if (localModules) {
+    localModuleErrors = await registerLocalModules(localModules, runtime, { context });
+  }
+  if (remotes) {
+    remoteModuleErrors = await registerRemoteModules(remotes, runtime, { context });
+  }
+  if (runtime.isMswEnabled) {
+    if (!isFunction(startMsw)) {
+      throw new Error('[squide] When MSW is enabled, the "startMsw" function must be provided.');
+    }
+    try {
+      await startMsw(runtime);
+      setMswAsReady();
+    } catch (error) {
+      runtime.logger.debug("[squide] An error occured while starting MSW.", error);
+    }
+  }
+  isBootstrapped = true;
+  return {
+    localModuleErrors,
+    remoteModuleErrors
+  };
+}
+function __resetBootstrapGuard() {
+  isBootstrapped = false;
+}
+
+export { ApplicationBootstrappingStartedEvent, __resetBootstrapGuard, bootstrap };

package/dist/chunk-JFMSLZ74.js

@@ -0,0 +1,253 @@
+import { useExecuteOnce } from './chunk-TURKCH7J.js';
+import { isApplicationBootstrapping } from './chunk-H2ILEMPE.js';
+import { getLocalModuleRegistrationStatus, useLogger, addLocalModuleRegistrationStatusChangedListener, removeLocalModuleRegistrationStatusChangedListener, useEventBus } from '@squide/core';
+import { getRemoteModuleRegistrationStatus, areModulesRegistered, areModulesReady, addRemoteModuleRegistrationStatusChangedListener, removeRemoteModuleRegistrationStatusChangedListener } from '@squide/module-federation';
+import { isMswReady, addMswStateChangedListener, removeMswStateChangedListener } from '@squide/msw';
+import { useCallback, useEffect, useReducer, useMemo } from 'react';
+
+var ModulesRegisteredEvent = "squide-modules-registered";
+var ModulesReadyEvent = "squide-modules-ready";
+var MswReadyEvent = "squide-msw-ready";
+var PublicDataReadyEvent = "squide-public-data-ready";
+var ProtectedDataReadyEvent = "squide-protected-data-ready";
+var PublicDataUpdatedEvent = "squide-public-data-updated";
+var ProtectedDataUpdatedEvent = "squide-protected-data-updated";
+var DeferredRegistrationsUpdatedEvent = "squide-deferred-registrations-updated";
+var ApplicationBoostrappedEvent = "squide-app-boostrapped";
+function reducer(state, action) {
+  let newState = state;
+  switch (action.type) {
+    case "modules-registered": {
+      newState = {
+        ...newState,
+        areModulesRegistered: true
+      };
+      break;
+    }
+    case "modules-ready": {
+      newState = {
+        ...newState,
+        areModulesReady: true,
+        // Will be set even if the app is not using deferred registrations.
+        deferredRegistrationsUpdatedAt: Date.now()
+      };
+      break;
+    }
+    case "msw-ready": {
+      newState = {
+        ...newState,
+        isMswReady: true
+      };
+      break;
+    }
+    case "public-data-ready": {
+      newState = {
+        ...newState,
+        isPublicDataReady: true,
+        publicDataUpdatedAt: Date.now()
+      };
+      break;
+    }
+    case "protected-data-ready": {
+      newState = {
+        ...newState,
+        isProtectedDataReady: true,
+        protectedDataUpdatedAt: Date.now()
+      };
+      break;
+    }
+    case "public-data-updated": {
+      newState = {
+        ...newState,
+        publicDataUpdatedAt: Date.now()
+      };
+      break;
+    }
+    case "protected-data-updated": {
+      newState = {
+        ...newState,
+        protectedDataUpdatedAt: Date.now()
+      };
+      break;
+    }
+    case "deferred-registrations-updated": {
+      newState = {
+        ...newState,
+        deferredRegistrationsUpdatedAt: Date.now()
+      };
+      break;
+    }
+    case "active-route-is-public": {
+      newState = {
+        ...newState,
+        activeRouteVisibility: "public"
+      };
+      break;
+    }
+    case "active-route-is-protected": {
+      newState = {
+        ...newState,
+        activeRouteVisibility: "protected"
+      };
+      break;
+    }
+    case "is-unauthorized": {
+      newState = {
+        ...newState,
+        isUnauthorized: true
+      };
+      break;
+    }
+    default: {
+      throw new Error(`[squide] The AppRouter component state reducer doesn't support action type "${action.type}".`);
+    }
+  }
+  return newState;
+}
+function getAreModulesRegistered() {
+  const localModuleStatus = getLocalModuleRegistrationStatus();
+  const remoteModuleStatus = getRemoteModuleRegistrationStatus();
+  return areModulesRegistered(localModuleStatus, remoteModuleStatus);
+}
+function getAreModulesReady() {
+  const localModuleStatus = getLocalModuleRegistrationStatus();
+  const remoteModuleStatus = getRemoteModuleRegistrationStatus();
+  return areModulesReady(localModuleStatus, remoteModuleStatus);
+}
+function useModuleRegistrationStatusDispatcher(areModulesRegisteredValue, areModulesReadyValue, dispatch) {
+  const logger = useLogger();
+  const dispatchModulesRegistered = useExecuteOnce(useCallback(() => {
+    if (getAreModulesRegistered()) {
+      dispatch({ type: "modules-registered" });
+      logger.debug("[squide] %cModules are registered%c.", "color: white; background-color: green;", "");
+      return true;
+    }
+    return false;
+  }, [dispatch, logger]));
+  const dispatchModulesReady = useExecuteOnce(useCallback(() => {
+    if (getAreModulesReady()) {
+      dispatch({ type: "modules-ready" });
+      logger.debug("[squide] %cModules are ready%c.", "color: white; background-color: green;", "");
+      return true;
+    }
+    return false;
+  }, [dispatch, logger]));
+  return useEffect(() => {
+    if (!areModulesRegisteredValue) {
+      addLocalModuleRegistrationStatusChangedListener(dispatchModulesRegistered);
+      addRemoteModuleRegistrationStatusChangedListener(dispatchModulesRegistered);
+    }
+    if (!areModulesReadyValue) {
+      addLocalModuleRegistrationStatusChangedListener(dispatchModulesReady);
+      addRemoteModuleRegistrationStatusChangedListener(dispatchModulesReady);
+    }
+    return () => {
+      removeLocalModuleRegistrationStatusChangedListener(dispatchModulesRegistered);
+      removeRemoteModuleRegistrationStatusChangedListener(dispatchModulesRegistered);
+      removeLocalModuleRegistrationStatusChangedListener(dispatchModulesReady);
+      removeRemoteModuleRegistrationStatusChangedListener(dispatchModulesReady);
+    };
+  }, [areModulesRegisteredValue, areModulesReadyValue, dispatchModulesRegistered, dispatchModulesReady]);
+}
+function useMswStatusDispatcher(isMswReadyValue, dispatch) {
+  const logger = useLogger();
+  const dispatchMswReady = useExecuteOnce(useCallback(() => {
+    if (isMswReady()) {
+      dispatch({ type: "msw-ready" });
+      logger.debug("[squide] %cMSW is ready%c.", "color: white; background-color: green;", "");
+      return true;
+    }
+    return false;
+  }, [dispatch, logger]));
+  useEffect(() => {
+    if (!isMswReadyValue) {
+      addMswStateChangedListener(dispatchMswReady);
+    }
+    return () => {
+      removeMswStateChangedListener(dispatchMswReady);
+    };
+  }, [isMswReadyValue, dispatchMswReady]);
+}
+function useBootstrappingCompletedDispatcher(state) {
+  const eventBus = useEventBus();
+  const areModulesRegisteredValue = state.areModulesRegistered;
+  const isBoostrapping = isApplicationBootstrapping(state);
+  useExecuteOnce(useCallback(() => {
+    if (areModulesRegisteredValue && !isBoostrapping) {
+      eventBus.dispatch(ApplicationBoostrappedEvent);
+      return true;
+    }
+    return false;
+  }, [areModulesRegisteredValue, isBoostrapping, eventBus]), true);
+}
+var dispatchProxyFactory;
+function __setAppReducerDispatchProxyFactory(factory) {
+  dispatchProxyFactory = factory;
+}
+function __clearAppReducerDispatchProxy() {
+  dispatchProxyFactory = void 0;
+}
+function useReducerDispatchProxy(reactDispatch) {
+  return useMemo(() => {
+    return dispatchProxyFactory ? dispatchProxyFactory(reactDispatch) : reactDispatch;
+  }, [reactDispatch]);
+}
+function useEnhancedReducerDispatch(reducerDispatch) {
+  const logger = useLogger();
+  const eventBus = useEventBus();
+  return useCallback((action) => {
+    logger.debug("[squide] The following action has been dispatched to the AppRouter reducer:", action);
+    eventBus.dispatch(`squide-${action.type}`);
+    reducerDispatch(action);
+  }, [reducerDispatch, logger, eventBus]);
+}
+function useAppRouterReducer(waitForMsw, waitForPublicData, waitForProtectedData) {
+  const areModulesInitiallyRegistered = getAreModulesRegistered();
+  const areModulesInitiallyReady = getAreModulesReady();
+  const isMswInitiallyReady = isMswReady();
+  const eventBus = useEventBus();
+  useExecuteOnce(useCallback(() => {
+    if (areModulesInitiallyRegistered) {
+      eventBus.dispatch(ModulesRegisteredEvent);
+    }
+    return true;
+  }, [areModulesInitiallyRegistered, eventBus]), true);
+  useExecuteOnce(useCallback(() => {
+    if (areModulesInitiallyReady) {
+      eventBus.dispatch(ModulesReadyEvent);
+    }
+    return true;
+  }, [areModulesInitiallyReady, eventBus]), true);
+  useExecuteOnce(useCallback(() => {
+    if (isMswInitiallyReady) {
+      eventBus.dispatch(MswReadyEvent);
+    }
+    return true;
+  }, [isMswInitiallyReady, eventBus]), true);
+  const [state, reactDispatch] = useReducer(reducer, {
+    waitForMsw,
+    waitForPublicData,
+    waitForProtectedData,
+    // When the modules registration functions are awaited, the event listeners are registered after the modules are registered.
+    areModulesRegistered: areModulesInitiallyRegistered,
+    areModulesReady: areModulesInitiallyReady,
+    isMswReady: isMswInitiallyReady,
+    isPublicDataReady: false,
+    isProtectedDataReady: false,
+    activeRouteVisibility: "unknown",
+    isUnauthorized: false
+  });
+  const {
+    areModulesRegistered: areModulesRegisteredValue,
+    areModulesReady: areModulesReadyValue,
+    isMswReady: isMswReadyValue
+  } = state;
+  const dispatchProxy = useReducerDispatchProxy(reactDispatch);
+  const dispatch = useEnhancedReducerDispatch(dispatchProxy);
+  useModuleRegistrationStatusDispatcher(areModulesRegisteredValue, areModulesReadyValue, dispatch);
+  useMswStatusDispatcher(isMswReadyValue, dispatch);
+  useBootstrappingCompletedDispatcher(state);
+  return [state, dispatch];
+}
+
+export { ApplicationBoostrappedEvent, DeferredRegistrationsUpdatedEvent, ModulesReadyEvent, ModulesRegisteredEvent, MswReadyEvent, ProtectedDataReadyEvent, ProtectedDataUpdatedEvent, PublicDataReadyEvent, PublicDataUpdatedEvent, __clearAppReducerDispatchProxy, __setAppReducerDispatchProxyFactory, getAreModulesReady, getAreModulesRegistered, useAppRouterReducer, useBootstrappingCompletedDispatcher, useModuleRegistrationStatusDispatcher, useMswStatusDispatcher };

package/dist/{chunk-36U4TTNR.js → chunk-L44KFU57.js}

@@ -1,6 +1,6 @@
 import { useStrictRegistrationMode } from './chunk-WOPD33CM.js';
-import { useAppRouterReducer } from './chunk-ENUCXEMN.js';
-import { RootRoute } from './chunk-MZG2PJJG.js';
+import { useAppRouterReducer } from './chunk-JFMSLZ74.js';
+import { RootRoute } from './chunk-PMVN3U47.js';
 import { AppRouterDispatcherContext, AppRouterStateContext } from './chunk-G32YX2KR.js';
 import { useLogger } from '@squide/core';
 import { useRoutes } from '@squide/react-router';

package/dist/{chunk-7R2Z7FXF.js → chunk-MKTGJHQR.js}

@@ -1,19 +1,25 @@
+import { useCanFetchProtectedData } from './chunk-XDWYPVAJ.js';
+import { useExecuteOnce } from './chunk-TURKCH7J.js';
 import { GlobalDataQueriesError } from './chunk-HE5HKFL3.js';
-import { useCanFetchProtectedData } from './chunk-L5BP3WP3.js';
 import { useAppRouterDispatcher, useAppRouterState } from './chunk-G32YX2KR.js';
+import { useEventBus } from '@squide/core';
 import { useQueries } from '@tanstack/react-query';
-import { useCallback, useEffect, useRef } from 'react';
+import { useCallback, useRef, useEffect } from 'react';
 
+var ProtectedDataFetchStartedEvent = "squide-protected-data-fetch-started";
+var ProtectedDataFetchFailedEvent = "squide-protected-data-fetch-failed";
 function useProtectedDataQueries(queries, isUnauthorizedError) {
   const canFetchProtectedData = useCanFetchProtectedData();
+  const eventBus = useEventBus();
   const dispatch = useAppRouterDispatcher();
   const combineResults = useCallback((results) => {
     const errors = results.filter((x) => x.error).map((x) => x.error);
+    const hasErrors2 = errors.length > 0;
     return {
       data: results.map((x) => x.data),
       errors,
-      hasErrors: errors.length > 0,
-      isReady: !results.some((x) => x.isPending)
+      hasErrors: hasErrors2,
+      isReady: !hasErrors2 && !results.some((x) => x.isPending)
     };
   }, []);
   const { data, errors: queriesErrors, hasErrors, isReady } = useQueries({
@@ -23,33 +29,43 @@ function useProtectedDataQueries(queries, isUnauthorizedError) {
     })),
     combine: combineResults
   });
-  const {
-    isProtectedDataReady,
-    isUnauthorized
-  } = useAppRouterState();
-  useEffect(() => {
-    if (hasErrors) {
-      if (!isProtectedDataReady && !isUnauthorized && queriesErrors.some((x) => isUnauthorizedError(x))) {
-        dispatch({ type: "is-unauthorized" });
-      }
-      if (!queriesErrors.every((x) => isUnauthorizedError(x))) {
-        throw new GlobalDataQueriesError("[squide] Global protected data queries failed.", queriesErrors);
-      }
+  const { isProtectedDataReady, isUnauthorized } = useAppRouterState();
+  useExecuteOnce(useCallback(() => {
+    if (canFetchProtectedData) {
+      eventBus.dispatch(ProtectedDataFetchStartedEvent);
+      return true;
     }
-  }, [hasErrors, queriesErrors, isProtectedDataReady, isUnauthorized, isUnauthorizedError, dispatch]);
+    return false;
+  }, [canFetchProtectedData, eventBus]), true);
   const isReadyRef = useRef(false);
+  const dispatchReady = useExecuteOnce(useCallback(() => {
+    if (isReady) {
+      isReadyRef.current = true;
+      dispatch({ type: "protected-data-ready" });
+      return true;
+    }
+    return false;
+  }, [isReady, dispatch]));
+  useEffect(() => {
+    dispatchReady();
+  }, [dispatchReady]);
   useEffect(() => {
     if (isReadyRef.current && data) {
       dispatch({ type: "protected-data-updated" });
     }
   }, [data, dispatch]);
   useEffect(() => {
-    if (isReady) {
-      isReadyRef.current = true;
-      dispatch({ type: "protected-data-ready" });
+    if (hasErrors) {
+      if (!isProtectedDataReady && !isUnauthorized && queriesErrors.some((x) => isUnauthorizedError(x))) {
+        dispatch({ type: "is-unauthorized" });
+      }
+      if (!queriesErrors.every((x) => isUnauthorizedError(x))) {
+        eventBus.dispatch(ProtectedDataFetchFailedEvent, queriesErrors);
+        throw new GlobalDataQueriesError("[squide] Global protected data queries failed.", queriesErrors);
+      }
     }
-  }, [isReady, dispatch]);
+  }, [hasErrors, queriesErrors, isProtectedDataReady, isUnauthorized, isUnauthorizedError, dispatch, eventBus]);
   return data;
 }
 
-export { useProtectedDataQueries };
+export { ProtectedDataFetchFailedEvent, ProtectedDataFetchStartedEvent, useProtectedDataQueries };

package/dist/{chunk-MZG2PJJG.js → chunk-PMVN3U47.js}

@@ -11,6 +11,8 @@ function RootRoute() {
   useEffect(() => {
     if (isActiveRouteProtected) {
       dispatch({ type: "active-route-is-protected" });
+    } else {
+      dispatch({ type: "active-route-is-public" });
     }
   }, [isActiveRouteProtected, dispatch]);
   return /* @__PURE__ */ jsx(Outlet, {});

package/dist/chunk-TURKCH7J.js

@@ -0,0 +1,20 @@
+import { useRef, useCallback } from 'react';
+
+// src/useExecuteOnce.ts
+function useExecuteOnce(fct, inline = false) {
+  const triggered = useRef(false);
+  const onceFct = useCallback(() => {
+    if (!triggered.current) {
+      const result = fct();
+      if (result) {
+        triggered.current = true;
+      }
+    }
+  }, [fct]);
+  if (inline) {
+    onceFct();
+  }
+  return onceFct;
+}
+
+export { useExecuteOnce };

package/dist/{chunk-L5BP3WP3.js → chunk-XDWYPVAJ.js}

@@ -8,13 +8,13 @@ function useCanFetchProtectedData() {
     areModulesReady,
     isMswReady,
     isProtectedDataReady,
-    isActiveRouteProtected
+    activeRouteVisibility
   } = useAppRouterState();
   return (
     // Always return true when the protected data has already been fetched sucessfully so TanStack Query can update the data in the background.
     isProtectedDataReady || // Wait until the modules has been registered, but do not wait for the deferred registrations to be registered as they will probably
     // depends on the protected data.
-    (areModulesRegistered || areModulesReady) && isActiveRouteProtected && (!waitForMsw || isMswReady)
+    (areModulesRegistered || areModulesReady) && activeRouteVisibility === "protected" && (!waitForMsw || isMswReady)
   );
 }
 

package/dist/index.d.ts

@@ -5,7 +5,7 @@ export * from '@squide/react-router';
 export { FireflyRuntime, FireflyRuntimeOptions } from './FireflyRuntime.js';
 export { AppRouter, AppRouterProps, AppRouterRenderFunctionArgs, RenderRouterProviderFunction, RenderRouterProviderFunctionArgs } from './AppRouter.js';
 export { AppRouterDispatcherContext, AppRouterStateContext, useAppRouterDispatcher, useAppRouterState } from './AppRouterContext.js';
-export { AppRouterAction, AppRouterActionType, AppRouterDispatch, AppRouterState, __clearAppReducerDispatchProxy, __setAppReducerDispatchProxyFactory, getAreModulesReady, getAreModulesRegistered, useAppRouterReducer, useModuleRegistrationStatusDispatcher, useMswStatusDispatcher } from './AppRouterReducer.js';
+export { ActiveRouteVisiblity, AppRouterAction, AppRouterActionType, AppRouterDispatch, AppRouterState, ApplicationBoostrappedEvent, DeferredRegistrationsUpdatedEvent, ModulesReadyEvent, ModulesRegisteredEvent, MswReadyEvent, ProtectedDataReadyEvent, ProtectedDataUpdatedEvent, PublicDataReadyEvent, PublicDataUpdatedEvent, __clearAppReducerDispatchProxy, __setAppReducerDispatchProxyFactory, getAreModulesReady, getAreModulesRegistered, useAppRouterReducer, useBootstrappingCompletedDispatcher, useModuleRegistrationStatusDispatcher, useMswStatusDispatcher } from './AppRouterReducer.js';
 export { GlobalDataQueriesError, isGlobalDataQueriesError } from './GlobalDataQueriesError.js';
 export { useCanFetchProtectedData } from './useCanFetchProtectedData.js';
 export { useCanFetchPublicData } from './useCanFetchPublicData.js';
@@ -13,13 +13,14 @@ export { useCanRegisterDeferredRegistrations } from './useCanRegisterDeferredReg
 export { useCanUpdateDeferredRegistrations } from './useCanUpdateDeferredRegistrations.js';
 export { DeferredRegistrationsErrorCallback, DeferredRegistrationsErrorsObject, UseDeferredRegistrationsOptions, useDeferredRegistrations } from './useDeferredRegistrations.js';
 export { useIsActiveRouteProtected } from './useIsActiveRouteProtected.js';
-export { useIsBootstrapping } from './useIsBootstrapping.js';
+export { isApplicationBootstrapping, useIsBootstrapping } from './useIsBootstrapping.js';
 export { UseNavigationItemsOptions, useNavigationItems } from './useNavigationItems.js';
-export { IsUnauthorizedErrorCallback, useProtectedDataQueries } from './useProtectedDataQueries.js';
-export { usePublicDataQueries } from './usePublicDataQueries.js';
+export { IsUnauthorizedErrorCallback, ProtectedDataFetchFailedEvent, ProtectedDataFetchStartedEvent, useProtectedDataQueries } from './useProtectedDataQueries.js';
+export { PublicDataFetchFailedEvent, PublicDataFetchStartedEvent, usePublicDataQueries } from './usePublicDataQueries.js';
 export { useRegisterDeferredRegistrations } from './useRegisterDeferredRegistrations.js';
 export { useStrictRegistrationMode } from './useStrictRegistrationMode.js';
 export { useUpdateDeferredRegistrations } from './useUpdateDeferredRegistrations.js';
+export { ApplicationBootstrappingStartedEvent, BootstrapAppOptions, StartMswFunction, __resetBootstrapGuard, bootstrap } from './boostrap.js';
 import 'msw';
 import 'react/jsx-runtime';
 import 'react';

package/dist/index.js

@@ -1,22 +1,24 @@
-export { usePublicDataQueries } from './chunk-VUMBZ5BP.js';
+export { useNavigationItems } from './chunk-GXSW4CZS.js';
+export { ProtectedDataFetchFailedEvent, ProtectedDataFetchStartedEvent, useProtectedDataQueries } from './chunk-MKTGJHQR.js';
+export { PublicDataFetchFailedEvent, PublicDataFetchStartedEvent, usePublicDataQueries } from './chunk-CTLPFYLM.js';
+export { useCanFetchProtectedData } from './chunk-XDWYPVAJ.js';
 export { useCanFetchPublicData } from './chunk-IOMSOUAL.js';
-export { useDeferredRegistrations } from './chunk-2E76JVV7.js';
+export { useDeferredRegistrations } from './chunk-BFHHJOJT.js';
 export { useRegisterDeferredRegistrations } from './chunk-YRWFYWK4.js';
 export { useUpdateDeferredRegistrations } from './chunk-N2GOIQ5E.js';
-export { useCanRegisterDeferredRegistrations } from './chunk-PU7MASPN.js';
+export { useCanRegisterDeferredRegistrations } from './chunk-4RUCDAUT.js';
 export { useCanUpdateDeferredRegistrations } from './chunk-WVRMJZV6.js';
-export { useIsBootstrapping } from './chunk-I6L3AYOB.js';
-export { useNavigationItems } from './chunk-GXSW4CZS.js';
-export { useProtectedDataQueries } from './chunk-7R2Z7FXF.js';
-export { AppRouter } from './chunk-36U4TTNR.js';
+export { AppRouter } from './chunk-L44KFU57.js';
 export { useStrictRegistrationMode } from './chunk-WOPD33CM.js';
-export { FireflyRuntime } from './chunk-FKQ7XQEU.js';
-export { __clearAppReducerDispatchProxy, __setAppReducerDispatchProxyFactory, getAreModulesReady, getAreModulesRegistered, useAppRouterReducer, useModuleRegistrationStatusDispatcher, useMswStatusDispatcher } from './chunk-ENUCXEMN.js';
+export { FireflyRuntime } from './chunk-CFNKNPS3.js';
+export { ApplicationBoostrappedEvent, DeferredRegistrationsUpdatedEvent, ModulesReadyEvent, ModulesRegisteredEvent, MswReadyEvent, ProtectedDataReadyEvent, ProtectedDataUpdatedEvent, PublicDataReadyEvent, PublicDataUpdatedEvent, __clearAppReducerDispatchProxy, __setAppReducerDispatchProxyFactory, getAreModulesReady, getAreModulesRegistered, useAppRouterReducer, useBootstrappingCompletedDispatcher, useModuleRegistrationStatusDispatcher, useMswStatusDispatcher } from './chunk-JFMSLZ74.js';
+import './chunk-TURKCH7J.js';
+export { isApplicationBootstrapping, useIsBootstrapping } from './chunk-H2ILEMPE.js';
 export { GlobalDataQueriesError, isGlobalDataQueriesError } from './chunk-HE5HKFL3.js';
-import './chunk-MZG2PJJG.js';
+import './chunk-PMVN3U47.js';
 export { useIsActiveRouteProtected } from './chunk-PP3MRMJJ.js';
-export { useCanFetchProtectedData } from './chunk-L5BP3WP3.js';
 export { AppRouterDispatcherContext, AppRouterStateContext, useAppRouterDispatcher, useAppRouterState } from './chunk-G32YX2KR.js';
+export { ApplicationBootstrappingStartedEvent, __resetBootstrapGuard, bootstrap } from './chunk-IGJHKH2A.js';
 export * from '@squide/core';
 export * from '@squide/module-federation';
 export * from '@squide/msw';

package/dist/useCanFetchProtectedData.js

@@ -1,2 +1,2 @@
-export { useCanFetchProtectedData } from './chunk-L5BP3WP3.js';
+export { useCanFetchProtectedData } from './chunk-XDWYPVAJ.js';
 import './chunk-G32YX2KR.js';

package/dist/useCanRegisterDeferredRegistrations.js

@@ -1,2 +1,2 @@
-export { useCanRegisterDeferredRegistrations } from './chunk-PU7MASPN.js';
+export { useCanRegisterDeferredRegistrations } from './chunk-4RUCDAUT.js';
 import './chunk-G32YX2KR.js';

package/dist/useDeferredRegistrations.js

@@ -1,6 +1,6 @@
-export { useDeferredRegistrations } from './chunk-2E76JVV7.js';
+export { useDeferredRegistrations } from './chunk-BFHHJOJT.js';
 import './chunk-YRWFYWK4.js';
 import './chunk-N2GOIQ5E.js';
-import './chunk-PU7MASPN.js';
+import './chunk-4RUCDAUT.js';
 import './chunk-WVRMJZV6.js';
 import './chunk-G32YX2KR.js';

package/dist/useExecuteOnce.d.ts

@@ -0,0 +1,3 @@
+declare function useExecuteOnce(fct: () => boolean, inline?: boolean): () => void;
+
+export { useExecuteOnce };

package/dist/useExecuteOnce.js

@@ -0,0 +1 @@
+export { useExecuteOnce } from './chunk-TURKCH7J.js';

package/dist/useIsBootstrapping.d.ts

@@ -1,3 +1,7 @@
+import { AppRouterState } from './AppRouterReducer.js';
+import 'react';
+
 declare function useIsBootstrapping(): boolean;
+declare function isApplicationBootstrapping(state: AppRouterState): boolean;
 
-export { useIsBootstrapping };
+export { isApplicationBootstrapping, useIsBootstrapping };

package/dist/useIsBootstrapping.js

@@ -1,2 +1,2 @@
-export { useIsBootstrapping } from './chunk-I6L3AYOB.js';
+export { isApplicationBootstrapping, useIsBootstrapping } from './chunk-H2ILEMPE.js';
 import './chunk-G32YX2KR.js';

package/dist/useProtectedDataQueries.d.ts

@@ -1,9 +1,11 @@
 import { QueriesOptions, QueriesResults, UseQueryResult } from '@tanstack/react-query';
 
+declare const ProtectedDataFetchStartedEvent = "squide-protected-data-fetch-started";
+declare const ProtectedDataFetchFailedEvent = "squide-protected-data-fetch-failed";
 type IsUnauthorizedErrorCallback = (error: unknown) => boolean;
 type MapUseQueryResultToData<T> = {
     [K in keyof T]: T[K] extends UseQueryResult<infer U> ? U : never;
 };
 declare function useProtectedDataQueries<T extends Array<any>>(queries: QueriesOptions<T>, isUnauthorizedError: IsUnauthorizedErrorCallback): MapUseQueryResultToData<QueriesResults<T>>;
 
-export { type IsUnauthorizedErrorCallback, useProtectedDataQueries };
+export { type IsUnauthorizedErrorCallback, ProtectedDataFetchFailedEvent, ProtectedDataFetchStartedEvent, useProtectedDataQueries };

package/dist/useProtectedDataQueries.js

@@ -1,4 +1,5 @@
-export { useProtectedDataQueries } from './chunk-7R2Z7FXF.js';
+export { ProtectedDataFetchFailedEvent, ProtectedDataFetchStartedEvent, useProtectedDataQueries } from './chunk-MKTGJHQR.js';
+import './chunk-XDWYPVAJ.js';
+import './chunk-TURKCH7J.js';
 import './chunk-HE5HKFL3.js';
-import './chunk-L5BP3WP3.js';
 import './chunk-G32YX2KR.js';

package/dist/usePublicDataQueries.d.ts

@@ -1,8 +1,10 @@
 import { QueriesOptions, QueriesResults, UseQueryResult } from '@tanstack/react-query';
 
+declare const PublicDataFetchStartedEvent = "squide-public-data-fetch-started";
+declare const PublicDataFetchFailedEvent = "squide-public-data-fetch-failed";
 type MapUseQueryResultToData<T> = {
     [K in keyof T]: T[K] extends UseQueryResult<infer U> ? U : never;
 };
 declare function usePublicDataQueries<T extends Array<any>>(queries: QueriesOptions<T>): MapUseQueryResultToData<QueriesResults<T>>;
 
-export { usePublicDataQueries };
+export { PublicDataFetchFailedEvent, PublicDataFetchStartedEvent, usePublicDataQueries };

package/dist/usePublicDataQueries.js

@@ -1,4 +1,5 @@
-export { usePublicDataQueries } from './chunk-VUMBZ5BP.js';
+export { PublicDataFetchFailedEvent, PublicDataFetchStartedEvent, usePublicDataQueries } from './chunk-CTLPFYLM.js';
 import './chunk-IOMSOUAL.js';
+import './chunk-TURKCH7J.js';
 import './chunk-HE5HKFL3.js';
 import './chunk-G32YX2KR.js';

package/dist/useRegisterDeferredRegistrations.d.ts

@@ -1,9 +1,10 @@
+import * as _squide_module_federation from '@squide/module-federation';
 import * as _squide_core from '@squide/core';
 import { Runtime } from '@squide/core';
 
 declare function useRegisterDeferredRegistrations(): <TData = unknown, TRuntime extends Runtime = Runtime<unknown, unknown>>(data: TData, runtime: TRuntime) => Promise<{
     localModuleErrors: _squide_core.ModuleRegistrationError[];
-    remoteModuleErrors: _squide_core.ModuleRegistrationError[];
+    remoteModuleErrors: _squide_module_federation.RemoteModuleRegistrationError[];
 }>;
 
 export { useRegisterDeferredRegistrations };

package/dist/useUpdateDeferredRegistrations.d.ts

@@ -1,9 +1,10 @@
+import * as _squide_module_federation from '@squide/module-federation';
 import * as _squide_core from '@squide/core';
 import { Runtime } from '@squide/core';
 
 declare function useUpdateDeferredRegistrations(): <TData = unknown, TRuntime extends Runtime = Runtime<unknown, unknown>>(data: TData, runtime: TRuntime) => Promise<{
     localModuleErrors: _squide_core.ModuleRegistrationError[];
-    remoteModuleErrors: _squide_core.ModuleRegistrationError[];
+    remoteModuleErrors: _squide_module_federation.RemoteModuleRegistrationError[];
 }>;
 
 export { useUpdateDeferredRegistrations };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@squide/firefly",
   "author": "Workleap",
-  "version": "9.2.1",
+  "version": "9.3.0",
   "description": "Helpers to facilitate the creation of an application with the Squide firefly technology stack.",
   "license": "Apache-2.0",
   "repository": {
@@ -39,7 +39,7 @@
     "@testing-library/jest-dom": "6.5.0",
     "@testing-library/react": "16.0.1",
     "@types/jest": "29.5.13",
-    "@types/react": "18.3.8",
+    "@types/react": "18.3.11",
     "@types/react-dom": "18.3.0",
     "@workleap/eslint-plugin": "3.2.2",
     "@workleap/swc-configs": "2.2.3",
@@ -57,10 +57,10 @@
     "typescript": "5.5.4"
   },
   "dependencies": {
-    "@squide/core": "5.3.0",
-    "@squide/module-federation": "6.1.1",
-    "@squide/msw": "3.1.1",
-    "@squide/react-router": "6.3.0"
+    "@squide/core": "5.4.0",
+    "@squide/module-federation": "6.2.0",
+    "@squide/msw": "3.2.0",
+    "@squide/react-router": "6.4.0"
   },
   "sideEffects": false,
   "engines": {

package/dist/chunk-ENUCXEMN.js

@@ -1,180 +0,0 @@
-import { getLocalModuleRegistrationStatus, useLogger, addLocalModuleRegistrationStatusChangedListener, removeLocalModuleRegistrationStatusChangedListener } from '@squide/core';
-import { getRemoteModuleRegistrationStatus, areModulesRegistered, areModulesReady, addRemoteModuleRegistrationStatusChangedListener, removeRemoteModuleRegistrationStatusChangedListener } from '@squide/module-federation';
-import { addMswStateChangedListener, removeMswStateChangedListener, isMswReady } from '@squide/msw';
-import { useEffect, useReducer, useCallback, useMemo } from 'react';
-
-// src/AppRouterReducer.ts
-function useVerboseDispatch(dispatch) {
-  const logger = useLogger();
-  return useCallback((action) => {
-    logger.debug("[squide] The following action has been dispatched to the AppRouter reducer:", action);
-    dispatch(action);
-  }, [dispatch, logger]);
-}
-function reducer(state, action) {
-  let newState = state;
-  switch (action.type) {
-    case "modules-registered": {
-      newState = {
-        ...newState,
-        areModulesRegistered: true
-      };
-      break;
-    }
-    case "modules-ready": {
-      newState = {
-        ...newState,
-        areModulesReady: true,
-        // Will be set even if the app is not using deferred registrations.
-        deferredRegistrationsUpdatedAt: Date.now()
-      };
-      break;
-    }
-    case "msw-ready": {
-      newState = {
-        ...newState,
-        isMswReady: true
-      };
-      break;
-    }
-    case "public-data-ready": {
-      newState = {
-        ...newState,
-        isPublicDataReady: true,
-        publicDataUpdatedAt: Date.now()
-      };
-      break;
-    }
-    case "protected-data-ready": {
-      newState = {
-        ...newState,
-        isProtectedDataReady: true,
-        protectedDataUpdatedAt: Date.now()
-      };
-      break;
-    }
-    case "public-data-updated": {
-      newState = {
-        ...newState,
-        publicDataUpdatedAt: Date.now()
-      };
-      break;
-    }
-    case "protected-data-updated": {
-      newState = {
-        ...newState,
-        protectedDataUpdatedAt: Date.now()
-      };
-      break;
-    }
-    case "deferred-registrations-updated": {
-      newState = {
-        ...newState,
-        deferredRegistrationsUpdatedAt: Date.now()
-      };
-      break;
-    }
-    case "active-route-is-protected": {
-      newState = {
-        ...newState,
-        isActiveRouteProtected: true
-      };
-      break;
-    }
-    case "is-unauthorized": {
-      newState = {
-        ...newState,
-        isUnauthorized: true
-      };
-      break;
-    }
-    default: {
-      throw new Error(`[squide] The AppRouter component state reducer doesn't support action type "${action.type}".`);
-    }
-  }
-  return newState;
-}
-function getAreModulesRegistered() {
-  const localModuleStatus = getLocalModuleRegistrationStatus();
-  const remoteModuleStatus = getRemoteModuleRegistrationStatus();
-  return areModulesRegistered(localModuleStatus, remoteModuleStatus);
-}
-function getAreModulesReady() {
-  const localModuleStatus = getLocalModuleRegistrationStatus();
-  const remoteModuleStatus = getRemoteModuleRegistrationStatus();
-  return areModulesReady(localModuleStatus, remoteModuleStatus);
-}
-function useModuleRegistrationStatusDispatcher(areModulesRegisteredValue, areModulesReadyValue, dispatch) {
-  const logger = useLogger();
-  return useEffect(() => {
-    const handleModulesRegistrationStatusChange = () => {
-      if (!areModulesRegisteredValue && getAreModulesRegistered()) {
-        dispatch({ type: "modules-registered" });
-      }
-      if (!areModulesReadyValue && getAreModulesReady()) {
-        dispatch({ type: "modules-ready" });
-        logger.debug("[squide] %cModules are ready%c.", "color: white; background-color: green;", "");
-      }
-    };
-    addLocalModuleRegistrationStatusChangedListener(handleModulesRegistrationStatusChange);
-    addRemoteModuleRegistrationStatusChangedListener(handleModulesRegistrationStatusChange);
-    return () => {
-      removeLocalModuleRegistrationStatusChangedListener(handleModulesRegistrationStatusChange);
-      removeRemoteModuleRegistrationStatusChangedListener(handleModulesRegistrationStatusChange);
-    };
-  }, [areModulesRegisteredValue, areModulesReadyValue, dispatch, logger]);
-}
-function useMswStatusDispatcher(isMswReadyValue, dispatch) {
-  const logger = useLogger();
-  useEffect(() => {
-    const handleMswStateChange = () => {
-      if (!isMswReadyValue && isMswReady()) {
-        dispatch({ type: "msw-ready" });
-        logger.debug("[squide] %cMSW is ready%c.", "color: white; background-color: green;", "");
-      }
-    };
-    addMswStateChangedListener(handleMswStateChange);
-    return () => {
-      removeMswStateChangedListener(handleMswStateChange);
-    };
-  }, [isMswReadyValue, dispatch, logger]);
-}
-var dispatchProxyFactory;
-function __setAppReducerDispatchProxyFactory(factory) {
-  dispatchProxyFactory = factory;
-}
-function __clearAppReducerDispatchProxy() {
-  dispatchProxyFactory = void 0;
-}
-function useDispatchProxy(reactDispatch) {
-  return useMemo(() => {
-    return dispatchProxyFactory ? dispatchProxyFactory(reactDispatch) : reactDispatch;
-  }, [reactDispatch]);
-}
-function useAppRouterReducer(waitForMsw, waitForPublicData, waitForProtectedData) {
-  const [state, reactDispatch] = useReducer(reducer, {
-    waitForMsw,
-    waitForPublicData,
-    waitForProtectedData,
-    // When the modules registration functions are awaited, the event listeners are registered after the modules are registered.
-    areModulesRegistered: getAreModulesRegistered(),
-    areModulesReady: getAreModulesReady(),
-    isMswReady: isMswReady(),
-    isPublicDataReady: false,
-    isProtectedDataReady: false,
-    isActiveRouteProtected: false,
-    isUnauthorized: false
-  });
-  const {
-    areModulesRegistered: areModulesRegisteredValue,
-    areModulesReady: areModulesReadyValue,
-    isMswReady: isMswReadyValue
-  } = state;
-  const dispatchProxy = useDispatchProxy(reactDispatch);
-  const dispatch = useVerboseDispatch(dispatchProxy);
-  useModuleRegistrationStatusDispatcher(areModulesRegisteredValue, areModulesReadyValue, dispatch);
-  useMswStatusDispatcher(isMswReadyValue, dispatch);
-  return [state, dispatch];
-}
-
-export { __clearAppReducerDispatchProxy, __setAppReducerDispatchProxyFactory, getAreModulesReady, getAreModulesRegistered, useAppRouterReducer, useModuleRegistrationStatusDispatcher, useMswStatusDispatcher };