@squide/firefly 9.3.1 → 9.3.2

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @squide/firefly
 
+## 9.3.2
+
+### Patch Changes
+
+- Updated dependencies [[`4eb46d6`](https://github.com/gsoft-inc/wl-squide/commit/4eb46d69283804a5809494f7275f9d447022a97d)]:
+  - @squide/react-router@6.4.2
+
 ## 9.3.1
 
 ### Patch Changes

package/dist/AppRouter.d.ts

@@ -1,23 +1,19 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { Route } from '@squide/react-router';
-import { ReactElement } from 'react';
-import { RouterProviderProps } from 'react-router-dom';
-
-interface AppRouterRenderFunctionArgs {
+import { type Route } from "@squide/react-router";
+import { type ReactElement } from "react";
+import type { RouterProviderProps } from "react-router-dom";
+export interface AppRouterRenderFunctionArgs {
     routes: Route[];
 }
-interface RenderRouterProviderFunctionArgs {
+export interface RenderRouterProviderFunctionArgs {
     rootRoute: ReactElement;
     registeredRoutes: Route[];
     routerProviderProps: Omit<RouterProviderProps, "router">;
 }
-type RenderRouterProviderFunction = (args: RenderRouterProviderFunctionArgs) => ReactElement;
-interface AppRouterProps {
+export type RenderRouterProviderFunction = (args: RenderRouterProviderFunctionArgs) => ReactElement;
+export interface AppRouterProps {
     waitForMsw: boolean;
     waitForPublicData?: boolean;
     waitForProtectedData?: boolean;
     children: RenderRouterProviderFunction;
 }
-declare function AppRouter(props: AppRouterProps): react_jsx_runtime.JSX.Element;
-
-export { AppRouter, type AppRouterProps, type AppRouterRenderFunctionArgs, type RenderRouterProviderFunction, type RenderRouterProviderFunctionArgs };
+export declare function AppRouter(props: AppRouterProps): import("react/jsx-runtime").JSX.Element;

package/dist/AppRouter.js

@@ -1,8 +1,66 @@
-export { AppRouter } from './chunk-L44KFU57.js';
-import './chunk-WOPD33CM.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';
+import * as __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime__ from "react/jsx-runtime";
+import * as __WEBPACK_EXTERNAL_MODULE__squide_core__ from "@squide/core";
+import * as __WEBPACK_EXTERNAL_MODULE__squide_react_router__ from "@squide/react-router";
+import * as __WEBPACK_EXTERNAL_MODULE_react__ from "react";
+import * as __WEBPACK_EXTERNAL_MODULE__AppRouterContext_js__ from "./AppRouterContext.js";
+import * as __WEBPACK_EXTERNAL_MODULE__AppRouterReducer_js__ from "./AppRouterReducer.js";
+import * as __WEBPACK_EXTERNAL_MODULE__RootRoute_js__ from "./RootRoute.js";
+import * as __WEBPACK_EXTERNAL_MODULE__useStrictRegistrationMode_js__ from "./useStrictRegistrationMode.js";
+
+;// CONCATENATED MODULE: external "react/jsx-runtime"
+
+;// CONCATENATED MODULE: external "@squide/core"
+
+;// CONCATENATED MODULE: external "@squide/react-router"
+
+;// CONCATENATED MODULE: external "react"
+
+;// CONCATENATED MODULE: external "./AppRouterContext.js"
+
+;// CONCATENATED MODULE: external "./AppRouterReducer.js"
+
+;// CONCATENATED MODULE: external "./RootRoute.js"
+
+;// CONCATENATED MODULE: external "./useStrictRegistrationMode.js"
+
+;// CONCATENATED MODULE: ./src/AppRouter.tsx?__rslib_entry__
+
+
+
+
+
+
+
+
+function AppRouter(props) {
+    const { waitForMsw, waitForPublicData = false, waitForProtectedData = false, children: renderRouterProvider } = props;
+    const [state, dispatch] = (0,__WEBPACK_EXTERNAL_MODULE__AppRouterReducer_js__.useAppRouterReducer)(waitForMsw, waitForPublicData, waitForProtectedData);
+    const logger = (0,__WEBPACK_EXTERNAL_MODULE__squide_core__.useLogger)();
+    const routes = (0,__WEBPACK_EXTERNAL_MODULE__squide_react_router__.useRoutes)();
+    (0,__WEBPACK_EXTERNAL_MODULE__useStrictRegistrationMode_js__.useStrictRegistrationMode)();
+    (0,__WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        logger.debug("[squide] AppRouter state updated:", state);
+    }, [
+        state,
+        logger
+    ]);
+    const routerProvider = (0,__WEBPACK_EXTERNAL_MODULE_react__.useMemo)(()=>{
+        return renderRouterProvider({
+            rootRoute: /*#__PURE__*/ (0,__WEBPACK_EXTERNAL_MODULE_react_jsx_runtime__.jsx)(__WEBPACK_EXTERNAL_MODULE__RootRoute_js__.RootRoute, {}),
+            registeredRoutes: routes,
+            routerProviderProps: {}
+        });
+    }, [
+        routes,
+        renderRouterProvider
+    ]);
+    return /*#__PURE__*/ (0,__WEBPACK_EXTERNAL_MODULE_react_jsx_runtime__.jsx)(__WEBPACK_EXTERNAL_MODULE__AppRouterContext_js__.AppRouterDispatcherContext.Provider, {
+        value: dispatch,
+        children: /*#__PURE__*/ (0,__WEBPACK_EXTERNAL_MODULE_react_jsx_runtime__.jsx)(__WEBPACK_EXTERNAL_MODULE__AppRouterContext_js__.AppRouterStateContext.Provider, {
+            value: state,
+            children: routerProvider
+        })
+    });
+}
+
+export { AppRouter };

package/dist/AppRouterContext.d.ts

@@ -1,9 +1,5 @@
-import * as react from 'react';
-import { AppRouterState, AppRouterDispatch } from './AppRouterReducer.js';
-
-declare const AppRouterStateContext: react.Context<AppRouterState | undefined>;
-declare function useAppRouterState(): AppRouterState;
-declare const AppRouterDispatcherContext: react.Context<AppRouterDispatch | undefined>;
-declare function useAppRouterDispatcher(): AppRouterDispatch;
-
-export { AppRouterDispatcherContext, AppRouterStateContext, useAppRouterDispatcher, useAppRouterState };
+import type { AppRouterDispatch, AppRouterState } from "./AppRouterReducer.ts";
+export declare const AppRouterStateContext: import("react").Context<AppRouterState | undefined>;
+export declare function useAppRouterState(): AppRouterState;
+export declare const AppRouterDispatcherContext: import("react").Context<AppRouterDispatch | undefined>;
+export declare function useAppRouterDispatcher(): AppRouterDispatch;

package/dist/AppRouterContext.js

@@ -1 +1,28 @@
-export { AppRouterDispatcherContext, AppRouterStateContext, useAppRouterDispatcher, useAppRouterState } from './chunk-G32YX2KR.js';
+import * as __WEBPACK_EXTERNAL_MODULE__squide_core__ from "@squide/core";
+import * as __WEBPACK_EXTERNAL_MODULE_react__ from "react";
+
+;// CONCATENATED MODULE: external "@squide/core"
+
+;// CONCATENATED MODULE: external "react"
+
+;// CONCATENATED MODULE: ./src/AppRouterContext.ts?__rslib_entry__
+
+
+const AppRouterStateContext = (0,__WEBPACK_EXTERNAL_MODULE_react__.createContext)(undefined);
+function useAppRouterState() {
+    const state = (0,__WEBPACK_EXTERNAL_MODULE_react__.useContext)(AppRouterStateContext);
+    if ((0,__WEBPACK_EXTERNAL_MODULE__squide_core__.isNil)(state)) {
+        throw new Error("[squide] The useAppRouterState hook must be called by a children of the AppRouter component.");
+    }
+    return state;
+}
+const AppRouterDispatcherContext = (0,__WEBPACK_EXTERNAL_MODULE_react__.createContext)(undefined);
+function useAppRouterDispatcher() {
+    const dispatch = (0,__WEBPACK_EXTERNAL_MODULE_react__.useContext)(AppRouterDispatcherContext);
+    if ((0,__WEBPACK_EXTERNAL_MODULE__squide_core__.isNil)(dispatch)) {
+        throw new Error("[squide] The useAppRouterDispatcher hook must be called by a children of the AppRouter component.");
+    }
+    return dispatch;
+}
+
+export { AppRouterDispatcherContext, AppRouterStateContext, useAppRouterDispatcher, useAppRouterState };

package/dist/AppRouterReducer.d.ts

@@ -1,7 +1,6 @@
-import { Dispatch } from 'react';
-
-type ActiveRouteVisiblity = "unknown" | "public" | "protected";
-interface AppRouterState {
+import { type Dispatch } from "react";
+export type ActiveRouteVisiblity = "unknown" | "public" | "protected";
+export interface AppRouterState {
     waitForMsw: boolean;
     waitForPublicData: boolean;
     waitForProtectedData: boolean;
@@ -16,27 +15,25 @@ interface AppRouterState {
     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-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 {
+export 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";
+export declare const ModulesRegisteredEvent = "squide-modules-registered";
+export declare const ModulesReadyEvent = "squide-modules-ready";
+export declare const MswReadyEvent = "squide-msw-ready";
+export declare const PublicDataReadyEvent = "squide-public-data-ready";
+export declare const ProtectedDataReadyEvent = "squide-protected-data-ready";
+export declare const PublicDataUpdatedEvent = "squide-public-data-updated";
+export declare const ProtectedDataUpdatedEvent = "squide-protected-data-updated";
+export declare const DeferredRegistrationsUpdatedEvent = "squide-deferred-registrations-updated";
+export declare const ApplicationBoostrappedEvent = "squide-app-boostrapped";
+export interface AppRouterAction {
     type: AppRouterActionType;
 }
-type AppRouterDispatch = Dispatch<AppRouterAction>;
-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 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 };
+export type AppRouterDispatch = Dispatch<AppRouterAction>;
+export declare function getAreModulesRegistered(): boolean;
+export declare function getAreModulesReady(): boolean;
+export declare function useModuleRegistrationStatusDispatcher(areModulesRegisteredValue: boolean, areModulesReadyValue: boolean, dispatch: AppRouterDispatch): void;
+export declare function useMswStatusDispatcher(isMswReadyValue: boolean, dispatch: AppRouterDispatch): void;
+export declare function useBootstrappingCompletedDispatcher(state: AppRouterState): void;
+export declare function __setAppReducerDispatchProxyFactory(factory: (reactDispatch: AppRouterDispatch) => AppRouterDispatch): void;
+export declare function __clearAppReducerDispatchProxy(): void;
+export declare function useAppRouterReducer(waitForMsw: boolean, waitForPublicData: boolean, waitForProtectedData: boolean): [AppRouterState, AppRouterDispatch];

package/dist/AppRouterReducer.js

@@ -1,4 +1,337 @@
-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';
+import * as __WEBPACK_EXTERNAL_MODULE__squide_core__ from "@squide/core";
+import * as __WEBPACK_EXTERNAL_MODULE__squide_module_federation__ from "@squide/module-federation";
+import * as __WEBPACK_EXTERNAL_MODULE__squide_msw__ from "@squide/msw";
+import * as __WEBPACK_EXTERNAL_MODULE_react__ from "react";
+import * as __WEBPACK_EXTERNAL_MODULE__useExecuteOnce_js__ from "./useExecuteOnce.js";
+import * as __WEBPACK_EXTERNAL_MODULE__useIsBootstrapping_js__ from "./useIsBootstrapping.js";
+
+;// CONCATENATED MODULE: external "@squide/core"
+
+;// CONCATENATED MODULE: external "@squide/module-federation"
+
+;// CONCATENATED MODULE: external "@squide/msw"
+
+;// CONCATENATED MODULE: external "react"
+
+;// CONCATENATED MODULE: external "./useExecuteOnce.js"
+
+;// CONCATENATED MODULE: external "./useIsBootstrapping.js"
+
+;// CONCATENATED MODULE: ./src/AppRouterReducer.ts?__rslib_entry__
+
+
+
+
+
+
+// The followings event const are a concatenation of "squide-" with AppRouterActionType.
+// They are dispatched by the useEnhancedReducerDispatch hook.
+const ModulesRegisteredEvent = "squide-modules-registered";
+const ModulesReadyEvent = "squide-modules-ready";
+const MswReadyEvent = "squide-msw-ready";
+const PublicDataReadyEvent = "squide-public-data-ready";
+const ProtectedDataReadyEvent = "squide-protected-data-ready";
+const PublicDataUpdatedEvent = "squide-public-data-updated";
+const ProtectedDataUpdatedEvent = "squide-protected-data-updated";
+const DeferredRegistrationsUpdatedEvent = "squide-deferred-registrations-updated";
+const 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 = (0,__WEBPACK_EXTERNAL_MODULE__squide_core__.getLocalModuleRegistrationStatus)();
+    const remoteModuleStatus = (0,__WEBPACK_EXTERNAL_MODULE__squide_module_federation__.getRemoteModuleRegistrationStatus)();
+    return (0,__WEBPACK_EXTERNAL_MODULE__squide_module_federation__.areModulesRegistered)(localModuleStatus, remoteModuleStatus);
+}
+function getAreModulesReady() {
+    const localModuleStatus = (0,__WEBPACK_EXTERNAL_MODULE__squide_core__.getLocalModuleRegistrationStatus)();
+    const remoteModuleStatus = (0,__WEBPACK_EXTERNAL_MODULE__squide_module_federation__.getRemoteModuleRegistrationStatus)();
+    return (0,__WEBPACK_EXTERNAL_MODULE__squide_module_federation__.areModulesReady)(localModuleStatus, remoteModuleStatus);
+}
+function useModuleRegistrationStatusDispatcher(areModulesRegisteredValue, areModulesReadyValue, dispatch) {
+    const logger = (0,__WEBPACK_EXTERNAL_MODULE__squide_core__.useLogger)();
+    const dispatchModulesRegistered = (0,__WEBPACK_EXTERNAL_MODULE__useExecuteOnce_js__.useExecuteOnce)((0,__WEBPACK_EXTERNAL_MODULE_react__.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 = (0,__WEBPACK_EXTERNAL_MODULE__useExecuteOnce_js__.useExecuteOnce)((0,__WEBPACK_EXTERNAL_MODULE_react__.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 (0,__WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        if (!areModulesRegisteredValue) {
+            (0,__WEBPACK_EXTERNAL_MODULE__squide_core__.addLocalModuleRegistrationStatusChangedListener)(dispatchModulesRegistered);
+            (0,__WEBPACK_EXTERNAL_MODULE__squide_module_federation__.addRemoteModuleRegistrationStatusChangedListener)(dispatchModulesRegistered);
+        }
+        if (!areModulesReadyValue) {
+            (0,__WEBPACK_EXTERNAL_MODULE__squide_core__.addLocalModuleRegistrationStatusChangedListener)(dispatchModulesReady);
+            (0,__WEBPACK_EXTERNAL_MODULE__squide_module_federation__.addRemoteModuleRegistrationStatusChangedListener)(dispatchModulesReady);
+        }
+        return ()=>{
+            (0,__WEBPACK_EXTERNAL_MODULE__squide_core__.removeLocalModuleRegistrationStatusChangedListener)(dispatchModulesRegistered);
+            (0,__WEBPACK_EXTERNAL_MODULE__squide_module_federation__.removeRemoteModuleRegistrationStatusChangedListener)(dispatchModulesRegistered);
+            (0,__WEBPACK_EXTERNAL_MODULE__squide_core__.removeLocalModuleRegistrationStatusChangedListener)(dispatchModulesReady);
+            (0,__WEBPACK_EXTERNAL_MODULE__squide_module_federation__.removeRemoteModuleRegistrationStatusChangedListener)(dispatchModulesReady);
+        };
+    }, [
+        areModulesRegisteredValue,
+        areModulesReadyValue,
+        dispatchModulesRegistered,
+        dispatchModulesReady
+    ]);
+}
+function useMswStatusDispatcher(isMswReadyValue, dispatch) {
+    const logger = (0,__WEBPACK_EXTERNAL_MODULE__squide_core__.useLogger)();
+    const dispatchMswReady = (0,__WEBPACK_EXTERNAL_MODULE__useExecuteOnce_js__.useExecuteOnce)((0,__WEBPACK_EXTERNAL_MODULE_react__.useCallback)(()=>{
+        if ((0,__WEBPACK_EXTERNAL_MODULE__squide_msw__.isMswReady)()) {
+            dispatch({
+                type: "msw-ready"
+            });
+            logger.debug("[squide] %cMSW is ready%c.", "color: white; background-color: green;", "");
+            return true;
+        }
+        return false;
+    }, [
+        dispatch,
+        logger
+    ]));
+    (0,__WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        if (!isMswReadyValue) {
+            (0,__WEBPACK_EXTERNAL_MODULE__squide_msw__.addMswStateChangedListener)(dispatchMswReady);
+        }
+        return ()=>{
+            (0,__WEBPACK_EXTERNAL_MODULE__squide_msw__.removeMswStateChangedListener)(dispatchMswReady);
+        };
+    }, [
+        isMswReadyValue,
+        dispatchMswReady
+    ]);
+}
+function useBootstrappingCompletedDispatcher(state) {
+    const eventBus = (0,__WEBPACK_EXTERNAL_MODULE__squide_core__.useEventBus)();
+    const areModulesRegisteredValue = state.areModulesRegistered;
+    const isBoostrapping = (0,__WEBPACK_EXTERNAL_MODULE__useIsBootstrapping_js__.isApplicationBootstrapping)(state);
+    (0,__WEBPACK_EXTERNAL_MODULE__useExecuteOnce_js__.useExecuteOnce)((0,__WEBPACK_EXTERNAL_MODULE_react__.useCallback)(()=>{
+        if (areModulesRegisteredValue && !isBoostrapping) {
+            eventBus.dispatch(ApplicationBoostrappedEvent);
+            return true;
+        }
+        return false;
+    }, [
+        areModulesRegisteredValue,
+        isBoostrapping,
+        eventBus
+    ]), true);
+}
+let dispatchProxyFactory;
+// This function should only be used by tests.
+function __setAppReducerDispatchProxyFactory(factory) {
+    dispatchProxyFactory = factory;
+}
+// This function should only be used by tests.
+function __clearAppReducerDispatchProxy() {
+    dispatchProxyFactory = undefined;
+}
+function useReducerDispatchProxy(reactDispatch) {
+    return (0,__WEBPACK_EXTERNAL_MODULE_react__.useMemo)(()=>{
+        return dispatchProxyFactory ? dispatchProxyFactory(reactDispatch) : reactDispatch;
+    }, [
+        reactDispatch
+    ]);
+}
+function useEnhancedReducerDispatch(reducerDispatch) {
+    const logger = (0,__WEBPACK_EXTERNAL_MODULE__squide_core__.useLogger)();
+    const eventBus = (0,__WEBPACK_EXTERNAL_MODULE__squide_core__.useEventBus)();
+    return (0,__WEBPACK_EXTERNAL_MODULE_react__.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 = (0,__WEBPACK_EXTERNAL_MODULE__squide_msw__.isMswReady)();
+    const eventBus = (0,__WEBPACK_EXTERNAL_MODULE__squide_core__.useEventBus)();
+    // When modules are initially registered, the reducer action will never be dispatched, therefore the event would not be dispatched as well.
+    // To ensure the bootstrapping events sequencing, the event is manually dispatched when the modules are initially registered.
+    (0,__WEBPACK_EXTERNAL_MODULE__useExecuteOnce_js__.useExecuteOnce)((0,__WEBPACK_EXTERNAL_MODULE_react__.useCallback)(()=>{
+        if (areModulesInitiallyRegistered) {
+            eventBus.dispatch(ModulesRegisteredEvent);
+        }
+        return true;
+    }, [
+        areModulesInitiallyRegistered,
+        eventBus
+    ]), true);
+    // When modules are initially registered, the reducer action will never be dispatched, therefore the event would not be dispatched as well.
+    // To ensure the bootstrapping events sequencing, the event is manually dispatched when the modules are initially registered.
+    (0,__WEBPACK_EXTERNAL_MODULE__useExecuteOnce_js__.useExecuteOnce)((0,__WEBPACK_EXTERNAL_MODULE_react__.useCallback)(()=>{
+        if (areModulesInitiallyReady) {
+            eventBus.dispatch(ModulesReadyEvent);
+        }
+        return true;
+    }, [
+        areModulesInitiallyReady,
+        eventBus
+    ]), true);
+    // When modules are initially registered, the reducer action will never be dispatched, therefore the event would not be dispatched as well.
+    // To ensure the bootstrapping events sequencing, the event is manually dispatched when the modules are initially registered.
+    (0,__WEBPACK_EXTERNAL_MODULE__useExecuteOnce_js__.useExecuteOnce)((0,__WEBPACK_EXTERNAL_MODULE_react__.useCallback)(()=>{
+        if (isMswInitiallyReady) {
+            eventBus.dispatch(MswReadyEvent);
+        }
+        return true;
+    }, [
+        isMswInitiallyReady,
+        eventBus
+    ]), true);
+    const [state, reactDispatch] = (0,__WEBPACK_EXTERNAL_MODULE_react__.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;
+    // The dispatch proxy is strictly an utility allowing tests to mock the useReducer dispatch function. It's easier
+    // than mocking the import from React.
+    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/FireflyRuntime.d.ts

@@ -1,11 +1,10 @@
-import { RuntimeOptions, RegisterRouteOptions } from '@squide/core';
-import { ReactRouterRuntime, Route } from '@squide/react-router';
-import { RequestHandler } from 'msw';
-
-interface FireflyRuntimeOptions extends RuntimeOptions {
+import type { RegisterRouteOptions, RuntimeOptions } from "@squide/core";
+import { ReactRouterRuntime, type Route } from "@squide/react-router";
+import type { RequestHandler } from "msw";
+export interface FireflyRuntimeOptions extends RuntimeOptions {
     useMsw?: boolean;
 }
-declare class FireflyRuntime extends ReactRouterRuntime {
+export declare class FireflyRuntime extends ReactRouterRuntime {
     #private;
     constructor({ plugins, useMsw, ...options }?: FireflyRuntimeOptions);
     registerRequestHandlers(handlers: RequestHandler[]): void;
@@ -13,5 +12,3 @@ declare class FireflyRuntime extends ReactRouterRuntime {
     registerRoute(route: Route, options?: RegisterRouteOptions): void;
     get isMswEnabled(): boolean;
 }
-
-export { FireflyRuntime, type FireflyRuntimeOptions };

package/dist/FireflyRuntime.js

@@ -1,5 +1,64 @@
-export { FireflyRuntime } from './chunk-LC233OPR.js';
-import './chunk-JFMSLZ74.js';
-import './chunk-TURKCH7J.js';
-import './chunk-H2ILEMPE.js';
-import './chunk-G32YX2KR.js';
+import * as __WEBPACK_EXTERNAL_MODULE__squide_msw__ from "@squide/msw";
+import * as __WEBPACK_EXTERNAL_MODULE__squide_react_router__ from "@squide/react-router";
+import * as __WEBPACK_EXTERNAL_MODULE__AppRouterReducer_js__ from "./AppRouterReducer.js";
+
+;// CONCATENATED MODULE: external "@squide/msw"
+
+;// CONCATENATED MODULE: external "@squide/react-router"
+
+;// CONCATENATED MODULE: external "./AppRouterReducer.js"
+
+;// CONCATENATED MODULE: ./src/FireflyRuntime.tsx?__rslib_entry__
+
+
+
+class FireflyRuntime extends __WEBPACK_EXTERNAL_MODULE__squide_react_router__.ReactRouterRuntime {
+    #useMsw;
+    constructor({ plugins, useMsw, ...options } = {}){
+        if (useMsw) {
+            super({
+                plugins: [
+                    ...plugins ?? [],
+                    (runtime)=>new __WEBPACK_EXTERNAL_MODULE__squide_msw__.MswPlugin(runtime)
+                ],
+                ...options
+            });
+            this.#useMsw = true;
+        } else {
+            super({
+                plugins,
+                ...options
+            });
+            this.#useMsw = false;
+        }
+    }
+    registerRequestHandlers(handlers) {
+        const mswPlugin = this.getPlugin(__WEBPACK_EXTERNAL_MODULE__squide_msw__.MswPluginName);
+        if (!mswPlugin) {
+            throw new Error("[squide] Cannot register the provided MSW request handlers because the runtime hasn't been initialized with MSW. Did you instanciate the FireflyRuntime with the \"useMsw\" option?");
+        }
+        if ((0,__WEBPACK_EXTERNAL_MODULE__AppRouterReducer_js__.getAreModulesRegistered)()) {
+            throw new Error("[squide] Cannot register an MSW request handlers once the modules are registered. Are you trying to register an MSW request handler in a deferred registration function? Only navigation items can be registered in a deferred registration function.");
+        }
+        mswPlugin.registerRequestHandlers(handlers);
+    }
+    // Must define a return type otherwise we get an "error TS2742: The inferred type of 'requestHandlers' cannot be named" error.
+    get requestHandlers() {
+        const mswPlugin = this.getPlugin(__WEBPACK_EXTERNAL_MODULE__squide_msw__.MswPluginName);
+        if (!mswPlugin) {
+            throw new Error("[squide] Cannot retrieve MSW request handlers because the runtime hasn't been initialized with MSW. Did you instanciate the FireflyRuntime with the \"useMsw\" option?");
+        }
+        return mswPlugin.requestHandlers;
+    }
+    registerRoute(route, options = {}) {
+        if ((0,__WEBPACK_EXTERNAL_MODULE__AppRouterReducer_js__.getAreModulesRegistered)()) {
+            throw new Error("[squide] Cannot register a route once the modules are registered. Are you trying to register a route in a deferred registration function? Only navigation items can be registered in a deferred registration function.");
+        }
+        super.registerRoute(route, options);
+    }
+    get isMswEnabled() {
+        return this.#useMsw;
+    }
+}
+
+export { FireflyRuntime };