@squide/firefly 9.3.1 → 9.3.3

package/src/useDeferredRegistrations.ts

@@ -0,0 +1,59 @@
+import { useRuntime, type ModuleRegistrationError } from "@squide/core";
+import { useEffect } from "react";
+import { useCanRegisterDeferredRegistrations } from "./useCanRegisterDeferredRegistrations.ts";
+import { useCanUpdateDeferredRegistrations } from "./useCanUpdateDeferredRegistrations.ts";
+import { useRegisterDeferredRegistrations } from "./useRegisterDeferredRegistrations.ts";
+import { useUpdateDeferredRegistrations } from "./useUpdateDeferredRegistrations.ts";
+
+export interface DeferredRegistrationsErrorsObject {
+    localModuleErrors: ModuleRegistrationError[];
+    remoteModuleErrors: ModuleRegistrationError[];
+}
+
+export type DeferredRegistrationsErrorCallback = (errorsObject: DeferredRegistrationsErrorsObject) => void;
+
+export interface UseDeferredRegistrationsOptions {
+    onError?: DeferredRegistrationsErrorCallback;
+}
+
+function hasError({ localModuleErrors, remoteModuleErrors }: DeferredRegistrationsErrorsObject) {
+    return localModuleErrors.length > 0 || remoteModuleErrors.length > 0;
+}
+
+export function useDeferredRegistrations(data: unknown, { onError }: UseDeferredRegistrationsOptions = {}) {
+    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]);
+}

package/src/useExecuteOnce.ts

@@ -0,0 +1,23 @@
+import { useCallback, useRef } from "react";
+
+// Not using useEffect or useLayoutEffect because this utility hook is often used to dispatch events
+// and it messed with the events dispatch order.
+export function useExecuteOnce(fct: () => boolean, inline: boolean = 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;
+}

package/src/useIsActiveRouteProtected.ts

@@ -0,0 +1,12 @@
+import { useIsRouteProtected, useRouteMatch } from "@squide/react-router";
+import { useLocation } from "react-router-dom";
+
+export function useIsActiveRouteProtected(areModulesReady: boolean) {
+    // Using this hook instead of window.location to retrieve the current location because it triggers a re-render everytime the browser location change.
+    const location = useLocation();
+
+    // Only throw when there's no match if the modules are ready, otherwise it's expected that no route will be found since they are not all registered yet.
+    const activeRoute = useRouteMatch(location, { throwWhenThereIsNoMatch: areModulesReady });
+
+    return useIsRouteProtected(activeRoute);
+}

package/src/useIsBootstrapping.ts

@@ -0,0 +1,45 @@
+import { useAppRouterState } from "./AppRouterContext.ts";
+import type { AppRouterState } from "./AppRouterReducer.ts";
+
+export function useIsBootstrapping() {
+    const state = useAppRouterState();
+
+    return isApplicationBootstrapping(state);
+}
+
+export function isApplicationBootstrapping(state: AppRouterState) {
+    const {
+        waitForMsw,
+        waitForPublicData,
+        waitForProtectedData,
+        areModulesReady,
+        isMswReady,
+        isPublicDataReady,
+        isProtectedDataReady,
+        activeRouteVisibility,
+        isUnauthorized
+    } = state;
+
+    const isAppReady = (
+        !isUnauthorized
+        // Wait until the modules has been registered and the deferred registrations has been registered if any.
+        && areModulesReady
+        // Not required but can sometimes prevent a re-render when the state value is somehow updated after the initial data is ready.
+        && (!waitForMsw || isMswReady)
+        // Wait for the initial data to be ready.
+        && (!waitForPublicData || isPublicDataReady)
+        && (!waitForProtectedData || activeRouteVisibility === "public" || isProtectedDataReady)
+    );
+
+    // When an API request returns a 401, the bootstrapping should be bypassed to render the login page.
+    const flush = (
+        // Only applicable when there's a unauthorized request while fetching the initial data.
+        isUnauthorized
+        // Not required but can sometimes prevent a re-render when the state value is somehow updated after the public data is ready.
+        && (!waitForMsw || isMswReady)
+        // If the application is loading public data, we want to wait for this data to be ready to prevent a re-render.
+        && (!waitForPublicData || isPublicDataReady)
+    );
+
+    return !isAppReady && !flush;
+}

package/src/useNavigationItems.ts

