@squide/firefly 8.0.0 → 9.0.1

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 };

package/dist/chunk-L5BP3WP3.js

@@ -0,0 +1,21 @@
+import { useAppRouterState } from './chunk-G32YX2KR.js';
+
+// src/useCanFetchProtectedData.ts
+function useCanFetchProtectedData() {
+  const {
+    waitForMsw,
+    areModulesRegistered,
+    areModulesReady,
+    isMswReady,
+    isProtectedDataReady,
+    isActiveRouteProtected
+  } = 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)
+  );
+}
+
+export { useCanFetchProtectedData };

package/dist/chunk-MZG2PJJG.js

@@ -0,0 +1,19 @@
+import { useIsActiveRouteProtected } from './chunk-PP3MRMJJ.js';
+import { useAppRouterState, useAppRouterDispatcher } from './chunk-G32YX2KR.js';
+import { useEffect } from 'react';
+import { Outlet } from 'react-router-dom';
+import { jsx } from 'react/jsx-runtime';
+
+function RootRoute() {
+  const state = useAppRouterState();
+  const isActiveRouteProtected = useIsActiveRouteProtected(state.areModulesReady);
+  const dispatch = useAppRouterDispatcher();
+  useEffect(() => {
+    if (isActiveRouteProtected) {
+      dispatch({ type: "active-route-is-protected" });
+    }
+  }, [isActiveRouteProtected, dispatch]);
+  return /* @__PURE__ */ jsx(Outlet, {});
+}
+
+export { RootRoute };

package/dist/chunk-N2GOIQ5E.js

@@ -0,0 +1,14 @@
+import { useAppRouterDispatcher } from './chunk-G32YX2KR.js';
+import { updateDeferredRegistrations } from '@squide/module-federation';
+import { useCallback } from 'react';
+
+function useUpdateDeferredRegistrations() {
+  const dispatch = useAppRouterDispatcher();
+  return useCallback(async (data, runtime) => {
+    const errors = await updateDeferredRegistrations(data, runtime);
+    dispatch({ type: "deferred-registrations-updated" });
+    return errors;
+  }, [dispatch]);
+}
+
+export { useUpdateDeferredRegistrations };

package/dist/chunk-PP3MRMJJ.js

@@ -0,0 +1,11 @@
+import { useRouteMatch, useIsRouteProtected } from '@squide/react-router';
+import { useLocation } from 'react-router-dom';
+
+// src/useIsActiveRouteProtected.ts
+function useIsActiveRouteProtected(areModulesReady) {
+  const location = useLocation();
+  const activeRoute = useRouteMatch(location, { throwWhenThereIsNoMatch: areModulesReady });
+  return useIsRouteProtected(activeRoute);
+}
+
+export { useIsActiveRouteProtected };

package/dist/chunk-PU7MASPN.js

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

package/dist/chunk-RG5N56BQ.js

@@ -0,0 +1,55 @@
+import { GlobalDataQueriesError } from './chunk-HE5HKFL3.js';
+import { useCanFetchProtectedData } from './chunk-L5BP3WP3.js';
+import { useAppRouterDispatcher, useAppRouterState } from './chunk-G32YX2KR.js';
+import { useQueries } from '@tanstack/react-query';
+import { useCallback, useEffect, useRef } from 'react';
+
+function useProtectedDataQueries(queries, isUnauthorizedError) {
+  const canFetchProtectedData = useCanFetchProtectedData();
+  const dispatch = useAppRouterDispatcher();
+  const combineResults = useCallback((results) => {
+    const errors = results.filter((x) => x.error).map((x) => x.error);
+    return {
+      data: results.map((x) => x.data),
+      errors,
+      hasErrors: errors.length > 0,
+      isReady: results.length === queries.length && results.every((x) => x.data)
+    };
+  }, [queries.length]);
+  const { data, errors: queriesErrors, hasErrors, isReady } = useQueries({
+    queries: queries.map((x) => ({
+      enabled: canFetchProtectedData,
+      ...x
+    })),
+    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);
+      }
+    }
+  }, [hasErrors, queriesErrors, isProtectedDataReady, isUnauthorized, isUnauthorizedError, dispatch]);
+  const isReadyRef = useRef(false);
+  useEffect(() => {
+    if (isReadyRef.current && data) {
+      dispatch({ type: "protected-data-updated" });
+    }
+  }, [data, dispatch]);
+  useEffect(() => {
+    if (isReady) {
+      isReadyRef.current = true;
+      dispatch({ type: "protected-data-ready" });
+    }
+  }, [isReady, dispatch]);
+  return data;
+}
+
+export { useProtectedDataQueries };

