@squide/firefly 10.0.1 → 12.0.0

package/dist/index.d.ts

@@ -2,6 +2,7 @@ export * from "@squide/core";
 export * from "@squide/module-federation";
 export * from "@squide/msw";
 export * from "@squide/react-router";
+export * from "./FireflyProvider.tsx";
 export * from "./FireflyRuntime.tsx";
 export * from "./AppRouter.tsx";
 export * from "./AppRouterContext.ts";
@@ -15,9 +16,11 @@ export * from "./useDeferredRegistrations.ts";
 export * from "./useIsActiveRouteProtected.ts";
 export * from "./useIsBootstrapping.ts";
 export * from "./useNavigationItems.ts";
+export * from "./useProtectedDataHandler.ts";
 export * from "./useProtectedDataQueries.ts";
+export * from "./usePublicDataHandler.ts";
 export * from "./usePublicDataQueries.ts";
 export * from "./useRegisterDeferredRegistrations.ts";
 export * from "./useStrictRegistrationMode.ts";
 export * from "./useUpdateDeferredRegistrations.ts";
-export * from "./boostrap.ts";
+export * from "./initializeFirefly.ts";

package/dist/index.js

@@ -2,6 +2,7 @@ export * from "@squide/core";
 export * from "@squide/module-federation";
 export * from "@squide/msw";
 export * from "@squide/react-router";
+export * from "./FireflyProvider.js";
 export * from "./FireflyRuntime.js";
 export * from "./AppRouter.js";
 export * from "./AppRouterContext.js";
@@ -15,12 +16,14 @@ export * from "./useDeferredRegistrations.js";
 export * from "./useIsActiveRouteProtected.js";
 export * from "./useIsBootstrapping.js";
 export * from "./useNavigationItems.js";
+export * from "./useProtectedDataHandler.js";
 export * from "./useProtectedDataQueries.js";
+export * from "./usePublicDataHandler.js";
 export * from "./usePublicDataQueries.js";
 export * from "./useRegisterDeferredRegistrations.js";
 export * from "./useStrictRegistrationMode.js";
 export * from "./useUpdateDeferredRegistrations.js";
-export * from "./boostrap.js";
+export * from "./initializeFirefly.js";
 
 ;// CONCATENATED MODULE: ./src/index.ts?__rslib_entry__
 
@@ -44,6 +47,9 @@ export * from "./boostrap.js";
 
 
 
