@ice/mf-runtime 1.0.1 → 1.0.2-beta.1

package/esm/__tests__/plugin-manager.test.js

@@ -0,0 +1,348 @@
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { EnhancedPluginManager, getEnhancedPluginManager, registerEnhancedPlugin, registerEnhancedPlugins } from "../plugin-manager";
+import * as React from "react";
+describe("EnhancedPluginManager", function() {
+    var manager;
+    beforeEach(function() {
+        manager = new EnhancedPluginManager();
+    });
+    describe("Plugin Registration", function() {
+        it("should register an enhanced plugin", function() {
+            var enhancedPlugin = {
+                name: "test-enhanced",
+                wrapComponent: function(Component) {
+                    return Component;
+                },
+                injectProps: function(props) {
+                    return props;
+                }
+            };
+            manager.register(enhancedPlugin);
+            var plugins = manager.getPlugins();
+            expect(plugins).toHaveLength(1);
+            expect(plugins[0].name).toBe("test-enhanced");
+        });
+        it("should replace existing plugin with same name", function() {
+            var plugin1 = {
+                name: "test-plugin",
+                wrapComponent: function(Component) {
+                    return Component;
+                }
+            };
+            var plugin2 = {
+                name: "test-plugin",
+                injectProps: function(props) {
+                    return props;
+                }
+            };
+            manager.register(plugin1);
+            manager.register(plugin2);
+            var plugins = manager.getPlugins();
+            expect(plugins).toHaveLength(1);
+            expect(plugins[0]).toBe(plugin2);
+        });
+        it("should register multiple plugins", function() {
+            var plugins = [
+                {
+                    name: "plugin1",
+                    wrapComponent: function(Component) {
+                        return Component;
+                    }
+                },
+                {
+                    name: "plugin2",
+                    injectProps: function(props) {
+                        return props;
+                    }
+                }
+            ];
+            manager.registerPlugins(plugins);
+            expect(manager.getPlugins()).toHaveLength(2);
+        });
+    });
+    describe("Component Wrapping", function() {
+        it("should wrap component with single plugin", function() {
+            var TestComponent = function() {
+                return React.createElement("div", null, "test");
+            };
+            var mockWrapper = vi.fn(function(Component) {
+                return Component;
+            });
+            var plugin = {
+                name: "wrapper-plugin",
+                wrapComponent: mockWrapper
+            };
+            manager.register(plugin);
+            var context = {
+                remoteName: "test-remote",
+                moduleName: "test-module",
+                props: {
+                    test: true
+                }
+            };
+            var wrappedComponent = manager.wrapComponent(TestComponent, context);
+            expect(mockWrapper).toHaveBeenCalledWith(TestComponent, context);
+            expect(wrappedComponent).toBe(TestComponent);
+        });
+        it("should apply multiple wrappers in order", function() {
+            var TestComponent = function() {
+                return React.createElement("div", null, "original");
+            };
+            var Wrapper1 = function() {
+                return React.createElement("div", null, "wrapper1");
+            };
+            var Wrapper2 = function() {
+                return React.createElement("div", null, "wrapper2");
+            };
+            var plugin1 = {
+                name: "wrapper1",
+                wrapComponent: function() {
+                    return Wrapper1;
+                }
+            };
+            var plugin2 = {
+                name: "wrapper2",
+                wrapComponent: function() {
+                    return Wrapper2;
+                }
+            };
+            // 注册顺序很重要
+            manager.register(plugin1);
+            manager.register(plugin2);
+            var context = {
+                remoteName: "test-remote",
+                moduleName: "test-module",
+                props: {}
+            };
+            var result = manager.wrapComponent(TestComponent, context);
+            // plugin2 应该最后执行，所以返回 Wrapper2
+            expect(result).toBe(Wrapper2);
+        });
+        it("should handle wrapper errors gracefully", function() {
+            var TestComponent = function() {
+                return React.createElement("div", null, "test");
+            };
+            var consoleSpy = vi.spyOn(console, "error").mockImplementation(function() {});
+            var plugin = {
+                name: "error-plugin",
+                wrapComponent: function() {
+                    throw new Error("Wrapper error");
+                }
+            };
+            manager.register(plugin);
+            var context = {
+                remoteName: "test-remote",
+                moduleName: "test-module",
+                props: {}
+            };
+            var result = manager.wrapComponent(TestComponent, context);
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Error applying wrapper from plugin "error-plugin"'), expect.any(Error));
+            expect(result).toBe(TestComponent); // 应该返回原始组件
+            consoleSpy.mockRestore();
+        });
+    });
+    describe("Props Injection", function() {
+        it("should inject props with single plugin", function() {
+            var mockInjector = vi.fn(function(props) {
+                return _object_spread_props(_object_spread({}, props), {
+                    injected: true
+                });
+            });
+            var plugin = {
+                name: "injector-plugin",
+                injectProps: mockInjector
+            };
+            manager.register(plugin);
+            var context = {
+                remoteName: "test-remote",
+                moduleName: "test-module"
+            };
+            var result = manager.injectProps({
+                original: true
+            }, context);
+            expect(mockInjector).toHaveBeenCalledWith({
+                original: true
+            }, context);
+            expect(result).toEqual({
+                original: true,
+                injected: true
+            });
+        });
+        it("should apply multiple injectors in order", function() {
+            var plugin1 = {
+                name: "injector1",
+                injectProps: function(props) {
+                    return _object_spread_props(_object_spread({}, props), {
+                        step1: true
+                    });
+                }
+            };
+            var plugin2 = {
+                name: "injector2",
+                injectProps: function(props) {
+                    return _object_spread_props(_object_spread({}, props), {
+                        step2: true
+                    });
+                }
+            };
+            manager.register(plugin1);
+            manager.register(plugin2);
+            var context = {
+                remoteName: "test-remote",
+                moduleName: "test-module"
+            };
+            var result = manager.injectProps({
+                original: true
+            }, context);
+            expect(result).toEqual({
+                original: true,
+                step1: true,
+                step2: true
+            });
+        });
+        it("should handle injection errors gracefully", function() {
+            var consoleSpy = vi.spyOn(console, "error").mockImplementation(function() {});
+            var plugin = {
+                name: "error-plugin",
+                injectProps: function() {
+                    throw new Error("Injection error");
+                }
+            };
+            manager.register(plugin);
+            var context = {
+                remoteName: "test-remote",
+                moduleName: "test-module"
+            };
+            var result = manager.injectProps({
+                original: true
+            }, context);
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Error injecting props from plugin "error-plugin"'), expect.any(Error));
+            expect(result).toEqual({
+                original: true
+            }); // 应该返回原始props
+            consoleSpy.mockRestore();
+        });
+    });
+    describe("Plugin Management", function() {
+        it("should get plugin info", function() {
+            var wrapperPlugin = {
+                name: "wrapper-plugin",
+                wrapComponent: function(Component) {
+                    return Component;
+                }
+            };
+            var injectorPlugin = {
+                name: "injector-plugin",
+                injectProps: function(props) {
+                    return props;
+                }
+            };
+            var hybridPlugin = {
+                name: "hybrid-plugin",
+                wrapComponent: function(Component) {
+                    return Component;
+                },
+                injectProps: function(props) {
+                    return props;
+                }
+            };
+            manager.register(wrapperPlugin);
+            manager.register(injectorPlugin);
+            manager.register(hybridPlugin);
+            var info = manager.getPluginInfo();
+            expect(info).toHaveLength(3);
+            expect(info[0]).toEqual({
+                name: "wrapper-plugin",
+                hasWrapper: true,
+                hasInjector: false
+            });
+            expect(info[1]).toEqual({
+                name: "injector-plugin",
+                hasWrapper: false,
+                hasInjector: true
+            });
+            expect(info[2]).toEqual({
+                name: "hybrid-plugin",
+                hasWrapper: true,
+                hasInjector: true
+            });
+        });
+        it("should remove plugin", function() {
+            var plugin = {
+                name: "test-plugin",
+                wrapComponent: function(Component) {
+                    return Component;
+                }
+            };
+            manager.register(plugin);
+            expect(manager.getPlugins()).toHaveLength(1);
+            var removed = manager.removePlugin("test-plugin");
+            expect(removed).toBe(true);
+            expect(manager.getPlugins()).toHaveLength(0);
+        });
+        it("should return false when removing non-existent plugin", function() {
+            var removed = manager.removePlugin("non-existent");
+            expect(removed).toBe(false);
+        });
+        it("should clear all plugins", function() {
+            manager.register({
+                name: "plugin1",
+                wrapComponent: function(Component) {
+                    return Component;
+                }
+            });
+            manager.register({
+                name: "plugin2",
+                injectProps: function(props) {
+                    return props;
+                }
+            });
+            expect(manager.getPlugins()).toHaveLength(2);
+            manager.clear();
+            expect(manager.getPlugins()).toHaveLength(0);
+        });
+    });
+    describe("Global Enhanced Plugin Manager", function() {
+        beforeEach(function() {
+            // 清理全局状态
+            getEnhancedPluginManager().clear();
+        });
+        it("should provide singleton instance", function() {
+            var manager1 = getEnhancedPluginManager();
+            var manager2 = getEnhancedPluginManager();
+            expect(manager1).toBe(manager2);
+        });
+        it("should register plugin via convenience function", function() {
+            var plugin = {
+                name: "convenience-plugin",
+                wrapComponent: function(Component) {
+                    return Component;
+                }
+            };
+            registerEnhancedPlugin(plugin);
+            var manager = getEnhancedPluginManager();
+            expect(manager.getPlugins()).toContainEqual(plugin);
+        });
+        it("should register multiple plugins via convenience function", function() {
+            var plugins = [
+                {
+                    name: "plugin1",
+                    wrapComponent: function(Component) {
+                        return Component;
+                    }
+                },
+                {
+                    name: "plugin2",
+                    injectProps: function(props) {
+                        return props;
+                    }
+                }
+            ];
+            registerEnhancedPlugins(plugins);
+            var manager = getEnhancedPluginManager();
+            expect(manager.getPlugins()).toHaveLength(2);
+        });
+    });
+});