@@ -0,0 +1,18 @@
+import { useRuntimeNavigationItems, type UseRuntimeNavigationItemsOptions } from "@squide/react-router";
+import { useAppRouterState } from "./AppRouterContext.ts";
+
+export type UseNavigationItemsOptions = UseRuntimeNavigationItemsOptions;
+
+export function useNavigationItems(options?: UseNavigationItemsOptions) {
+    // This is not the most sophisticated strategy but it seems to be good enough for now.
+    // The idea is that when deferred registrations are used by the consumer applications, the deferred registrations could
+    // be updated when the global data is updated. If the deferred registrations are updated, it means that the registered
+    // navigation items might have been updated and a re-render must happens to display the new navigation items.
+    // Since the "deferredRegistrationsUpdatedAt" state value of the AppRouterReducer is updated everytime the deferred registrations
+    // are updated, subscribing to the state with useAppRouterState ensure that the navigation items will be re-rendered.
+    // A more sophisticated strategy could be implemented later on if needed, something involving a subscription to the "runtime" changes, or
+    // even introducing new module states.
+    useAppRouterState();
+
+    return useRuntimeNavigationItems(options);
+}

package/src/useProtectedDataQueries.ts

@@ -0,0 +1,101 @@
+import { useEventBus } from "@squide/core";
+import { useQueries, type QueriesOptions, type QueriesResults, type UseQueryResult } from "@tanstack/react-query";
+import { useCallback, useEffect, useRef } from "react";
+import { useAppRouterDispatcher, useAppRouterState } from "./AppRouterContext.ts";
+import { GlobalDataQueriesError } from "./GlobalDataQueriesError.ts";
+import { useCanFetchProtectedData } from "./useCanFetchProtectedData.ts";
+import { useExecuteOnce } from "./useExecuteOnce.ts";
+
+export const ProtectedDataFetchStartedEvent = "squide-protected-data-fetch-started";
+export const ProtectedDataFetchFailedEvent = "squide-protected-data-fetch-failed";
+
+export type IsUnauthorizedErrorCallback = (error: unknown) => boolean;
+
+// This converts an array of UseQueryResult to an array of the data type of each query result.
+// For more information, view: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-1.html#mapped-types-on-tuples-and-arrays.
+type MapUseQueryResultToData<T> = { [K in keyof T]: T[K] extends UseQueryResult<infer U> ? U : never };
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function useProtectedDataQueries<T extends Array<any>>(queries: QueriesOptions<T>, isUnauthorizedError: IsUnauthorizedErrorCallback): MapUseQueryResultToData<QueriesResults<T>> {
+    const canFetchProtectedData = useCanFetchProtectedData();
+    const eventBus = useEventBus();
+
+    const dispatch = useAppRouterDispatcher();
+
+    const combineResults = useCallback((results: UseQueryResult<unknown, Error>[]) => {
+        const errors = results.filter(x => x.error).map(x => x.error) as Error[];
+        const hasErrors = errors.length > 0;
+
+        return {
+            data: results.map(x => x.data) as MapUseQueryResultToData<QueriesResults<T>>,
+            errors,
+            hasErrors,
+            isReady: !hasErrors && !results.some(x => x.isPending)
+        };
+    }, []);
+
+    const { data, errors: queriesErrors, hasErrors, isReady } = useQueries({
+        queries: queries.map(x => ({
+            enabled: canFetchProtectedData,
+            ...x
+        })),
+        combine: combineResults
+    });
+
+    const { isProtectedDataReady, isUnauthorized } = useAppRouterState();
+
+    useExecuteOnce(useCallback(() => {
+        if (canFetchProtectedData) {
+            eventBus.dispatch(ProtectedDataFetchStartedEvent);
+
+            return true;
+        }
+
+        return false;
+    }, [canFetchProtectedData, eventBus]), true);
+
+    // Using a ref seems to be the only way to prevent starting two deferred registrations scope.
+    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(() => {
+        // State update must be executed in useEffect.
+        dispatchReady();
+    }, [dispatchReady]);
+
+    useEffect(() => {
+        if (isReadyRef.current && data) {
+            dispatch({ type: "protected-data-updated" });
+        }
+    }, [data, dispatch]);
+
+    useEffect(() => {
+        if (hasErrors) {
+            if (!isProtectedDataReady && !isUnauthorized && queriesErrors.some(x => isUnauthorizedError(x))) {
+                // Will transition the state to allow the routes to render even if the bootstrapping is not complete, because otherwise
+                // a login page for example could not be rendered.
+                dispatch({ type: "is-unauthorized" });
+            }
+
+            // Otherwise, when a user is logged off, a refetch might throws a 401.
+            if (!queriesErrors.every(x => isUnauthorizedError(x))) {
+                eventBus.dispatch(ProtectedDataFetchFailedEvent, queriesErrors);
+
+                throw new GlobalDataQueriesError("[squide] Global protected data queries failed.", queriesErrors);
+            }
+        }
+    }, [hasErrors, queriesErrors, isProtectedDataReady, isUnauthorized, isUnauthorizedError, dispatch, eventBus]);
+
+    return data;
+}