package/dist/chunk-VUMBZ5BP.js

@@ -0,0 +1,46 @@
+import { useCanFetchPublicData } from './chunk-IOMSOUAL.js';
+import { GlobalDataQueriesError } from './chunk-HE5HKFL3.js';
+import { useAppRouterDispatcher } from './chunk-G32YX2KR.js';
+import { useQueries } from '@tanstack/react-query';
+import { useCallback, useEffect, useRef } from 'react';
+
+function usePublicDataQueries(queries) {
+  const canFetchPublicData = useCanFetchPublicData();
+  const dispatch = useAppRouterDispatcher();
+  const combineResults = useCallback((results) => {
+    const errors = results.filter((x) => x.error).map((x) => x.error);
+    return {
+      data: results.map((x) => x.data),
+      errors,
+      hasErrors: errors.length > 0,
+      isReady: results.length === queries.length && results.every((x) => x.data)
+    };
+  }, [queries.length]);
+  const { data, errors: queriesErrors, hasErrors, isReady } = useQueries({
+    queries: queries.map((x) => ({
+      enabled: canFetchPublicData,
+      ...x
+    })),
+    combine: combineResults
+  });
+  useEffect(() => {
+    if (hasErrors) {
+      throw new GlobalDataQueriesError("[squide] Global public data queries failed.", queriesErrors);
+    }
+  }, [hasErrors, queriesErrors]);
+  const isReadyRef = useRef(false);
+  useEffect(() => {
+    if (isReadyRef.current && data) {
+      dispatch({ type: "public-data-updated" });
+    }
+  }, [data, dispatch]);
+  useEffect(() => {
+    if (isReady) {
+      isReadyRef.current = true;
+      dispatch({ type: "public-data-ready" });
+    }
+  }, [isReady, dispatch]);
+  return data;
+}
+
+export { usePublicDataQueries };

package/dist/chunk-WOPD33CM.js

@@ -0,0 +1,25 @@
+import { useRuntime, getLocalModuleRegistrationStatus, addLocalModuleRegistrationStatusChangedListener, removeLocalModuleRegistrationStatusChangedListener } from '@squide/core';
+import { getRemoteModuleRegistrationStatus, areModulesReady, addRemoteModuleRegistrationStatusChangedListener, removeRemoteModuleRegistrationStatusChangedListener } from '@squide/module-federation';
+import { useSyncExternalStore, useEffect } from 'react';
+
+// src/useStrictRegistrationMode.ts
+function subscribeToLocalModuleRegistrationStatusChanged(callback) {
+  addLocalModuleRegistrationStatusChangedListener(callback);
+  return () => removeLocalModuleRegistrationStatusChangedListener(callback);
+}
+function subscribeToRemoteModuleRegistrationStatusChanged(callback) {
+  addRemoteModuleRegistrationStatusChangedListener(callback);
+  return () => removeRemoteModuleRegistrationStatusChangedListener(callback);
+}
+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]);
+}
+
+export { useStrictRegistrationMode };

package/dist/chunk-WVRMJZV6.js

@@ -0,0 +1,18 @@
+import { useAppRouterState } from './chunk-G32YX2KR.js';
+
+// src/useCanUpdateDeferredRegistrations.ts
+function useCanUpdateDeferredRegistrations() {
+  const {
+    areModulesReady,
+    publicDataUpdatedAt,
+    protectedDataUpdatedAt,
+    deferredRegistrationsUpdatedAt
+  } = useAppRouterState();
+  return (
+    // Do not trigger an update if the deferred registrations has not been registered yet (if there are deferred registrations, once they are
+    // registered, the modules will be marked as ready).
+    areModulesReady && deferredRegistrationsUpdatedAt && (publicDataUpdatedAt && publicDataUpdatedAt > deferredRegistrationsUpdatedAt || protectedDataUpdatedAt && protectedDataUpdatedAt > deferredRegistrationsUpdatedAt)
+  );
+}
+
+export { useCanUpdateDeferredRegistrations };

