@squide/firefly-module-federation 0.0.0

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { initializeFirefly, type InitializeFireflyOptions } from "./initializeFirefly.ts";
+export { getModuleFederationPlugin, ModuleFederationPluginName, type ModuleFederationPlugin } from "./ModuleFederationPlugin.ts";
+export type { RemoteDefinition } from "./RemoteDefinition.ts";
+export { RemoteModuleDeferredRegistrationFailedEvent, RemoteModuleDeferredRegistrationUpdateFailedEvent, RemoteModuleRegistrationFailedEvent, RemoteModuleRegistryId, RemoteModulesDeferredRegistrationCompletedEvent, RemoteModulesDeferredRegistrationStartedEvent, RemoteModulesDeferredRegistrationsUpdateCompletedEvent, RemoteModulesDeferredRegistrationsUpdateStartedEvent, RemoteModulesRegistrationCompletedEvent, RemoteModulesRegistrationStartedEvent, type RemoteModuleRegistrationError, type RemoteModulesDeferredRegistrationCompletedEventPayload, type RemoteModulesDeferredRegistrationStartedEventPayload, type RemoteModulesDeferredRegistrationsUpdateCompletedEventPayload, type RemoteModulesDeferredRegistrationsUpdateStartedEventPayload, type RemoteModulesRegistrationCompletedEventPayload, type RemoteModulesRegistrationStartedEventPayload } from "./RemoteModuleRegistry.ts";

package/dist/index.js

@@ -0,0 +1,18 @@
+import { initializeFirefly } from "./initializeFirefly.js";
+import { ModuleFederationPluginName, getModuleFederationPlugin } from "./ModuleFederationPlugin.js";
+import { RemoteModuleDeferredRegistrationFailedEvent, RemoteModuleDeferredRegistrationUpdateFailedEvent, RemoteModuleRegistrationFailedEvent, RemoteModuleRegistryId, RemoteModulesDeferredRegistrationCompletedEvent, RemoteModulesDeferredRegistrationStartedEvent, RemoteModulesDeferredRegistrationsUpdateCompletedEvent, RemoteModulesDeferredRegistrationsUpdateStartedEvent, RemoteModulesRegistrationCompletedEvent, RemoteModulesRegistrationStartedEvent } from "./RemoteModuleRegistry.js";
+
+;// CONCATENATED MODULE: external "./initializeFirefly.js"
+
+;// CONCATENATED MODULE: external "./ModuleFederationPlugin.js"
+
+;// CONCATENATED MODULE: external "./RemoteModuleRegistry.js"
+
+;// CONCATENATED MODULE: ./src/index.ts
+
+
+
+
+export { ModuleFederationPluginName, RemoteModuleDeferredRegistrationFailedEvent, RemoteModuleDeferredRegistrationUpdateFailedEvent, RemoteModuleRegistrationFailedEvent, RemoteModuleRegistryId, RemoteModulesDeferredRegistrationCompletedEvent, RemoteModulesDeferredRegistrationStartedEvent, RemoteModulesDeferredRegistrationsUpdateCompletedEvent, RemoteModulesDeferredRegistrationsUpdateStartedEvent, RemoteModulesRegistrationCompletedEvent, RemoteModulesRegistrationStartedEvent, getModuleFederationPlugin, initializeFirefly };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../src/index.ts"],"sourcesContent":["export { initializeFirefly, type InitializeFireflyOptions } from \"./initializeFirefly.ts\";\nexport { getModuleFederationPlugin, ModuleFederationPluginName, type ModuleFederationPlugin } from \"./ModuleFederationPlugin.ts\";\nexport type { RemoteDefinition } from \"./RemoteDefinition.ts\";\nexport {\n    RemoteModuleDeferredRegistrationFailedEvent,\n    RemoteModuleDeferredRegistrationUpdateFailedEvent,\n    RemoteModuleRegistrationFailedEvent,\n    RemoteModuleRegistryId,\n    RemoteModulesDeferredRegistrationCompletedEvent,\n    RemoteModulesDeferredRegistrationStartedEvent,\n    RemoteModulesDeferredRegistrationsUpdateCompletedEvent,\n    RemoteModulesDeferredRegistrationsUpdateStartedEvent,\n    RemoteModulesRegistrationCompletedEvent,\n    RemoteModulesRegistrationStartedEvent,\n    type RemoteModuleRegistrationError,\n    type RemoteModulesDeferredRegistrationCompletedEventPayload,\n    type RemoteModulesDeferredRegistrationStartedEventPayload,\n    type RemoteModulesDeferredRegistrationsUpdateCompletedEventPayload,\n    type RemoteModulesDeferredRegistrationsUpdateStartedEventPayload,\n    type RemoteModulesRegistrationCompletedEventPayload,\n    type RemoteModulesRegistrationStartedEventPayload\n} from \"./RemoteModuleRegistry.ts\";\n\n"],"names":["initializeFirefly","getModuleFederationPlugin","ModuleFederationPluginName","RemoteModuleDeferredRegistrationFailedEvent","RemoteModuleDeferredRegistrationUpdateFailedEvent","RemoteModuleRegistrationFailedEvent","RemoteModuleRegistryId","RemoteModulesDeferredRegistrationCompletedEvent","RemoteModulesDeferredRegistrationStartedEvent","RemoteModulesDeferredRegistrationsUpdateCompletedEvent","RemoteModulesDeferredRegistrationsUpdateStartedEvent","RemoteModulesRegistrationCompletedEvent","RemoteModulesRegistrationStartedEvent"],"mappings":";;;;;;;;;;;AAA0F;AACuC;AAoB9F"}

