@squide/firefly 10.0.1 → 12.0.0

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/FireflyProvider.tsx

@@ -0,0 +1,19 @@
+import { type Runtime, RuntimeContext } from "@squide/core";
+import type { PropsWithChildren } from "react";
+
+export interface FireflyProviderProps extends PropsWithChildren {
+    runtime: Runtime;
+}
+
+export function FireflyProvider(props: FireflyProviderProps) {
+    const {
+        runtime,
+        children
+    } = props;
+
+    return (
+        <RuntimeContext.Provider value={runtime}>
+            {children}
+        </RuntimeContext.Provider>
+    );
+}

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

@@ -3,6 +3,7 @@ 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";
@@ -18,11 +19,13 @@ 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/src/initializeFirefly.ts

@@ -0,0 +1,95 @@
+import { isFunction, registerLocalModules, type ModuleRegisterFunction, type RegisterModulesOptions } from "@squide/core";
+import { registerRemoteModules, type RemoteDefinition } from "@squide/module-federation";
+import { setMswAsReady } from "@squide/msw";
+import { FireflyRuntime, type FireflyRuntimeOptions } from "./FireflyRuntime.tsx";
+
+export 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;
+}
+
+function propagateRegistrationErrors(results: PromiseSettledResult<unknown[]>, onError: OnInitializationErrorFunction) {
+    if (results) {
+        if (results.status === "fulfilled") {
+            results.value.forEach(x => {
+                onError(x);
+            });
+        }
+    }
+}
+
+export function bootstrap<TRuntime extends FireflyRuntime = FireflyRuntime, TContext = unknown, TData = unknown>(runtime: TRuntime, options: InitializeFireflyOptions<TRuntime, TContext, TData> = {}) {
+    const {
+        localModules = [],
+        remotes = [],
+        startMsw,
+        onError,
+        context
+    } = options;
+
+    runtime.eventBus.dispatch(ApplicationBootstrappingStartedEvent);
+
+    Promise.allSettled([
+        registerLocalModules<TRuntime, TContext, TData>(localModules, runtime, { context }),
+        registerRemoteModules(remotes, runtime, { context })
+    ]).then(results => {
+        if (runtime.isMswEnabled) {
+            if (!isFunction(startMsw)) {
+                throw new Error("[squide] When MSW is enabled, the \"startMsw\" function must be provided.");
+            }
+
+            startMsw(runtime)
+                .then(() => {
+                    setMswAsReady();
+                })
+                .catch((error: unknown) => {
+                    runtime.logger.debug("[squide] An error occured while starting MSW.", error);
+                });
+        }
+
+        if (onError) {
+            propagateRegistrationErrors(results[0], onError);
+            propagateRegistrationErrors(results[1], onError);
+        }
+    });
+}
+
+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/useCanFetchProtectedData.ts

@@ -1,4 +1,25 @@
 import { useAppRouterState } from "./AppRouterContext.ts";
+import type { ActiveRouteVisiblity } from "./AppRouterReducer.ts";
+
+// This function is exported for external integration, like the integration
+// with the Platform Widgets. Do not remove.
+export function canFetchProtectedData(
+    waitForMsw: boolean,
+    areModulesRegistered: boolean,
+    areModulesReady: boolean,
+    activeRouteVisibility: ActiveRouteVisiblity,
+    isMswReady: boolean
+) {
+    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)
+        // Only fetch the protected data for protected routes, aka do not fetch the protected data for public routes.
+        && activeRouteVisibility === "protected"
+        // Wait for MSW since the endpoints for the protected data might be an MSW endpoint when in development.
+        && (!waitForMsw || isMswReady)
+    );
+}
 
 export function useCanFetchProtectedData() {
     const {
@@ -10,17 +31,12 @@ export function useCanFetchProtectedData() {
         activeRouteVisibility
     } = 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)
-            // Only fetch the protected data for protected routes, aka do not fetch the protected data for public routes.
-            && activeRouteVisibility === "protected"
-            // Wait for MSW since the endpoints for the protected data might be an MSW endpoint when in development.
-            && (!waitForMsw || isMswReady)
-        )
+    // 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
     );
 }

package/src/useIsBootstrapping.ts

@@ -4,10 +4,10 @@ import type { AppRouterState } from "./AppRouterReducer.ts";
 export function useIsBootstrapping() {
     const state = useAppRouterState();
 
-    return isApplicationBootstrapping(state);
+    return isBootstrapping(state);
 }
 