package/dist/chunk-YRWFYWK4.js

@@ -0,0 +1,11 @@
+import { registerDeferredRegistrations } from '@squide/module-federation';
+import { useCallback } from 'react';
+
+// src/useRegisterDeferredRegistrations.ts
+function useRegisterDeferredRegistrations() {
+  return useCallback((data, runtime) => {
+    return registerDeferredRegistrations(data, runtime);
+  }, []);
+}
+
+export { useRegisterDeferredRegistrations };

package/dist/index.d.ts

@@ -2,9 +2,26 @@ export * from '@squide/core';
 export * from '@squide/module-federation';
 export * from '@squide/msw';
 export * from '@squide/react-router';
-export { AppRouter, AppRouterProps, BootstrappingRoute, OnCompleteRegistrationsFunction, OnLoadProtectedDataFunction, OnLoadPublicDataFunction, RenderRouterProviderFunction } from './AppRouter.js';
-export { FireflyRuntime, FireflyRuntimeOptions } from './fireflyRuntime.js';
-import 'react';
+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 { GlobalDataQueriesError, isGlobalDataQueriesError } from './GlobalDataQueriesError.js';
+export { useCanFetchProtectedData } from './useCanFetchProtectedData.js';
+export { useCanFetchPublicData } from './useCanFetchPublicData.js';
+export { useCanRegisterDeferredRegistrations } from './useCanRegisterDeferredRegistrations.js';
+export { useCanUpdateDeferredRegistrations } from './useCanUpdateDeferredRegistrations.js';
+export { DeferredRegistrationsErrorCallback, DeferredRegistrationsErrorsObject, UseDeferredRegistrationsOptions, useDeferredRegistrations } from './useDeferredRegistrations.js';
+export { useIsActiveRouteProtected } from './useIsActiveRouteProtected.js';
+export { useIsBootstrapping } from './useIsBootstrapping.js';
+export { useNavigationItems } from './useNavigationItems.js';
+export { IsUnauthorizedErrorCallback, useProtectedDataQueries } from './useProtectedDataQueries.js';
+export { usePublicDataQueries } from './usePublicDataQueries.js';
+export { useRegisterDeferredRegistrations } from './useRegisterDeferredRegistrations.js';
+export { useStrictRegistrationMode } from './useStrictRegistrationMode.js';
+export { useUpdateDeferredRegistrations } from './useUpdateDeferredRegistrations.js';
+import 'msw';
 import 'react/jsx-runtime';
+import 'react';
 import 'react-router-dom';
-import 'msw';
+import '@tanstack/react-query';

package/dist/index.js

@@ -1,5 +1,22 @@
-export { AppRouter, BootstrappingRoute } from './chunk-URNAUMUG.js';
-export { FireflyRuntime } from './chunk-YXMNS6U3.js';
+export { usePublicDataQueries } from './chunk-VUMBZ5BP.js';
+export { useCanFetchPublicData } from './chunk-IOMSOUAL.js';
+export { useDeferredRegistrations } from './chunk-2E76JVV7.js';
+export { useRegisterDeferredRegistrations } from './chunk-YRWFYWK4.js';
+export { useUpdateDeferredRegistrations } from './chunk-N2GOIQ5E.js';
+export { useCanRegisterDeferredRegistrations } from './chunk-PU7MASPN.js';
+export { useCanUpdateDeferredRegistrations } from './chunk-WVRMJZV6.js';
+export { useIsBootstrapping } from './chunk-I6L3AYOB.js';
+export { useNavigationItems } from './chunk-GXSW4CZS.js';
+export { useProtectedDataQueries } from './chunk-RG5N56BQ.js';
+export { AppRouter } from './chunk-36U4TTNR.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 { GlobalDataQueriesError, isGlobalDataQueriesError } from './chunk-HE5HKFL3.js';
+import './chunk-MZG2PJJG.js';
+export { useIsActiveRouteProtected } from './chunk-PP3MRMJJ.js';
+export { useCanFetchProtectedData } from './chunk-L5BP3WP3.js';
+export { AppRouterDispatcherContext, AppRouterStateContext, useAppRouterDispatcher, useAppRouterState } from './chunk-G32YX2KR.js';
 export * from '@squide/core';
 export * from '@squide/module-federation';
 export * from '@squide/msw';