package/dist/initializeFirefly.d.ts

@@ -0,0 +1,6 @@
+import { FireflyRuntime, type InitializeFireflyOptions as BaseInitializeFireflyOptions } from "@squide/firefly";
+import { RemoteDefinition } from "./RemoteDefinition.ts";
+export interface InitializeFireflyOptions<TRuntime extends FireflyRuntime, TContext = unknown, TData = unknown> extends BaseInitializeFireflyOptions<TRuntime, TContext, TData> {
+    remotes?: RemoteDefinition[];
+}
+export declare function initializeFirefly<TContext = unknown, TData = unknown>(options?: InitializeFireflyOptions<FireflyRuntime, TContext, TData>): FireflyRuntime<any>;

package/dist/initializeFirefly.js

@@ -0,0 +1,32 @@
+import { initializeFirefly } from "@squide/firefly";
+import { ModuleFederationPlugin } from "./ModuleFederationPlugin.js";
+import { toRemoteModuleDefinitions } from "./RemoteModuleRegistry.js";
+
+;// CONCATENATED MODULE: external "@squide/firefly"
+
+;// CONCATENATED MODULE: external "./ModuleFederationPlugin.js"
+
+;// CONCATENATED MODULE: external "./RemoteModuleRegistry.js"
+
+;// CONCATENATED MODULE: ./src/initializeFirefly.ts
+
+
+
+function initializeFirefly_initializeFirefly(options = {}) {
+    const { remotes = [], moduleDefinitions = [], plugins = [], ...rest } = options;
+    return initializeFirefly({
+        moduleDefinitions: [
+            ...moduleDefinitions,
+            ...toRemoteModuleDefinitions(remotes)
+        ],
+        plugins: [
+            (x)=>new ModuleFederationPlugin(x),
+            ...plugins
+        ],
+        ...rest
+    });
+}
+
+export { initializeFirefly_initializeFirefly as initializeFirefly };
+
+//# sourceMappingURL=initializeFirefly.js.map

