@squide/firefly 15.0.5 → 16.0.1

package/src/initializeFirefly.ts

@@ -1,6 +1,6 @@
-import { isFunction, registerLocalModules, type ModuleRegisterFunction, type RegisterModulesOptions } from "@squide/core";
-import { registerRemoteModules, type RemoteDefinition } from "@squide/module-federation";
-import { setMswAsReady } from "@squide/msw";
+import { isFunction, ModuleDefinition, toLocalModuleDefinitions, type ModuleRegisterFunction, type RegisterModulesOptions } from "@squide/core";
+import { EnvironmentVariables, EnvironmentVariablesPlugin } from "@squide/env-vars";
+import { MswPlugin } from "@squide/msw";
 import type { HoneycombInstrumentationPartialClient } from "@workleap-telemetry/core";
 import { FireflyRuntime, type FireflyRuntimeOptions } from "./FireflyRuntime.tsx";
 import { initializeHoneycomb } from "./honeycomb/initializeHoneycomb.ts";
@@ -13,26 +13,20 @@ export type StartMswFunction<TRuntime = FireflyRuntime> = (runtime: TRuntime) =>
 
 export interface InitializeFireflyOptions<TRuntime extends FireflyRuntime, TContext = unknown, TData = unknown> extends RegisterModulesOptions<TContext>, FireflyRuntimeOptions {
     localModules?: ModuleRegisterFunction<TRuntime, TContext, TData>[];
-    remotes?: RemoteDefinition[];
+    moduleDefinitions?: ModuleDefinition<TRuntime, TContext, TData>[];
+    useMsw?: boolean;
+    environmentVariables?: Partial<EnvironmentVariables>;
     honeycombInstrumentationClient?: HoneycombInstrumentationPartialClient;
     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> = {}) {
+export function bootstrap<TRuntime extends FireflyRuntime = FireflyRuntime, TContext = unknown, TData = unknown>(
+    runtime: TRuntime,
+    modulesDefinitions: ModuleDefinition<TRuntime, TContext, TData>[],
+    options: Omit<InitializeFireflyOptions<TRuntime, TContext, TData>, "localModules" | "moduleDefinitions"> = {}
+) {
     const {
-        localModules = [],
-        remotes = [],
         startMsw,
         onError,
         context
@@ -40,43 +34,52 @@ export function bootstrap<TRuntime extends FireflyRuntime = FireflyRuntime, TCon
 
     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.");
+    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();
+                    });
             }
 
-            startMsw(runtime)
-                .then(() => {
-                    setMswAsReady();
-                })
-                .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);
                 });
-        }
-
-        if (onError) {
-            propagateRegistrationErrors(results[0], onError);
-            propagateRegistrationErrors(results[1], onError);
-        }
-    });
+            }
+        });
 }
 
 let hasExecuted = false;
 
+// Should only be used by tests.
+export function __resetHasExecutedGuard() {
+    hasExecuted = false;
+}
+
 export function initializeFirefly<TContext = unknown, TData = unknown>(options: InitializeFireflyOptions<FireflyRuntime, TContext, TData> = {}) {
     const {
         mode,
+        localModules = [],
+        moduleDefinitions = [],
         useMsw,
-        loggers,
-        plugins,
+        plugins = [],
+        environmentVariables,
         honeycombInstrumentationClient,
+        loggers,
         onError
     } = options;
 
@@ -86,12 +89,20 @@ export function initializeFirefly<TContext = unknown, TData = unknown>(options:
 
     hasExecuted = true;
 
+    if (useMsw) {
+        plugins.push(x => new MswPlugin(x));
+    }
+
     const runtime = new FireflyRuntime({
         mode,
-        useMsw,
         honeycombInstrumentationClient,
         loggers,
-        plugins
+        plugins: [
+            x => new EnvironmentVariablesPlugin(x, {
+                variables: environmentVariables
+            }),
+            ...plugins
+        ]
     });
 
     initializeHoneycomb(runtime)
@@ -101,12 +112,12 @@ export function initializeFirefly<TContext = unknown, TData = unknown>(options:
             }
         })
         .finally(() => {
-            bootstrap(runtime, options);
+            bootstrap(
+                runtime,
+                [...moduleDefinitions, ...toLocalModuleDefinitions(localModules)],
+                options
+            );
         });
 
     return runtime;
 }
-
-export function __resetHasExecuteGuard() {
-    hasExecuted = false;
-}

package/src/internal.ts

@@ -0,0 +1,22 @@
+export { AppRouterDispatcherContext, AppRouterStateContext } from "./AppRouterContext.ts";
+export { __clearAppReducerDispatchProxy, __setAppReducerDispatchProxyFactory, useAppRouterReducer, type AppRouterDispatch, type AppRouterState } from "./AppRouterReducer.ts";
+
+export type { ActiveSpan, ActiveSpanId } from "./honeycomb/activeSpan.ts";
+export { addProtectedListener, type AddProtectedListenerOptions, type GetSpanFunction, type HoneycombTrackingUnmanagedErrorHandler } from "./honeycomb/registerHoneycombInstrumentation.ts";
+export { getTracer } from "./honeycomb/tracer.ts";
+export {
+    endActiveSpan,
+    startActiveChildSpan,
+    startActiveSpan,
+    startChildSpan,
+    startSpan,
+    traceError,
+    type StartActiveChildSpanFactory,
+    type StartActiveChildSpanFactoryReturn,
+    type StartActiveSpanFactory,
+    type StartActiveSpanFactoryReturn,
+    type StartChildSpanFactory,
+    type StartSpanFactory,
+    type TraceErrorOptions
+} from "./honeycomb/utils.ts";
+

