@squide/firefly 16.0.3 → 16.1.0

package/src/AppRouterContext.ts

@@ -1,4 +1,4 @@
-import { isNil } from "@squide/core";
+import { isNil } from "@squide/core/internal";
 import { createContext, useContext } from "react";
 import type { AppRouterDispatch, AppRouterState } from "./AppRouterReducer.ts";
 

package/src/AppRouterReducer.ts

@@ -1,4 +1,5 @@
 import { useEventBus, useLogger, useRuntime } from "@squide/core";
+import type { FeatureFlagSetSnapshotChangedListener } from "@squide/launch-darkly";
 import { useCallback, useEffect, useMemo, useReducer, type Dispatch } from "react";
 import type { FireflyRuntime } from "./FireflyRuntime.tsx";
 import { useAppRouterStore } from "./useAppRouterStore.ts";
@@ -21,6 +22,7 @@ export interface AppRouterState extends AppRouterWaitState {
     isProtectedDataReady: boolean;
     publicDataUpdatedAt?: number;
     protectedDataUpdatedAt?: number;
+    featureFlagsUpdatedAt?: number;
     deferredRegistrationsUpdatedAt?: number;
     activeRouteVisibility: ActiveRouteVisiblity;
     isUnauthorized: boolean;
@@ -34,6 +36,7 @@ export type AppRouterActionType =
     | "protected-data-ready"
     | "public-data-updated"
     | "protected-data-updated"
+    | "feature-flags-updated"
     | "deferred-registrations-updated"
     | "active-route-is-public"
     | "active-route-is-protected"
@@ -124,6 +127,14 @@ function reducer(state: AppRouterState, action: AppRouterAction) {
 
             break;
         }
+        case "feature-flags-updated": {
+            newState = {
+                ...newState,
+                featureFlagsUpdatedAt: Date.now()
+            };
+
+            break;
+        }
         case "deferred-registrations-updated": {
             newState = {
                 ...newState,
@@ -225,16 +236,39 @@ export function useMswStatusDispatcher(runtime: FireflyRuntime, isMswReadyValue:
     useEffect(() => {
         if (runtime.isMswEnabled) {
             if (!isMswReadyValue) {
-                runtime.getMswState().addMswReadyListener(dispatchMswReady);
+                runtime.mswState.addMswReadyListener(dispatchMswReady);
             }
 
             return () => {
-                runtime.getMswState().removeMswReadyListener(dispatchMswReady);
+                runtime.mswState.removeMswReadyListener(dispatchMswReady);
             };
         }
     }, [runtime, isMswReadyValue, dispatchMswReady]);
 }
 
+export function useFeatureFlagsUpdatedDispatcher(runtime: FireflyRuntime, dispatch: AppRouterDispatch) {
+    const logger = useLogger();
+
+    const dispatchFeatureFlagsUpdated = useCallback((changes => {
+        dispatch({ type: "feature-flags-updated" });
+
+        logger
+            .withText("[squide] Feature flags has been updated to:")
+            .withObject(changes)
+            .debug();
+    }) satisfies FeatureFlagSetSnapshotChangedListener, [dispatch, logger]);
+
+    useEffect(() => {
+        if (runtime.isLaunchDarklyEnabled) {
+            runtime.featureFlagSetSnapshot.addSnapshotChangedListener(dispatchFeatureFlagsUpdated);
+
+            return () => {
+                runtime.featureFlagSetSnapshot.removeSnapshotChangedListener(dispatchFeatureFlagsUpdated);
+            };
+        }
+    }, [runtime]);
+}
+
 function useBootstrappingCompletedDispatcher(waitState: AppRouterWaitState, state: AppRouterState) {
     const eventBus = useEventBus();
 
@@ -296,7 +330,7 @@ export function useAppRouterReducer(waitForPublicData: boolean, waitForProtected
     const isMswEnabled = runtime.isMswEnabled;
     const areModulesInitiallyRegistered = runtime.moduleManager.getAreModulesRegistered();
     const areModulesInitiallyReady = runtime.moduleManager.getAreModulesReady();
-    const isMswInitiallyReady = runtime.isMswEnabled ? runtime.getMswState().isReady : false;
+    const isMswInitiallyReady = runtime.isMswEnabled ? runtime.mswState.isReady : false;
 
     const waitState = useMemo(() => ({
         waitForMsw: isMswEnabled,
@@ -366,6 +400,7 @@ export function useAppRouterReducer(waitForPublicData: boolean, waitForProtected
 
     useModuleRegistrationStatusDispatcher(runtime, areModulesRegisteredValue, areModulesReadyValue, dispatch);
     useMswStatusDispatcher(runtime, isMswReadyValue, dispatch);
+    useFeatureFlagsUpdatedDispatcher(runtime, dispatch);
     useBootstrappingCompletedDispatcher(waitState, state);
 
     return [state, dispatch];

package/src/AppRouterStore.ts

@@ -115,6 +115,14 @@ export class AppRouterStore {
 
                 break;
             }
+            case "feature-flags-updated": {
+                newState = {
+                    ...newState,
+                    featureFlagsUpdatedAt: Date.now()
+                };
+
+                break;
+            }
             case "deferred-registrations-updated": {
                 newState = {
                     ...newState,

package/src/FireflyRuntime.tsx

@@ -1,9 +1,11 @@
 import type { RegisterRouteOptions, RuntimeMethodOptions, RuntimeOptions } from "@squide/core";
-import { EnvironmentVariableKey, EnvironmentVariables, EnvironmentVariableValue, getEnvironmentVariablesPlugin } from "@squide/env-vars";
+import { EnvironmentVariableKey, EnvironmentVariables, getEnvironmentVariablesPlugin } from "@squide/env-vars";
+import { FeatureFlagKey, FeatureFlags, FeatureFlagSetSnapshot, getLaunchDarklyPlugin, LaunchDarklyPluginName } from "@squide/launch-darkly";
 import { getMswPlugin, MswPluginName, MswState } from "@squide/msw";
 import { type IReactRouterRuntime, ReactRouterRuntime, ReactRouterRuntimeScope, type Route } from "@squide/react-router";
 import type { HoneycombInstrumentationPartialClient } from "@workleap-telemetry/core";
 import type { Logger } from "@workleap/logging";
+import { LDClient } from "launchdarkly-js-client-sdk";
 import type { RequestHandler } from "msw";
 import { type AppRouterStore, createAppRouterStore } from "./AppRouterStore.ts";
 
@@ -14,22 +16,29 @@ export interface FireflyRuntimeOptions<TRuntime extends FireflyRuntime = Firefly
 export interface RegisterRequestHandlersOptions extends RuntimeMethodOptions {}
 
 export interface IFireflyRuntime extends IReactRouterRuntime {
-    getMswState(): MswState;
+    get isMswEnabled(): boolean;
+    get mswState(): MswState;
     registerRequestHandlers: (handlers: RequestHandler[]) => void;
     get requestHandlers(): RequestHandler[];
-    get isMswEnabled(): boolean;
-    registerEnvironmentVariable(key: EnvironmentVariableKey, value: EnvironmentVariableValue): void;
+    registerEnvironmentVariable<T extends EnvironmentVariableKey>(key: T, value: EnvironmentVariables[T]): void;
     registerEnvironmentVariables(variables: Partial<EnvironmentVariables>): void;
-    getEnvironmentVariable(key: EnvironmentVariableKey): EnvironmentVariableValue;
-    getEnvironmentVariables(): EnvironmentVariables;
+    getEnvironmentVariable<T extends EnvironmentVariableKey>(key: T): EnvironmentVariables[T];
+    get environmentVariables(): EnvironmentVariables;
     get appRouterStore(): AppRouterStore;
     get honeycombInstrumentationClient(): HoneycombInstrumentationPartialClient | undefined;
+    get isLaunchDarklyEnabled(): boolean;
+    get launchDarklyClient(): LDClient;
+    get featureFlags(): FeatureFlags;
+    getFeatureFlag(key: string, defaultValue?: unknown): unknown;
+    get featureFlagSetSnapshot(): FeatureFlagSetSnapshot;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export class FireflyRuntime<TRuntime extends FireflyRuntime = any> extends ReactRouterRuntime<TRuntime> implements IFireflyRuntime {
-    protected _appRouterStore: AppRouterStore;
-    protected _honeycombInstrumentationClient: HoneycombInstrumentationPartialClient | undefined;
+    readonly #appRouterStore: AppRouterStore;
+    readonly #honeycombInstrumentationClient: HoneycombInstrumentationPartialClient | undefined;
+    readonly #isMswEnabled: boolean;
+    readonly #isLaunchDarklyEnabled: boolean;
 
     constructor(options: FireflyRuntimeOptions = {}) {
         const {
@@ -38,8 +47,10 @@ export class FireflyRuntime<TRuntime extends FireflyRuntime = any> extends React
 
         super(options);
 
-        this._appRouterStore = createAppRouterStore(this._logger);
-        this._honeycombInstrumentationClient = honeycombInstrumentationClient;
+        this.#appRouterStore = createAppRouterStore(this._logger);
+        this.#honeycombInstrumentationClient = honeycombInstrumentationClient;
+        this.#isMswEnabled = this._plugins.some(x => x.name === MswPluginName);
+        this.#isLaunchDarklyEnabled = this._plugins.some(x => x.name === LaunchDarklyPluginName);
     }
 
     registerRoute(route: Route, options: RegisterRouteOptions = {}) {
@@ -50,7 +61,11 @@ export class FireflyRuntime<TRuntime extends FireflyRuntime = any> extends React
         super.registerRoute(route, options);
     }
 
-    getMswState() {
+    get isMswEnabled() {
+        return this.#isMswEnabled;
+    }
+
+    get mswState() {
         const plugin = getMswPlugin(this);
 
         return plugin.mswState;
@@ -76,23 +91,19 @@ export class FireflyRuntime<TRuntime extends FireflyRuntime = any> extends React
         return plugin.requestHandlers;
     }
 
-    get isMswEnabled() {
-        return this._plugins.some(x => x.name === MswPluginName);
-    }
-
     getEnvironmentVariable(key: EnvironmentVariableKey) {
         const plugin = getEnvironmentVariablesPlugin(this);
 
         return plugin.getVariable(key);
     }
 
-    getEnvironmentVariables() {
+    get environmentVariables() {
         const plugin = getEnvironmentVariablesPlugin(this);
 
         return plugin.getVariables();
     }
 
-    registerEnvironmentVariable(key: EnvironmentVariableKey, value: EnvironmentVariableValue) {
+    registerEnvironmentVariable<T extends EnvironmentVariableKey>(key: T, value: EnvironmentVariables[T]) {
         const plugin = getEnvironmentVariablesPlugin(this);
 
         return plugin.registerVariable(key, value);
@@ -105,11 +116,31 @@ export class FireflyRuntime<TRuntime extends FireflyRuntime = any> extends React
     }
 
     get appRouterStore() {
-        return this._appRouterStore;
+        return this.#appRouterStore;
     }
 
     get honeycombInstrumentationClient() {
-        return this._honeycombInstrumentationClient;
+        return this.#honeycombInstrumentationClient;
+    }
+
+    get isLaunchDarklyEnabled() {
+        return this.#isLaunchDarklyEnabled;
+    }
+
+    get launchDarklyClient() {
+        return getLaunchDarklyPlugin(this).client;
+    }
+
+    get featureFlags() {
+        return this.featureFlagSetSnapshot.value;
+    }
+
+    getFeatureFlag<T extends FeatureFlagKey>(key: T, defaultValue?: FeatureFlags[T]) {
+        return getLaunchDarklyPlugin(this).getFeatureFlag(key, defaultValue);
+    }
+
+    get featureFlagSetSnapshot() {
+        return getLaunchDarklyPlugin(this).featureFlagSetSnapshot;
     }
 
     startScope(logger: Logger): TRuntime {
@@ -118,8 +149,12 @@ export class FireflyRuntime<TRuntime extends FireflyRuntime = any> extends React
 }
 
 export class FireflyRuntimeScope<TRuntime extends FireflyRuntime = FireflyRuntime> extends ReactRouterRuntimeScope<TRuntime> implements IFireflyRuntime {
-    getMswState() {
-        return this._runtime.getMswState();
+    get isMswEnabled() {
+        return this._runtime.isMswEnabled;
+    }
+
+    get mswState() {
+        return this._runtime.mswState;
     }
 
     registerRequestHandlers(handlers: RequestHandler[], options: RegisterRequestHandlersOptions = {}) {
@@ -134,19 +169,15 @@ export class FireflyRuntimeScope<TRuntime extends FireflyRuntime = FireflyRuntim
         return this._runtime.requestHandlers;
     }
 
-    get isMswEnabled() {
-        return this._runtime.isMswEnabled;
-    }
-
-    getEnvironmentVariables() {
-        return this._runtime.getEnvironmentVariables();
-    }
-
     getEnvironmentVariable(key: EnvironmentVariableKey) {
         return this._runtime.getEnvironmentVariable(key);
     }
 
-    registerEnvironmentVariable(key: EnvironmentVariableKey, value: EnvironmentVariableValue) {
+    get environmentVariables() {
+        return this._runtime.environmentVariables;
+    }
+
+    registerEnvironmentVariable<T extends EnvironmentVariableKey>(key: T, value: EnvironmentVariables[T]) {
         this._runtime.registerEnvironmentVariable(key, value);
     }
 
@@ -161,4 +192,28 @@ export class FireflyRuntimeScope<TRuntime extends FireflyRuntime = FireflyRuntim
     get honeycombInstrumentationClient(): HoneycombInstrumentationPartialClient {
         throw new Error("[squide] Cannot retrieve the Honeycomb instrumentation client from a runtime scope instance.");
     }
+
+    get isLaunchDarklyEnabled() {
+        return this._runtime.isLaunchDarklyEnabled;
+    }
+
+    get launchDarklyClient() {
+        return this._runtime.launchDarklyClient;
+    }
+
+    get featureFlags() {
+        return this._runtime.featureFlags;
+    }
+
+    getFeatureFlag<T extends FeatureFlagKey>(key: T, defaultValue?: FeatureFlags[T]) {
+        // The error is because the FeatureFlags interface is empty as it is expected to be augmented by the
+        // consumer application.
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        return this._runtime.getFeatureFlag(key, defaultValue);
+    }
+
+    get featureFlagSetSnapshot() {
+        return this._runtime.featureFlagSetSnapshot;
+    }
 }

package/src/honeycomb/activeSpan.ts

@@ -1,5 +1,5 @@
 import type { Span } from "@opentelemetry/api";
-import { isPlainObject } from "@squide/core";
+import { isPlainObject } from "@squide/core/internal";
 import type { Logger } from "@workleap/logging";
 import { v4 as uuidv4 } from "uuid";
 import { createTraceContextId } from "./createTraceContextId.ts";

package/src/index.ts

@@ -7,9 +7,25 @@ export {
     useEnvironmentVariables,
     type EnvironmentVariableKey,
     type EnvironmentVariables,
-    type EnvironmentVariablesPluginOptions,
-    type EnvironmentVariableValue
+    type EnvironmentVariablesPluginOptions
 } from "@squide/env-vars";
+export {
+    FeatureFlagSetSnapshot,
+    getFeatureFlag,
+    getLaunchDarklyPlugin,
+    InMemoryLaunchDarklyClient,
+    LaunchDarklyClientNotifier,
+    LaunchDarklyPlugin,
+    LaunchDarklyPluginName,
+    useFeatureFlag,
+    useFeatureFlags,
+    useLaunchDarklyClient,
+    type FeatureFlagKey,
+    type FeatureFlags,
+    type FeatureFlagSetSnapshotChangedListener,
+    type InMemoryLaunchDarklyClientOptions,
+    type LaunchDarklyClientListener
+} from "@squide/launch-darkly";
 export {
     getMswPlugin,
     MswPlugin,

package/src/initializeFirefly.ts

@@ -1,7 +1,10 @@
-import { isFunction, ModuleDefinition, toLocalModuleDefinitions, type ModuleRegisterFunction, type RegisterModulesOptions } from "@squide/core";
+import { ModuleDefinition, toLocalModuleDefinitions, type ModuleRegisterFunction, type RegisterModulesOptions } from "@squide/core";
+import { isFunction } from "@squide/core/internal";
 import { EnvironmentVariables, EnvironmentVariablesPlugin } from "@squide/env-vars";
+import { LaunchDarklyPlugin } from "@squide/launch-darkly";
 import { MswPlugin } from "@squide/msw";
 import type { HoneycombInstrumentationPartialClient } from "@workleap-telemetry/core";
+import { LDClient } from "launchdarkly-js-client-sdk";
 import { FireflyRuntime, type FireflyRuntimeOptions } from "./FireflyRuntime.tsx";
 import { initializeHoneycomb } from "./honeycomb/initializeHoneycomb.ts";
 
@@ -12,18 +15,19 @@ 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>[];
+    localModules?: (ModuleRegisterFunction<TRuntime, TContext, TData> | undefined)[];
     moduleDefinitions?: ModuleDefinition<TRuntime, TContext, TData>[];
     useMsw?: boolean;
     environmentVariables?: Partial<EnvironmentVariables>;
     honeycombInstrumentationClient?: HoneycombInstrumentationPartialClient;
+    launchDarklyClient?: LDClient;
     startMsw?: StartMswFunction<FireflyRuntime>;
     onError?: OnInitializationErrorFunction;
 }
 
 export function bootstrap<TRuntime extends FireflyRuntime = FireflyRuntime, TContext = unknown, TData = unknown>(
     runtime: TRuntime,
-    modulesDefinitions: ModuleDefinition<TRuntime, TContext, TData>[],
+    modulesDefinitions: (ModuleDefinition<TRuntime, TContext, TData> | undefined)[],
     options: Omit<InitializeFireflyOptions<TRuntime, TContext, TData>, "localModules" | "moduleDefinitions"> = {}
 ) {
     const {
@@ -34,33 +38,35 @@ export function bootstrap<TRuntime extends FireflyRuntime = FireflyRuntime, TCon
 
     runtime.eventBus.dispatch(ApplicationBootstrappingStartedEvent);
 
-    runtime.moduleManager.registerModules(modulesDefinitions, { 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(() => {
-                        if (runtime.isMswEnabled) {
-                            runtime.getMswState().setAsReady();
-                        }
-                    })
-                    .catch((error: unknown) => {
-                        runtime.logger
-                            .withText("[squide] An error occured while starting MSW.")
-                            .withError(error as Error)
-                            .error();
-                    });
+    runtime.moduleManager.registerModules(
+        modulesDefinitions.filter((x): x is ModuleDefinition => Boolean(x)),
+        { context }
+    ).then(results => {
+        if (runtime.isMswEnabled) {
+            if (!isFunction(startMsw)) {
+                throw new Error("[squide] When MSW is enabled, the \"startMsw\" function must be provided.");
             }
 
-            if (onError) {
-                results.forEach(error => {
-                    onError(error);
+            startMsw(runtime)
+                .then(() => {
+                    if (runtime.isMswEnabled) {
+                        runtime.mswState.setAsReady();
+                    }
+                })
+                .catch((error: unknown) => {
+                    runtime.logger
+                        .withText("[squide] An error occured while starting MSW.")
+                        .withError(error as Error)
+                        .error();
                 });
-            }
-        });
+        }
+
+        if (onError) {
+            results.forEach(error => {
+                onError(error);
+            });
+        }
+    });
 }
 
 let hasExecuted = false;
@@ -79,6 +85,7 @@ export function initializeFirefly<TContext = unknown, TData = unknown>(options:
         plugins = [],
         environmentVariables,
         honeycombInstrumentationClient,
+        launchDarklyClient,
         loggers,
         onError
     } = options;
@@ -93,6 +100,10 @@ export function initializeFirefly<TContext = unknown, TData = unknown>(options:
         plugins.push(x => new MswPlugin(x));
     }
 
+    if (launchDarklyClient) {
+        plugins.push(x => new LaunchDarklyPlugin(x, launchDarklyClient));
+    }
+
     const runtime = new FireflyRuntime({
         mode,
         honeycombInstrumentationClient,

package/src/useCanUpdateDeferredRegistrations.ts

@@ -5,6 +5,7 @@ export function useCanUpdateDeferredRegistrations() {
         areModulesReady,
         publicDataUpdatedAt,
         protectedDataUpdatedAt,
+        featureFlagsUpdatedAt,
         deferredRegistrationsUpdatedAt
     } = useAppRouterState();
 
@@ -17,7 +18,8 @@ export function useCanUpdateDeferredRegistrations() {
         // If either the public data or the protected data has been updated, update the deferred registrations.
         && (
             (publicDataUpdatedAt && publicDataUpdatedAt > deferredRegistrationsUpdatedAt) ||
-            (protectedDataUpdatedAt && protectedDataUpdatedAt > deferredRegistrationsUpdatedAt)
+            (protectedDataUpdatedAt && protectedDataUpdatedAt > deferredRegistrationsUpdatedAt) ||
+            (featureFlagsUpdatedAt && featureFlagsUpdatedAt > deferredRegistrationsUpdatedAt)
         )
     );
 }

package/src/useDeferredRegistrations.ts

@@ -1,5 +1,6 @@
 import { useRuntime, type ModuleRegistrationError } from "@squide/core";
 import { useEffect } from "react";
+import { FireflyRuntime } from "./FireflyRuntime.tsx";
 import { useCanRegisterDeferredRegistrations } from "./useCanRegisterDeferredRegistrations.ts";
 import { useCanUpdateDeferredRegistrations } from "./useCanUpdateDeferredRegistrations.ts";
 import { useRegisterDeferredRegistrations } from "./useRegisterDeferredRegistrations.ts";
@@ -11,8 +12,8 @@ export interface UseDeferredRegistrationsOptions {
     onError?: DeferredRegistrationsErrorCallback;
 }
 
-export function useDeferredRegistrations(data: unknown, { onError }: UseDeferredRegistrationsOptions = {}) {
-    const runtime = useRuntime();
+export function useDeferredRegistrations(data?: unknown, { onError }: UseDeferredRegistrationsOptions = {}) {
+    const runtime = useRuntime() as FireflyRuntime;
 
     const canRegisterDeferredRegistrations = useCanRegisterDeferredRegistrations();
     const canUpdateDeferredRegistrations = useCanUpdateDeferredRegistrations();
@@ -23,7 +24,7 @@ export function useDeferredRegistrations(data: unknown, { onError }: UseDeferred
     useEffect(() => {
         if (canRegisterDeferredRegistrations) {
             const register = async () => {
-                const errors = await registerDeferredRegistrations(data, runtime);
+                const errors = await registerDeferredRegistrations(data);
 
                 if (errors.length > 0 && onError) {
                     onError(errors);
@@ -32,12 +33,12 @@ export function useDeferredRegistrations(data: unknown, { onError }: UseDeferred
 
             register();
         }
-    }, [canRegisterDeferredRegistrations, registerDeferredRegistrations, data, onError, runtime]);
+    }, [canRegisterDeferredRegistrations, registerDeferredRegistrations, data, onError]);
 
     useEffect(() => {
         if (canUpdateDeferredRegistrations) {
             const update = async () => {
-                const errors = await updateDeferredRegistrations(data, runtime);
+                const errors = await updateDeferredRegistrations(data);
 
                 if (errors.length > 0 && onError) {
                     onError(errors);
@@ -46,5 +47,13 @@ export function useDeferredRegistrations(data: unknown, { onError }: UseDeferred
 
             update();
         }
-    }, [canUpdateDeferredRegistrations, updateDeferredRegistrations, data, onError, runtime]);
+    }, [
+        canUpdateDeferredRegistrations,
+        updateDeferredRegistrations,
+        data,
+        onError,
+        // Trigger this closure when the feature flags changed. Using the timestamp because the
+        // actual feature flags are not forwarded to the deferred registrations.
+        runtime.appRouterStore.state.featureFlagsUpdatedAt
+    ]);
 }

package/src/useRegisterDeferredRegistrations.ts

@@ -1,8 +1,10 @@
-import type { Runtime } from "@squide/core";
+import { useRuntime } from "@squide/core";
 import { useCallback } from "react";
 
 export function useRegisterDeferredRegistrations() {
-    return useCallback(<TData = unknown, TRuntime extends Runtime = Runtime>(data: TData, runtime: TRuntime) => {
+    const runtime = useRuntime();
+
+    return useCallback(<TData = unknown>(data?: TData) => {
         return runtime.moduleManager.registerDeferredRegistrations(data);
-    }, []);
+    }, [runtime]);
 }

package/src/useStrictRegistrationMode.ts

@@ -1,13 +1,5 @@
-import { Runtime, useRuntime } from "@squide/core";
-import { useEffect, useSyncExternalStore } from "react";
-
-function subscribeToModulesReady(runtime: Runtime) {
-    return (callback: () => void) => {
-        runtime.moduleManager.registerModulesReadyListener(callback);
-
-        return () => runtime.moduleManager.removeModulesReadyListener(callback);
-    };
-}
+import { useRuntime } from "@squide/core";
+import { useCallback, useEffect, useSyncExternalStore } from "react";
 
 export interface UseStrictRegistrationModeOptions {
     isEnabled?: boolean;
@@ -20,8 +12,16 @@ export function useStrictRegistrationMode(options: UseStrictRegistrationModeOpti
 
     const runtime = useRuntime();
 
+    const subscribe = useCallback((callback: () => void) => {
+        runtime.moduleManager.registerModulesReadyListener(callback);
+
+        return () => {
+            runtime.moduleManager.removeModulesReadyListener(callback);
+        };
+    }, [runtime]);
+
     // This listener is only executed if the modules are ready.
-    const areModulesReady = useSyncExternalStore(subscribeToModulesReady(runtime), () => runtime.moduleManager.getAreModulesReady());
+    const areModulesReady = useSyncExternalStore(subscribe, () => runtime.moduleManager.getAreModulesReady());
 
     useEffect(() => {
         if (areModulesReady && isEnabled) {

package/src/useUpdateDeferredRegistrations.ts

@@ -1,4 +1,4 @@
-import type { Runtime } from "@squide/core";
+import { useRuntime } from "@squide/core";
 import { useCallback } from "react";
 import { useAppRouterDispatcher } from "./AppRouterContext.ts";
 
@@ -6,9 +6,10 @@ export const DeferredRegistrationsUpdateStartedEvent = "squide-deferred-registra
 export const DeferredRegistrationsUpdateCompletedEvent = "squide-deferred-registrations-update-completed-started";
 
 export function useUpdateDeferredRegistrations() {
+    const runtime = useRuntime();
     const dispatch = useAppRouterDispatcher();
 
-    return useCallback(async <TData = unknown, TRuntime extends Runtime = Runtime>(data: TData, runtime: TRuntime) => {
+    return useCallback(async <TData = unknown>(data?: TData) => {
         runtime.eventBus.dispatch(DeferredRegistrationsUpdateStartedEvent);
 
         const errors = await runtime.moduleManager.updateDeferredRegistrations(data);
@@ -18,5 +19,5 @@ export function useUpdateDeferredRegistrations() {
         runtime.eventBus.dispatch(DeferredRegistrationsUpdateCompletedEvent);
 
         return errors;
-    }, [dispatch]);
+    }, [runtime, dispatch]);
 }