@squide/firefly 9.3.0 → 9.3.2

package/dist/useIsActiveRouteProtected.js

@@ -1 +1,21 @@
-export { useIsActiveRouteProtected } from './chunk-PP3MRMJJ.js';
+import * as __WEBPACK_EXTERNAL_MODULE__squide_react_router__ from "@squide/react-router";
+import * as __WEBPACK_EXTERNAL_MODULE_react_router_dom__ from "react-router-dom";
+
+;// CONCATENATED MODULE: external "@squide/react-router"
+
+;// CONCATENATED MODULE: external "react-router-dom"
+
+;// CONCATENATED MODULE: ./src/useIsActiveRouteProtected.ts?__rslib_entry__
+
+
+function useIsActiveRouteProtected(areModulesReady) {
+    // 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 = (0,__WEBPACK_EXTERNAL_MODULE_react_router_dom__.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 = (0,__WEBPACK_EXTERNAL_MODULE__squide_react_router__.useRouteMatch)(location, {
+        throwWhenThereIsNoMatch: areModulesReady
+    });
+    return (0,__WEBPACK_EXTERNAL_MODULE__squide_react_router__.useIsRouteProtected)(activeRoute);
+}
+
+export { useIsActiveRouteProtected };

package/dist/useIsBootstrapping.d.ts

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

package/dist/useIsBootstrapping.js

@@ -1,2 +1,20 @@
-export { isApplicationBootstrapping, useIsBootstrapping } from './chunk-H2ILEMPE.js';
-import './chunk-G32YX2KR.js';
+import * as __WEBPACK_EXTERNAL_MODULE__AppRouterContext_js__ from "./AppRouterContext.js";
+
+;// CONCATENATED MODULE: external "./AppRouterContext.js"
+
+;// CONCATENATED MODULE: ./src/useIsBootstrapping.ts?__rslib_entry__
+
+function useIsBootstrapping() {
+    const state = (0,__WEBPACK_EXTERNAL_MODULE__AppRouterContext_js__.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);
+    // 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 && (!waitForMsw || isMswReady) && (!waitForPublicData || isPublicDataReady);
+    return !isAppReady && !flush;
+}
+
+export { isApplicationBootstrapping, useIsBootstrapping };

package/dist/useNavigationItems.d.ts

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

package/dist/useNavigationItems.js

@@ -1,2 +1,24 @@
-export { useNavigationItems } from './chunk-GXSW4CZS.js';
-import './chunk-G32YX2KR.js';
+import * as __WEBPACK_EXTERNAL_MODULE__squide_react_router__ from "@squide/react-router";
+import * as __WEBPACK_EXTERNAL_MODULE__AppRouterContext_js__ from "./AppRouterContext.js";
+
+;// CONCATENATED MODULE: external "@squide/react-router"
+
+;// CONCATENATED MODULE: external "./AppRouterContext.js"
+
+;// CONCATENATED MODULE: ./src/useNavigationItems.ts?__rslib_entry__
+
+
+function useNavigationItems(options) {
+    // 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.
+    (0,__WEBPACK_EXTERNAL_MODULE__AppRouterContext_js__.useAppRouterState)();
+    return (0,__WEBPACK_EXTERNAL_MODULE__squide_react_router__.useRuntimeNavigationItems)(options);
+}
+
+export { useNavigationItems };

package/dist/useProtectedDataQueries.d.ts