package/esm/__tests__/setup.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/__tests__/setup.js

@@ -0,0 +1,43 @@
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { vi } from "vitest";
+// Test setup for ice-mf-runtime
+// Mock @ice/stark-app dependency
+vi.mock("@ice/stark-app", function() {
+    return {
+        getBasename: function() {
+            return "/app";
+        }
+    };
+});
+// Mock @module-federation/runtime
+vi.mock("@module-federation/runtime", function() {
+    return {
+        init: vi.fn(),
+        registerPlugins: vi.fn(),
+        loadRemote: vi.fn()
+    };
+});
+// Mock performance API
+Object.defineProperty(globalThis, "performance", {
+    value: {
+        now: function() {
+            return Date.now();
+        }
+    },
+    writable: true
+});
+// Suppress console warnings during tests
+var originalWarn = console.warn;
+console.warn = function() {
+    for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+        args[_key] = arguments[_key];
+    }
+    var _originalWarn;
+    var _args__includes, _args_;
+    if ((_args_ = args[0]) === null || _args_ === void 0 ? void 0 : (_args__includes = _args_.includes) === null || _args__includes === void 0 ? void 0 : _args__includes.call(_args_, "Warning: ReactDOM.render is no longer supported")) {
+        return;
+    }
+    (_originalWarn = originalWarn).call.apply(_originalWarn, [
+        console
+    ].concat(_to_consumable_array(args)));
+};

