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

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

@@ -1,348 +0,0 @@
-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

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

package/esm/__tests__/setup.js

@@ -1,43 +0,0 @@
-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/plugin-manager.d.ts

@@ -1,79 +0,0 @@
-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;

package/esm/plugin-manager.js

@@ -1,207 +0,0 @@
-import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
-import { _ as _create_class } from "@swc/helpers/_/_create_class";
-import { _ as _define_property } from "@swc/helpers/_/_define_property";
-import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
-import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
-import * as React from "react";
-/**
- * 增强插件管理器 - 专门负责管理和执行增强运行时插件
- * 标准 MF 插件交由底层 @module-federation/runtime 管理
- */ export var EnhancedPluginManager = /*#__PURE__*/ function() {
-    "use strict";
-    function EnhancedPluginManager() {
-        _class_call_check(this, EnhancedPluginManager);
-        _define_property(this, "plugins", []);
-    }
-    _create_class(EnhancedPluginManager, [
-        {
-            /**
-   * 注册增强插件
-   * @param plugin 增强运行时插件
-   */ key: "register",
-            value: function register(plugin) {
-                // 检查是否已存在同名插件
-                var existingIndex = this.plugins.findIndex(function(p) {
-                    return p.name === plugin.name;
-                });
-                if (existingIndex >= 0) {
-                    console.warn('Enhanced plugin "'.concat(plugin.name, '" already exists, replacing it.'));
-                    this.plugins[existingIndex] = plugin;
-                } else {
-                    this.plugins.push(plugin);
-                }
-            }
-        },
-        {
-            /**
-   * 注册多个增强插件
-   * @param plugins 增强插件数组
-   */ key: "registerPlugins",
-            value: function registerPlugins(plugins) {
-                var _this = this;
-                plugins.forEach(function(plugin) {
-                    return _this.register(plugin);
-                });
-            }
-        },
-        {
-            /**
-   * 获取所有增强插件列表
-   * @returns 增强插件数组
-   */ key: "getPlugins",
-            value: function getPlugins() {
-                return _to_consumable_array(this.plugins);
-            }
-        },
-        {
-            /**
-   * 应用组件包装器
-   * 按插件注册顺序依次应用所有组件包装器
-   * @param Component 原始组件
-   * @param context 包装器上下文
-   * @returns 包装后的组件
-   */ key: "wrapComponent",
-            value: function wrapComponent(Component, context) {
-                var WrappedComponent = Component;
-                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                try {
-                    // 按数组顺序依次应用所有组件包装器
-                    for(var _iterator = this.plugins[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                        var plugin = _step.value;
-                        if (plugin.wrapComponent) {
-                            try {
-                                WrappedComponent = plugin.wrapComponent(WrappedComponent, context);
-                            } catch (error) {
-                                console.error('Error applying wrapper from plugin "'.concat(plugin.name, '":'), error);
-                            }
-                        }
-                    }
-                } catch (err) {
-                    _didIteratorError = true;
-                    _iteratorError = err;
-                } finally{
-                    try {
-                        if (!_iteratorNormalCompletion && _iterator.return != null) {
-                            _iterator.return();
-                        }
-                    } finally{
-                        if (_didIteratorError) {
-                            throw _iteratorError;
-                        }
-                    }
-                }
-                return WrappedComponent;
-            }
-        },
-        {
-            /**
-   * 注入属性
-   * 按插件注册顺序依次应用所有属性注入器
-   * @param props 原始属性
-   * @param context 注入上下文
-   * @returns 注入后的属性
-   */ key: "injectProps",
-            value: function injectProps(props, context) {
-                var injectedProps = _object_spread({}, props);
-                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                try {
-                    // 按数组顺序依次应用所有属性注入器
-                    for(var _iterator = this.plugins[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                        var plugin = _step.value;
-                        if (plugin.injectProps) {
-                            try {
-                                injectedProps = plugin.injectProps(injectedProps, context);
-                            } catch (error) {
-                                console.error('Error injecting props from plugin "'.concat(plugin.name, '":'), error);
-                            }
-                        }
-                    }
-                } catch (err) {
-                    _didIteratorError = true;
-                    _iteratorError = err;
-                } finally{
-                    try {
-                        if (!_iteratorNormalCompletion && _iterator.return != null) {
-                            _iterator.return();
-                        }
-                    } finally{
-                        if (_didIteratorError) {
-                            throw _iteratorError;
-                        }
-                    }
-                }
-                return injectedProps;
-            }
-        },
-        {
-            /**
-   * 获取所有插件信息
-   * @returns 插件信息数组
-   */ key: "getPluginInfo",
-            value: function getPluginInfo() {
-                return this.plugins.map(function(plugin) {
-                    return {
-                        name: plugin.name,
-                        hasWrapper: !!plugin.wrapComponent,
-                        hasInjector: !!plugin.injectProps
-                    };
-                });
-            }
-        },
-        {
-            /**
-   * 移除插件
-   * @param name 插件名称
-   * @returns 是否成功移除
-   */ key: "removePlugin",
-            value: function removePlugin(name) {
-                var index = this.plugins.findIndex(function(p) {
-                    return p.name === name;
-                });
-                if (index !== -1) {
-                    this.plugins.splice(index, 1);
-                    return true;
-                }
-                return false;
-            }
-        },
-        {
-            /**
-   * 清空所有插件
-   */ key: "clear",
-            value: function clear() {
-                this.plugins = [];
-            }
-        }
-    ]);
-    return EnhancedPluginManager;
-}();
-// 全局增强插件管理器实例
-var globalEnhancedPluginManager = null;
-/**
- * 获取全局增强插件管理器实例
- * @returns 增强插件管理器实例
- */ export function getEnhancedPluginManager() {
-    if (!globalEnhancedPluginManager) {
-        globalEnhancedPluginManager = new EnhancedPluginManager();
-    }
-    return globalEnhancedPluginManager;
-}
-/**
- * 注册增强插件（便捷函数）
- * @param plugin 增强运行时插件
- */ export function registerEnhancedPlugin(plugin) {
-    getEnhancedPluginManager().register(plugin);
-}
-/**
- * 注册多个增强插件（便捷函数）
- * @param plugins 增强插件数组
- */ export function registerEnhancedPlugins(plugins) {
-    getEnhancedPluginManager().registerPlugins(plugins);
-}
-/**
- * React Hook：使用增强插件管理器
- * @returns 增强插件管理器实例
- */ export function useEnhancedPluginManager() {
-    return getEnhancedPluginManager();
-}