@@ -1,11 +1,9 @@
-import { QueriesOptions, QueriesResults, UseQueryResult } from '@tanstack/react-query';
-
-declare const ProtectedDataFetchStartedEvent = "squide-protected-data-fetch-started";
-declare const ProtectedDataFetchFailedEvent = "squide-protected-data-fetch-failed";
-type IsUnauthorizedErrorCallback = (error: unknown) => boolean;
+import { type QueriesOptions, type QueriesResults, type UseQueryResult } from "@tanstack/react-query";
+export declare const ProtectedDataFetchStartedEvent = "squide-protected-data-fetch-started";
+export declare const ProtectedDataFetchFailedEvent = "squide-protected-data-fetch-failed";
+export 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, ProtectedDataFetchFailedEvent, ProtectedDataFetchStartedEvent, useProtectedDataQueries };
+export declare function useProtectedDataQueries<T extends Array<any>>(queries: QueriesOptions<T>, isUnauthorizedError: IsUnauthorizedErrorCallback): MapUseQueryResultToData<QueriesResults<T>>;
+export {};

package/dist/useProtectedDataQueries.js

@@ -1,5 +1,124 @@
-export { ProtectedDataFetchFailedEvent, ProtectedDataFetchStartedEvent, useProtectedDataQueries } from './chunk-MKTGJHQR.js';
-import './chunk-XDWYPVAJ.js';
-import './chunk-TURKCH7J.js';
-import './chunk-HE5HKFL3.js';
-import './chunk-G32YX2KR.js';
+import * as __WEBPACK_EXTERNAL_MODULE__squide_core__ from "@squide/core";
+import * as __WEBPACK_EXTERNAL_MODULE__tanstack_react_query__ from "@tanstack/react-query";
+import * as __WEBPACK_EXTERNAL_MODULE_react__ from "react";
+import * as __WEBPACK_EXTERNAL_MODULE__AppRouterContext_js__ from "./AppRouterContext.js";
+import * as __WEBPACK_EXTERNAL_MODULE__GlobalDataQueriesError_js__ from "./GlobalDataQueriesError.js";
+import * as __WEBPACK_EXTERNAL_MODULE__useCanFetchProtectedData_js__ from "./useCanFetchProtectedData.js";
+import * as __WEBPACK_EXTERNAL_MODULE__useExecuteOnce_js__ from "./useExecuteOnce.js";
+
+;// CONCATENATED MODULE: external "@squide/core"
+
+;// CONCATENATED MODULE: external "@tanstack/react-query"
+
+;// CONCATENATED MODULE: external "react"
+
+;// CONCATENATED MODULE: external "./AppRouterContext.js"
+
+;// CONCATENATED MODULE: external "./GlobalDataQueriesError.js"
+
+;// CONCATENATED MODULE: external "./useCanFetchProtectedData.js"
+
+;// CONCATENATED MODULE: external "./useExecuteOnce.js"
+
+;// CONCATENATED MODULE: ./src/useProtectedDataQueries.ts?__rslib_entry__
+
+
+
+
+
+
+
+const ProtectedDataFetchStartedEvent = "squide-protected-data-fetch-started";
+const ProtectedDataFetchFailedEvent = "squide-protected-data-fetch-failed";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function useProtectedDataQueries(queries, isUnauthorizedError) {
+    const canFetchProtectedData = (0,__WEBPACK_EXTERNAL_MODULE__useCanFetchProtectedData_js__.useCanFetchProtectedData)();
+    const eventBus = (0,__WEBPACK_EXTERNAL_MODULE__squide_core__.useEventBus)();
+    const dispatch = (0,__WEBPACK_EXTERNAL_MODULE__AppRouterContext_js__.useAppRouterDispatcher)();
+    const combineResults = (0,__WEBPACK_EXTERNAL_MODULE_react__.useCallback)((results)=>{
+        const errors = results.filter((x)=>x.error).map((x)=>x.error);
+        const hasErrors = errors.length > 0;
+        return {
+            data: results.map((x)=>x.data),
+            errors,
+            hasErrors,
+            isReady: !hasErrors && !results.some((x)=>x.isPending)
+        };
+    }, []);
+    const { data, errors: queriesErrors, hasErrors, isReady } = (0,__WEBPACK_EXTERNAL_MODULE__tanstack_react_query__.useQueries)({
+        queries: queries.map((x)=>({
+                enabled: canFetchProtectedData,
+                ...x
+            })),
+        combine: combineResults
+    });
+    const { isProtectedDataReady, isUnauthorized } = (0,__WEBPACK_EXTERNAL_MODULE__AppRouterContext_js__.useAppRouterState)();
+    (0,__WEBPACK_EXTERNAL_MODULE__useExecuteOnce_js__.useExecuteOnce)((0,__WEBPACK_EXTERNAL_MODULE_react__.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 = (0,__WEBPACK_EXTERNAL_MODULE_react__.useRef)(false);
+    const dispatchReady = (0,__WEBPACK_EXTERNAL_MODULE__useExecuteOnce_js__.useExecuteOnce)((0,__WEBPACK_EXTERNAL_MODULE_react__.useCallback)(()=>{
+        if (isReady) {
+            isReadyRef.current = true;
+            dispatch({
+                type: "protected-data-ready"
+            });
+            return true;
+        }
+        return false;
+    }, [
+        isReady,
+        dispatch
+    ]));
+    (0,__WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        // State update must be executed in useEffect.
+        dispatchReady();
+    }, [
+        dispatchReady
+    ]);
+    (0,__WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        if (isReadyRef.current && data) {
+            dispatch({
+                type: "protected-data-updated"
+            });
+        }
+    }, [
+        data,
+        dispatch
+    ]);
+    (0,__WEBPACK_EXTERNAL_MODULE_react__.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 __WEBPACK_EXTERNAL_MODULE__GlobalDataQueriesError_js__.GlobalDataQueriesError("[squide] Global protected data queries failed.", queriesErrors);
+            }
+        }
+    }, [
+        hasErrors,
+        queriesErrors,
+        isProtectedDataReady,
+        isUnauthorized,
+        isUnauthorizedError,
+        dispatch,
+        eventBus
+    ]);
+    return data;
+}
+
+export { ProtectedDataFetchFailedEvent, ProtectedDataFetchStartedEvent, useProtectedDataQueries };