-export function isApplicationBootstrapping(state: AppRouterState) {
+export function isBootstrapping(state: AppRouterState) {
     const {
         waitForMsw,
         waitForPublicData,

package/src/useProtectedDataHandler.ts

@@ -0,0 +1,12 @@
+import { useEffect } from "react";
+import { useCanFetchProtectedData } from "./useCanFetchProtectedData.ts";
+
+export function useProtectedDataHandler(handler: () => void) {
+    const canFetchProtectedData = useCanFetchProtectedData();
+
+    useEffect(() => {
+        if (canFetchProtectedData) {
+            handler();
+        }
+    }, [canFetchProtectedData, handler]);
+}

package/src/usePublicDataHandler.ts

@@ -0,0 +1,12 @@
+import { useEffect } from "react";
+import { useCanFetchPublicData } from "./useCanFetchPublicData.ts";
+
+export function usePublicDataHandler(handler: () => void) {
+    const canFetchPublicData = useCanFetchPublicData();
+
+    useEffect(() => {
+        if (canFetchPublicData) {
+            handler();
+        }
+    }, [canFetchPublicData, handler]);
+}

package/dist/boostrap.d.ts

@@ -1,15 +0,0 @@
-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>;
-}
-export declare function bootstrap<TRuntime extends FireflyRuntime = FireflyRuntime, TContext = unknown, TData = unknown>(runtime: TRuntime, options?: BootstrapAppOptions<TRuntime, TContext, TData>): Promise<{
-    localModuleErrors: ModuleRegistrationError[];
-    remoteModuleErrors: RemoteModuleRegistrationError[];
-}>;
-export declare function __resetHasExecuteGuard(): void;

package/dist/boostrap.js

@@ -1,54 +0,0 @@
-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";
-
-;// 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 hasExecuted = false;
-async function bootstrap(runtime, options = {}) {
-    const { localModules = [], remotes = [], context, startMsw } = 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);
-    let localModuleErrors = [];
-    let remoteModuleErrors = [];
-    localModuleErrors = await (0,__WEBPACK_EXTERNAL_MODULE__squide_core_7a405b8f__.registerLocalModules)(localModules, runtime, {
-        context
-    });
-    remoteModuleErrors = await (0,__WEBPACK_EXTERNAL_MODULE__squide_module_federation_054d2ec6__.registerRemoteModules)(remotes, runtime, {
-        context
-    });
-    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.");
-        }
-        try {
-            await startMsw(runtime);
-            (0,__WEBPACK_EXTERNAL_MODULE__squide_msw_9f7e76df__.setMswAsReady)();
-        } catch (error) {
-            runtime.logger.debug("[squide] An error occured while starting MSW.", error);
-        }
-    }
-    return {
-        localModuleErrors,
-        remoteModuleErrors
-    };
-}
-function __resetHasExecuteGuard() {
-    hasExecuted = false;
-}
-
-export { ApplicationBootstrappingStartedEvent, __resetHasExecuteGuard, bootstrap };
-
-//# sourceMappingURL=boostrap.js.map

