@squide/firefly 8.0.0 → 9.0.0

package/CHANGELOG.md

@@ -1,5 +1,69 @@
 # @squide/firefly
 
+## 9.0.0
+
+### Major Changes
+
+- [#182](https://github.com/gsoft-inc/wl-squide/pull/182) [`58cf066`](https://github.com/gsoft-inc/wl-squide/commit/58cf066e87e23611510c254cca96016bd2bad08a) Thanks [@patricklafrance](https://github.com/patricklafrance)! - ## Firefly v9
+
+  This major version of @squide/firefly introduces TanStack Query as the official library for fetching the global data of a Squide's application and features a complete rewrite of the AppRouter component, which now uses a state machine to manage the application's bootstrapping flow.
+
+  Prior to v9, Squide applications couldn't use TanStack Query to fetch global data, making it challenging for Workleap's applications to keep their global data in sync with the server state. With v9, applications can now leverage custom wrappers of the useQueries hook to fetch and keep their global data up-to-date with the server state. Additionally, the new deferred registrations update feature allows applications to even keep their conditional navigation items in sync with the server state.
+
+  Finally, with v9, Squide's philosophy has evolved. We used to describe Squide as a shell for federated applications. Now, we refer to Squide as a shell for modular applications. After playing with Squide's local module feature for a while, we discovered that Squide offers significant value even for non-federated applications, which triggered this shift in philosophy.
+
+  > For a full breakdown of the changres and a migration procedure, read the following [documentation](https://gsoft-inc.github.io/wl-squide/guides/migrate-to-firefly-v9/).
+
+  ## Breaking changes
+
+  - The `useAreModulesRegistered` hook has been removed, use the `useIsBootstrapping` hook instead.
+  - The `useAreModulesReady` hook has been removed, use the `useIsBootstrapping` hook instead.
+  - The `useIsMswStarted` hook has been removed, use the `useIsBootstrapping` hook instead.
+  - The `completeModuleRegistrations` function as been removed use the `useDeferredRegistrations` hook instead.
+  - The `completeLocalModulesRegistrations` function has been removed use the `useDeferredRegistrations` hook instead.
+  - The `completeRemoteModuleRegistrations` function has been removed use the `useDeferredRegistrations` hook instead.
+  - The `useSession` hook has been removed, define your own React context instead.
+  - The `useIsAuthenticated` hook has been removed, define your own React context instead.
+  - The `sessionAccessor` option has been removed from the `FireflyRuntime` options, define your own React context instead.
+  - Removed supports for deferred routes.
+  - Plugin's constructor now requires a runtime instance argument.
+  - Plugins now registers with a factory function.
+  - Full rewrite of the `AppRouter` component.
+
+  ## Renamed
+
+  - The `setMswAsStarted` function has been renamed to `setMswIsReady`.
+
+  ## Others
+
+  - The `@squide/firefly` package now takes a peerDependency on `@tanstack/react-query`.
+  - The `@squide/firefly` package doesn't takes a peerDependency on `react-error-boundary` anymore.
+
+  ## New hooks and functions
+
+  - A new `useIsBoostrapping` hook is now available.
+  - A new `useDeferredRegistrations` hook is now available.
+  - A new `usePublicDataQueries` hook is now available.
+  - A new `useProtectedDataQueries` hook is now available.
+  - A new `isGlobalDataQueriesError` function is now available.
+
+  ## Improvements
+
+  - Deferred registration functions now always receive a `data` argument.
+  - Deferred registration functions now receives a new `operation` argument.
+  - Navigation items now include a `$canRender` option, enabling modules to control whether a navigation item should be rendered.
+  - New `$key` option for navigation items.
+
+  For more details about the changes and a migration procedure, read the following [documentation](https://gsoft-inc.github.io/wl-squide/guides/migrate-to-firefly-v9/).
+
+### Patch Changes
+
+- Updated dependencies [[`58cf066`](https://github.com/gsoft-inc/wl-squide/commit/58cf066e87e23611510c254cca96016bd2bad08a)]:
+  - @squide/core@5.0.0
+  - @squide/module-federation@6.0.0
+  - @squide/msw@3.0.0
+  - @squide/react-router@6.0.0
+
 ## 8.0.0
 
 ### Major Changes
@@ -58,7 +122,7 @@
   import { defineDevHostConfig } from "@squide/firefly-webpack-configs";
   import { swcConfig } from "./swc.dev.js";
 
-  export default defineDevHostConfig(swcConfig, "host", 8080, {
+  export default defineDevHostConfig(swcConfig, 8080, {
     overlay: false,
   });
   ```
@@ -98,7 +162,7 @@
     },
   ];
 
-  export default defineDevHostConfig(swcConfig, "host", 8080, Remotes, {
+  export default defineDevHostConfig(swcConfig, 8080, Remotes, {
     overlay: false,
   });
   ```

package/dist/AppRouter.d.ts

@@ -1,36 +1,23 @@
-import * as react from 'react';
-import { ReactElement } from 'react';
 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';
 
-type OnLoadPublicDataFunction = (signal: AbortSignal) => Promise<unknown>;
-type OnLoadProtectedDataFunction = (signal: AbortSignal) => Promise<unknown>;
-type OnCompleteRegistrationsFunction = () => Promise<unknown>;
-interface BootstrappingRouteProps {
-    fallbackElement: ReactElement;
-    onLoadPublicData?: OnLoadPublicDataFunction;
-    onLoadProtectedData?: OnLoadProtectedDataFunction;
-    isPublicDataLoaded: boolean;
-    isProtectedDataLoaded: boolean;
-    onCompleteRegistrations?: OnCompleteRegistrationsFunction;
-    waitForMsw: boolean;
-    areModulesRegistered: boolean;
-    areModulesReady: boolean;
+interface AppRouterRenderFunctionArgs {
+    routes: Route[];
+}
+interface RenderRouterProviderFunctionArgs {
+    rootRoute: ReactElement;
+    registeredRoutes: Route[];
+    routerProviderProps: Omit<RouterProviderProps, "router">;
 }
-declare function BootstrappingRoute(props: BootstrappingRouteProps): react_jsx_runtime.JSX.Element;
-type RenderRouterProviderFunction = (routes: Route[], providerProps: Omit<RouterProviderProps, "router">) => ReactElement;
+type RenderRouterProviderFunction = (args: RenderRouterProviderFunctionArgs) => ReactElement;
 interface AppRouterProps {
-    fallbackElement: ReactElement;
-    errorElement: ReactElement;
-    onLoadPublicData?: OnLoadPublicDataFunction;
-    onLoadProtectedData?: OnLoadProtectedDataFunction;
-    isPublicDataLoaded?: boolean;
-    isProtectedDataLoaded?: boolean;
-    onCompleteRegistrations?: OnCompleteRegistrationsFunction;
     waitForMsw: boolean;
+    waitForPublicData?: boolean;
+    waitForProtectedData?: boolean;
     children: RenderRouterProviderFunction;
 }
-declare function AppRouter(props: AppRouterProps): ReactElement<any, string | react.JSXElementConstructor<any>>;
+declare function AppRouter(props: AppRouterProps): react_jsx_runtime.JSX.Element;
 
-export { AppRouter, type AppRouterProps, BootstrappingRoute, type OnCompleteRegistrationsFunction, type OnLoadProtectedDataFunction, type OnLoadPublicDataFunction, type RenderRouterProviderFunction };
+export { AppRouter, type AppRouterProps, type AppRouterRenderFunctionArgs, type RenderRouterProviderFunction, type RenderRouterProviderFunctionArgs };

package/dist/AppRouter.js

@@ -1 +1,6 @@
-export { AppRouter, BootstrappingRoute } from './chunk-URNAUMUG.js';
+export { AppRouter } from './chunk-36U4TTNR.js';
+import './chunk-WOPD33CM.js';
+import './chunk-ENUCXEMN.js';
+import './chunk-MZG2PJJG.js';
+import './chunk-PP3MRMJJ.js';
+import './chunk-G32YX2KR.js';

package/dist/AppRouterContext.d.ts

@@ -0,0 +1,9 @@
+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 };

package/dist/AppRouterContext.js

@@ -0,0 +1 @@
+export { AppRouterDispatcherContext, AppRouterStateContext, useAppRouterDispatcher, useAppRouterState } from './chunk-G32YX2KR.js';

package/dist/AppRouterReducer.d.ts

@@ -0,0 +1,31 @@
+import { Dispatch } from 'react';
+
+interface AppRouterState {
+    waitForMsw: boolean;
+    waitForPublicData: boolean;
+    waitForProtectedData: boolean;
+    areModulesRegistered: boolean;
+    areModulesReady: boolean;
+    isMswReady: boolean;
+    isPublicDataReady: boolean;
+    isProtectedDataReady: boolean;
+    publicDataUpdatedAt?: number;
+    protectedDataUpdatedAt?: number;
+    deferredRegistrationsUpdatedAt?: number;
+    isActiveRouteProtected: boolean;
+    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";
+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 __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 };

package/dist/AppRouterReducer.js

@@ -0,0 +1 @@
+export { __clearAppReducerDispatchProxy, __setAppReducerDispatchProxyFactory, getAreModulesReady, getAreModulesRegistered, useAppRouterReducer, useModuleRegistrationStatusDispatcher, useMswStatusDispatcher } from './chunk-ENUCXEMN.js';

package/dist/{fireflyRuntime.d.ts → FireflyRuntime.d.ts}

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

package/dist/FireflyRuntime.js

@@ -0,0 +1,2 @@
+export { FireflyRuntime } from './chunk-FKQ7XQEU.js';
+import './chunk-ENUCXEMN.js';

package/dist/GlobalDataQueriesError.d.ts

@@ -0,0 +1,8 @@
+declare class GlobalDataQueriesError extends Error {
+    #private;
+    constructor(message: string, errors: Error[]);
+    get errors(): Error[];
+}
+declare function isGlobalDataQueriesError(error?: unknown): error is GlobalDataQueriesError;
+
+export { GlobalDataQueriesError, isGlobalDataQueriesError };

package/dist/GlobalDataQueriesError.js

@@ -0,0 +1 @@
+export { GlobalDataQueriesError, isGlobalDataQueriesError } from './chunk-HE5HKFL3.js';

package/dist/RootRoute.d.ts

@@ -0,0 +1,5 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+declare function RootRoute(): react_jsx_runtime.JSX.Element;
+
+export { RootRoute };

package/dist/RootRoute.js

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

package/dist/chunk-2E76JVV7.js

@@ -0,0 +1,41 @@
+import { useRegisterDeferredRegistrations } from './chunk-YRWFYWK4.js';
+import { useUpdateDeferredRegistrations } from './chunk-N2GOIQ5E.js';
+import { useCanRegisterDeferredRegistrations } from './chunk-PU7MASPN.js';
+import { useCanUpdateDeferredRegistrations } from './chunk-WVRMJZV6.js';
+import { useRuntime } from '@squide/core';
+import { useEffect } from 'react';
+
+function hasError({ localModuleErrors, remoteModuleErrors }) {
+  return localModuleErrors.length > 0 || remoteModuleErrors.length > 0;
+}
+function useDeferredRegistrations(data, { onError } = {}) {
+  const runtime = useRuntime();
+  const canRegisterDeferredRegistrations = useCanRegisterDeferredRegistrations();
+  const canUpdateDeferredRegistrations = useCanUpdateDeferredRegistrations();
+  const registerDeferredRegistrations = useRegisterDeferredRegistrations();
+  const updateDeferredRegistrations = useUpdateDeferredRegistrations();
+  useEffect(() => {
+    if (canRegisterDeferredRegistrations) {
+      const register = async () => {
+        const errors = await registerDeferredRegistrations(data, runtime);
+        if (hasError(errors) && onError) {
+          onError(errors);
+        }
+      };
+      register();
+    }
+  }, [canRegisterDeferredRegistrations, registerDeferredRegistrations, data, onError, runtime]);
+  useEffect(() => {
+    if (canUpdateDeferredRegistrations) {
+      const update = async () => {
+        const errors = await updateDeferredRegistrations(data, runtime);
+        if (hasError(errors) && onError) {
+          onError(errors);
+        }
+      };
+      update();
+    }
+  }, [canUpdateDeferredRegistrations, updateDeferredRegistrations, data, onError, runtime]);
+}
+
+export { useDeferredRegistrations };

package/dist/chunk-36U4TTNR.js

@@ -0,0 +1,34 @@
+import { useStrictRegistrationMode } from './chunk-WOPD33CM.js';
+import { useAppRouterReducer } from './chunk-ENUCXEMN.js';
+import { RootRoute } from './chunk-MZG2PJJG.js';
+import { AppRouterDispatcherContext, AppRouterStateContext } from './chunk-G32YX2KR.js';
+import { useLogger } from '@squide/core';
+import { useRoutes } from '@squide/react-router';
+import { useEffect, useMemo } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+function AppRouter(props) {
+  const {
+    waitForMsw,
+    waitForPublicData = false,
+    waitForProtectedData = false,
+    children: renderRouterProvider
+  } = props;
+  const [state, dispatch] = useAppRouterReducer(waitForMsw, waitForPublicData, waitForProtectedData);
+  const logger = useLogger();
+  const routes = useRoutes();
+  useStrictRegistrationMode();
+  useEffect(() => {
+    logger.debug("[squide] AppRouter state updated:", state);
+  }, [state, logger]);
+  const routerProvider = useMemo(() => {
+    return renderRouterProvider({
+      rootRoute: /* @__PURE__ */ jsx(RootRoute, {}),
+      registeredRoutes: routes,
+      routerProviderProps: {}
+    });
+  }, [routes, renderRouterProvider]);
+  return /* @__PURE__ */ jsx(AppRouterDispatcherContext.Provider, { value: dispatch, children: /* @__PURE__ */ jsx(AppRouterStateContext.Provider, { value: state, children: routerProvider }) });
+}
+
+export { AppRouter };

package/dist/chunk-ENUCXEMN.js

@@ -0,0 +1,180 @@
+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 };

package/dist/chunk-FKQ7XQEU.js

@@ -0,0 +1,54 @@
+import { getAreModulesRegistered } from './chunk-ENUCXEMN.js';
+import { MswPlugin } from '@squide/msw';
+import { ReactRouterRuntime } from '@squide/react-router';
+
+var FireflyRuntime = class extends ReactRouterRuntime {
+  #useMsw;
+  constructor({ plugins, useMsw, ...options } = {}) {
+    if (useMsw) {
+      super({
+        plugins: [
+          ...plugins ?? [],
+          (runtime) => new MswPlugin(runtime)
+        ],
+        ...options
+      });
+      this.#useMsw = true;
+    } else {
+      super({
+        plugins,
+        ...options
+      });
+      this.#useMsw = false;
+    }
+  }
+  registerRequestHandlers(handlers) {
+    const mswPlugin = this.getPlugin(MswPlugin.name);
+    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 (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(MswPlugin.name);
+    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 (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 };

package/dist/chunk-G32YX2KR.js

@@ -0,0 +1,22 @@
+import { isNil } from '@squide/core';
+import { createContext, useContext } from 'react';
+
+// src/AppRouterContext.ts
+var AppRouterStateContext = createContext(void 0);
+function useAppRouterState() {
+  const state = useContext(AppRouterStateContext);
+  if (isNil(state)) {
+    throw new Error("[squide] The useAppRouterState hook must be called by a children of the AppRouter component.");
+  }
+  return state;
+}
+var AppRouterDispatcherContext = createContext(void 0);
+function useAppRouterDispatcher() {
+  const dispatch = useContext(AppRouterDispatcherContext);
+  if (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/chunk-H6F7HDB3.js

@@ -0,0 +1,9 @@
+import { useAppRouterState } from './chunk-G32YX2KR.js';
+import { useRuntimeNavigationItems } from '@squide/react-router';
+
+function useNavigationItems() {
+  useAppRouterState();
+  return useRuntimeNavigationItems();
+}
+
+export { useNavigationItems };

package/dist/chunk-HE5HKFL3.js

@@ -0,0 +1,16 @@
+// src/GlobalDataQueriesError.ts
+var GlobalDataQueriesError = class extends Error {
+  #errors;
+  constructor(message, errors) {
+    super(message);
+    this.#errors = errors;
+  }
+  get errors() {
+    return this.#errors;
+  }
+};
+function isGlobalDataQueriesError(error) {
+  return error !== void 0 && error !== null && error instanceof GlobalDataQueriesError;
+}
+
+export { GlobalDataQueriesError, isGlobalDataQueriesError };

package/dist/chunk-I6L3AYOB.js

@@ -0,0 +1,24 @@
+import { useAppRouterState } from './chunk-G32YX2KR.js';
+
+// src/useIsBootstrapping.ts
+function useIsBootstrapping() {
+  const {
+    waitForMsw,
+    waitForPublicData,
+    waitForProtectedData,
+    areModulesReady,
+    isMswReady,
+    isPublicDataReady,
+    isProtectedDataReady,
+    isActiveRouteProtected,
+    isUnauthorized
+  } = useAppRouterState();
+  const isAppReady = !isUnauthorized && areModulesReady && (!waitForMsw || isMswReady) && (!waitForPublicData || isPublicDataReady) && (!waitForProtectedData || !isActiveRouteProtected || isProtectedDataReady);
+  const flush = (
+    // Only applicable when there's a unauthorized request while fetching the initial data.
+    isUnauthorized && (!waitForMsw || isMswReady) && (!waitForPublicData || isPublicDataReady)
+  );
+  return !isAppReady && !flush;
+}
+
+export { useIsBootstrapping };

package/dist/chunk-IOMSOUAL.js

@@ -0,0 +1,20 @@
+import { useAppRouterState } from './chunk-G32YX2KR.js';
+
+// src/useCanFetchPublicData.ts
+function useCanFetchPublicData() {
+  const {
+    waitForMsw,
+    areModulesRegistered,
+    areModulesReady,
+    isMswReady,
+    isPublicDataReady
+  } = useAppRouterState();
+  return (
+    // Always return true when the public data has already been fetched sucessfully so TanStack Query can update the data in the background.
+    isPublicDataReady || // Wait until the modules has been registered, but do not wait for the deferred registrations to be registered has they will probably
+    // depends on the protected data.
+    (areModulesRegistered || areModulesReady) && (!waitForMsw || isMswReady)
+  );
+}
+
+export { useCanFetchPublicData };