@squide/firefly 9.3.1 → 9.3.2

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.1",
+  "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.8.0",
+    "@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.0.1",
+    "@testing-library/react": "16.1.0",
     "@types/jest": "29.5.14",
-    "@types/react": "18.3.12",
-    "@types/react-dom": "18.3.1",
-    "@workleap/eslint-plugin": "3.2.3",
+    "@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.5.2",
-    "react": "18.3.1",
-    "react-dom": "18.3.1",
+    "msw": "2.6.9",
+    "react": "19.0.0",
+    "react-dom": "19.0.0",
     "react-router-dom": "6.27.0",
-    "ts-jest": "29.2.5",
-    "tsup": "8.3.5",
+    "ts-node": "10.9.2",
     "typescript": "5.5.4"
   },
-  "dependencies": {
-    "@squide/core": "5.4.1",
-    "@squide/module-federation": "6.2.1",
-    "@squide/msw": "3.2.1",
-    "@squide/react-router": "6.4.1"
-  },
   "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 };

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