package/dist/initializeFirefly.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"initializeFirefly.js","sources":["../src/initializeFirefly.ts"],"sourcesContent":["import { FireflyRuntime, initializeFirefly as baseInitializeFirefly, type InitializeFireflyOptions as BaseInitializeFireflyOptions } from \"@squide/firefly\";\nimport { ModuleFederationPlugin } from \"./ModuleFederationPlugin.ts\";\nimport { RemoteDefinition } from \"./RemoteDefinition.ts\";\nimport { toRemoteModuleDefinitions } from \"./RemoteModuleRegistry.ts\";\n\nexport interface InitializeFireflyOptions<TRuntime extends FireflyRuntime, TContext = unknown, TData = unknown> extends BaseInitializeFireflyOptions<TRuntime, TContext, TData> {\n    remotes?: RemoteDefinition[];\n}\n\nexport function initializeFirefly<TContext = unknown, TData = unknown>(options: InitializeFireflyOptions<FireflyRuntime, TContext, TData> = {}) {\n    const {\n        remotes = [],\n        moduleDefinitions = [],\n        plugins = [],\n        ...rest\n    } = options;\n\n    return baseInitializeFirefly({\n        moduleDefinitions: [\n            ...moduleDefinitions,\n            ...toRemoteModuleDefinitions(remotes)\n        ],\n        plugins: [\n            x => new ModuleFederationPlugin(x),\n            ...plugins\n        ],\n        ...rest\n    });\n}\n"],"names":["initializeFirefly","baseInitializeFirefly","ModuleFederationPlugin","toRemoteModuleDefinitions","options","remotes","moduleDefinitions","plugins","rest","x"],"mappings":";;;;;;;;;;;AAA4J;AACvF;AAEC;AAM/D,SAASA,mCAAiBA,CAAsCI,UAAqE,CAAC,CAAC;IAC1I,MAAM,EACFC,UAAU,EAAE,EACZC,oBAAoB,EAAE,EACtBC,UAAU,EAAE,EACZ,GAAGC,MACN,GAAGJ;IAEJ,OAAOH,iBAAqBA,CAAC;QACzB,mBAAmB;eACZK;eACAH,yBAAyBA,CAACE;SAChC;QACD,SAAS;YACLI,CAAAA,IAAK,IAAIP,sBAAsBA,CAACO;eAC7BF;SACN;QACD,GAAGC,IAAI;IACX;AACJ"}

package/package.json

@@ -0,0 +1,70 @@
+{
+    "name": "@squide/firefly-module-federation",
+    "author": "Workleap",
+    "version": "0.0.0",
+    "description": "Add support for Module Federation to @squide application shell.",
+    "license": "Apache-2.0",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/workleap/wl-squide.git",
+        "directory": "packages/firefly-module-federation"
+    },
+    "type": "module",
+    "publishConfig": {
+        "access": "public",
+        "provenance": true,
+        "exports": {
+            ".": {
+                "types": "./dist/index.d.ts",
+                "import": "./dist/index.js",
+                "default": "./dist/index.js"
+            }
+        }
+    },
+    "exports": "./src/index.ts",
+    "files": [
+        "src",
+        "dist",
+        "CHANGELOG.md"
+    ],
+    "scripts": {
+        "build": "rslib build --config ./rslib.build.ts",
+        "eslint": "eslint . --max-warnings=0 --cache --cache-location node_modules/.cache/eslint",
+        "typecheck": "tsc",
+        "test": "vitest --config vitest.config.ts --no-watch"
+    },
+    "peerDependencies": {
+        "@opentelemetry/api": "^1.9.0",
+        "@tanstack/react-query": "^5.90.10",
+        "msw": "^2.12.2",
+        "react": "^18.0.0 || ^19.0.0",
+        "react-dom": "^18.0.0 || ^19.0.0",
+        "react-router": "^7.9.6"
+    },
+    "dependencies": {
+        "@module-federation/enhanced": "0.11.4",
+        "@rspack/core": "^1.6.4",
+        "@squide/core": "workspace:*",
+        "@squide/firefly": "workspace:*",
+        "@workleap/logging": "^1.3.2"
+    },
+    "devDependencies": {
+        "@eslint/js": "9.39.1",
+        "@rsbuild/core": "1.6.7",
+        "@rslib/core": "0.18.0",
+        "@testing-library/react": "16.3.0",
+        "@types/react": "19.2.6",
+        "@types/react-dom": "19.2.3",
+        "@typescript-eslint/parser": "8.47.0",
+        "@vitejs/plugin-react": "5.1.1",
+        "@workleap/eslint-configs": "1.1.5",
+        "@workleap/rslib-configs": "1.1.3",
+        "@workleap/typescript-configs": "3.0.7",
+        "eslint": "9.39.1",
+        "happy-dom": "20.0.10",
+        "typescript": "5.9.3",
+        "typescript-eslint": "8.47.0",
+        "vitest": "4.0.10"
+    },
+    "sideEffects": false
+}