package/dist/usePublicDataQueries.d.ts

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

package/dist/usePublicDataQueries.js

@@ -1,5 +1,109 @@
-export { PublicDataFetchFailedEvent, PublicDataFetchStartedEvent, usePublicDataQueries } from './chunk-CTLPFYLM.js';
-import './chunk-IOMSOUAL.js';
-import './chunk-TURKCH7J.js';
-import './chunk-HE5HKFL3.js';
-import './chunk-G32YX2KR.js';
+import * as __WEBPACK_EXTERNAL_MODULE__squide_core__ from "@squide/core";
+import * as __WEBPACK_EXTERNAL_MODULE__tanstack_react_query__ from "@tanstack/react-query";
+import * as __WEBPACK_EXTERNAL_MODULE_react__ from "react";
+import * as __WEBPACK_EXTERNAL_MODULE__AppRouterContext_js__ from "./AppRouterContext.js";
+import * as __WEBPACK_EXTERNAL_MODULE__GlobalDataQueriesError_js__ from "./GlobalDataQueriesError.js";
+import * as __WEBPACK_EXTERNAL_MODULE__useCanFetchPublicData_js__ from "./useCanFetchPublicData.js";
+import * as __WEBPACK_EXTERNAL_MODULE__useExecuteOnce_js__ from "./useExecuteOnce.js";
+
+;// CONCATENATED MODULE: external "@squide/core"
+
+;// CONCATENATED MODULE: external "@tanstack/react-query"
+
+;// CONCATENATED MODULE: external "react"
+
+;// CONCATENATED MODULE: external "./AppRouterContext.js"
+
+;// CONCATENATED MODULE: external "./GlobalDataQueriesError.js"
+
+;// CONCATENATED MODULE: external "./useCanFetchPublicData.js"
+
+;// CONCATENATED MODULE: external "./useExecuteOnce.js"
+
+;// CONCATENATED MODULE: ./src/usePublicDataQueries.ts?__rslib_entry__
+
+
+
+
+
+
+
+const PublicDataFetchStartedEvent = "squide-public-data-fetch-started";
+const PublicDataFetchFailedEvent = "squide-public-data-fetch-failed";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function usePublicDataQueries(queries) {
+    const canFetchPublicData = (0,__WEBPACK_EXTERNAL_MODULE__useCanFetchPublicData_js__.useCanFetchPublicData)();
+    const eventBus = (0,__WEBPACK_EXTERNAL_MODULE__squide_core__.useEventBus)();
+    const dispatch = (0,__WEBPACK_EXTERNAL_MODULE__AppRouterContext_js__.useAppRouterDispatcher)();
+    const combineResults = (0,__WEBPACK_EXTERNAL_MODULE_react__.useCallback)((results)=>{
+        const errors = results.filter((x)=>x.error).map((x)=>x.error);
+        const hasErrors = errors.length > 0;
+        return {
+            data: results.map((x)=>x.data),
+            errors,
+            hasErrors,
+            isReady: !hasErrors && !results.some((x)=>x.isPending)
+        };
+    }, []);
+    const { data, errors: queriesErrors, hasErrors, isReady } = (0,__WEBPACK_EXTERNAL_MODULE__tanstack_react_query__.useQueries)({
+        queries: queries.map((x)=>({
+                enabled: canFetchPublicData,
+                ...x
+            })),
+        combine: combineResults
+    });
+    (0,__WEBPACK_EXTERNAL_MODULE__useExecuteOnce_js__.useExecuteOnce)((0,__WEBPACK_EXTERNAL_MODULE_react__.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 = (0,__WEBPACK_EXTERNAL_MODULE_react__.useRef)(false);
+    const dispatchReady = (0,__WEBPACK_EXTERNAL_MODULE__useExecuteOnce_js__.useExecuteOnce)((0,__WEBPACK_EXTERNAL_MODULE_react__.useCallback)(()=>{
+        if (isReady) {
+            isReadyRef.current = true;
+            dispatch({
+                type: "public-data-ready"
+            });
+            return true;
+        }
+        return false;
+    }, [
+        isReady,
+        dispatch
+    ]));
+    (0,__WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        // State update must be executed in useEffect.
+        dispatchReady();
+    }, [
+        dispatchReady
+    ]);
+    (0,__WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        if (isReadyRef.current && data) {
+            dispatch({
+                type: "public-data-updated"
+            });
+        }
+    }, [
+        data,
+        dispatch
+    ]);
+    (0,__WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        if (hasErrors) {
+            eventBus.dispatch(PublicDataFetchFailedEvent, queriesErrors);
+            throw new __WEBPACK_EXTERNAL_MODULE__GlobalDataQueriesError_js__.GlobalDataQueriesError("[squide] Global public data queries failed.", queriesErrors);
+        }
+    }, [
+        hasErrors,
+        queriesErrors,
+        eventBus
+    ]);
+    return data;
+}
+
+export { PublicDataFetchFailedEvent, PublicDataFetchStartedEvent, usePublicDataQueries };