package/dist/useCanFetchProtectedData.d.ts

@@ -0,0 +1,3 @@
+declare function useCanFetchProtectedData(): boolean;
+
+export { useCanFetchProtectedData };

package/dist/useCanFetchProtectedData.js

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

package/dist/useCanFetchPublicData.d.ts

@@ -0,0 +1,3 @@
+declare function useCanFetchPublicData(): boolean;
+
+export { useCanFetchPublicData };

package/dist/useCanFetchPublicData.js

@@ -0,0 +1,2 @@
+export { useCanFetchPublicData } from './chunk-IOMSOUAL.js';
+import './chunk-G32YX2KR.js';

package/dist/useCanRegisterDeferredRegistrations.d.ts

@@ -0,0 +1,3 @@
+declare function useCanRegisterDeferredRegistrations(): boolean;
+
+export { useCanRegisterDeferredRegistrations };

package/dist/useCanRegisterDeferredRegistrations.js

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

package/dist/useCanUpdateDeferredRegistrations.d.ts

@@ -0,0 +1,3 @@
+declare function useCanUpdateDeferredRegistrations(): boolean | 0 | undefined;
+
+export { useCanUpdateDeferredRegistrations };

package/dist/useCanUpdateDeferredRegistrations.js

@@ -0,0 +1,2 @@
+export { useCanUpdateDeferredRegistrations } from './chunk-WVRMJZV6.js';
+import './chunk-G32YX2KR.js';

package/dist/useDeferredRegistrations.d.ts

@@ -0,0 +1,13 @@
+import { ModuleRegistrationError } from '@squide/core';
+
+interface DeferredRegistrationsErrorsObject {
+    localModuleErrors: ModuleRegistrationError[];
+    remoteModuleErrors: ModuleRegistrationError[];
+}
+type DeferredRegistrationsErrorCallback = (errorsObject: DeferredRegistrationsErrorsObject) => void;
+interface UseDeferredRegistrationsOptions {
+    onError?: DeferredRegistrationsErrorCallback;
+}
+declare function useDeferredRegistrations(data: unknown, { onError }?: UseDeferredRegistrationsOptions): void;
+
+export { type DeferredRegistrationsErrorCallback, type DeferredRegistrationsErrorsObject, type UseDeferredRegistrationsOptions, useDeferredRegistrations };

package/dist/useDeferredRegistrations.js

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

package/dist/useIsActiveRouteProtected.d.ts

@@ -0,0 +1,3 @@
+declare function useIsActiveRouteProtected(areModulesReady: boolean): boolean;
+
+export { useIsActiveRouteProtected };

package/dist/useIsActiveRouteProtected.js

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

package/dist/useIsBootstrapping.d.ts

@@ -0,0 +1,3 @@
+declare function useIsBootstrapping(): boolean;
+
+export { useIsBootstrapping };

package/dist/useIsBootstrapping.js

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

package/dist/useNavigationItems.d.ts

@@ -0,0 +1,6 @@
+import * as _squide_react_router from '@squide/react-router';
+import { UseRuntimeNavigationItemsOptions } from '@squide/react-router';
+
+declare function useNavigationItems(options?: UseRuntimeNavigationItemsOptions): _squide_react_router.RootNavigationItem[];
+
+export { useNavigationItems };

package/dist/useNavigationItems.js

@@ -0,0 +1,2 @@
+export { useNavigationItems } from './chunk-GXSW4CZS.js';
+import './chunk-G32YX2KR.js';

package/dist/useProtectedDataQueries.d.ts

@@ -0,0 +1,9 @@
+import { QueriesOptions, QueriesResults, UseQueryResult } from '@tanstack/react-query';
+
+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 };

