@squide/firefly 11.0.0 → 12.0.1

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 \"./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 \"./boostrap.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;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 \"./AppRouterStore.ts\";\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;AAEF;AACQ;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/{boostrap.js → initializeFirefly.js}

@@ -1,6 +1,7 @@
 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"
 
@@ -8,7 +9,10 @@ import * as __WEBPACK_EXTERNAL_MODULE__squide_msw_9f7e76df__ from "@squide/msw";
 
 ;// CONCATENATED MODULE: external "@squide/msw"
 
-;// CONCATENATED MODULE: ./src/boostrap.ts?__rslib_entry__
+;// CONCATENATED MODULE: external "./FireflyRuntime.js"
+
+;// CONCATENATED MODULE: ./src/initializeFirefly.ts?__rslib_entry__
+
 
 
 
@@ -22,13 +26,8 @@ function propagateRegistrationErrors(results, onError) {
         }
     }
 }
-let hasExecuted = false;
 function bootstrap(runtime, options = {}) {
-    const { localModules = [], remotes = [], context, startMsw, onError } = options;
-    if (hasExecuted) {
-        throw new Error("[squide] A squide application can only be bootstrapped once. Did you call the \"bootstrap\" function twice?");
-    }
-    hasExecuted = true;
+    const { localModules = [], remotes = [], startMsw, onError, context } = options;
     runtime.eventBus.dispatch(ApplicationBootstrappingStartedEvent);
     Promise.allSettled([
         (0,__WEBPACK_EXTERNAL_MODULE__squide_core_7a405b8f__.registerLocalModules)(localModules, runtime, {
@@ -54,10 +53,26 @@ function bootstrap(runtime, options = {}) {
         }
     });
 }
+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 };
+export { ApplicationBootstrappingStartedEvent, __resetHasExecuteGuard, bootstrap, initializeFirefly };
 
-//# sourceMappingURL=boostrap.js.map
+//# 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/useAppRouterStore.d.ts

@@ -0,0 +1 @@
+export declare function useAppRouterStore(): import("./AppRouterStore.ts").AppRouterStore;

package/dist/useAppRouterStore.js

@@ -0,0 +1,14 @@
+import * as __WEBPACK_EXTERNAL_MODULE__squide_core_7a405b8f__ from "@squide/core";
+
+;// CONCATENATED MODULE: external "@squide/core"
+
+;// CONCATENATED MODULE: ./src/useAppRouterStore.ts?__rslib_entry__
+
+function useAppRouterStore() {
+    const runtime = (0,__WEBPACK_EXTERNAL_MODULE__squide_core_7a405b8f__.useRuntime)();
+    return runtime.appRouterStore;
+}
+
+export { useAppRouterStore };
+
+//# sourceMappingURL=useAppRouterStore.js.map

package/dist/useAppRouterStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAppRouterStore.js","sources":["webpack://@squide/firefly/./src/useAppRouterStore.ts"],"sourcesContent":["import { useRuntime } from \"@squide/core\";\nimport type { FireflyRuntime } from \"./FireflyRuntime.tsx\";\n\nexport function useAppRouterStore() {\n    const runtime = useRuntime() as FireflyRuntime;\n\n    return runtime.appRouterStore;\n}\n"],"names":["useRuntime","useAppRouterStore","runtime"],"mappings":";;;;;AAA0C;AAGnC,SAASC;IACZ,MAAMC,UAAUF,gEAAUA;IAE1B,OAAOE,QAAQ,cAAc;AACjC"}

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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@squide/firefly",
   "author": "Workleap",
-  "version": "11.0.0",
+  "version": "12.0.1",
   "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/module-federation": "6.2.4",
-    "@squide/core": "5.4.4",
-    "@squide/msw": "3.2.4",
-    "@squide/react-router": "7.0.2"
+    "@squide/core": "5.4.5",
+    "@squide/module-federation": "6.2.5",
+    "@squide/msw": "3.2.5",
+    "@squide/react-router": "7.0.3"
   },
   "devDependencies": {
     "@rsbuild/core": "1.2.19",

package/src/AppRouter.tsx

@@ -48,7 +48,6 @@ function useRenderRouterProvider(state: AppRouterState, renderRouterProvider: Re
 }
 
 export interface AppRouterProps {
-    waitForMsw: boolean;
     waitForPublicData?: boolean;
     waitForProtectedData?: boolean;
     children: RenderRouterProviderFunction;
@@ -56,13 +55,11 @@ 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();
 

package/src/AppRouterReducer.ts

@@ -1,7 +1,9 @@
-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 { useAppRouterStore } from "./useAppRouterStore.ts";
 import { useExecuteOnce } from "./useExecuteOnce.ts";
 import { isBootstrapping } from "./useIsBootstrapping.ts";
 
@@ -41,6 +43,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";
@@ -283,55 +287,63 @@ function useReducerDispatchProxy(reactDispatch: AppRouterDispatch) {
 
 function useEnhancedReducerDispatch(reducerDispatch: AppRouterDispatch) {
     const logger = useLogger();
+    const appRouterStore = useAppRouterStore();
     const eventBus = useEventBus();
 
     return useCallback((action: AppRouterAction) => {
         logger.debug("[squide] The following action has been dispatched to the AppRouter reducer:", action);
+
+        appRouterStore.dispatch(action);
         eventBus.dispatch(`squide-${action.type}`);
 
         reducerDispatch(action);
-    }, [reducerDispatch, logger, eventBus]);
+    }, [reducerDispatch, logger, appRouterStore, eventBus]);
 }
 
-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 eventBus = useEventBus();
+    const appRouterStore = useAppRouterStore();
+
     const areModulesInitiallyRegistered = getAreModulesRegistered();
     const areModulesInitiallyReady = getAreModulesReady();
     const isMswInitiallyReady = isMswReady();
 
-    const eventBus = useEventBus();
-
     // When modules are initially registered, the reducer action will never be dispatched, therefore the event would not be dispatched as well.
     // To ensure the bootstrapping events sequencing, the event is manually dispatched when the modules are initially registered.
     useExecuteOnce(useCallback(() => {
         if (areModulesInitiallyRegistered) {
+            appRouterStore.dispatch({ type: "modules-registered" });
             eventBus.dispatch(ModulesRegisteredEvent);
         }
 
         return true;
-    }, [areModulesInitiallyRegistered, eventBus]), true);
+    }, [areModulesInitiallyRegistered, appRouterStore, eventBus]), true);
 
     // When modules are initially registered, the reducer action will never be dispatched, therefore the event would not be dispatched as well.
     // To ensure the bootstrapping events sequencing, the event is manually dispatched when the modules are initially registered.
     useExecuteOnce(useCallback(() => {
         if (areModulesInitiallyReady) {
+            appRouterStore.dispatch({ type: "modules-ready" });
             eventBus.dispatch(ModulesReadyEvent);
         }
 
         return true;
-    }, [areModulesInitiallyReady, eventBus]), true);
+    }, [areModulesInitiallyReady, appRouterStore, eventBus]), true);
 
     // When modules are initially registered, the reducer action will never be dispatched, therefore the event would not be dispatched as well.
     // To ensure the bootstrapping events sequencing, the event is manually dispatched when the modules are initially registered.
     useExecuteOnce(useCallback(() => {
         if (isMswInitiallyReady) {
+            appRouterStore.dispatch({ type: "msw-ready" });
             eventBus.dispatch(MswReadyEvent);
         }
 
         return true;
-    }, [isMswInitiallyReady, eventBus]), true);
+    }, [isMswInitiallyReady, appRouterStore, 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.

package/src/AppRouterStore.ts

@@ -0,0 +1,171 @@
+// This file is a low cost port of the AppRouterReducer to a non-React store. It allows, non-React parts of the library to get
+// access to the state and ease the integration with third-party libraries such as the Platform Widgets.
+// Eventually, AppRouterReducer should be deprecated in favor of this new AppRouterStore.
+
+import type { RuntimeLogger } from "@squide/core";
+import type { AppRouterAction, AppRouterState } from "./AppRouterReducer.ts";
+
+export type AppRouterStoreState = Omit<AppRouterState, "waitForMsw" | "waitForPublicData" | "waitForProtectedData">;
+
+export type AppRouterStoreListenerFunction = (store: AppRouterStore, unsuscribe: () => void) => void;
+
+export class AppRouterStore {
+    #state: AppRouterStoreState;
+
+    readonly #listeners = new Set<AppRouterStoreListenerFunction>();
+    readonly #logger?: RuntimeLogger;
+
+    constructor(initialialState: AppRouterStoreState, logger: RuntimeLogger) {
+        this.#state = initialialState;
+        this.#logger = logger;
+    }
+
+    subscribe(listener: AppRouterStoreListenerFunction) {
+        this.#listeners.add(listener);
+
+        return () => {
+            this.unsuscribe(listener);
+        };
+    }
+
+    unsuscribe(listener: AppRouterStoreListenerFunction) {
+        this.#listeners.delete(listener);
+    }
+
+    dispatch(action: AppRouterAction) {
+        const newState = this.#reducer({ ...this.#state }, action);
+
+        this.#logger?.debug("[squide] The AppRouterStore state has been updated to:", newState);
+        this.#state = newState;
+
+        // Creating a copy of the listeners in case some are removed during the looping.
+        // To be honest, it might not be necessary, I simply don't know.
+        new Set(this.#listeners).forEach(x => {
+            x(this, () => {
+                this.unsuscribe(x);
+            });
+        });
+    }
+
+    #reducer(state: AppRouterStoreState, action: AppRouterAction) {
+        let newState = state;
+
+        switch (action.type) {
+            case "modules-registered": {
+                newState = {
+                    ...newState,
+                    areModulesRegistered: true
+                };
+
+                break;
+            }
+            case "modules-ready": {
+                newState = {
+                    ...newState,
+                    areModulesReady: true,
+                    // Will be set even if the app is not using deferred registrations.
+                    deferredRegistrationsUpdatedAt: Date.now()
+                };
+
+                break;
+            }
+            case "msw-ready": {
+                newState = {
+                    ...newState,
+                    isMswReady: true
+                };
+
+                break;
+            }
+            case "public-data-ready": {
+                newState = {
+                    ...newState,
+                    isPublicDataReady: true,
+                    publicDataUpdatedAt: Date.now()
+                };
+
+                break;
+            }
+            case "protected-data-ready": {
+                newState = {
+                    ...newState,
+                    isProtectedDataReady: true,
+                    protectedDataUpdatedAt: Date.now()
+                };
+
+                break;
+            }
+            case "public-data-updated": {
+                newState = {
+                    ...newState,
+                    publicDataUpdatedAt: Date.now()
+                };
+
+                break;
+            }
+            case "protected-data-updated": {
+                newState = {
+                    ...newState,
+                    protectedDataUpdatedAt: Date.now()
+                };
+
+                break;
+            }
+            case "deferred-registrations-updated": {
+                newState = {
+                    ...newState,
+                    deferredRegistrationsUpdatedAt: Date.now()
+                };
+
+                break;
+            }
+            case "active-route-is-public": {
+                newState = {
+                    ...newState,
+                    activeRouteVisibility: "public"
+                };
+
+                break;
+            }
+            case "active-route-is-protected": {
+                newState = {
+                    ...newState,
+                    activeRouteVisibility: "protected"
+                };
+
+                break;
+            }
+            case "is-unauthorized": {
+                newState = {
+                    ...newState,
+                    isUnauthorized: true
+                };
+
+                break;
+            }
+            default: {
+                throw new Error(`[squide] The AppRouterStore state reducer doesn't support action type "${action.type}".`);
+            }
+        }
+
+        return newState;
+    }
+
+    get state() {
+        return this.#state;
+    }
+}
+
+export function createAppRouterStore(logger: RuntimeLogger) {
+    const initialState: AppRouterStoreState = {
+        areModulesRegistered: false,
+        areModulesReady: false,
+        isMswReady: false,
+        isPublicDataReady: false,
+        isProtectedDataReady: false,
+        activeRouteVisibility: "unknown",
+        isUnauthorized: false
+    };
+
+    return new AppRouterStore(initialState, logger);
+}