package/src/usePublicDataQueries.ts

@@ -0,0 +1,88 @@
+import { useEventBus } from "@squide/core";
+import { useQueries, type QueriesOptions, type QueriesResults, type UseQueryResult } from "@tanstack/react-query";
+import { useCallback, useEffect, useRef } from "react";
+import { useAppRouterDispatcher } from "./AppRouterContext.ts";
+import { GlobalDataQueriesError } from "./GlobalDataQueriesError.ts";
+import { useCanFetchPublicData } from "./useCanFetchPublicData.ts";
+import { useExecuteOnce } from "./useExecuteOnce.ts";
+
+export const PublicDataFetchStartedEvent = "squide-public-data-fetch-started";
+export const PublicDataFetchFailedEvent = "squide-public-data-fetch-failed";
+
+// This converts an array of UseQueryResult to an array of the data type of each query result.
+// For more information, view: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-1.html#mapped-types-on-tuples-and-arrays.
+type MapUseQueryResultToData<T> = { [K in keyof T]: T[K] extends UseQueryResult<infer U> ? U : never };
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function usePublicDataQueries<T extends Array<any>>(queries: QueriesOptions<T>): MapUseQueryResultToData<QueriesResults<T>> {
+    const canFetchPublicData = useCanFetchPublicData();
+    const eventBus = useEventBus();
+
+    const dispatch = useAppRouterDispatcher();
+
+    const combineResults = useCallback((results: UseQueryResult<unknown, Error>[]) => {
+        const errors = results.filter(x => x.error).map(x => x.error) as Error[];
+        const hasErrors = errors.length > 0;
+
+        return {
+            data: results.map(x => x.data) as MapUseQueryResultToData<QueriesResults<T>>,
+            errors,
+            hasErrors,
+            isReady: !hasErrors && !results.some(x => x.isPending)
+        };
+    }, []);
+
+    const { data, errors: queriesErrors, hasErrors, isReady } = useQueries({
+        queries: queries.map(x => ({
+            enabled: canFetchPublicData,
+            ...x
+        })),
+        combine: combineResults
+    });
+
+    useExecuteOnce(useCallback(() => {
+        if (canFetchPublicData) {
+            eventBus.dispatch(PublicDataFetchStartedEvent);
+
+            return true;
+        }
+
+        return false;
+    }, [canFetchPublicData, eventBus]), true);
+
+    // Using a ref seems to be the only way to prevent starting two deferred registrations scope.
+    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(() => {
+        // State update must be executed in useEffect.
+        dispatchReady();
+    }, [dispatchReady]);
+
+    useEffect(() => {
+        if (isReadyRef.current && data) {
+            dispatch({ type: "public-data-updated" });
+        }
+    }, [data, dispatch]);
+
+    useEffect(() => {
+        if (hasErrors) {
+            eventBus.dispatch(PublicDataFetchFailedEvent, queriesErrors);
+
+            throw new GlobalDataQueriesError("[squide] Global public data queries failed.", queriesErrors);
+        }
+    }, [hasErrors, queriesErrors, eventBus]);
+
+    return data;
+}

package/src/useRegisterDeferredRegistrations.ts

@@ -0,0 +1,9 @@
+import type { Runtime } from "@squide/core";
+import { registerDeferredRegistrations } from "@squide/module-federation";
+import { useCallback } from "react";
+
+export function useRegisterDeferredRegistrations() {
+    return useCallback(<TData = unknown, TRuntime extends Runtime = Runtime>(data: TData, runtime: TRuntime) => {
+        return registerDeferredRegistrations(data, runtime);
+    }, []);
+}

package/src/useStrictRegistrationMode.ts

@@ -0,0 +1,28 @@
+import { addLocalModuleRegistrationStatusChangedListener, getLocalModuleRegistrationStatus, removeLocalModuleRegistrationStatusChangedListener, useRuntime } from "@squide/core";
+import { addRemoteModuleRegistrationStatusChangedListener, areModulesReady, getRemoteModuleRegistrationStatus, removeRemoteModuleRegistrationStatusChangedListener } from "@squide/module-federation";
+import { useEffect, useSyncExternalStore } from "react";
+
+function subscribeToLocalModuleRegistrationStatusChanged(callback: () => void) {
+    addLocalModuleRegistrationStatusChangedListener(callback);
+
+    return () => removeLocalModuleRegistrationStatusChangedListener(callback);
+}
+
+function subscribeToRemoteModuleRegistrationStatusChanged(callback: () => void) {
+    addRemoteModuleRegistrationStatusChangedListener(callback);
+
+    return () => removeRemoteModuleRegistrationStatusChangedListener(callback);
+}
+
+export function useStrictRegistrationMode() {
+    const runtime = useRuntime();
+
+    const localModuleStatus = useSyncExternalStore(subscribeToLocalModuleRegistrationStatusChanged, getLocalModuleRegistrationStatus);
+    const remoteModuleStatus = useSyncExternalStore(subscribeToRemoteModuleRegistrationStatusChanged, getRemoteModuleRegistrationStatus);
+
+    useEffect(() => {
+        if (areModulesReady(localModuleStatus, remoteModuleStatus)) {
+            runtime._validateRegistrations();
+        }
+    }, [runtime, localModuleStatus, remoteModuleStatus]);
+}