package/dist/useRegisterDeferredRegistrations.d.ts

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

package/dist/useRegisterDeferredRegistrations.js

@@ -1 +1,17 @@
-export { useRegisterDeferredRegistrations } from './chunk-YRWFYWK4.js';
+import * as __WEBPACK_EXTERNAL_MODULE__squide_module_federation__ from "@squide/module-federation";
+import * as __WEBPACK_EXTERNAL_MODULE_react__ from "react";
+
+;// CONCATENATED MODULE: external "@squide/module-federation"
+
+;// CONCATENATED MODULE: external "react"
+
+;// CONCATENATED MODULE: ./src/useRegisterDeferredRegistrations.ts?__rslib_entry__
+
+
+function useRegisterDeferredRegistrations() {
+    return (0,__WEBPACK_EXTERNAL_MODULE_react__.useCallback)((data, runtime)=>{
+        return (0,__WEBPACK_EXTERNAL_MODULE__squide_module_federation__.registerDeferredRegistrations)(data, runtime);
+    }, []);
+}
+
+export { useRegisterDeferredRegistrations };

package/dist/useStrictRegistrationMode.d.ts

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

package/dist/useStrictRegistrationMode.js

@@ -1 +1,38 @@
-export { useStrictRegistrationMode } from './chunk-WOPD33CM.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_react__ from "react";
+
+;// CONCATENATED MODULE: external "@squide/core"
+
+;// CONCATENATED MODULE: external "@squide/module-federation"
+
+;// CONCATENATED MODULE: external "react"
+
+;// CONCATENATED MODULE: ./src/useStrictRegistrationMode.ts?__rslib_entry__
+
+
+
+function subscribeToLocalModuleRegistrationStatusChanged(callback) {
+    (0,__WEBPACK_EXTERNAL_MODULE__squide_core__.addLocalModuleRegistrationStatusChangedListener)(callback);
+    return ()=>(0,__WEBPACK_EXTERNAL_MODULE__squide_core__.removeLocalModuleRegistrationStatusChangedListener)(callback);
+}
+function subscribeToRemoteModuleRegistrationStatusChanged(callback) {
+    (0,__WEBPACK_EXTERNAL_MODULE__squide_module_federation__.addRemoteModuleRegistrationStatusChangedListener)(callback);
+    return ()=>(0,__WEBPACK_EXTERNAL_MODULE__squide_module_federation__.removeRemoteModuleRegistrationStatusChangedListener)(callback);
+}
+function useStrictRegistrationMode() {
+    const runtime = (0,__WEBPACK_EXTERNAL_MODULE__squide_core__.useRuntime)();
+    const localModuleStatus = (0,__WEBPACK_EXTERNAL_MODULE_react__.useSyncExternalStore)(subscribeToLocalModuleRegistrationStatusChanged, __WEBPACK_EXTERNAL_MODULE__squide_core__.getLocalModuleRegistrationStatus);
+    const remoteModuleStatus = (0,__WEBPACK_EXTERNAL_MODULE_react__.useSyncExternalStore)(subscribeToRemoteModuleRegistrationStatusChanged, __WEBPACK_EXTERNAL_MODULE__squide_module_federation__.getRemoteModuleRegistrationStatus);
+    (0,__WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        if ((0,__WEBPACK_EXTERNAL_MODULE__squide_module_federation__.areModulesReady)(localModuleStatus, remoteModuleStatus)) {
+            runtime._validateRegistrations();
+        }
+    }, [
+        runtime,
+        localModuleStatus,
+        remoteModuleStatus
+    ]);
+}
+
+export { useStrictRegistrationMode };