+
+
+
 
 
 

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["webpack://@squide/firefly/./src/index.ts"],"sourcesContent":["export * from \"@squide/core\";\nexport * from \"@squide/module-federation\";\nexport * from \"@squide/msw\";\nexport * from \"@squide/react-router\";\n\nexport * from \"./FireflyRuntime.tsx\";\n\nexport * from \"./AppRouter.tsx\";\nexport * from \"./AppRouterContext.ts\";\nexport * from \"./AppRouterReducer.ts\";\n\nexport * from \"./GlobalDataQueriesError.ts\";\nexport * from \"./useCanFetchProtectedData.ts\";\nexport * from \"./useCanFetchPublicData.ts\";\nexport * from \"./useCanRegisterDeferredRegistrations.ts\";\nexport * from \"./useCanUpdateDeferredRegistrations.ts\";\nexport * from \"./useDeferredRegistrations.ts\";\nexport * from \"./useIsActiveRouteProtected.ts\";\nexport * from \"./useIsBootstrapping.ts\";\nexport * from \"./useNavigationItems.ts\";\nexport * from \"./useProtectedDataQueries.ts\";\nexport * from \"./usePublicDataQueries.ts\";\nexport * from \"./useRegisterDeferredRegistrations.ts\";\nexport * from \"./useStrictRegistrationMode.ts\";\nexport * from \"./useUpdateDeferredRegistrations.ts\";\n\nexport * from \"./boostrap.ts\";\n\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAA6B;AACa;AACd;AACS;AAEA;AAEL;AACM;AACA;AAEM;AACE;AACH;AACc;AACF;AACT;AACC;AACP;AACA;AACK;AACH;AACY;AACP;AACK;AAEtB"}
+{"version":3,"file":"index.js","sources":["webpack://@squide/firefly/./src/index.ts"],"sourcesContent":["export * from \"@squide/core\";\nexport * from \"@squide/module-federation\";\nexport * from \"@squide/msw\";\nexport * from \"@squide/react-router\";\n\nexport * from \"./FireflyProvider.tsx\";\nexport * from \"./FireflyRuntime.tsx\";\n\nexport * from \"./AppRouter.tsx\";\nexport * from \"./AppRouterContext.ts\";\nexport * from \"./AppRouterReducer.ts\";\n\nexport * from \"./GlobalDataQueriesError.ts\";\nexport * from \"./useCanFetchProtectedData.ts\";\nexport * from \"./useCanFetchPublicData.ts\";\nexport * from \"./useCanRegisterDeferredRegistrations.ts\";\nexport * from \"./useCanUpdateDeferredRegistrations.ts\";\nexport * from \"./useDeferredRegistrations.ts\";\nexport * from \"./useIsActiveRouteProtected.ts\";\nexport * from \"./useIsBootstrapping.ts\";\nexport * from \"./useNavigationItems.ts\";\nexport * from \"./useProtectedDataHandler.ts\";\nexport * from \"./useProtectedDataQueries.ts\";\nexport * from \"./usePublicDataHandler.ts\";\nexport * from \"./usePublicDataQueries.ts\";\nexport * from \"./useRegisterDeferredRegistrations.ts\";\nexport * from \"./useStrictRegistrationMode.ts\";\nexport * from \"./useUpdateDeferredRegistrations.ts\";\n\nexport * from \"./initializeFirefly.ts\";\n\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAA6B;AACa;AACd;AACS;AAEC;AACD;AAEL;AACM;AACA;AAEM;AACE;AACH;AACc;AACF;AACT;AACC;AACP;AACA;AACK;AACA;AACH;AACA;AACY;AACP;AACK;AAEb"}

package/dist/initializeFirefly.d.ts

@@ -0,0 +1,15 @@
+import { type ModuleRegisterFunction, type RegisterModulesOptions } from "@squide/core";
+import { type RemoteDefinition } from "@squide/module-federation";
+import { FireflyRuntime, type FireflyRuntimeOptions } from "./FireflyRuntime.tsx";
+export declare const ApplicationBootstrappingStartedEvent = "squide-app-bootstrapping-started";
+export type OnInitializationErrorFunction = (error: unknown) => void;
+export type StartMswFunction<TRuntime = FireflyRuntime> = (runtime: TRuntime) => Promise<void>;
+export interface InitializeFireflyOptions<TRuntime extends FireflyRuntime, TContext = unknown, TData = unknown> extends RegisterModulesOptions<TContext>, FireflyRuntimeOptions {
+    localModules?: ModuleRegisterFunction<TRuntime, TContext, TData>[];
+    remotes?: RemoteDefinition[];
+    startMsw?: StartMswFunction<FireflyRuntime>;
+    onError?: OnInitializationErrorFunction;
+}
+export declare function bootstrap<TRuntime extends FireflyRuntime = FireflyRuntime, TContext = unknown, TData = unknown>(runtime: TRuntime, options?: InitializeFireflyOptions<TRuntime, TContext, TData>): void;
+export declare function initializeFirefly<TContext = unknown, TData = unknown>(options?: InitializeFireflyOptions<FireflyRuntime, TContext, TData>): FireflyRuntime;
+export declare function __resetHasExecuteGuard(): void;

package/dist/initializeFirefly.js

@@ -0,0 +1,78 @@
+import * as __WEBPACK_EXTERNAL_MODULE__squide_core_7a405b8f__ from "@squide/core";
+import * as __WEBPACK_EXTERNAL_MODULE__squide_module_federation_054d2ec6__ from "@squide/module-federation";
+import * as __WEBPACK_EXTERNAL_MODULE__squide_msw_9f7e76df__ from "@squide/msw";
+import * as __WEBPACK_EXTERNAL_MODULE__FireflyRuntime_js_318ddfd4__ from "./FireflyRuntime.js";
+
+;// CONCATENATED MODULE: external "@squide/core"
+
+;// CONCATENATED MODULE: external "@squide/module-federation"
+
+;// CONCATENATED MODULE: external "@squide/msw"
+
+;// CONCATENATED MODULE: external "./FireflyRuntime.js"
+
+;// CONCATENATED MODULE: ./src/initializeFirefly.ts?__rslib_entry__
+
+
+
+
+const ApplicationBootstrappingStartedEvent = "squide-app-bootstrapping-started";
+function propagateRegistrationErrors(results, onError) {
+    if (results) {
+        if (results.status === "fulfilled") {
+            results.value.forEach((x)=>{
+                onError(x);
+            });
+        }
+    }
+}
+function bootstrap(runtime, options = {}) {
+    const { localModules = [], remotes = [], startMsw, onError, context } = options;
+    runtime.eventBus.dispatch(ApplicationBootstrappingStartedEvent);
+    Promise.allSettled([
+        (0,__WEBPACK_EXTERNAL_MODULE__squide_core_7a405b8f__.registerLocalModules)(localModules, runtime, {
+            context
+        }),
+        (0,__WEBPACK_EXTERNAL_MODULE__squide_module_federation_054d2ec6__.registerRemoteModules)(remotes, runtime, {
+            context
+        })
+    ]).then((results)=>{
+        if (runtime.isMswEnabled) {
+            if (!(0,__WEBPACK_EXTERNAL_MODULE__squide_core_7a405b8f__.isFunction)(startMsw)) {
+                throw new Error("[squide] When MSW is enabled, the \"startMsw\" function must be provided.");
+            }
+            startMsw(runtime).then(()=>{
+                (0,__WEBPACK_EXTERNAL_MODULE__squide_msw_9f7e76df__.setMswAsReady)();
+            }).catch((error)=>{
+                runtime.logger.debug("[squide] An error occured while starting MSW.", error);
+            });
+        }
+        if (onError) {
+            propagateRegistrationErrors(results[0], onError);
+            propagateRegistrationErrors(results[1], onError);
+        }
+    });
+}
+let hasExecuted = false;
+function initializeFirefly(options = {}) {
+    const { mode, useMsw, loggers, plugins } = options;
+    if (hasExecuted) {
+        throw new Error("[squide] A squide application can only be initialized once. Did you call the \"initializeSquide\" function twice?");
+    }
+    hasExecuted = true;
+    const runtime = new __WEBPACK_EXTERNAL_MODULE__FireflyRuntime_js_318ddfd4__.FireflyRuntime({
+        mode,
+        useMsw,
+        loggers,
+        plugins
+    });
+    bootstrap(runtime, options);
+    return runtime;
+}
+function __resetHasExecuteGuard() {
+    hasExecuted = false;
+}
+
+export { ApplicationBootstrappingStartedEvent, __resetHasExecuteGuard, bootstrap, initializeFirefly };
+
+//# sourceMappingURL=initializeFirefly.js.map

package/dist/initializeFirefly.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"initializeFirefly.js","sources":["webpack://@squide/firefly/./src/initializeFirefly.ts"],"sourcesContent":["import { isFunction, registerLocalModules, type ModuleRegisterFunction, type RegisterModulesOptions } from \"@squide/core\";\nimport { registerRemoteModules, type RemoteDefinition } from \"@squide/module-federation\";\nimport { setMswAsReady } from \"@squide/msw\";\nimport { FireflyRuntime, type FireflyRuntimeOptions } from \"./FireflyRuntime.tsx\";\n\nexport const ApplicationBootstrappingStartedEvent = \"squide-app-bootstrapping-started\";\n\nexport type OnInitializationErrorFunction = (error: unknown) => void;\n\nexport type StartMswFunction<TRuntime = FireflyRuntime> = (runtime: TRuntime) => Promise<void>;\n\nexport interface InitializeFireflyOptions<TRuntime extends FireflyRuntime, TContext = unknown, TData = unknown> extends RegisterModulesOptions<TContext>, FireflyRuntimeOptions {\n    localModules?: ModuleRegisterFunction<TRuntime, TContext, TData>[];\n    remotes?: RemoteDefinition[];\n    startMsw?: StartMswFunction<FireflyRuntime>;\n    onError?: OnInitializationErrorFunction;\n}\n\nfunction propagateRegistrationErrors(results: PromiseSettledResult<unknown[]>, onError: OnInitializationErrorFunction) {\n    if (results) {\n        if (results.status === \"fulfilled\") {\n            results.value.forEach(x => {\n                onError(x);\n            });\n        }\n    }\n}\n\nexport function bootstrap<TRuntime extends FireflyRuntime = FireflyRuntime, TContext = unknown, TData = unknown>(runtime: TRuntime, options: InitializeFireflyOptions<TRuntime, TContext, TData> = {}) {\n    const {\n        localModules = [],\n        remotes = [],\n        startMsw,\n        onError,\n        context\n    } = options;\n\n    runtime.eventBus.dispatch(ApplicationBootstrappingStartedEvent);\n\n    Promise.allSettled([\n        registerLocalModules<TRuntime, TContext, TData>(localModules, runtime, { context }),\n        registerRemoteModules(remotes, runtime, { context })\n    ]).then(results => {\n        if (runtime.isMswEnabled) {\n            if (!isFunction(startMsw)) {\n                throw new Error(\"[squide] When MSW is enabled, the \\\"startMsw\\\" function must be provided.\");\n            }\n\n            startMsw(runtime)\n                .then(() => {\n                    setMswAsReady();\n                })\n                .catch((error: unknown) => {\n                    runtime.logger.debug(\"[squide] An error occured while starting MSW.\", error);\n                });\n        }\n\n        if (onError) {\n            propagateRegistrationErrors(results[0], onError);\n            propagateRegistrationErrors(results[1], onError);\n        }\n    });\n}\n\nlet hasExecuted = false;\n\nexport function initializeFirefly<TContext = unknown, TData = unknown>(options: InitializeFireflyOptions<FireflyRuntime, TContext, TData> = {}) {\n    const {\n        mode,\n        useMsw,\n        loggers,\n        plugins\n    } = options;\n\n    if (hasExecuted) {\n        throw new Error(\"[squide] A squide application can only be initialized once. Did you call the \\\"initializeSquide\\\" function twice?\");\n    }\n\n    hasExecuted = true;\n\n    const runtime = new FireflyRuntime({\n        mode,\n        useMsw,\n        loggers,\n        plugins\n    });\n\n    bootstrap(runtime, options);\n\n    return runtime;\n}\n\nexport function __resetHasExecuteGuard() {\n    hasExecuted = false;\n}\n"],"names":["isFunction","registerLocalModules","registerRemoteModules","setMswAsReady","FireflyRuntime","ApplicationBootstrappingStartedEvent","propagateRegistrationErrors","results","onError","x","bootstrap","runtime","options","localModules","remotes","startMsw","context","Promise","Error","error","hasExecuted","initializeFirefly","mode","useMsw","loggers","plugins","__resetHasExecuteGuard"],"mappings":";;;;;;;;;;;;;;AAA0H;AACjC;AAC7C;AACsC;AAE3E,MAAMK,uCAAuC,mCAAmC;AAavF,SAASC,4BAA4BC,OAAwC,EAAEC,OAAsC;IACjH,IAAID,SAAS;QACT,IAAIA,QAAQ,MAAM,KAAK,aAAa;YAChCA,QAAQ,KAAK,CAAC,OAAO,CAACE,CAAAA;gBAClBD,QAAQC;YACZ;QACJ;IACJ;AACJ;AAEO,SAASC,UAAiGC,OAAiB,EAAEC,UAA+D,CAAC,CAAC;IACjM,MAAM,EACFC,eAAe,EAAE,EACjBC,UAAU,EAAE,EACZC,QAAQ,EACRP,OAAO,EACPQ,OAAO,EACV,GAAGJ;IAEJD,QAAQ,QAAQ,CAAC,QAAQ,CAACN;IAE1BY,QAAQ,UAAU,CAAC;QACfhB,0EAAoBA,CAA4BY,cAAcF,SAAS;YAAEK;QAAQ;QACjFd,wFAAqBA,CAACY,SAASH,SAAS;YAAEK;QAAQ;KACrD,EAAE,IAAI,CAACT,CAAAA;QACJ,IAAII,QAAQ,YAAY,EAAE;YACtB,IAAI,CAACX,gEAAUA,CAACe,WAAW;gBACvB,MAAM,IAAIG,MAAM;YACpB;YAEAH,SAASJ,SACJ,IAAI,CAAC;gBACFR,kEAAaA;YACjB,GACC,KAAK,CAAC,CAACgB;gBACJR,QAAQ,MAAM,CAAC,KAAK,CAAC,iDAAiDQ;YAC1E;QACR;QAEA,IAAIX,SAAS;YACTF,4BAA4BC,OAAO,CAAC,EAAE,EAAEC;YACxCF,4BAA4BC,OAAO,CAAC,EAAE,EAAEC;QAC5C;IACJ;AACJ;AAEA,IAAIY,cAAc;AAEX,SAASC,kBAAuDT,UAAqE,CAAC,CAAC;IAC1I,MAAM,EACFU,IAAI,EACJC,MAAM,EACNC,OAAO,EACPC,OAAO,EACV,GAAGb;IAEJ,IAAIQ,aAAa;QACb,MAAM,IAAIF,MAAM;IACpB;IAEAE,cAAc;IAEd,MAAMT,UAAU,IAAIP,sEAAcA,CAAC;QAC/BkB;QACAC;QACAC;QACAC;IACJ;IAEAf,UAAUC,SAASC;IAEnB,OAAOD;AACX;AAEO,SAASe;IACZN,cAAc;AAClB"}