package/src/FireflyRuntime.tsx

@@ -3,12 +3,14 @@ import { MswPlugin, MswPluginName } from "@squide/msw";
 import { ReactRouterRuntime, type Route } from "@squide/react-router";
 import type { RequestHandler } from "msw";
 import { getAreModulesRegistered } from "./AppRouterReducer.ts";
+import { type AppRouterStore, createAppRouterStore } from "./AppRouterStore.ts";
 
 export interface FireflyRuntimeOptions extends RuntimeOptions {
     useMsw?: boolean;
 }
 
 export class FireflyRuntime extends ReactRouterRuntime {
+    readonly #appRouterStore: AppRouterStore;
     readonly #useMsw: boolean;
 
     constructor({ plugins, useMsw, ...options }: FireflyRuntimeOptions = {}) {
@@ -30,6 +32,8 @@ export class FireflyRuntime extends ReactRouterRuntime {
 
             this.#useMsw = false;
         }
+
+        this.#appRouterStore = createAppRouterStore(this._logger);
     }
 
     registerRequestHandlers(handlers: RequestHandler[]) {
@@ -65,6 +69,10 @@ export class FireflyRuntime extends ReactRouterRuntime {
         super.registerRoute(route, options);
     }
 
+    get appRouterStore() {
+        return this.#appRouterStore;
+    }
+
     get isMswEnabled() {
         return this.#useMsw;
     }

package/src/index.ts

@@ -10,6 +10,7 @@ export * from "./AppRouter.tsx";
 export * from "./AppRouterContext.ts";
 export * from "./AppRouterReducer.ts";
 
+export * from "./AppRouterStore.ts";
 export * from "./GlobalDataQueriesError.ts";
 export * from "./useCanFetchProtectedData.ts";
 export * from "./useCanFetchPublicData.ts";
@@ -27,5 +28,5 @@ export * from "./useRegisterDeferredRegistrations.ts";
 export * from "./useStrictRegistrationMode.ts";
 export * from "./useUpdateDeferredRegistrations.ts";
 
-export * from "./boostrap.ts";
+export * from "./initializeFirefly.ts";
 

package/src/{boostrap.ts → initializeFirefly.ts}

@@ -1,22 +1,22 @@
 import { isFunction, registerLocalModules, type ModuleRegisterFunction, type RegisterModulesOptions } from "@squide/core";
 import { registerRemoteModules, type RemoteDefinition } from "@squide/module-federation";
 import { setMswAsReady } from "@squide/msw";
-import type { FireflyRuntime } from "./FireflyRuntime.tsx";
+import { FireflyRuntime, type FireflyRuntimeOptions } from "./FireflyRuntime.tsx";
 
 export const ApplicationBootstrappingStartedEvent = "squide-app-bootstrapping-started";
 
-export type StartMswFunction<TRuntime = FireflyRuntime> = (runtime: TRuntime) => Promise<void>;
+export type OnInitializationErrorFunction = (error: unknown) => void;
 
-export type OnBootstrapErrorFunction = (error: unknown) => void;
+export type StartMswFunction<TRuntime = FireflyRuntime> = (runtime: TRuntime) => Promise<void>;
 
-export interface BootstrapAppOptions<TRuntime extends FireflyRuntime = FireflyRuntime, TContext = unknown, TData = unknown> extends RegisterModulesOptions<TContext> {
+export interface InitializeFireflyOptions<TRuntime extends FireflyRuntime, TContext = unknown, TData = unknown> extends RegisterModulesOptions<TContext>, FireflyRuntimeOptions {
     localModules?: ModuleRegisterFunction<TRuntime, TContext, TData>[];
     remotes?: RemoteDefinition[];
-    startMsw?: StartMswFunction<TRuntime>;
-    onError?: OnBootstrapErrorFunction;
+    startMsw?: StartMswFunction<FireflyRuntime>;
+    onError?: OnInitializationErrorFunction;
 }
 
-function propagateRegistrationErrors(results: PromiseSettledResult<unknown[]>, onError: OnBootstrapErrorFunction) {
+function propagateRegistrationErrors(results: PromiseSettledResult<unknown[]>, onError: OnInitializationErrorFunction) {
     if (results) {
         if (results.status === "fulfilled") {
             results.value.forEach(x => {
@@ -26,23 +26,15 @@ function propagateRegistrationErrors(results: PromiseSettledResult<unknown[]>, o
     }
 }
 
-let hasExecuted = false;
-
-export function bootstrap<TRuntime extends FireflyRuntime = FireflyRuntime, TContext = unknown, TData = unknown>(runtime: TRuntime, options: BootstrapAppOptions<TRuntime, TContext, TData> = {}) {
+export function bootstrap<TRuntime extends FireflyRuntime = FireflyRuntime, TContext = unknown, TData = unknown>(runtime: TRuntime, options: InitializeFireflyOptions<TRuntime, TContext, TData> = {}) {
     const {
         localModules = [],
         remotes = [],
-        context,
         startMsw,
-        onError
+        onError,
+        context
     } = options;
 
-    if (hasExecuted) {
-        throw new Error("[squide] A squide application can only be bootstrapped once. Did you call the \"bootstrap\" function twice?");
-    }
-
-    hasExecuted = true;
-
     runtime.eventBus.dispatch(ApplicationBootstrappingStartedEvent);
 
     Promise.allSettled([
@@ -70,6 +62,34 @@ export function bootstrap<TRuntime extends FireflyRuntime = FireflyRuntime, TCon
     });
 }
 
+let hasExecuted = false;
+
+export function initializeFirefly<TContext = unknown, TData = unknown>(options: InitializeFireflyOptions<FireflyRuntime, TContext, TData> = {}) {
+    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 FireflyRuntime({
+        mode,
+        useMsw,
+        loggers,
+        plugins
+    });
+
+    bootstrap(runtime, options);
+
+    return runtime;
+}
+
 export function __resetHasExecuteGuard() {
     hasExecuted = false;
 }

package/src/useAppRouterStore.ts

@@ -0,0 +1,8 @@
+import { useRuntime } from "@squide/core";
+import type { FireflyRuntime } from "./FireflyRuntime.tsx";
+
+export function useAppRouterStore() {
+    const runtime = useRuntime() as FireflyRuntime;
+
+    return runtime.appRouterStore;
+}