@squide/firefly 9.3.0 → 9.3.2

package/dist/FireflyRuntime.js

@@ -1,5 +1,64 @@
-export { FireflyRuntime } from './chunk-CFNKNPS3.js';
-import './chunk-JFMSLZ74.js';
-import './chunk-TURKCH7J.js';
-import './chunk-H2ILEMPE.js';
-import './chunk-G32YX2KR.js';
+import * as __WEBPACK_EXTERNAL_MODULE__squide_msw__ from "@squide/msw";
+import * as __WEBPACK_EXTERNAL_MODULE__squide_react_router__ from "@squide/react-router";
+import * as __WEBPACK_EXTERNAL_MODULE__AppRouterReducer_js__ from "./AppRouterReducer.js";
+
+;// CONCATENATED MODULE: external "@squide/msw"
+
+;// CONCATENATED MODULE: external "@squide/react-router"
+
+;// CONCATENATED MODULE: external "./AppRouterReducer.js"
+
+;// CONCATENATED MODULE: ./src/FireflyRuntime.tsx?__rslib_entry__
+
+
+
+class FireflyRuntime extends __WEBPACK_EXTERNAL_MODULE__squide_react_router__.ReactRouterRuntime {
+    #useMsw;
+    constructor({ plugins, useMsw, ...options } = {}){
+        if (useMsw) {
+            super({
+                plugins: [
+                    ...plugins ?? [],
+                    (runtime)=>new __WEBPACK_EXTERNAL_MODULE__squide_msw__.MswPlugin(runtime)
+                ],
+                ...options
+            });
+            this.#useMsw = true;
+        } else {
+            super({
+                plugins,
+                ...options
+            });
+            this.#useMsw = false;
+        }
+    }
+    registerRequestHandlers(handlers) {
+        const mswPlugin = this.getPlugin(__WEBPACK_EXTERNAL_MODULE__squide_msw__.MswPluginName);
+        if (!mswPlugin) {
+            throw new Error("[squide] Cannot register the provided MSW request handlers because the runtime hasn't been initialized with MSW. Did you instanciate the FireflyRuntime with the \"useMsw\" option?");
+        }
+        if ((0,__WEBPACK_EXTERNAL_MODULE__AppRouterReducer_js__.getAreModulesRegistered)()) {
+            throw new Error("[squide] Cannot register an MSW request handlers once the modules are registered. Are you trying to register an MSW request handler in a deferred registration function? Only navigation items can be registered in a deferred registration function.");
+        }
+        mswPlugin.registerRequestHandlers(handlers);
+    }
+    // Must define a return type otherwise we get an "error TS2742: The inferred type of 'requestHandlers' cannot be named" error.
+    get requestHandlers() {
+        const mswPlugin = this.getPlugin(__WEBPACK_EXTERNAL_MODULE__squide_msw__.MswPluginName);
+        if (!mswPlugin) {
+            throw new Error("[squide] Cannot retrieve MSW request handlers because the runtime hasn't been initialized with MSW. Did you instanciate the FireflyRuntime with the \"useMsw\" option?");
+        }
+        return mswPlugin.requestHandlers;
+    }
+    registerRoute(route, options = {}) {
+        if ((0,__WEBPACK_EXTERNAL_MODULE__AppRouterReducer_js__.getAreModulesRegistered)()) {
+            throw new Error("[squide] Cannot register a route once the modules are registered. Are you trying to register a route in a deferred registration function? Only navigation items can be registered in a deferred registration function.");
+        }
+        super.registerRoute(route, options);
+    }
+    get isMswEnabled() {
+        return this.#useMsw;
+    }
+}
+
+export { FireflyRuntime };

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-IGJHKH2A.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-CFNKNPS3.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-IGJHKH2A.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;