package/src/useUpdateDeferredRegistrations.ts

@@ -0,0 +1,16 @@
+import type { Runtime } from "@squide/core";
+import { updateDeferredRegistrations } from "@squide/module-federation";
+import { useCallback } from "react";
+import { useAppRouterDispatcher } from "./AppRouterContext.ts";
+
+export function useUpdateDeferredRegistrations() {
+    const dispatch = useAppRouterDispatcher();
+
+    return useCallback(async <TData = unknown, TRuntime extends Runtime = Runtime>(data: TData, runtime: TRuntime) => {
+        const errors = await updateDeferredRegistrations(data, runtime);
+
+        dispatch({ type: "deferred-registrations-updated" });
+
+        return errors;
+    }, [dispatch]);
+}

package/dist/chunk-4RUCDAUT.js

@@ -1,18 +0,0 @@
-import { useAppRouterState } from './chunk-G32YX2KR.js';
-
-// src/useCanRegisterDeferredRegistrations.ts
-function useCanRegisterDeferredRegistrations() {
-  const {
-    waitForPublicData,
-    waitForProtectedData,
-    areModulesReady,
-    areModulesRegistered,
-    isPublicDataReady,
-    isProtectedDataReady,
-    activeRouteVisibility,
-    isUnauthorized
-  } = useAppRouterState();
-  return !isUnauthorized && areModulesRegistered && !areModulesReady && (!waitForPublicData || isPublicDataReady) && (!waitForProtectedData || activeRouteVisibility === "public" || isProtectedDataReady);
-}
-
-export { useCanRegisterDeferredRegistrations };

package/dist/chunk-BFHHJOJT.js

@@ -1,41 +0,0 @@
-import { useRegisterDeferredRegistrations } from './chunk-YRWFYWK4.js';
-import { useUpdateDeferredRegistrations } from './chunk-N2GOIQ5E.js';
-import { useCanRegisterDeferredRegistrations } from './chunk-4RUCDAUT.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-CTLPFYLM.js

@@ -1,65 +0,0 @@
-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, 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: hasErrors2,
-      isReady: !hasErrors2 && !results.some((x) => x.isPending)
-    };
-  }, []);
-  const { data, errors: queriesErrors, hasErrors, isReady } = useQueries({
-    queries: queries.map((x) => ({
-      enabled: canFetchPublicData,
-      ...x
-    })),
-    combine: combineResults
-  });
-  useExecuteOnce(useCallback(() => {
-    if (canFetchPublicData) {
-      eventBus.dispatch(PublicDataFetchStartedEvent);
-      return true;
-    }
-    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 (hasErrors) {
-      eventBus.dispatch(PublicDataFetchFailedEvent, queriesErrors);
-      throw new GlobalDataQueriesError("[squide] Global public data queries failed.", queriesErrors);
-    }
-  }, [hasErrors, queriesErrors, eventBus]);
-  return data;
-}
-
-export { PublicDataFetchFailedEvent, PublicDataFetchStartedEvent, usePublicDataQueries };

package/dist/chunk-G32YX2KR.js

@@ -1,22 +0,0 @@
-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-GXSW4CZS.js

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

package/dist/chunk-H2ILEMPE.js

@@ -1,28 +0,0 @@
-import { useAppRouterState } from './chunk-G32YX2KR.js';
-
-// src/useIsBootstrapping.ts
-function useIsBootstrapping() {
-  const state = useAppRouterState();
-  return isApplicationBootstrapping(state);
-}
-function isApplicationBootstrapping(state) {
-  const {
-    waitForMsw,
-    waitForPublicData,
-    waitForProtectedData,
-    areModulesReady,
-    isMswReady,
-    isPublicDataReady,
-    isProtectedDataReady,
-    activeRouteVisibility,
-    isUnauthorized
-  } = 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)
-  );
-  return !isAppReady && !flush;
-}
-
-export { isApplicationBootstrapping, useIsBootstrapping };

package/dist/chunk-HE5HKFL3.js

@@ -1,16 +0,0 @@
-// 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-IOMSOUAL.js

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