@squide/firefly 9.3.1 → 9.3.2

package/dist/GlobalDataQueriesError.d.ts

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

package/dist/GlobalDataQueriesError.js

@@ -1 +1,17 @@
-export { GlobalDataQueriesError, isGlobalDataQueriesError } from './chunk-HE5HKFL3.js';
+
+;// CONCATENATED MODULE: ./src/GlobalDataQueriesError.ts?__rslib_entry__
+class GlobalDataQueriesError extends Error {
+    #errors;
+    constructor(message, errors){
+        super(message);
+        this.#errors = errors;
+    }
+    get errors() {
+        return this.#errors;
+    }
+}
+function isGlobalDataQueriesError(error) {
+    return error !== undefined && error !== null && error instanceof GlobalDataQueriesError;
+}
+
+export { GlobalDataQueriesError, isGlobalDataQueriesError };

package/dist/RootRoute.d.ts

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

package/dist/RootRoute.js

@@ -1,3 +1,46 @@
-export { RootRoute } from './chunk-PMVN3U47.js';
-import './chunk-PP3MRMJJ.js';
-import './chunk-G32YX2KR.js';
+import * as __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime__ from "react/jsx-runtime";
+import * as __WEBPACK_EXTERNAL_MODULE_react__ from "react";
+import * as __WEBPACK_EXTERNAL_MODULE_react_router_dom__ from "react-router-dom";
+import * as __WEBPACK_EXTERNAL_MODULE__AppRouterContext_js__ from "./AppRouterContext.js";
+import * as __WEBPACK_EXTERNAL_MODULE__useIsActiveRouteProtected_js__ from "./useIsActiveRouteProtected.js";
+
+;// CONCATENATED MODULE: external "react/jsx-runtime"
+
+;// CONCATENATED MODULE: external "react"
+
+;// CONCATENATED MODULE: external "react-router-dom"
+
+;// CONCATENATED MODULE: external "./AppRouterContext.js"
+
+;// CONCATENATED MODULE: external "./useIsActiveRouteProtected.js"
+
+;// CONCATENATED MODULE: ./src/RootRoute.tsx?__rslib_entry__
+
+
+
+
+
+function RootRoute() {
+    const state = (0,__WEBPACK_EXTERNAL_MODULE__AppRouterContext_js__.useAppRouterState)();
+    const isActiveRouteProtected = (0,__WEBPACK_EXTERNAL_MODULE__useIsActiveRouteProtected_js__.useIsActiveRouteProtected)(state.areModulesReady);
+    const dispatch = (0,__WEBPACK_EXTERNAL_MODULE__AppRouterContext_js__.useAppRouterDispatcher)();
+    (0,__WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        // Dispatching the active route visibility must be done in a route because React Router's useLocation
+        // hook throws if it's not called from a child of the router component.
+        if (isActiveRouteProtected) {
+            dispatch({
+                type: "active-route-is-protected"
+            });
+        } else {
+            dispatch({
+                type: "active-route-is-public"
+            });
+        }
+    }, [
+        isActiveRouteProtected,
+        dispatch
+    ]);
+    return /*#__PURE__*/ (0,__WEBPACK_EXTERNAL_MODULE_react_jsx_runtime__.jsx)(__WEBPACK_EXTERNAL_MODULE_react_router_dom__.Outlet, {});
+}
+
+export { RootRoute };

package/dist/boostrap.d.ts