package/dist/useUpdateDeferredRegistrations.d.ts

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

package/dist/useUpdateDeferredRegistrations.js

@@ -1,2 +1,28 @@
-export { useUpdateDeferredRegistrations } from './chunk-N2GOIQ5E.js';
-import './chunk-G32YX2KR.js';
+import * as __WEBPACK_EXTERNAL_MODULE__squide_module_federation__ from "@squide/module-federation";
+import * as __WEBPACK_EXTERNAL_MODULE_react__ from "react";
+import * as __WEBPACK_EXTERNAL_MODULE__AppRouterContext_js__ from "./AppRouterContext.js";
+
+;// CONCATENATED MODULE: external "@squide/module-federation"
+
+;// CONCATENATED MODULE: external "react"
+
+;// CONCATENATED MODULE: external "./AppRouterContext.js"
+
+;// CONCATENATED MODULE: ./src/useUpdateDeferredRegistrations.ts?__rslib_entry__
+
+
+
+function useUpdateDeferredRegistrations() {
+    const dispatch = (0,__WEBPACK_EXTERNAL_MODULE__AppRouterContext_js__.useAppRouterDispatcher)();
+    return (0,__WEBPACK_EXTERNAL_MODULE_react__.useCallback)(async (data, runtime)=>{
+        const errors = await (0,__WEBPACK_EXTERNAL_MODULE__squide_module_federation__.updateDeferredRegistrations)(data, runtime);
+        dispatch({
+            type: "deferred-registrations-updated"
+        });
+        return errors;
+    }, [
+        dispatch
+    ]);
+}
+
+export { useUpdateDeferredRegistrations };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@squide/firefly",
   "author": "Workleap",