package/esm/index.d.ts

@@ -2,5 +2,7 @@ import type { ExtendedUserOptions, MicroMod } from './types';
 export { loadRemote, registerPlugins } from '@module-federation/runtime';
 export * from './FallBack';
 export * from './RemoteModule';
+export * from './types';
+export * from './plugin-manager';
 export declare function init(options: ExtendedUserOptions, microMods?: MicroMod[]): void;
 export declare function initByMicroMods(microMods: MicroMod[], hostName?: string): void;

package/esm/index.js

@@ -1,14 +1,16 @@
 import { getBasename } from "@ice/stark-app";
-import { registerPlugins, init as mfInit } from "@module-federation/runtime";
+import { registerPlugins as mfRegisterPlugins, init as mfInit } from "@module-federation/runtime";
 import { runtimePlugin } from "./runtime-plugin";
 import { initGlobalStore } from "./mf-global-store";
 export { loadRemote, registerPlugins } from "@module-federation/runtime";
 export * from "./FallBack";
 export * from "./RemoteModule";
+export * from "./types";
+export * from "./plugin-manager";
 export function init(options, microMods) {
     initGlobalStore(options, microMods);
     mfInit(options);
-    registerPlugins([
+    mfRegisterPlugins([
         runtimePlugin()
     ]);
 }

package/esm/plugin-manager.d.ts

@@ -0,0 +1,79 @@
+import type { EnhancedRuntimePlugin, WrapperContext, InjectionContext } from './types';
+import * as React from 'react';
+/**
+ * 增强插件管理器 - 专门负责管理和执行增强运行时插件
+ * 标准 MF 插件交由底层 @module-federation/runtime 管理
+ */
+export declare class EnhancedPluginManager {
+    private plugins;
+    /**
+     * 注册增强插件
+     * @param plugin 增强运行时插件
+     */
+    register(plugin: EnhancedRuntimePlugin): void;
+    /**
+     * 注册多个增强插件
+     * @param plugins 增强插件数组
+     */
+    registerPlugins(plugins: EnhancedRuntimePlugin[]): void;
+    /**
+     * 获取所有增强插件列表
+     * @returns 增强插件数组
+     */
+    getPlugins(): EnhancedRuntimePlugin[];
+    /**
+     * 应用组件包装器
+     * 按插件注册顺序依次应用所有组件包装器
+     * @param Component 原始组件
+     * @param context 包装器上下文
+     * @returns 包装后的组件
+     */
+    wrapComponent(Component: React.ComponentType, context: WrapperContext): React.ComponentType;
+    /**
+     * 注入属性
+     * 按插件注册顺序依次应用所有属性注入器
+     * @param props 原始属性
+     * @param context 注入上下文
+     * @returns 注入后的属性
+     */
+    injectProps(props: Record<string, any>, context: InjectionContext): Record<string, any>;
+    /**
+     * 获取所有插件信息
+     * @returns 插件信息数组
+     */
+    getPluginInfo(): Array<{
+        name: string;
+        hasWrapper: boolean;
+        hasInjector: boolean;
+    }>;
+    /**
+     * 移除插件
+     * @param name 插件名称
+     * @returns 是否成功移除
+     */
+    removePlugin(name: string): boolean;
+    /**
+     * 清空所有插件
+     */
+    clear(): void;
+}
+/**
+ * 获取全局增强插件管理器实例
+ * @returns 增强插件管理器实例
+ */
+export declare function getEnhancedPluginManager(): EnhancedPluginManager;
+/**
+ * 注册增强插件（便捷函数）
+ * @param plugin 增强运行时插件
+ */
+export declare function registerEnhancedPlugin(plugin: EnhancedRuntimePlugin): void;
+/**
+ * 注册多个增强插件（便捷函数）
+ * @param plugins 增强插件数组
+ */
+export declare function registerEnhancedPlugins(plugins: EnhancedRuntimePlugin[]): void;
+/**
+ * React Hook：使用增强插件管理器
+ * @returns 增强插件管理器实例
+ */
+export declare function useEnhancedPluginManager(): EnhancedPluginManager;