@@ -1,20 +1,15 @@
-import { RegisterModulesOptions, ModuleRegisterFunction, ModuleRegistrationError } from '@squide/core';
-import { RemoteDefinition, RemoteModuleRegistrationError } from '@squide/module-federation';
-import { FireflyRuntime } from './FireflyRuntime.js';
-import '@squide/react-router';
-import 'msw';
-
-declare const ApplicationBootstrappingStartedEvent = "squide-app-bootstrapping-started";
-type StartMswFunction<TRuntime = FireflyRuntime> = (runtime: TRuntime) => Promise<void>;
-interface BootstrapAppOptions<TRuntime extends FireflyRuntime = FireflyRuntime, TContext = unknown, TData = unknown> extends RegisterModulesOptions<TContext> {
+import { type ModuleRegisterFunction, type ModuleRegistrationError, type RegisterModulesOptions } from "@squide/core";
+import { type RemoteDefinition, type RemoteModuleRegistrationError } from "@squide/module-federation";
+import type { FireflyRuntime } from "./FireflyRuntime.tsx";
+export declare const ApplicationBootstrappingStartedEvent = "squide-app-bootstrapping-started";
+export type StartMswFunction<TRuntime = FireflyRuntime> = (runtime: TRuntime) => Promise<void>;
+export interface BootstrapAppOptions<TRuntime extends FireflyRuntime = FireflyRuntime, TContext = unknown, TData = unknown> extends RegisterModulesOptions<TContext> {
     localModules?: ModuleRegisterFunction<TRuntime, TContext, TData>[];
     remotes?: RemoteDefinition[];
     startMsw?: StartMswFunction<TRuntime>;
 }
-declare function bootstrap<TRuntime extends FireflyRuntime = FireflyRuntime, TContext = unknown, TData = unknown>(runtime: TRuntime, options?: BootstrapAppOptions<TRuntime, TContext, TData>): Promise<{
+export declare function bootstrap<TRuntime extends FireflyRuntime = FireflyRuntime, TContext = unknown, TData = unknown>(runtime: TRuntime, options?: BootstrapAppOptions<TRuntime, TContext, TData>): Promise<{
     localModuleErrors: ModuleRegistrationError[];
     remoteModuleErrors: RemoteModuleRegistrationError[];
 }>;
-declare function __resetBootstrapGuard(): void;
-
-export { ApplicationBootstrappingStartedEvent, type BootstrapAppOptions, type StartMswFunction, __resetBootstrapGuard, bootstrap };
+export declare function __resetBootstrapGuard(): void;

package/dist/boostrap.js

@@ -1 +1,52 @@
-export { ApplicationBootstrappingStartedEvent, __resetBootstrapGuard, bootstrap } from './chunk-ROE2YHN5.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__squide_msw__ from "@squide/msw";
+
+;// CONCATENATED MODULE: external "@squide/core"
+
+;// CONCATENATED MODULE: external "@squide/module-federation"
+
+;// CONCATENATED MODULE: external "@squide/msw"
+
+;// CONCATENATED MODULE: ./src/boostrap.ts?__rslib_entry__
+
+
+
+const ApplicationBootstrappingStartedEvent = "squide-app-bootstrapping-started";
+let isBootstrapped = false;
+async function bootstrap(runtime, options = {}) {
+    const { localModules = [], remotes = [], context, startMsw } = options;
+    if (isBootstrapped) {
+        throw new Error("[squide] A squide application can only be bootstrapped once. Did you call the \"bootstrap\" function twice?");
+    }
+    runtime.eventBus.dispatch(ApplicationBootstrappingStartedEvent);
+    let localModuleErrors = [];
+    let remoteModuleErrors = [];
+    localModuleErrors = await (0,__WEBPACK_EXTERNAL_MODULE__squide_core__.registerLocalModules)(localModules, runtime, {
+        context
+    });
+    remoteModuleErrors = await (0,__WEBPACK_EXTERNAL_MODULE__squide_module_federation__.registerRemoteModules)(remotes, runtime, {
+        context
+    });
+    if (runtime.isMswEnabled) {
+        if (!(0,__WEBPACK_EXTERNAL_MODULE__squide_core__.isFunction)(startMsw)) {
+            throw new Error("[squide] When MSW is enabled, the \"startMsw\" function must be provided.");
+        }
+        try {
+            await startMsw(runtime);
+            (0,__WEBPACK_EXTERNAL_MODULE__squide_msw__.setMswAsReady)();
+        } catch (error) {
+            runtime.logger.debug("[squide] An error occured while starting MSW.", error);
+        }
+    }
+    isBootstrapped = true;
+    return {
+        localModuleErrors,
+        remoteModuleErrors
+    };
+}
+function __resetBootstrapGuard() {
+    isBootstrapped = false;
+}
+
+export { ApplicationBootstrappingStartedEvent, __resetBootstrapGuard, bootstrap };

package/dist/index.d.ts

@@ -1,28 +1,23 @@
-export * from '@squide/core';
-export * from '@squide/module-federation';
-export * from '@squide/msw';
-export * from '@squide/react-router';
-export { FireflyRuntime, FireflyRuntimeOptions } from './FireflyRuntime.js';
-export { AppRouter, AppRouterProps, AppRouterRenderFunctionArgs, RenderRouterProviderFunction, RenderRouterProviderFunctionArgs } from './AppRouter.js';
-export { AppRouterDispatcherContext, AppRouterStateContext, useAppRouterDispatcher, useAppRouterState } from './AppRouterContext.js';
-export { ActiveRouteVisiblity, AppRouterAction, AppRouterActionType, AppRouterDispatch, AppRouterState, ApplicationBoostrappedEvent, DeferredRegistrationsUpdatedEvent, ModulesReadyEvent, ModulesRegisteredEvent, MswReadyEvent, ProtectedDataReadyEvent, ProtectedDataUpdatedEvent, PublicDataReadyEvent, PublicDataUpdatedEvent, __clearAppReducerDispatchProxy, __setAppReducerDispatchProxyFactory, getAreModulesReady, getAreModulesRegistered, useAppRouterReducer, useBootstrappingCompletedDispatcher, 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 { isApplicationBootstrapping, useIsBootstrapping } from './useIsBootstrapping.js';
-export { UseNavigationItemsOptions, useNavigationItems } from './useNavigationItems.js';
-export { IsUnauthorizedErrorCallback, ProtectedDataFetchFailedEvent, ProtectedDataFetchStartedEvent, useProtectedDataQueries } from './useProtectedDataQueries.js';
-export { PublicDataFetchFailedEvent, PublicDataFetchStartedEvent, usePublicDataQueries } from './usePublicDataQueries.js';
-export { useRegisterDeferredRegistrations } from './useRegisterDeferredRegistrations.js';
-export { useStrictRegistrationMode } from './useStrictRegistrationMode.js';
-export { useUpdateDeferredRegistrations } from './useUpdateDeferredRegistrations.js';
-export { ApplicationBootstrappingStartedEvent, BootstrapAppOptions, StartMswFunction, __resetBootstrapGuard, bootstrap } from './boostrap.js';
-import 'msw';
-import 'react/jsx-runtime';
-import 'react';
-import 'react-router-dom';
-import '@tanstack/react-query';
+export * from "@squide/core";
+export * from "@squide/module-federation";
+export * from "@squide/msw";
+export * from "@squide/react-router";
+export * from "./FireflyRuntime.tsx";
+export * from "./AppRouter.tsx";
+export * from "./AppRouterContext.ts";
+export * from "./AppRouterReducer.ts";
+export * from "./GlobalDataQueriesError.ts";
+export * from "./useCanFetchProtectedData.ts";
+export * from "./useCanFetchPublicData.ts";
+export * from "./useCanRegisterDeferredRegistrations.ts";
+export * from "./useCanUpdateDeferredRegistrations.ts";
+export * from "./useDeferredRegistrations.ts";
+export * from "./useIsActiveRouteProtected.ts";
+export * from "./useIsBootstrapping.ts";
+export * from "./useNavigationItems.ts";
+export * from "./useProtectedDataQueries.ts";
+export * from "./usePublicDataQueries.ts";
+export * from "./useRegisterDeferredRegistrations.ts";
+export * from "./useStrictRegistrationMode.ts";
+export * from "./useUpdateDeferredRegistrations.ts";
+export * from "./boostrap.ts";

package/dist/index.js

@@ -1,25 +1,49 @@
-export { useNavigationItems } from './chunk-GXSW4CZS.js';
-export { ProtectedDataFetchFailedEvent, ProtectedDataFetchStartedEvent, useProtectedDataQueries } from './chunk-MKTGJHQR.js';
-export { PublicDataFetchFailedEvent, PublicDataFetchStartedEvent, usePublicDataQueries } from './chunk-CTLPFYLM.js';
-export { useCanFetchProtectedData } from './chunk-XDWYPVAJ.js';
-export { useCanFetchPublicData } from './chunk-IOMSOUAL.js';
-export { useDeferredRegistrations } from './chunk-BFHHJOJT.js';
-export { useRegisterDeferredRegistrations } from './chunk-YRWFYWK4.js';
-export { useUpdateDeferredRegistrations } from './chunk-N2GOIQ5E.js';
-export { useCanRegisterDeferredRegistrations } from './chunk-4RUCDAUT.js';
-export { useCanUpdateDeferredRegistrations } from './chunk-WVRMJZV6.js';
-export { AppRouter } from './chunk-L44KFU57.js';
-export { useStrictRegistrationMode } from './chunk-WOPD33CM.js';
-export { FireflyRuntime } from './chunk-LC233OPR.js';
-export { ApplicationBoostrappedEvent, DeferredRegistrationsUpdatedEvent, ModulesReadyEvent, ModulesRegisteredEvent, MswReadyEvent, ProtectedDataReadyEvent, ProtectedDataUpdatedEvent, PublicDataReadyEvent, PublicDataUpdatedEvent, __clearAppReducerDispatchProxy, __setAppReducerDispatchProxyFactory, getAreModulesReady, getAreModulesRegistered, useAppRouterReducer, useBootstrappingCompletedDispatcher, useModuleRegistrationStatusDispatcher, useMswStatusDispatcher } from './chunk-JFMSLZ74.js';
-import './chunk-TURKCH7J.js';
-export { isApplicationBootstrapping, useIsBootstrapping } from './chunk-H2ILEMPE.js';
-export { GlobalDataQueriesError, isGlobalDataQueriesError } from './chunk-HE5HKFL3.js';
-import './chunk-PMVN3U47.js';
-export { useIsActiveRouteProtected } from './chunk-PP3MRMJJ.js';
-export { AppRouterDispatcherContext, AppRouterStateContext, useAppRouterDispatcher, useAppRouterState } from './chunk-G32YX2KR.js';
-export { ApplicationBootstrappingStartedEvent, __resetBootstrapGuard, bootstrap } from './chunk-ROE2YHN5.js';
-export * from '@squide/core';
-export * from '@squide/module-federation';
-export * from '@squide/msw';
-export * from '@squide/react-router';
+export * from "@squide/core";
+export * from "@squide/module-federation";
+export * from "@squide/msw";
+export * from "@squide/react-router";
+export * from "./FireflyRuntime.js";
+export * from "./AppRouter.js";
+export * from "./AppRouterContext.js";
+export * from "./AppRouterReducer.js";
+export * from "./GlobalDataQueriesError.js";
+export * from "./useCanFetchProtectedData.js";
+export * from "./useCanFetchPublicData.js";
+export * from "./useCanRegisterDeferredRegistrations.js";
+export * from "./useCanUpdateDeferredRegistrations.js";
+export * from "./useDeferredRegistrations.js";
+export * from "./useIsActiveRouteProtected.js";
+export * from "./useIsBootstrapping.js";
+export * from "./useNavigationItems.js";
+export * from "./useProtectedDataQueries.js";
+export * from "./usePublicDataQueries.js";
+export * from "./useRegisterDeferredRegistrations.js";
+export * from "./useStrictRegistrationMode.js";
+export * from "./useUpdateDeferredRegistrations.js";
+export * from "./boostrap.js";
+
+;// CONCATENATED MODULE: ./src/index.ts?__rslib_entry__
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

package/dist/useCanFetchProtectedData.d.ts

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

package/dist/useCanFetchProtectedData.js

@@ -1,2 +1,15 @@
-export { useCanFetchProtectedData } from './chunk-XDWYPVAJ.js';
-import './chunk-G32YX2KR.js';
+import * as __WEBPACK_EXTERNAL_MODULE__AppRouterContext_js__ from "./AppRouterContext.js";
+
+;// CONCATENATED MODULE: external "./AppRouterContext.js"
+
+;// CONCATENATED MODULE: ./src/useCanFetchProtectedData.ts?__rslib_entry__
+
+function useCanFetchProtectedData() {
+    const { waitForMsw, areModulesRegistered, areModulesReady, isMswReady, isProtectedDataReady, activeRouteVisibility } = (0,__WEBPACK_EXTERNAL_MODULE__AppRouterContext_js__.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) && activeRouteVisibility === "protected" && (!waitForMsw || isMswReady));
+}
+
+export { useCanFetchProtectedData };

package/dist/useCanFetchPublicData.d.ts

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

package/dist/useCanFetchPublicData.js

@@ -1,2 +1,15 @@
-export { useCanFetchPublicData } from './chunk-IOMSOUAL.js';
-import './chunk-G32YX2KR.js';
+import * as __WEBPACK_EXTERNAL_MODULE__AppRouterContext_js__ from "./AppRouterContext.js";
+
+;// CONCATENATED MODULE: external "./AppRouterContext.js"
+
+;// CONCATENATED MODULE: ./src/useCanFetchPublicData.ts?__rslib_entry__
+
+function useCanFetchPublicData() {
+    const { waitForMsw, areModulesRegistered, areModulesReady, isMswReady, isPublicDataReady } = (0,__WEBPACK_EXTERNAL_MODULE__AppRouterContext_js__.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/useCanRegisterDeferredRegistrations.d.ts

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

package/dist/useCanRegisterDeferredRegistrations.js

@@ -1,2 +1,12 @@
-export { useCanRegisterDeferredRegistrations } from './chunk-4RUCDAUT.js';
-import './chunk-G32YX2KR.js';
+import * as __WEBPACK_EXTERNAL_MODULE__AppRouterContext_js__ from "./AppRouterContext.js";
+
+;// CONCATENATED MODULE: external "./AppRouterContext.js"
+
+;// CONCATENATED MODULE: ./src/useCanRegisterDeferredRegistrations.ts?__rslib_entry__
+
+function useCanRegisterDeferredRegistrations() {
+    const { waitForPublicData, waitForProtectedData, areModulesReady, areModulesRegistered, isPublicDataReady, isProtectedDataReady, activeRouteVisibility, isUnauthorized } = (0,__WEBPACK_EXTERNAL_MODULE__AppRouterContext_js__.useAppRouterState)();
+    return !isUnauthorized && areModulesRegistered && !areModulesReady && (!waitForPublicData || isPublicDataReady) && (!waitForProtectedData || activeRouteVisibility === "public" || isProtectedDataReady);
+}
+
+export { useCanRegisterDeferredRegistrations };

package/dist/useCanUpdateDeferredRegistrations.d.ts

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

package/dist/useCanUpdateDeferredRegistrations.js

@@ -1,2 +1,14 @@
-export { useCanUpdateDeferredRegistrations } from './chunk-WVRMJZV6.js';
-import './chunk-G32YX2KR.js';
+import * as __WEBPACK_EXTERNAL_MODULE__AppRouterContext_js__ from "./AppRouterContext.js";
+
+;// CONCATENATED MODULE: external "./AppRouterContext.js"
+
+;// CONCATENATED MODULE: ./src/useCanUpdateDeferredRegistrations.ts?__rslib_entry__
+
+function useCanUpdateDeferredRegistrations() {
+    const { areModulesReady, publicDataUpdatedAt, protectedDataUpdatedAt, deferredRegistrationsUpdatedAt } = (0,__WEBPACK_EXTERNAL_MODULE__AppRouterContext_js__.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/useDeferredRegistrations.d.ts

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

package/dist/useDeferredRegistrations.js

@@ -1,6 +1,72 @@
-export { useDeferredRegistrations } from './chunk-BFHHJOJT.js';
-import './chunk-YRWFYWK4.js';
-import './chunk-N2GOIQ5E.js';
-import './chunk-4RUCDAUT.js';
-import './chunk-WVRMJZV6.js';
-import './chunk-G32YX2KR.js';
+import * as __WEBPACK_EXTERNAL_MODULE__squide_core__ from "@squide/core";
+import * as __WEBPACK_EXTERNAL_MODULE_react__ from "react";
+import * as __WEBPACK_EXTERNAL_MODULE__useCanRegisterDeferredRegistrations_js__ from "./useCanRegisterDeferredRegistrations.js";
+import * as __WEBPACK_EXTERNAL_MODULE__useCanUpdateDeferredRegistrations_js__ from "./useCanUpdateDeferredRegistrations.js";
+import * as __WEBPACK_EXTERNAL_MODULE__useRegisterDeferredRegistrations_js__ from "./useRegisterDeferredRegistrations.js";
+import * as __WEBPACK_EXTERNAL_MODULE__useUpdateDeferredRegistrations_js__ from "./useUpdateDeferredRegistrations.js";
+
+;// CONCATENATED MODULE: external "@squide/core"
+
+;// CONCATENATED MODULE: external "react"
+
+;// CONCATENATED MODULE: external "./useCanRegisterDeferredRegistrations.js"
+
+;// CONCATENATED MODULE: external "./useCanUpdateDeferredRegistrations.js"
+
+;// CONCATENATED MODULE: external "./useRegisterDeferredRegistrations.js"
+
+;// CONCATENATED MODULE: external "./useUpdateDeferredRegistrations.js"
+
+;// CONCATENATED MODULE: ./src/useDeferredRegistrations.ts?__rslib_entry__
+
+
+
+
+
+
+function hasError({ localModuleErrors, remoteModuleErrors }) {
+    return localModuleErrors.length > 0 || remoteModuleErrors.length > 0;
+}
+function useDeferredRegistrations(data, { onError } = {}) {
+    const runtime = (0,__WEBPACK_EXTERNAL_MODULE__squide_core__.useRuntime)();
+    const canRegisterDeferredRegistrations = (0,__WEBPACK_EXTERNAL_MODULE__useCanRegisterDeferredRegistrations_js__.useCanRegisterDeferredRegistrations)();
+    const canUpdateDeferredRegistrations = (0,__WEBPACK_EXTERNAL_MODULE__useCanUpdateDeferredRegistrations_js__.useCanUpdateDeferredRegistrations)();
+    const registerDeferredRegistrations = (0,__WEBPACK_EXTERNAL_MODULE__useRegisterDeferredRegistrations_js__.useRegisterDeferredRegistrations)();
+    const updateDeferredRegistrations = (0,__WEBPACK_EXTERNAL_MODULE__useUpdateDeferredRegistrations_js__.useUpdateDeferredRegistrations)();
+    (0,__WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        if (canRegisterDeferredRegistrations) {
+            const register = async ()=>{
+                const errors = await registerDeferredRegistrations(data, runtime);
+                if (hasError(errors) && onError) {
+                    onError(errors);
+                }
+            };
+            register();
+        }
+    }, [
+        canRegisterDeferredRegistrations,
+        registerDeferredRegistrations,
+        data,
+        onError,
+        runtime
+    ]);
+    (0,__WEBPACK_EXTERNAL_MODULE_react__.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/useExecuteOnce.d.ts

@@ -1,3 +1 @@
-declare function useExecuteOnce(fct: () => boolean, inline?: boolean): () => void;
-
-export { useExecuteOnce };
+export declare function useExecuteOnce(fct: () => boolean, inline?: boolean): () => void;

package/dist/useExecuteOnce.js

@@ -1 +1,27 @@
-export { useExecuteOnce } from './chunk-TURKCH7J.js';
+import * as __WEBPACK_EXTERNAL_MODULE_react__ from "react";
+
+;// CONCATENATED MODULE: external "react"
+
+;// CONCATENATED MODULE: ./src/useExecuteOnce.ts?__rslib_entry__
+
+// Not using useEffect or useLayoutEffect because this utility hook is often used to dispatch events
+// and it messed with the events dispatch order.
+function useExecuteOnce(fct, inline = false) {
+    const triggered = (0,__WEBPACK_EXTERNAL_MODULE_react__.useRef)(false);
+    const onceFct = (0,__WEBPACK_EXTERNAL_MODULE_react__.useCallback)(()=>{
+        if (!triggered.current) {
+            const result = fct();
+            if (result) {
+                triggered.current = true;
+            }
+        }
+    }, [
+        fct
+    ]);
+    if (inline) {
+        onceFct();
+    }
+    return onceFct;
+}
+
+export { useExecuteOnce };

package/dist/useIsActiveRouteProtected.d.ts

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

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[];