package/src/useDeferredRegistrations.ts

@@ -5,21 +5,12 @@ import { useCanUpdateDeferredRegistrations } from "./useCanUpdateDeferredRegistr
 import { useRegisterDeferredRegistrations } from "./useRegisterDeferredRegistrations.ts";
 import { useUpdateDeferredRegistrations } from "./useUpdateDeferredRegistrations.ts";
 
-export interface DeferredRegistrationsErrorsObject {
-    localModuleErrors: ModuleRegistrationError[];
-    remoteModuleErrors: ModuleRegistrationError[];
-}
-
-export type DeferredRegistrationsErrorCallback = (errorsObject: DeferredRegistrationsErrorsObject) => void;
+export type DeferredRegistrationsErrorCallback = (errors: ModuleRegistrationError[]) => void;
 
 export interface UseDeferredRegistrationsOptions {
     onError?: DeferredRegistrationsErrorCallback;
 }
 
-function hasError({ localModuleErrors, remoteModuleErrors }: DeferredRegistrationsErrorsObject) {
-    return localModuleErrors.length > 0 || remoteModuleErrors.length > 0;
-}
-
 export function useDeferredRegistrations(data: unknown, { onError }: UseDeferredRegistrationsOptions = {}) {
     const runtime = useRuntime();
 
@@ -34,7 +25,7 @@ export function useDeferredRegistrations(data: unknown, { onError }: UseDeferred
             const register = async () => {
                 const errors = await registerDeferredRegistrations(data, runtime);
 
-                if (hasError(errors) && onError) {
+                if (errors.length > 0 && onError) {
                     onError(errors);
                 }
             };
@@ -48,7 +39,7 @@ export function useDeferredRegistrations(data: unknown, { onError }: UseDeferred
             const update = async () => {
                 const errors = await updateDeferredRegistrations(data, runtime);
 
-                if (hasError(errors) && onError) {
+                if (errors.length > 0 && onError) {
                     onError(errors);
                 }
             };

package/src/useRegisterDeferredRegistrations.ts

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

package/src/useStrictRegistrationMode.ts

@@ -1,28 +1,23 @@
-import { addLocalModuleRegistrationStatusChangedListener, getLocalModuleRegistrationStatus, removeLocalModuleRegistrationStatusChangedListener, useRuntime } from "@squide/core";
-import { addRemoteModuleRegistrationStatusChangedListener, areModulesReady, getRemoteModuleRegistrationStatus, removeRemoteModuleRegistrationStatusChangedListener } from "@squide/module-federation";
+import { Runtime, useRuntime } from "@squide/core";
 import { useEffect, useSyncExternalStore } from "react";
 
-function subscribeToLocalModuleRegistrationStatusChanged(callback: () => void) {
-    addLocalModuleRegistrationStatusChangedListener(callback);
+function subscribeToModulesReady(runtime: Runtime) {
+    return (callback: () => void) => {
+        runtime.moduleManager.registerModulesReadyListener(callback);
 
-    return () => removeLocalModuleRegistrationStatusChangedListener(callback);
-}
-
-function subscribeToRemoteModuleRegistrationStatusChanged(callback: () => void) {
-    addRemoteModuleRegistrationStatusChangedListener(callback);
-
-    return () => removeRemoteModuleRegistrationStatusChangedListener(callback);
+        return () => runtime.moduleManager.removeModulesReadyListener(callback);
+    };
 }
 
 export function useStrictRegistrationMode() {
     const runtime = useRuntime();
 
-    const localModuleStatus = useSyncExternalStore(subscribeToLocalModuleRegistrationStatusChanged, getLocalModuleRegistrationStatus);
-    const remoteModuleStatus = useSyncExternalStore(subscribeToRemoteModuleRegistrationStatusChanged, getRemoteModuleRegistrationStatus);
+    // This listener is only executed if the modules are ready.
+    const areModulesReady = useSyncExternalStore(subscribeToModulesReady(runtime), () => runtime.moduleManager.getAreModulesReady());
 
     useEffect(() => {
-        if (areModulesReady(localModuleStatus, remoteModuleStatus)) {
+        if (areModulesReady) {
             runtime._validateRegistrations();
         }
-    }, [runtime, localModuleStatus, remoteModuleStatus]);
+    }, [runtime, areModulesReady]);
 }

package/src/useUpdateDeferredRegistrations.ts

@@ -1,16 +1,22 @@
 import type { Runtime } from "@squide/core";
-import { updateDeferredRegistrations } from "@squide/module-federation";
 import { useCallback } from "react";
 import { useAppRouterDispatcher } from "./AppRouterContext.ts";
 
+export const DeferredRegistrationsUpdateStartedEvent = "squide-deferred-registrations-update-started";
+export const DeferredRegistrationsUpdateCompletedEvent = "squide-deferred-registrations-update-completed-started";
+
 export function useUpdateDeferredRegistrations() {
     const dispatch = useAppRouterDispatcher();
 
     return useCallback(async <TData = unknown, TRuntime extends Runtime = Runtime>(data: TData, runtime: TRuntime) => {
-        const errors = await updateDeferredRegistrations(data, runtime);
+        runtime.eventBus.dispatch(DeferredRegistrationsUpdateStartedEvent);
+
+        const errors = await runtime.moduleManager.updateDeferredRegistrations(data);
 
         dispatch({ type: "deferred-registrations-updated" });
 
+        runtime.eventBus.dispatch(DeferredRegistrationsUpdateCompletedEvent);
+
         return errors;
     }, [dispatch]);
 }