-  "version": "9.3.0",
+  "version": "9.3.2",
   "description": "Helpers to facilitate the creation of an application with the Squide firefly technology stack.",
   "license": "Apache-2.0",
   "repository": {
@@ -9,11 +9,11 @@
     "url": "git+https://github.com/gsoft-inc/wl-squide.git",
     "directory": "packages/firefly"
   },
+  "type": "module",
   "publishConfig": {
     "access": "public",
     "provenance": true
   },
-  "type": "module",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -33,41 +33,44 @@
     "react-dom": "*",
     "react-router-dom": "*"
   },
+  "dependencies": {
+    "@types/react": "19.0.1",
+    "@types/react-dom": "19.0.2",
+    "@squide/core": "5.4.1",
+    "@squide/module-federation": "6.2.1",
+    "@squide/msw": "3.2.1",
+    "@squide/react-router": "6.4.2"
+  },
   "devDependencies": {
-    "@swc/core": "1.7.26",
-    "@swc/jest": "0.2.36",
-    "@testing-library/jest-dom": "6.5.0",
-    "@testing-library/react": "16.0.1",
-    "@types/jest": "29.5.13",
-    "@types/react": "18.3.11",
-    "@types/react-dom": "18.3.0",
-    "@workleap/eslint-plugin": "3.2.2",
+    "@rsbuild/plugin-react": "1.1.0",
+    "@rslib/core": "0.1.4",
+    "@swc/core": "1.10.1",
+    "@swc/jest": "0.2.37",
+    "@testing-library/jest-dom": "6.6.3",
+    "@testing-library/react": "16.1.0",
+    "@types/jest": "29.5.14",
+    "@typescript-eslint/parser": "8.18.0",
+    "@workleap/eslint-plugin": "3.2.5",
     "@workleap/swc-configs": "2.2.3",
-    "@workleap/tsup-configs": "3.0.6",
     "@workleap/typescript-configs": "3.0.2",
     "eslint": "8.57.0",
     "jest": "29.7.0",
     "jest-environment-jsdom": "29.7.0",
-    "msw": "2.4.9",
-    "react": "18.3.1",
-    "react-dom": "18.3.1",
-    "react-router-dom": "6.26.2",
-    "ts-jest": "29.2.5",
-    "tsup": "8.3.0",
+    "msw": "2.6.9",
+    "react": "19.0.0",
+    "react-dom": "19.0.0",
+    "react-router-dom": "6.27.0",
+    "ts-node": "10.9.2",
     "typescript": "5.5.4"
   },
-  "dependencies": {
-    "@squide/core": "5.4.0",
-    "@squide/module-federation": "6.2.0",
-    "@squide/msw": "3.2.0",
-    "@squide/react-router": "6.4.0"
-  },
   "sideEffects": false,
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=21.1.0"
   },
   "scripts": {
-    "dev": "tsup --config ./tsup.dev.ts",
-    "build": "tsup --config ./tsup.build.ts"
+    "build": "rslib build --config ./rslib.build.ts",
+    "eslint": "eslint . --max-warnings=-0 --cache --cache-location node_modules/.cache/eslint",
+    "typecheck": "tsc",
+    "test": "jest"
   }
 }

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