package/dist/boostrap.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"boostrap.js","sources":["webpack://@squide/firefly/./src/boostrap.ts"],"sourcesContent":["import { isFunction, registerLocalModules, type ModuleRegisterFunction, type ModuleRegistrationError, type RegisterModulesOptions } from \"@squide/core\";\nimport { registerRemoteModules, type RemoteDefinition, type RemoteModuleRegistrationError } from \"@squide/module-federation\";\nimport { setMswAsReady } from \"@squide/msw\";\nimport type { FireflyRuntime } from \"./FireflyRuntime.tsx\";\n\nexport const ApplicationBootstrappingStartedEvent = \"squide-app-bootstrapping-started\";\n\nexport type StartMswFunction<TRuntime = FireflyRuntime> = (runtime: TRuntime) => Promise<void>;\n\nexport interface BootstrapAppOptions<TRuntime extends FireflyRuntime = FireflyRuntime, TContext = unknown, TData = unknown> extends RegisterModulesOptions<TContext> {\n    localModules?: ModuleRegisterFunction<TRuntime, TContext, TData>[];\n    remotes?: RemoteDefinition[];\n    startMsw?: StartMswFunction<TRuntime>;\n}\n\nlet hasExecuted = false;\n\nexport async function bootstrap<TRuntime extends FireflyRuntime = FireflyRuntime, TContext = unknown, TData = unknown>(runtime: TRuntime, options: BootstrapAppOptions<TRuntime, TContext, TData> = {}) {\n    const {\n        localModules = [],\n        remotes = [],\n        context,\n        startMsw\n    } = options;\n\n    if (hasExecuted) {\n        throw new Error(\"[squide] A squide application can only be bootstrapped once. Did you call the \\\"bootstrap\\\" function twice?\");\n    }\n\n    hasExecuted = true;\n\n    runtime.eventBus.dispatch(ApplicationBootstrappingStartedEvent);\n\n    let localModuleErrors: ModuleRegistrationError[] = [];\n    let remoteModuleErrors: RemoteModuleRegistrationError[] = [];\n\n    localModuleErrors = await registerLocalModules<TRuntime, TContext, TData>(localModules, runtime, { context });\n    remoteModuleErrors = await registerRemoteModules(remotes, runtime, { context });\n\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        try {\n            await startMsw(runtime);\n\n            setMswAsReady();\n        } catch (error: unknown) {\n            runtime.logger.debug(\"[squide] An error occured while starting MSW.\", error);\n        }\n    }\n\n    return {\n        localModuleErrors,\n        remoteModuleErrors\n    };\n}\n\nexport function __resetHasExecuteGuard() {\n    hasExecuted = false;\n}\n"],"names":["isFunction","registerLocalModules","registerRemoteModules","setMswAsReady","ApplicationBootstrappingStartedEvent","hasExecuted","bootstrap","runtime","options","localModules","remotes","context","startMsw","Error","localModuleErrors","remoteModuleErrors","error","__resetHasExecuteGuard"],"mappings":";;;;;;;;;;;AAAwJ;AAC3B;AACjF;AAGrC,MAAMI,uCAAuC,mCAAmC;AAUvF,IAAIC,cAAc;AAEX,eAAeC,UAAiGC,OAAiB,EAAEC,UAA0D,CAAC,CAAC;IAClM,MAAM,EACFC,eAAe,EAAE,EACjBC,UAAU,EAAE,EACZC,OAAO,EACPC,QAAQ,EACX,GAAGJ;IAEJ,IAAIH,aAAa;QACb,MAAM,IAAIQ,MAAM;IACpB;IAEAR,cAAc;IAEdE,QAAQ,QAAQ,CAAC,QAAQ,CAACH;IAE1B,IAAIU,oBAA+C,EAAE;IACrD,IAAIC,qBAAsD,EAAE;IAE5DD,oBAAoB,MAAMb,0EAAoBA,CAA4BQ,cAAcF,SAAS;QAAEI;IAAQ;IAC3GI,qBAAqB,MAAMb,wFAAqBA,CAACQ,SAASH,SAAS;QAAEI;IAAQ;IAE7E,IAAIJ,QAAQ,YAAY,EAAE;QACtB,IAAI,CAACP,gEAAUA,CAACY,WAAW;YACvB,MAAM,IAAIC,MAAM;QACpB;QAEA,IAAI;YACA,MAAMD,SAASL;YAEfJ,kEAAaA;QACjB,EAAE,OAAOa,OAAgB;YACrBT,QAAQ,MAAM,CAAC,KAAK,CAAC,iDAAiDS;QAC1E;IACJ;IAEA,OAAO;QACHF;QACAC;IACJ;AACJ;AAEO,SAASE;IACZZ,cAAc;AAClB"}

package/src/boostrap.ts

@@ -1,62 +0,0 @@
-import { isFunction, registerLocalModules, type ModuleRegisterFunction, type ModuleRegistrationError, type RegisterModulesOptions } from "@squide/core";
-import { registerRemoteModules, type RemoteDefinition, type RemoteModuleRegistrationError } from "@squide/module-federation";
-import { setMswAsReady } from "@squide/msw";
-import type { FireflyRuntime } from "./FireflyRuntime.tsx";
-
-export 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>;
-}
-
-let hasExecuted = false;
-
-export async function bootstrap<TRuntime extends FireflyRuntime = FireflyRuntime, TContext = unknown, TData = unknown>(runtime: TRuntime, options: BootstrapAppOptions<TRuntime, TContext, TData> = {}) {
-    const {
-        localModules = [],
-        remotes = [],
-        context,
-        startMsw
-    } = 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);
-
-    let localModuleErrors: ModuleRegistrationError[] = [];
-    let remoteModuleErrors: RemoteModuleRegistrationError[] = [];
-
-    localModuleErrors = await registerLocalModules<TRuntime, TContext, TData>(localModules, runtime, { context });
-    remoteModuleErrors = await registerRemoteModules(remotes, runtime, { context });
-
-    if (runtime.isMswEnabled) {
-        if (!isFunction(startMsw)) {
-            throw new Error("[squide] When MSW is enabled, the \"startMsw\" function must be provided.");
-        }
-
-        try {
-            await startMsw(runtime);
-
-            setMswAsReady();
-        } catch (error: unknown) {
-            runtime.logger.debug("[squide] An error occured while starting MSW.", error);
-        }
-    }
-
-    return {
-        localModuleErrors,
-        remoteModuleErrors
-    };
-}
-
-export function __resetHasExecuteGuard() {
-    hasExecuted = false;
-}