package/dist/useProtectedDataQueries.js

@@ -0,0 +1,4 @@
+export { useProtectedDataQueries } from './chunk-RG5N56BQ.js';
+import './chunk-HE5HKFL3.js';
+import './chunk-L5BP3WP3.js';
+import './chunk-G32YX2KR.js';

package/dist/usePublicDataQueries.d.ts

@@ -0,0 +1,8 @@
+import { QueriesOptions, QueriesResults, UseQueryResult } from '@tanstack/react-query';
+
+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 };

package/dist/usePublicDataQueries.js

@@ -0,0 +1,4 @@
+export { usePublicDataQueries } from './chunk-VUMBZ5BP.js';
+import './chunk-IOMSOUAL.js';
+import './chunk-HE5HKFL3.js';
+import './chunk-G32YX2KR.js';

package/dist/useRegisterDeferredRegistrations.d.ts

@@ -0,0 +1,9 @@
+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[];
+}>;
+
+export { useRegisterDeferredRegistrations };

package/dist/useRegisterDeferredRegistrations.js

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

package/dist/useStrictRegistrationMode.d.ts

@@ -0,0 +1,3 @@
+declare function useStrictRegistrationMode(): void;
+
+export { useStrictRegistrationMode };

package/dist/useStrictRegistrationMode.js

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

package/dist/useUpdateDeferredRegistrations.d.ts

@@ -0,0 +1,9 @@
+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[];
+}>;
+
+export { useUpdateDeferredRegistrations };

package/dist/useUpdateDeferredRegistrations.js

@@ -0,0 +1,2 @@
+export { useUpdateDeferredRegistrations } from './chunk-N2GOIQ5E.js';
+import './chunk-G32YX2KR.js';

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@squide/firefly",
   "author": "Workleap",
-  "version": "8.0.0",
-  "description": "Helpers to facilitate the creation of a shell package with Squide firefly technology stack.",
+  "version": "9.0.1",
+  "description": "Helpers to facilitate the creation of an application with the Squide firefly technology stack.",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -27,19 +27,19 @@
     "README.md"
   ],
   "peerDependencies": {
+    "@tanstack/react-query": "*",
     "msw": "*",
     "react": "*",
     "react-dom": "*",
-    "react-error-boundary": "*",
     "react-router-dom": "*"
   },
   "devDependencies": {
-    "@swc/core": "1.4.17",
+    "@swc/core": "1.7.0",
     "@swc/jest": "0.2.36",
-    "@testing-library/jest-dom": "6.4.2",
-    "@testing-library/react": "15.0.5",
+    "@testing-library/jest-dom": "6.4.6",
+    "@testing-library/react": "16.0.0",
     "@types/jest": "29.5.12",
-    "@types/react": "18.3.1",
+    "@types/react": "18.3.3",
     "@types/react-dom": "18.3.0",
     "@workleap/eslint-plugin": "3.2.2",
     "@workleap/swc-configs": "2.2.3",
@@ -48,20 +48,19 @@
     "eslint": "8.57.0",
     "jest": "29.7.0",
     "jest-environment-jsdom": "29.7.0",
-    "msw": "2.2.14",
+    "msw": "2.3.1",
     "react": "18.3.1",
     "react-dom": "18.3.1",
-    "react-error-boundary": "4.0.13",
-    "react-router-dom": "6.23.0",
-    "ts-jest": "29.1.2",
-    "tsup": "8.0.2",
-    "typescript": "5.4.5"
+    "react-router-dom": "6.25.1",
+    "ts-jest": "29.2.3",
+    "tsup": "8.1.2",
+    "typescript": "5.5.3"
   },
   "dependencies": {
-    "@squide/core": "4.0.0",
-    "@squide/module-federation": "5.0.0",
-    "@squide/msw": "2.0.14",
-    "@squide/react-router": "5.0.0"
+    "@squide/core": "5.0.1",
+    "@squide/module-federation": "6.0.1",
+    "@squide/msw": "3.0.1",
+    "@squide/react-router": "6.0.1"
   },
   "sideEffects": false,
   "engines": {