package/src/ModuleFederationPlugin.ts

@@ -0,0 +1,216 @@
+import { loadRemote as loadModuleFederationRemote } from "@module-federation/enhanced/runtime";
+import { Span } from "@opentelemetry/api";
+import { isNil, Plugin, RegisterModulesOptions, type Runtime } from "@squide/core";
+import { FireflyPlugin, FireflyRuntime } from "@squide/firefly";
+import { ActiveSpan, addProtectedListener, endActiveSpan, getTracer, HoneycombTrackingUnmanagedErrorHandler, startActiveChildSpan, startChildSpan, traceError, type GetSpanFunction } from "@squide/firefly/internal";
+import { RemoteDefinition } from "./RemoteDefinition.ts";
+import { RemoteModuleDeferredRegistrationFailedEvent, RemoteModuleDeferredRegistrationUpdateFailedEvent, RemoteModuleRegistrationError, RemoteModuleRegistrationFailedEvent, RemoteModuleRegistry, RemoteModuleRegistryId, RemoteModulesDeferredRegistrationCompletedEvent, RemoteModulesDeferredRegistrationCompletedEventPayload, RemoteModulesDeferredRegistrationStartedEvent, RemoteModulesDeferredRegistrationStartedEventPayload, RemoteModulesDeferredRegistrationsUpdateCompletedEvent, RemoteModulesDeferredRegistrationsUpdateCompletedEventPayload, RemoteModulesDeferredRegistrationsUpdateStartedEvent, RemoteModulesDeferredRegistrationsUpdateStartedEventPayload, RemoteModulesRegistrationCompletedEvent, RemoteModulesRegistrationCompletedEventPayload, RemoteModulesRegistrationStartedEvent, RemoteModulesRegistrationStartedEventPayload } from "./RemoteModuleRegistry.ts";
+
+export const ModuleFederationPluginName = "module-federation-plugin";
+
+export class ModuleFederationPlugin extends Plugin<FireflyRuntime> implements FireflyPlugin {
+    constructor(runtime: FireflyRuntime) {
+        super(ModuleFederationPluginName, runtime);
+
+        this._runtime.moduleManager.addModuleRegistry(new RemoteModuleRegistry((remoteName, moduleName) => loadModuleFederationRemote(`${remoteName}/${moduleName}`)));
+    }
+
+    registerRemoteModules<TContext = unknown>(remotes: RemoteDefinition[], options?: RegisterModulesOptions<TContext>) {
+        return this._runtime.moduleManager.registerModules(remotes.map(x => ({
+            definition: x,
+            registryId: RemoteModuleRegistryId
+        })), options);
+    }
+
+    registerHoneycombTrackingListeners(
+        getBootstrappingSpan: GetSpanFunction,
+        getDeferredRegistrationsUpdateSpan: GetSpanFunction,
+        onUnmanagedError: HoneycombTrackingUnmanagedErrorHandler
+    ) {
+        let remoteModuleRegistrationSpan: Span;
+        let remoteModuleDeferredRegistrationSpan: Span;
+        let remoteModuleDeferredRegistrationsUpdateSpan: ActiveSpan;
+
+        const handleUnmanagedError = (error: unknown) => {
+            if (remoteModuleRegistrationSpan) {
+                remoteModuleRegistrationSpan.end();
+            }
+
+            if (remoteModuleDeferredRegistrationSpan) {
+                remoteModuleDeferredRegistrationSpan.end();
+            }
+
+            if (remoteModuleDeferredRegistrationsUpdateSpan) {
+                remoteModuleDeferredRegistrationsUpdateSpan.instance.end();
+            }
+
+            onUnmanagedError(error);
+        };
+
+        addProtectedListener(this._runtime, RemoteModulesRegistrationStartedEvent, (payload: unknown) => {
+            const bootstrappingSpan = getBootstrappingSpan();
+
+            const attributes = {
+                "app.squide.remote_count": (payload as RemoteModulesRegistrationStartedEventPayload).remoteCount
+            };
+
+            if (bootstrappingSpan) {
+                bootstrappingSpan.addEvent("remote-module-registration-started", attributes);
+            }
+
+            remoteModuleRegistrationSpan = startChildSpan(bootstrappingSpan, (options, context) => {
+                return getTracer().startSpan("remote-module-registration", { ...options, attributes }, context);
+            });
+        }, {
+            once: true,
+            onError: handleUnmanagedError
+        });
+
+        addProtectedListener(this._runtime, RemoteModulesRegistrationCompletedEvent, (payload: unknown) => {
+            const bootstrappingSpan = getBootstrappingSpan();
+
+            if (bootstrappingSpan) {
+                bootstrappingSpan.addEvent("remote-module-registration-completed", {
+                    "app.squide.remote_count": (payload as RemoteModulesRegistrationCompletedEventPayload).remoteCount
+                });
+            }
+
+            if (remoteModuleRegistrationSpan) {
+                remoteModuleRegistrationSpan.end();
+            }
+        }, {
+            once: true,
+            onError: handleUnmanagedError
+        });
+
+        // Can occur multiple times.
+        addProtectedListener(this._runtime, RemoteModuleRegistrationFailedEvent, (payload: unknown) => {
+            const registrationError = payload as RemoteModuleRegistrationError;
+
+            if (remoteModuleRegistrationSpan) {
+                traceError(remoteModuleRegistrationSpan, registrationError);
+            }
+        }, {
+            onError: handleUnmanagedError
+        });
+
+        addProtectedListener(this._runtime, RemoteModulesDeferredRegistrationStartedEvent, (payload: unknown) => {
+            const bootstrappingSpan = getBootstrappingSpan();
+
+            const attributes = {
+                "app.squide.registration_count": (payload as RemoteModulesDeferredRegistrationStartedEventPayload).registrationCount
+            };
+
+            if (bootstrappingSpan) {
+                bootstrappingSpan.addEvent("remote-module-deferred-registration-started", attributes);
+            }
+
+            remoteModuleDeferredRegistrationSpan = startChildSpan(bootstrappingSpan, (options, context) => {
+                return getTracer().startSpan("remote-module-deferred-registration", { ...options, attributes }, context);
+            });
+        }, {
+            once: true,
+            onError: handleUnmanagedError
+        });
+
+        addProtectedListener(this._runtime, RemoteModulesDeferredRegistrationCompletedEvent, (payload: unknown) => {
+            const bootstrappingSpan = getBootstrappingSpan();
+
+            if (bootstrappingSpan) {
+                bootstrappingSpan.addEvent("remote-module-deferred-registration-completed", {
+                    "app.squide.registration_count": (payload as RemoteModulesDeferredRegistrationCompletedEventPayload).registrationCount
+                });
+            }
+
+            if (remoteModuleDeferredRegistrationSpan) {
+                remoteModuleDeferredRegistrationSpan.end();
+            }
+        }, {
+            once: true,
+            onError: handleUnmanagedError
+        });
+
+        // Can occur multiple times.
+        addProtectedListener(this._runtime, RemoteModuleDeferredRegistrationFailedEvent, (payload: unknown) => {
+            const registrationError = payload as RemoteModuleRegistrationError;
+
+            if (remoteModuleDeferredRegistrationSpan) {
+                traceError(remoteModuleDeferredRegistrationSpan, registrationError);
+            }
+        }, {
+            onError: handleUnmanagedError
+        });
+
+        // Can occur multiple times.
+        addProtectedListener(this._runtime, RemoteModulesDeferredRegistrationsUpdateStartedEvent, (payload: unknown) => {
+            const deferredRegistrationsUpdateSpan = getDeferredRegistrationsUpdateSpan();
+
+            const attributes = {
+                "app.squide.registration_count": (payload as RemoteModulesDeferredRegistrationsUpdateStartedEventPayload).registrationCount
+            };
+
+            if (deferredRegistrationsUpdateSpan) {
+                deferredRegistrationsUpdateSpan.addEvent("remote-module-deferred-registrations-update-started", attributes);
+            }
+
+            remoteModuleDeferredRegistrationsUpdateSpan = startActiveChildSpan(deferredRegistrationsUpdateSpan, (options, context) => {
+                const name = "remote-module-deferred-registrations-update";
+
+                const span = getTracer().startSpan(name, {
+                    attributes,
+                    ...options
+                }, context);
+
+                return {
+                    name,
+                    span
+                };
+            });
+        }, {
+            onError: handleUnmanagedError
+        });
+
+        // Can occur multiple times.
+        addProtectedListener(this._runtime, RemoteModulesDeferredRegistrationsUpdateCompletedEvent, (payload: unknown) => {
+            const deferredRegistrationsUpdateSpan = getDeferredRegistrationsUpdateSpan();
+
+            if (deferredRegistrationsUpdateSpan) {
+                deferredRegistrationsUpdateSpan.addEvent("remote-module-deferred-registrations-update-completed", {
+                    "app.squide.registration_count": (payload as RemoteModulesDeferredRegistrationsUpdateCompletedEventPayload).registrationCount
+                });
+            }
+
+            if (remoteModuleDeferredRegistrationsUpdateSpan) {
+                endActiveSpan(remoteModuleDeferredRegistrationsUpdateSpan);
+            }
+        }, {
+            onError: handleUnmanagedError
+        });
+
+        // Can occur multiple times.
+        addProtectedListener(this._runtime, RemoteModuleDeferredRegistrationUpdateFailedEvent, (payload: unknown) => {
+            const registrationError = payload as RemoteModuleRegistrationError;
+
+            if (remoteModuleDeferredRegistrationsUpdateSpan) {
+                traceError(remoteModuleDeferredRegistrationsUpdateSpan.instance, registrationError);
+            }
+        }, {
+            onError: handleUnmanagedError
+        });
+
+        // Cleanup the spans if the root tracking is failing.
+        return (error: unknown) => {
+            handleUnmanagedError(error);
+        };
+    }
+}
+
+export function getModuleFederationPlugin(runtime: Runtime) {
+    const plugin = runtime.getPlugin(ModuleFederationPluginName);
+
+    if (isNil(plugin)) {
+        throw new Error("[squide] The getModuleFederationPlugin function is called but no ModuleFederationPlugin instance has been registered with the runtime.");
+    }
+
+    return plugin as ModuleFederationPlugin;
+}

package/src/RemoteDefinition.ts

@@ -0,0 +1,5 @@
+export interface RemoteDefinition extends Record<string, unknown> {
+    // The name of the remote module.
+    name: string;
+}
+