package/dist/useCanFetchProtectedData.d.ts

@@ -1 +1,3 @@
+import type { ActiveRouteVisiblity } from "./AppRouterReducer.ts";
+export declare function canFetchProtectedData(waitForMsw: boolean, areModulesRegistered: boolean, areModulesReady: boolean, activeRouteVisibility: ActiveRouteVisiblity, isMswReady: boolean): boolean;
 export declare function useCanFetchProtectedData(): boolean;

package/dist/useCanFetchProtectedData.js

@@ -4,14 +4,19 @@ import * as __WEBPACK_EXTERNAL_MODULE__AppRouterContext_js_3c4a3c33__ from "./Ap
 
 ;// CONCATENATED MODULE: ./src/useCanFetchProtectedData.ts?__rslib_entry__
 
-function useCanFetchProtectedData() {
-    const { waitForMsw, areModulesRegistered, areModulesReady, isMswReady, isProtectedDataReady, activeRouteVisibility } = (0,__WEBPACK_EXTERNAL_MODULE__AppRouterContext_js_3c4a3c33__.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
+// This function is exported for external integration, like the integration
+// with the Platform Widgets. Do not remove.
+function canFetchProtectedData(waitForMsw, areModulesRegistered, areModulesReady, activeRouteVisibility, isMswReady) {
+    return(// 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));
 }
+function useCanFetchProtectedData() {
+    const { waitForMsw, areModulesRegistered, areModulesReady, isMswReady, isProtectedDataReady, activeRouteVisibility } = (0,__WEBPACK_EXTERNAL_MODULE__AppRouterContext_js_3c4a3c33__.useAppRouterState)();
+    // Always return true when the protected data has already been fetched sucessfully so TanStack Query can update the data in the background.
+    return isProtectedDataReady || canFetchProtectedData(waitForMsw, areModulesRegistered, areModulesReady, activeRouteVisibility, isMswReady);
+}
 
-export { useCanFetchProtectedData };
+export { canFetchProtectedData, useCanFetchProtectedData };
 
 //# sourceMappingURL=useCanFetchProtectedData.js.map

package/dist/useCanFetchProtectedData.js.map

@@ -1 +1 @@
-{"version":3,"file":"useCanFetchProtectedData.js","sources":["webpack://@squide/firefly/./src/useCanFetchProtectedData.ts"],"sourcesContent":["import { useAppRouterState } from \"./AppRouterContext.ts\";\n\nexport function useCanFetchProtectedData() {\n    const {\n        waitForMsw,\n        areModulesRegistered,\n        areModulesReady,\n        isMswReady,\n        isProtectedDataReady,\n        activeRouteVisibility\n    } = useAppRouterState();\n\n    return (\n        // Always return true when the protected data has already been fetched sucessfully so TanStack Query can update the data in the background.\n        isProtectedDataReady\n        || (\n            // Wait until the modules has been registered, but do not wait for the deferred registrations to be registered as they will probably\n            // depends on the protected data.\n            (areModulesRegistered || areModulesReady)\n            // Only fetch the protected data for protected routes, aka do not fetch the protected data for public routes.\n            && activeRouteVisibility === \"protected\"\n            // Wait for MSW since the endpoints for the protected data might be an MSW endpoint when in development.\n            && (!waitForMsw || isMswReady)\n        )\n    );\n}\n"],"names":["useAppRouterState","useCanFetchProtectedData","waitForMsw","areModulesRegistered","areModulesReady","isMswReady","isProtectedDataReady","activeRouteVisibility"],"mappings":";;;;;AAA0D;AAEnD,SAASC;IACZ,MAAM,EACFC,UAAU,EACVC,oBAAoB,EACpBC,eAAe,EACfC,UAAU,EACVC,oBAAoB,EACpBC,qBAAqB,EACxB,GAAGP,+EAAiBA;IAErB,OACI,2IAA2I;IAC3IM,wBAEI,oIAAoI;IACpI,iCAAiC;IAChCH,CAAAA,wBAAwBC,eAAc,KAEpCG,0BAA0B,eAEzB,EAACL,cAAcG,UAAS;AAGxC"}
+{"version":3,"file":"useCanFetchProtectedData.js","sources":["webpack://@squide/firefly/./src/useCanFetchProtectedData.ts"],"sourcesContent":["import { useAppRouterState } from \"./AppRouterContext.ts\";\nimport type { ActiveRouteVisiblity } from \"./AppRouterReducer.ts\";\n\n// This function is exported for external integration, like the integration\n// with the Platform Widgets. Do not remove.\nexport function canFetchProtectedData(\n    waitForMsw: boolean,\n    areModulesRegistered: boolean,\n    areModulesReady: boolean,\n    activeRouteVisibility: ActiveRouteVisiblity,\n    isMswReady: boolean\n) {\n    return (\n        // Wait until the modules has been registered, but do not wait for the deferred registrations to be registered as they will probably\n        // depends on the protected data.\n        (areModulesRegistered || areModulesReady)\n        // Only fetch the protected data for protected routes, aka do not fetch the protected data for public routes.\n        && activeRouteVisibility === \"protected\"\n        // Wait for MSW since the endpoints for the protected data might be an MSW endpoint when in development.\n        && (!waitForMsw || isMswReady)\n    );\n}\n\nexport function useCanFetchProtectedData() {\n    const {\n        waitForMsw,\n        areModulesRegistered,\n        areModulesReady,\n        isMswReady,\n        isProtectedDataReady,\n        activeRouteVisibility\n    } = useAppRouterState();\n\n    // Always return true when the protected data has already been fetched sucessfully so TanStack Query can update the data in the background.\n    return isProtectedDataReady || canFetchProtectedData(\n        waitForMsw,\n        areModulesRegistered,\n        areModulesReady,\n        activeRouteVisibility,\n        isMswReady\n    );\n}\n"],"names":["useAppRouterState","canFetchProtectedData","waitForMsw","areModulesRegistered","areModulesReady","activeRouteVisibility","isMswReady","useCanFetchProtectedData","isProtectedDataReady"],"mappings":";;;;;AAA0D;AAG1D,2EAA2E;AAC3E,4CAA4C;AACrC,SAASC,sBACZC,UAAmB,EACnBC,oBAA6B,EAC7BC,eAAwB,EACxBC,qBAA2C,EAC3CC,UAAmB;IAEnB,OACI,oIAAoI;IACpI,iCAAiC;IAChCH,CAAAA,wBAAwBC,eAAc,KAEpCC,0BAA0B,eAEzB,EAACH,cAAcI,UAAS;AAEpC;AAEO,SAASC;IACZ,MAAM,EACFL,UAAU,EACVC,oBAAoB,EACpBC,eAAe,EACfE,UAAU,EACVE,oBAAoB,EACpBH,qBAAqB,EACxB,GAAGL,+EAAiBA;IAErB,2IAA2I;IAC3I,OAAOQ,wBAAwBP,sBAC3BC,YACAC,sBACAC,iBACAC,uBACAC;AAER"}

package/dist/useIsBootstrapping.d.ts

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

package/dist/useIsBootstrapping.js

@@ -6,9 +6,9 @@ import * as __WEBPACK_EXTERNAL_MODULE__AppRouterContext_js_3c4a3c33__ from "./Ap
 
 function useIsBootstrapping() {
     const state = (0,__WEBPACK_EXTERNAL_MODULE__AppRouterContext_js_3c4a3c33__.useAppRouterState)();
-    return isApplicationBootstrapping(state);
+    return isBootstrapping(state);
 }
-function isApplicationBootstrapping(state) {
+function isBootstrapping(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.
@@ -17,6 +17,6 @@ function isApplicationBootstrapping(state) {
     return !isAppReady && !flush;
 }
 
-export { isApplicationBootstrapping, useIsBootstrapping };
+export { isBootstrapping, useIsBootstrapping };
 
 //# sourceMappingURL=useIsBootstrapping.js.map

package/dist/useIsBootstrapping.js.map

@@ -1 +1 @@
-{"version":3,"file":"useIsBootstrapping.js","sources":["webpack://@squide/firefly/./src/useIsBootstrapping.ts"],"sourcesContent":["import { useAppRouterState } from \"./AppRouterContext.ts\";\nimport type { AppRouterState } from \"./AppRouterReducer.ts\";\n\nexport function useIsBootstrapping() {\n    const state = useAppRouterState();\n\n    return isApplicationBootstrapping(state);\n}\n\nexport function isApplicationBootstrapping(state: AppRouterState) {\n    const {\n        waitForMsw,\n        waitForPublicData,\n        waitForProtectedData,\n        areModulesReady,\n        isMswReady,\n        isPublicDataReady,\n        isProtectedDataReady,\n        activeRouteVisibility,\n        isUnauthorized\n    } = state;\n\n    const isAppReady = (\n        !isUnauthorized\n        // Wait until the modules has been registered and the deferred registrations has been registered if any.\n        && areModulesReady\n        // Not required but can sometimes prevent a re-render when the state value is somehow updated after the initial data is ready.\n        && (!waitForMsw || isMswReady)\n        // Wait for the initial data to be ready.\n        && (!waitForPublicData || isPublicDataReady)\n        && (!waitForProtectedData || activeRouteVisibility === \"public\" || isProtectedDataReady)\n    );\n\n    // When an API request returns a 401, the bootstrapping should be bypassed to render the login page.\n    const flush = (\n        // Only applicable when there's a unauthorized request while fetching the initial data.\n        isUnauthorized\n        // Not required but can sometimes prevent a re-render when the state value is somehow updated after the public data is ready.\n        && (!waitForMsw || isMswReady)\n        // If the application is loading public data, we want to wait for this data to be ready to prevent a re-render.\n        && (!waitForPublicData || isPublicDataReady)\n    );\n\n    return !isAppReady && !flush;\n}\n"],"names":["useAppRouterState","useIsBootstrapping","state","isApplicationBootstrapping","waitForMsw","waitForPublicData","waitForProtectedData","areModulesReady","isMswReady","isPublicDataReady","isProtectedDataReady","activeRouteVisibility","isUnauthorized","isAppReady","flush"],"mappings":";;;;;AAA0D;AAGnD,SAASC;IACZ,MAAMC,QAAQF,+EAAiBA;IAE/B,OAAOG,2BAA2BD;AACtC;AAEO,SAASC,2BAA2BD,KAAqB;IAC5D,MAAM,EACFE,UAAU,EACVC,iBAAiB,EACjBC,oBAAoB,EACpBC,eAAe,EACfC,UAAU,EACVC,iBAAiB,EACjBC,oBAAoB,EACpBC,qBAAqB,EACrBC,cAAc,EACjB,GAAGV;IAEJ,MAAMW,aACF,CAACD,kBAEEL,mBAEC,EAACH,cAAcI,UAAS,KAExB,EAACH,qBAAqBI,iBAAgB,KACtC,EAACH,wBAAwBK,0BAA0B,YAAYD,oBAAmB;IAG1F,oGAAoG;IACpG,MAAMI,QACF,uFAAuF;IACvFF,kBAEI,EAACR,cAAcI,UAAS,KAExB,EAACH,qBAAqBI,iBAAgB;IAG9C,OAAO,CAACI,cAAc,CAACC;AAC3B"}
+{"version":3,"file":"useIsBootstrapping.js","sources":["webpack://@squide/firefly/./src/useIsBootstrapping.ts"],"sourcesContent":["import { useAppRouterState } from \"./AppRouterContext.ts\";\nimport type { AppRouterState } from \"./AppRouterReducer.ts\";\n\nexport function useIsBootstrapping() {\n    const state = useAppRouterState();\n\n    return isBootstrapping(state);\n}\n\nexport function isBootstrapping(state: AppRouterState) {\n    const {\n        waitForMsw,\n        waitForPublicData,\n        waitForProtectedData,\n        areModulesReady,\n        isMswReady,\n        isPublicDataReady,\n        isProtectedDataReady,\n        activeRouteVisibility,\n        isUnauthorized\n    } = state;\n\n    const isAppReady = (\n        !isUnauthorized\n        // Wait until the modules has been registered and the deferred registrations has been registered if any.\n        && areModulesReady\n        // Not required but can sometimes prevent a re-render when the state value is somehow updated after the initial data is ready.\n        && (!waitForMsw || isMswReady)\n        // Wait for the initial data to be ready.\n        && (!waitForPublicData || isPublicDataReady)\n        && (!waitForProtectedData || activeRouteVisibility === \"public\" || isProtectedDataReady)\n    );\n\n    // When an API request returns a 401, the bootstrapping should be bypassed to render the login page.\n    const flush = (\n        // Only applicable when there's a unauthorized request while fetching the initial data.\n        isUnauthorized\n        // Not required but can sometimes prevent a re-render when the state value is somehow updated after the public data is ready.\n        && (!waitForMsw || isMswReady)\n        // If the application is loading public data, we want to wait for this data to be ready to prevent a re-render.\n        && (!waitForPublicData || isPublicDataReady)\n    );\n\n    return !isAppReady && !flush;\n}\n"],"names":["useAppRouterState","useIsBootstrapping","state","isBootstrapping","waitForMsw","waitForPublicData","waitForProtectedData","areModulesReady","isMswReady","isPublicDataReady","isProtectedDataReady","activeRouteVisibility","isUnauthorized","isAppReady","flush"],"mappings":";;;;;AAA0D;AAGnD,SAASC;IACZ,MAAMC,QAAQF,+EAAiBA;IAE/B,OAAOG,gBAAgBD;AAC3B;AAEO,SAASC,gBAAgBD,KAAqB;IACjD,MAAM,EACFE,UAAU,EACVC,iBAAiB,EACjBC,oBAAoB,EACpBC,eAAe,EACfC,UAAU,EACVC,iBAAiB,EACjBC,oBAAoB,EACpBC,qBAAqB,EACrBC,cAAc,EACjB,GAAGV;IAEJ,MAAMW,aACF,CAACD,kBAEEL,mBAEC,EAACH,cAAcI,UAAS,KAExB,EAACH,qBAAqBI,iBAAgB,KACtC,EAACH,wBAAwBK,0BAA0B,YAAYD,oBAAmB;IAG1F,oGAAoG;IACpG,MAAMI,QACF,uFAAuF;IACvFF,kBAEI,EAACR,cAAcI,UAAS,KAExB,EAACH,qBAAqBI,iBAAgB;IAG9C,OAAO,CAACI,cAAc,CAACC;AAC3B"}

package/dist/useProtectedDataHandler.d.ts

@@ -0,0 +1 @@
+export declare function useProtectedDataHandler(handler: () => void): void;

package/dist/useProtectedDataHandler.js

@@ -0,0 +1,25 @@
+import * as __WEBPACK_EXTERNAL_MODULE_react__ from "react";
+import * as __WEBPACK_EXTERNAL_MODULE__useCanFetchProtectedData_js_52158d16__ from "./useCanFetchProtectedData.js";
+
+;// CONCATENATED MODULE: external "react"
+
+;// CONCATENATED MODULE: external "./useCanFetchProtectedData.js"
+
+;// CONCATENATED MODULE: ./src/useProtectedDataHandler.ts?__rslib_entry__
+
+
+function useProtectedDataHandler(handler) {
+    const canFetchProtectedData = (0,__WEBPACK_EXTERNAL_MODULE__useCanFetchProtectedData_js_52158d16__.useCanFetchProtectedData)();
+    (0,__WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        if (canFetchProtectedData) {
+            handler();
+        }
+    }, [
+        canFetchProtectedData,
+        handler
+    ]);
+}
+
+export { useProtectedDataHandler };
+
+//# sourceMappingURL=useProtectedDataHandler.js.map

package/dist/useProtectedDataHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useProtectedDataHandler.js","sources":["webpack://@squide/firefly/./src/useProtectedDataHandler.ts"],"sourcesContent":["import { useEffect } from \"react\";\nimport { useCanFetchProtectedData } from \"./useCanFetchProtectedData.ts\";\n\nexport function useProtectedDataHandler(handler: () => void) {\n    const canFetchProtectedData = useCanFetchProtectedData();\n\n    useEffect(() => {\n        if (canFetchProtectedData) {\n            handler();\n        }\n    }, [canFetchProtectedData, handler]);\n}\n"],"names":["useEffect","useCanFetchProtectedData","useProtectedDataHandler","handler","canFetchProtectedData"],"mappings":";;;;;;;;AAAkC;AACuC;AAElE,SAASE,wBAAwBC,OAAmB;IACvD,MAAMC,wBAAwBH,8FAAwBA;IAEtDD,+CAASA,CAAC;QACN,IAAII,uBAAuB;YACvBD;QACJ;IACJ,GAAG;QAACC;QAAuBD;KAAQ;AACvC"}

package/dist/usePublicDataHandler.d.ts

@@ -0,0 +1 @@
+export declare function usePublicDataHandler(handler: () => void): void;

package/dist/usePublicDataHandler.js

@@ -0,0 +1,25 @@
+import * as __WEBPACK_EXTERNAL_MODULE_react__ from "react";
+import * as __WEBPACK_EXTERNAL_MODULE__useCanFetchPublicData_js_b8d90132__ from "./useCanFetchPublicData.js";
+
+;// CONCATENATED MODULE: external "react"
+
+;// CONCATENATED MODULE: external "./useCanFetchPublicData.js"
+
+;// CONCATENATED MODULE: ./src/usePublicDataHandler.ts?__rslib_entry__
+
+
+function usePublicDataHandler(handler) {
+    const canFetchPublicData = (0,__WEBPACK_EXTERNAL_MODULE__useCanFetchPublicData_js_b8d90132__.useCanFetchPublicData)();
+    (0,__WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        if (canFetchPublicData) {
+            handler();
+        }
+    }, [
+        canFetchPublicData,
+        handler
+    ]);
+}
+
+export { usePublicDataHandler };
+
+//# sourceMappingURL=usePublicDataHandler.js.map

package/dist/usePublicDataHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePublicDataHandler.js","sources":["webpack://@squide/firefly/./src/usePublicDataHandler.ts"],"sourcesContent":["import { useEffect } from \"react\";\nimport { useCanFetchPublicData } from \"./useCanFetchPublicData.ts\";\n\nexport function usePublicDataHandler(handler: () => void) {\n    const canFetchPublicData = useCanFetchPublicData();\n\n    useEffect(() => {\n        if (canFetchPublicData) {\n            handler();\n        }\n    }, [canFetchPublicData, handler]);\n}\n"],"names":["useEffect","useCanFetchPublicData","usePublicDataHandler","handler","canFetchPublicData"],"mappings":";;;;;;;;AAAkC;AACiC;AAE5D,SAASE,qBAAqBC,OAAmB;IACpD,MAAMC,qBAAqBH,wFAAqBA;IAEhDD,+CAASA,CAAC;QACN,IAAII,oBAAoB;YACpBD;QACJ;IACJ,GAAG;QAACC;QAAoBD;KAAQ;AACpC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@squide/firefly",
   "author": "Workleap",
-  "version": "10.0.1",
+  "version": "12.0.0",
   "description": "Helpers to facilitate the creation of an application with the Squide firefly technology stack.",
   "license": "Apache-2.0",
   "repository": {
@@ -37,10 +37,10 @@
   "dependencies": {
     "@types/react": "19.0.10",
     "@types/react-dom": "19.0.4",
-    "@squide/core": "5.4.3",
-    "@squide/module-federation": "6.2.3",
-    "@squide/msw": "3.2.3",
-    "@squide/react-router": "7.0.1"
+    "@squide/core": "5.4.5",
+    "@squide/module-federation": "6.2.5",
+    "@squide/react-router": "7.0.3",
+    "@squide/msw": "3.2.5"
   },
   "devDependencies": {
     "@rsbuild/core": "1.2.19",

package/src/AppRouter.tsx

@@ -3,7 +3,7 @@ import { useRoutes, type Route } from "@squide/react-router";
 import { useEffect, useMemo, type ReactElement } from "react";
 import type { RouterProviderProps } from "react-router/dom";
 import { AppRouterDispatcherContext, AppRouterStateContext } from "./AppRouterContext.ts";
-import { useAppRouterReducer } from "./AppRouterReducer.ts";
+import { useAppRouterReducer, type AppRouterState } from "./AppRouterReducer.ts";
 import { RootRoute } from "./RootRoute.tsx";
 import { useStrictRegistrationMode } from "./useStrictRegistrationMode.ts";
 
@@ -19,8 +19,35 @@ export interface RenderRouterProviderFunctionArgs {
 
 export type RenderRouterProviderFunction = (args: RenderRouterProviderFunctionArgs) => ReactElement;
 
+export function useCanRenderRouter({ areModulesRegistered, areModulesReady: areModulesReadyValue }: AppRouterState) {
+    return (
+        // 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 || areModulesReadyValue)
+    );
+}
+
+function useRenderRouterProvider(state: AppRouterState, renderRouterProvider: RenderRouterProviderFunction) {
+    const routes = useRoutes();
+
+    // The value is computed outside of the router provider memo to prevent
+    // rendering a new router provider everytime the app router state change.
+    const canRenderRouter = useCanRenderRouter(state);
+
+    return useMemo(() => {
+        if (canRenderRouter) {
+            return renderRouterProvider({
+                rootRoute: <RootRoute />,
+                registeredRoutes: routes,
+                routerProviderProps: {}
+            });
+        }
+
+        return null;
+    }, [canRenderRouter, routes, renderRouterProvider]);
+}
+
 export interface AppRouterProps {
-    waitForMsw: boolean;
     waitForPublicData?: boolean;
     waitForProtectedData?: boolean;
     children: RenderRouterProviderFunction;
@@ -28,16 +55,13 @@ export interface AppRouterProps {
 
 export function AppRouter(props: AppRouterProps) {
     const {
-        waitForMsw,
         waitForPublicData = false,
         waitForProtectedData = false,
         children: renderRouterProvider
     } = props;
-
-    const [state, dispatch] = useAppRouterReducer(waitForMsw, waitForPublicData, waitForProtectedData);
+    const [state, dispatch] = useAppRouterReducer(waitForPublicData, waitForProtectedData);
 
     const logger = useLogger();
-    const routes = useRoutes();
 
     useStrictRegistrationMode();
 
@@ -45,13 +69,7 @@ export function AppRouter(props: AppRouterProps) {
         logger.debug("[squide] AppRouter state updated:", state);
     }, [state, logger]);
 
-    const routerProvider = useMemo(() => {
-        return renderRouterProvider({
-            rootRoute: <RootRoute />,
-            registeredRoutes: routes,
-            routerProviderProps: {}
-        });
-    }, [routes, renderRouterProvider]);
+    const routerProvider = useRenderRouterProvider(state, renderRouterProvider);
 
     return (
         <AppRouterDispatcherContext.Provider value={dispatch}>

package/src/AppRouterReducer.ts

@@ -1,9 +1,10 @@
-import { addLocalModuleRegistrationStatusChangedListener, getLocalModuleRegistrationStatus, removeLocalModuleRegistrationStatusChangedListener, useEventBus, useLogger } from "@squide/core";
+import { addLocalModuleRegistrationStatusChangedListener, getLocalModuleRegistrationStatus, removeLocalModuleRegistrationStatusChangedListener, useEventBus, useLogger, useRuntime } from "@squide/core";
 import { addRemoteModuleRegistrationStatusChangedListener, areModulesReady, areModulesRegistered, getRemoteModuleRegistrationStatus, removeRemoteModuleRegistrationStatusChangedListener } from "@squide/module-federation";
 import { addMswStateChangedListener, isMswReady, removeMswStateChangedListener } from "@squide/msw";
 import { useCallback, useEffect, useMemo, useReducer, type Dispatch } from "react";
+import type { FireflyRuntime } from "./FireflyRuntime.tsx";
 import { useExecuteOnce } from "./useExecuteOnce.ts";
-import { isApplicationBootstrapping } from "./useIsBootstrapping.ts";
+import { isBootstrapping } from "./useIsBootstrapping.ts";
 
 export type ActiveRouteVisiblity = "unknown" | "public" | "protected";
 
@@ -41,6 +42,8 @@ export type AppRouterActionType =
 export const ModulesRegisteredEvent = "squide-modules-registered";
 export const ModulesReadyEvent = "squide-modules-ready";
 export const MswReadyEvent = "squide-msw-ready";
+export const ActiveRouteIsPublicEvent = "squide-active-route-is-public";
+export const ActiveRouteIsProtectedEvent = "squide-active-route-is-protected";
 export const PublicDataReadyEvent = "squide-public-data-ready";
 export const ProtectedDataReadyEvent = "squide-protected-data-ready";
 export const PublicDataUpdatedEvent = "squide-public-data-updated";
@@ -250,7 +253,7 @@ export function useBootstrappingCompletedDispatcher(state: AppRouterState) {
     const eventBus = useEventBus();
 
     const areModulesRegisteredValue = state.areModulesRegistered;
-    const isBoostrapping = isApplicationBootstrapping(state);
+    const isBoostrapping = isBootstrapping(state);
 
     useExecuteOnce(useCallback(() => {
         if (areModulesRegisteredValue && !isBoostrapping) {
@@ -282,18 +285,21 @@ function useReducerDispatchProxy(reactDispatch: AppRouterDispatch) {
 }
 
 function useEnhancedReducerDispatch(reducerDispatch: AppRouterDispatch) {
-    const logger = useLogger();
-    const eventBus = useEventBus();
+    const runtime = useRuntime() as FireflyRuntime;
 
     return useCallback((action: AppRouterAction) => {
-        logger.debug("[squide] The following action has been dispatched to the AppRouter reducer:", action);
-        eventBus.dispatch(`squide-${action.type}`);
+        runtime.logger.debug("[squide] The following action has been dispatched to the AppRouter reducer:", action);
+
+        runtime.appRouterStore.dispatch(action);
+        runtime.eventBus.dispatch(`squide-${action.type}`);
 
         reducerDispatch(action);
-    }, [reducerDispatch, logger, eventBus]);
+    }, [reducerDispatch, runtime]);
 }
 
-export function useAppRouterReducer(waitForMsw: boolean, waitForPublicData: boolean, waitForProtectedData: boolean): [AppRouterState, AppRouterDispatch] {
+export function useAppRouterReducer(waitForPublicData: boolean, waitForProtectedData: boolean): [AppRouterState, AppRouterDispatch] {
+    const runtime = useRuntime() as FireflyRuntime;
+
     const areModulesInitiallyRegistered = getAreModulesRegistered();
     const areModulesInitiallyReady = getAreModulesReady();
     const isMswInitiallyReady = isMswReady();
@@ -331,7 +337,7 @@ export function useAppRouterReducer(waitForMsw: boolean, waitForPublicData: bool
     }, [isMswInitiallyReady, eventBus]), true);
 
     const [state, reactDispatch] = useReducer(reducer, {
-        waitForMsw,
+        waitForMsw: runtime.isMswEnabled,
         waitForPublicData,
         waitForProtectedData,
         // When the modules registration functions are awaited, the event listeners are registered after the modules are registered.