@module-federation/runtime-core 0.23.0 → 0.24.1

package/dist/index.cjs.cjs

@@ -201,7 +201,7 @@ function getGlobalFederationConstructor() {
 function setGlobalFederationConstructor(FederationConstructor, isDebug = sdk.isDebugMode()) {
     if (isDebug) {
         CurrentGlobal.__FEDERATION__.__DEBUG_CONSTRUCTOR__ = FederationConstructor;
-        CurrentGlobal.__FEDERATION__.__DEBUG_CONSTRUCTOR_VERSION__ = "0.23.0";
+        CurrentGlobal.__FEDERATION__.__DEBUG_CONSTRUCTOR_VERSION__ = "0.24.1";
     }
 }
 // eslint-disable-next-line @typescript-eslint/ban-types
@@ -808,6 +808,9 @@ function formatShare(shareArgs, from, name, shareStrategy) {
             throw new Error(`Can not get shared '${name}'!`);
         });
     }
+    if (shareArgs.shareConfig?.eager && shareArgs.treeShaking) {
+        throw new Error('Can not set "eager:true" and "treeShaking" at the same time!');
+    }
     return {
         deps: [],
         useIn: [],
@@ -828,37 +831,67 @@ function formatShare(shareArgs, from, name, shareStrategy) {
             ? shareArgs.scope
             : [shareArgs.scope ?? 'default'],
         strategy: (shareArgs.strategy ?? shareStrategy) || 'version-first',
+        treeShaking: shareArgs.treeShaking
+            ? {
+                ...shareArgs.treeShaking,
+                mode: shareArgs.treeShaking.mode ?? 'server-calc',
+                status: shareArgs.treeShaking.status ?? 1 /* TreeShakingStatus.UNKNOWN */,
+                useIn: [],
+            }
+            : undefined,
     };
 }
-function formatShareConfigs(globalOptions, userOptions) {
-    const shareArgs = userOptions.shared || {};
-    const from = userOptions.name;
-    const shareInfos = Object.keys(shareArgs).reduce((res, pkgName) => {
+function formatShareConfigs(prevOptions, newOptions) {
+    const shareArgs = newOptions.shared || {};
+    const from = newOptions.name;
+    const newShareInfos = Object.keys(shareArgs).reduce((res, pkgName) => {
         const arrayShareArgs = arrayOptions(shareArgs[pkgName]);
         res[pkgName] = res[pkgName] || [];
         arrayShareArgs.forEach((shareConfig) => {
-            res[pkgName].push(formatShare(shareConfig, from, pkgName, userOptions.shareStrategy));
+            res[pkgName].push(formatShare(shareConfig, from, pkgName, newOptions.shareStrategy));
         });
         return res;
     }, {});
-    const shared = {
-        ...globalOptions.shared,
+    const allShareInfos = {
+        ...prevOptions.shared,
     };
-    Object.keys(shareInfos).forEach((shareKey) => {
-        if (!shared[shareKey]) {
-            shared[shareKey] = shareInfos[shareKey];
+    Object.keys(newShareInfos).forEach((shareKey) => {
+        if (!allShareInfos[shareKey]) {
+            allShareInfos[shareKey] = newShareInfos[shareKey];
         }
         else {
-            shareInfos[shareKey].forEach((newUserSharedOptions) => {
-                const isSameVersion = shared[shareKey].find((sharedVal) => sharedVal.version === newUserSharedOptions.version);
+            newShareInfos[shareKey].forEach((newUserSharedOptions) => {
+                const isSameVersion = allShareInfos[shareKey].find((sharedVal) => sharedVal.version === newUserSharedOptions.version);
                 if (!isSameVersion) {
-                    shared[shareKey].push(newUserSharedOptions);
+                    allShareInfos[shareKey].push(newUserSharedOptions);
                 }
             });
         }
     });
-    return { shared, shareInfos };
+    return { allShareInfos, newShareInfos };
 }
+function shouldUseTreeShaking(treeShaking, usedExports) {
+    if (!treeShaking) {
+        return false;
+    }
+    const { status, mode } = treeShaking;
+    if (status === 0 /* TreeShakingStatus.NO_USE */) {
+        return false;
+    }
+    if (status === 2 /* TreeShakingStatus.CALCULATED */) {
+        return true;
+    }
+    if (mode === 'runtime-infer') {
+        if (!usedExports) {
+            return true;
+        }
+        return isMatchUsedExports(treeShaking, usedExports);
+    }
+    return false;
+}
+/**
+ * compare version a and b, return true if a is less than b
+ */
 function versionLt(a, b) {
     const transformInvalidVersion = (version) => {
         const isNumberVersion = !Number.isNaN(Number(version));
@@ -904,19 +937,79 @@ const isLoaded = (shared) => {
 const isLoading = (shared) => {
     return Boolean(shared.loading);
 };
-function findSingletonVersionOrderByVersion(shareScopeMap, scope, pkgName) {
+const isMatchUsedExports = (treeShaking, usedExports) => {
+    if (!treeShaking || !usedExports) {
+        return false;
+    }
+    const { usedExports: treeShakingUsedExports } = treeShaking;
+    if (!treeShakingUsedExports) {
+        return false;
+    }
+    if (usedExports.every((e) => treeShakingUsedExports.includes(e))) {
+        return true;
+    }
+    return false;
+};
+function findSingletonVersionOrderByVersion(shareScopeMap, scope, pkgName, treeShaking) {
     const versions = shareScopeMap[scope][pkgName];
+    let version = '';
+    let useTreesShaking = shouldUseTreeShaking(treeShaking);
+    // return false means use prev version
     const callback = function (prev, cur) {
+        if (useTreesShaking) {
+            if (!versions[prev].treeShaking) {
+                return true;
+            }
+            if (!versions[cur].treeShaking) {
+                return false;
+            }
+            return !isLoaded(versions[prev].treeShaking) && versionLt(prev, cur);
+        }
         return !isLoaded(versions[prev]) && versionLt(prev, cur);
     };
-    return findVersion(shareScopeMap[scope][pkgName], callback);
+    if (useTreesShaking) {
+        version = findVersion(shareScopeMap[scope][pkgName], callback);
+        if (version) {
+            return {
+                version,
+                useTreesShaking,
+            };
+        }
+        useTreesShaking = false;
+    }
+    return {
+        version: findVersion(shareScopeMap[scope][pkgName], callback),
+        useTreesShaking,
+    };
 }
-function findSingletonVersionOrderByLoaded(shareScopeMap, scope, pkgName) {
+const isLoadingOrLoaded = (shared) => {
+    return isLoaded(shared) || isLoading(shared);
+};
+function findSingletonVersionOrderByLoaded(shareScopeMap, scope, pkgName, treeShaking) {
     const versions = shareScopeMap[scope][pkgName];
+    let version = '';
+    let useTreesShaking = shouldUseTreeShaking(treeShaking);
+    // return false means use prev version
     const callback = function (prev, cur) {
-        const isLoadingOrLoaded = (shared) => {
-            return isLoaded(shared) || isLoading(shared);
-        };
+        if (useTreesShaking) {
+            if (!versions[prev].treeShaking) {
+                return true;
+            }
+            if (!versions[cur].treeShaking) {
+                return false;
+            }
+            if (isLoadingOrLoaded(versions[cur].treeShaking)) {
+                if (isLoadingOrLoaded(versions[prev].treeShaking)) {
+                    return Boolean(versionLt(prev, cur));
+                }
+                else {
+                    return true;
+                }
+            }
+            if (isLoadingOrLoaded(versions[prev].treeShaking)) {
+                return false;
+            }
+        }
         if (isLoadingOrLoaded(versions[cur])) {
             if (isLoadingOrLoaded(versions[prev])) {
                 return Boolean(versionLt(prev, cur));
@@ -930,7 +1023,20 @@ function findSingletonVersionOrderByLoaded(shareScopeMap, scope, pkgName) {
         }
         return versionLt(prev, cur);
     };
-    return findVersion(shareScopeMap[scope][pkgName], callback);
+    if (useTreesShaking) {
+        version = findVersion(shareScopeMap[scope][pkgName], callback);
+        if (version) {
+            return {
+                version,
+                useTreesShaking,
+            };
+        }
+        useTreesShaking = false;
+    }
+    return {
+        version: findVersion(shareScopeMap[scope][pkgName], callback),
+        useTreesShaking,
+    };
 }
 function getFindShareFunction(strategy) {
     if (strategy === 'loaded-first') {
@@ -942,7 +1048,7 @@ function getRegisteredShare(localShareScopeMap, pkgName, shareInfo, resolveShare
     if (!localShareScopeMap) {
         return;
     }
-    const { shareConfig, scope = DEFAULT_SCOPE, strategy } = shareInfo;
+    const { shareConfig, scope = DEFAULT_SCOPE, strategy, treeShaking, } = shareInfo;
     const scopes = Array.isArray(scope) ? scope : [scope];
     for (const sc of scopes) {
         if (shareConfig &&
@@ -950,14 +1056,13 @@ function getRegisteredShare(localShareScopeMap, pkgName, shareInfo, resolveShare
             localShareScopeMap[sc][pkgName]) {
             const { requiredVersion } = shareConfig;
             const findShareFunction = getFindShareFunction(strategy);
-            const maxOrSingletonVersion = findShareFunction(localShareScopeMap, sc, pkgName);
-            //@ts-ignore
+            const { version: maxOrSingletonVersion, useTreesShaking } = findShareFunction(localShareScopeMap, sc, pkgName, treeShaking);
             const defaultResolver = () => {
+                const shared = localShareScopeMap[sc][pkgName][maxOrSingletonVersion];
                 if (shareConfig.singleton) {
                     if (typeof requiredVersion === 'string' &&
                         !satisfy(maxOrSingletonVersion, requiredVersion)) {
-                        const msg = `Version ${maxOrSingletonVersion} from ${maxOrSingletonVersion &&
-                            localShareScopeMap[sc][pkgName][maxOrSingletonVersion].from} of shared singleton module ${pkgName} does not satisfy the requirement of ${shareInfo.from} which needs ${requiredVersion})`;
+                        const msg = `Version ${maxOrSingletonVersion} from ${maxOrSingletonVersion && shared.from} of shared singleton module ${pkgName} does not satisfy the requirement of ${shareInfo.from} which needs ${requiredVersion})`;
                         if (shareConfig.strictVersion) {
                             error(msg);
                         }
@@ -965,21 +1070,48 @@ function getRegisteredShare(localShareScopeMap, pkgName, shareInfo, resolveShare
                             warn(msg);
                         }
                     }
-                    return localShareScopeMap[sc][pkgName][maxOrSingletonVersion];
+                    return {
+                        shared,
+                        useTreesShaking,
+                    };
                 }
                 else {
                     if (requiredVersion === false || requiredVersion === '*') {
-                        return localShareScopeMap[sc][pkgName][maxOrSingletonVersion];
+                        return {
+                            shared,
+                            useTreesShaking,
+                        };
                     }
                     if (satisfy(maxOrSingletonVersion, requiredVersion)) {
-                        return localShareScopeMap[sc][pkgName][maxOrSingletonVersion];
+                        return {
+                            shared,
+                            useTreesShaking,
+                        };
+                    }
+                    const _usedTreeShaking = shouldUseTreeShaking(treeShaking);
+                    if (_usedTreeShaking) {
+                        for (const [versionKey, versionValue] of Object.entries(localShareScopeMap[sc][pkgName])) {
+                            if (!shouldUseTreeShaking(versionValue.treeShaking, treeShaking?.usedExports)) {
+                                continue;
+                            }
+                            if (satisfy(versionKey, requiredVersion)) {
+                                return {
+                                    shared: versionValue,
+                                    useTreesShaking: _usedTreeShaking,
+                                };
+                            }
+                        }
                     }
                     for (const [versionKey, versionValue] of Object.entries(localShareScopeMap[sc][pkgName])) {
                         if (satisfy(versionKey, requiredVersion)) {
-                            return versionValue;
+                            return {
+                                shared: versionValue,
+                                useTreesShaking: false,
+                            };
                         }
                     }
                 }
+                return;
             };
             const params = {
                 shareScopeMap: localShareScopeMap,
@@ -987,6 +1119,7 @@ function getRegisteredShare(localShareScopeMap, pkgName, shareInfo, resolveShare
                 pkgName,
                 version: maxOrSingletonVersion,
                 GlobalFederation: Global.__FEDERATION__,
+                shareInfo,
                 resolver: defaultResolver,
             };
             const resolveShared = resolveShare.emit(params) || params;
@@ -1008,13 +1141,47 @@ function getTargetSharedOptions(options) {
             shareVersionMap[shared.version] = shared;
         });
         const callback = function (prev, cur) {
-            return !isLoaded(shareVersionMap[prev]) && versionLt(prev, cur);
+            return (
+            // TODO: consider multiple treeShaking shared scenes
+            !isLoaded(shareVersionMap[prev]) && versionLt(prev, cur));
         };
         const maxVersion = findVersion(shareVersionMap, callback);
         return shareVersionMap[maxVersion];
     };
     const resolver = extraOptions?.resolver ?? defaultResolver;
-    return Object.assign({}, resolver(shareInfos[pkgName]), extraOptions?.customShareInfo);
+    const isPlainObject = (val) => {
+        return val !== null && typeof val === 'object' && !Array.isArray(val);
+    };
+    const merge = (...sources) => {
+        const out = {};
+        for (const src of sources) {
+            if (!src)
+                continue;
+            for (const [key, value] of Object.entries(src)) {
+                const prev = out[key];
+                if (isPlainObject(prev) && isPlainObject(value)) {
+                    out[key] = merge(prev, value);
+                }
+                else if (value !== undefined) {
+                    out[key] = value;
+                }
+            }
+        }
+        return out;
+    };
+    return merge(resolver(shareInfos[pkgName]), extraOptions?.customShareInfo);
+}
+const addUseIn = (shared, from) => {
+    if (!shared.useIn) {
+        shared.useIn = [];
+    }
+    addUniqueItem(shared.useIn, from);
+};
+function directShare(shared, useTreesShaking) {
+    if (useTreesShaking && shared.treeShaking) {
+        return shared.treeShaking;
+    }
+    return shared;
 }
 
 function getBuilderId() {
@@ -1526,9 +1693,44 @@ var helpers = {
     },
 };
 
+function createRemoteEntryInitOptions(remoteInfo, hostShareScopeMap) {
+    const localShareScopeMap = hostShareScopeMap;
+    const shareScopeKeys = Array.isArray(remoteInfo.shareScope)
+        ? remoteInfo.shareScope
+        : [remoteInfo.shareScope];
+    if (!shareScopeKeys.length) {
+        shareScopeKeys.push('default');
+    }
+    shareScopeKeys.forEach((shareScopeKey) => {
+        if (!localShareScopeMap[shareScopeKey]) {
+            localShareScopeMap[shareScopeKey] = {};
+        }
+    });
+    const remoteEntryInitOptions = {
+        version: remoteInfo.version || '',
+        shareScopeKeys: Array.isArray(remoteInfo.shareScope)
+            ? shareScopeKeys
+            : remoteInfo.shareScope || 'default',
+    };
+    // Help to find host instance
+    Object.defineProperty(remoteEntryInitOptions, 'shareScopeMap', {
+        value: localShareScopeMap,
+        // remoteEntryInitOptions will be traversed and assigned during container init, ,so this attribute is not allowed to be traversed
+        enumerable: false,
+    });
+    // TODO: compate legacy init params, should use shareScopeMap if exist
+    const shareScope = localShareScopeMap[shareScopeKeys[0]];
+    const initScope = [];
+    return {
+        remoteEntryInitOptions,
+        shareScope,
+        initScope,
+    };
+}
 class Module {
     constructor({ remoteInfo, host, }) {
         this.inited = false;
+        this.initing = false;
         this.lib = undefined;
         this.remoteInfo = remoteInfo;
         this.host = host;
@@ -1550,34 +1752,9 @@ class Module {
     async init(id, remoteSnapshot) {
         // Get remoteEntry.js
         const remoteEntryExports = await this.getEntry();
-        if (!this.inited) {
-            const localShareScopeMap = this.host.shareScopeMap;
-            const shareScopeKeys = Array.isArray(this.remoteInfo.shareScope)
-                ? this.remoteInfo.shareScope
-                : [this.remoteInfo.shareScope];
-            if (!shareScopeKeys.length) {
-                shareScopeKeys.push('default');
-            }
-            shareScopeKeys.forEach((shareScopeKey) => {
-                if (!localShareScopeMap[shareScopeKey]) {
-                    localShareScopeMap[shareScopeKey] = {};
-                }
-            });
-            // TODO: compate legacy init params, should use shareScopeMap if exist
-            const shareScope = localShareScopeMap[shareScopeKeys[0]];
-            const initScope = [];
-            const remoteEntryInitOptions = {
-                version: this.remoteInfo.version || '',
-                shareScopeKeys: Array.isArray(this.remoteInfo.shareScope)
-                    ? shareScopeKeys
-                    : this.remoteInfo.shareScope || 'default',
-            };
-            // Help to find host instance
-            Object.defineProperty(remoteEntryInitOptions, 'shareScopeMap', {
-                value: localShareScopeMap,
-                // remoteEntryInitOptions will be traversed and assigned during container init, ,so this attribute is not allowed to be traversed
-                enumerable: false,
-            });
+        if (!this.inited && !this.initing) {
+            this.initing = true;
+            const { remoteEntryInitOptions, shareScope, initScope } = createRemoteEntryInitOptions(this.remoteInfo, this.host.shareScopeMap);
             const initContainerOptions = await this.host.hooks.lifecycle.beforeInitContainer.emit({
                 shareScope,
                 // @ts-ignore shareScopeMap will be set by Object.defineProperty
@@ -1601,6 +1778,7 @@ class Module {
                 remoteSnapshot,
                 remoteEntryExports,
             });
+            this.inited = true;
         }
         return remoteEntryExports;
     }
@@ -1609,7 +1787,6 @@ class Module {
         const { loadFactory = true } = options || { loadFactory: true };
         const remoteEntryExports = await this.init(id, remoteSnapshot);
         this.lib = remoteEntryExports;
-        this.inited = true;
         let moduleFactory;
         moduleFactory = await this.host.loaderHook.lifecycle.getModuleFactory.emit({
             remoteEntryExports,
@@ -2063,7 +2240,7 @@ function generatePreloadAssets(origin, preloadOptions, remote, globalSnapshot, r
     }, true, memo, remoteSnapshot);
     if (remoteSnapshot.shared && remoteSnapshot.shared.length > 0) {
         const collectSharedAssets = (shareInfo, snapshotShared) => {
-            const registeredShared = getRegisteredShare(origin.shareScopeMap, snapshotShared.sharedName, shareInfo, origin.sharedHandler.hooks.lifecycle.resolveShare);
+            const { shared: registeredShared } = getRegisteredShare(origin.shareScopeMap, snapshotShared.sharedName, shareInfo, origin.sharedHandler.hooks.lifecycle.resolveShare) || {};
             // If the global share does not exist, or the lib function does not exist, it means that the shared has not been loaded yet and can be preloaded.
             if (registeredShared && typeof registeredShared.lib === 'function') {
                 snapshotShared.assets.js.sync.forEach((asset) => {
@@ -2354,6 +2531,7 @@ class SnapshotHandler {
 class SharedHandler {
     constructor(host) {
         this.hooks = new PluginSystem({
+            beforeRegisterShare: new SyncWaterfallHook('beforeRegisterShare'),
             afterResolve: new AsyncWaterfallHook('afterResolve'),
             beforeLoadShare: new AsyncWaterfallHook('beforeLoadShare'),
             // not used yet
@@ -2369,12 +2547,17 @@ class SharedHandler {
     }
     // register shared in shareScopeMap
     registerShared(globalOptions, userOptions) {
-        const { shareInfos, shared } = formatShareConfigs(globalOptions, userOptions);
-        const sharedKeys = Object.keys(shareInfos);
+        const { newShareInfos, allShareInfos } = formatShareConfigs(globalOptions, userOptions);
+        const sharedKeys = Object.keys(newShareInfos);
         sharedKeys.forEach((sharedKey) => {
-            const sharedVals = shareInfos[sharedKey];
+            const sharedVals = newShareInfos[sharedKey];
             sharedVals.forEach((sharedVal) => {
                 sharedVal.scope.forEach((sc) => {
+                    this.hooks.lifecycle.beforeRegisterShare.emit({
+                        origin: this.host,
+                        pkgName: sharedKey,
+                        shared: sharedVal,
+                    });
                     const registeredShared = this.shareScopeMap[sc]?.[sharedKey];
                     if (!registeredShared) {
                         this.setShared({
@@ -2390,8 +2573,8 @@ class SharedHandler {
             });
         });
         return {
-            shareInfos,
-            shared,
+            newShareInfos,
+            allShareInfos,
         };
     }
     async loadShare(pkgName, extraOptions) {
@@ -2422,61 +2605,61 @@ class SharedHandler {
         const { shareInfo: shareOptionsRes } = loadShareRes;
         // Assert that shareInfoRes exists, if not, throw an error
         assert(shareOptionsRes, `Cannot find ${pkgName} Share in the ${host.options.name}. Please ensure that the ${pkgName} Share parameters have been injected`);
-        // Retrieve from cache
-        const registeredShared = getRegisteredShare(this.shareScopeMap, pkgName, shareOptionsRes, this.hooks.lifecycle.resolveShare);
-        const addUseIn = (shared) => {
-            if (!shared.useIn) {
-                shared.useIn = [];
-            }
-            addUniqueItem(shared.useIn, host.options.name);
-        };
-        if (registeredShared && registeredShared.lib) {
-            addUseIn(registeredShared);
-            return registeredShared.lib;
-        }
-        else if (registeredShared &&
-            registeredShared.loading &&
-            !registeredShared.loaded) {
-            const factory = await registeredShared.loading;
-            registeredShared.loaded = true;
-            if (!registeredShared.lib) {
-                registeredShared.lib = factory;
-            }
-            addUseIn(registeredShared);
-            return factory;
-        }
-        else if (registeredShared) {
-            const asyncLoadProcess = async () => {
-                const factory = await registeredShared.get();
-                addUseIn(registeredShared);
-                registeredShared.loaded = true;
-                registeredShared.lib = factory;
+        const { shared: registeredShared, useTreesShaking } = getRegisteredShare(this.shareScopeMap, pkgName, shareOptionsRes, this.hooks.lifecycle.resolveShare) || {};
+        if (registeredShared) {
+            const targetShared = directShare(registeredShared, useTreesShaking);
+            if (targetShared.lib) {
+                addUseIn(targetShared, host.options.name);
+                return targetShared.lib;
+            }
+            else if (targetShared.loading && !targetShared.loaded) {
+                const factory = await targetShared.loading;
+                targetShared.loaded = true;
+                if (!targetShared.lib) {
+                    targetShared.lib = factory;
+                }
+                addUseIn(targetShared, host.options.name);
                 return factory;
-            };
-            const loading = asyncLoadProcess();
-            this.setShared({
-                pkgName,
-                loaded: false,
-                shared: registeredShared,
-                from: host.options.name,
-                lib: null,
-                loading,
-            });
-            return loading;
+            }
+            else {
+                const asyncLoadProcess = async () => {
+                    const factory = await targetShared.get();
+                    addUseIn(targetShared, host.options.name);
+                    targetShared.loaded = true;
+                    targetShared.lib = factory;
+                    return factory;
+                };
+                const loading = asyncLoadProcess();
+                this.setShared({
+                    pkgName,
+                    loaded: false,
+                    shared: registeredShared,
+                    from: host.options.name,
+                    lib: null,
+                    loading,
+                    treeShaking: useTreesShaking
+                        ? targetShared
+                        : undefined,
+                });
+                return loading;
+            }
         }
         else {
             if (extraOptions?.customShareInfo) {
                 return false;
             }
+            const _useTreeShaking = shouldUseTreeShaking(shareOptionsRes.treeShaking);
+            const targetShared = directShare(shareOptionsRes, _useTreeShaking);
             const asyncLoadProcess = async () => {
-                const factory = await shareOptionsRes.get();
-                shareOptionsRes.lib = factory;
-                shareOptionsRes.loaded = true;
-                addUseIn(shareOptionsRes);
-                const gShared = getRegisteredShare(this.shareScopeMap, pkgName, shareOptionsRes, this.hooks.lifecycle.resolveShare);
+                const factory = await targetShared.get();
+                targetShared.lib = factory;
+                targetShared.loaded = true;
+                addUseIn(targetShared, host.options.name);
+                const { shared: gShared, useTreesShaking: gUseTreeShaking } = getRegisteredShare(this.shareScopeMap, pkgName, shareOptionsRes, this.hooks.lifecycle.resolveShare) || {};
                 if (gShared) {
-                    gShared.lib = factory;
-                    gShared.loaded = true;
+                    const targetGShared = directShare(gShared, gUseTreeShaking);
+                    targetGShared.lib = factory;
+                    targetGShared.loaded = true;
                     gShared.from = shareOptionsRes.from;
                 }
                 return factory;
@@ -2489,6 +2672,9 @@ class SharedHandler {
                 from: host.options.name,
                 lib: null,
                 loading,
+                treeShaking: _useTreeShaking
+                    ? targetShared
+                    : undefined,
             });
             return loading;
         }
@@ -2528,15 +2714,17 @@ class SharedHandler {
             const { version, eager } = shared;
             scope[name] = scope[name] || {};
             const versions = scope[name];
-            const activeVersion = versions[version];
+            const activeVersion = versions[version] && directShare(versions[version]);
             const activeVersionEager = Boolean(activeVersion &&
-                (activeVersion.eager || activeVersion.shareConfig?.eager));
+                (('eager' in activeVersion && activeVersion.eager) ||
+                    ('shareConfig' in activeVersion &&
+                        activeVersion.shareConfig?.eager)));
             if (!activeVersion ||
                 (activeVersion.strategy !== 'loaded-first' &&
                     !activeVersion.loaded &&
                     (Boolean(!eager) !== !activeVersionEager
                         ? eager
-                        : hostName > activeVersion.from))) {
+                        : hostName > versions[version].from))) {
                 versions[version] = shared;
             }
         };
@@ -2544,7 +2732,26 @@ class SharedHandler {
             const { module } = await host.remoteHandler.getRemoteModuleAndOptions({
                 id: key,
             });
-            await module.init();
+            let remoteEntryExports = undefined;
+            try {
+                remoteEntryExports = await module.getEntry();
+            }
+            catch (error) {
+                remoteEntryExports =
+                    (await host.remoteHandler.hooks.lifecycle.errorLoadRemote.emit({
+                        id: key,
+                        error,
+                        from: 'runtime',
+                        lifecycle: 'beforeLoadShare',
+                        origin: host,
+                    }));
+            }
+            finally {
+                if (remoteEntryExports?.init) {
+                    module.remoteEntryExports = remoteEntryExports;
+                    await module.init();
+                }
+            }
         };
         Object.keys(host.options.shared).forEach((shareName) => {
             const sharedArr = host.options.shared[shareName];
@@ -2581,16 +2788,10 @@ class SharedHandler {
                 this.initializeSharing(shareScope, { strategy: shareOptions.strategy });
             });
         }
-        const registeredShared = getRegisteredShare(this.shareScopeMap, pkgName, shareOptions, this.hooks.lifecycle.resolveShare);
-        const addUseIn = (shared) => {
-            if (!shared.useIn) {
-                shared.useIn = [];
-            }
-            addUniqueItem(shared.useIn, host.options.name);
-        };
+        const { shared: registeredShared, useTreesShaking } = getRegisteredShare(this.shareScopeMap, pkgName, shareOptions, this.hooks.lifecycle.resolveShare) || {};
         if (registeredShared) {
             if (typeof registeredShared.lib === 'function') {
-                addUseIn(registeredShared);
+                addUseIn(registeredShared, host.options.name);
                 if (!registeredShared.loaded) {
                     registeredShared.loaded = true;
                     if (registeredShared.from === host.options.name) {
@@ -2602,7 +2803,7 @@ class SharedHandler {
             if (typeof registeredShared.get === 'function') {
                 const module = registeredShared.get();
                 if (!(module instanceof Promise)) {
-                    addUseIn(registeredShared);
+                    addUseIn(registeredShared, host.options.name);
                     this.setShared({
                         pkgName,
                         loaded: true,
@@ -2655,9 +2856,20 @@ class SharedHandler {
             hostShareScopeMap: extraOptions.hostShareScopeMap,
         });
     }
-    setShared({ pkgName, shared, from, lib, loading, loaded, get, }) {
+    setShared({ pkgName, shared, from, lib, loading, loaded, get, treeShaking, }) {
         const { version, scope = 'default', ...shareInfo } = shared;
         const scopes = Array.isArray(scope) ? scope : [scope];
+        const mergeAttrs = (shared) => {
+            const merge = (s, key, val) => {
+                if (val && !s[key]) {
+                    s[key] = val;
+                }
+            };
+            const targetShared = (treeShaking ? shared.treeShaking : shared);
+            merge(targetShared, 'loaded', loaded);
+            merge(targetShared, 'loading', loading);
+            merge(targetShared, 'get', get);
+        };
         scopes.forEach((sc) => {
             if (!this.shareScopeMap[sc]) {
                 this.shareScopeMap[sc] = {};
@@ -2671,21 +2883,10 @@ class SharedHandler {
                     scope: [sc],
                     ...shareInfo,
                     lib,
-                    loaded,
-                    loading,
                 };
-                if (get) {
-                    this.shareScopeMap[sc][pkgName][version].get = get;
-                }
-                return;
             }
             const registeredShared = this.shareScopeMap[sc][pkgName][version];
-            if (loading && !registeredShared.loading) {
-                registeredShared.loading = loading;
-            }
-            if (loaded && !registeredShared.loaded) {
-                registeredShared.loaded = loaded;
-            }
+            mergeAttrs(registeredShared);
             if (from && registeredShared.from !== from) {
                 registeredShared.from = from;
             }
@@ -2713,6 +2914,7 @@ class RemoteHandler {
             generatePreloadAssets: new AsyncHook('generatePreloadAssets'),
             // not used yet
             afterPreloadRemote: new AsyncHook(),
+            // TODO: Move to loaderHook
             loadEntry: new AsyncHook(),
         });
         this.host = host;
@@ -3061,7 +3263,7 @@ class ModuleFederation {
             // maybe will change, temporarily for internal use only
             initContainer: new AsyncWaterfallHook('initContainer'),
         });
-        this.version = "0.23.0";
+        this.version = "0.24.1";
         this.moduleCache = new Map();
         this.loaderHook = new PluginSystem({
             // FIXME: may not be suitable , not open to the public yet
@@ -3142,7 +3344,7 @@ class ModuleFederation {
         this.sharedHandler.initShareScopeMap(scopeName, shareScope, extraOptions);
     }
     formatOptions(globalOptions, userOptions) {
-        const { shared } = formatShareConfigs(globalOptions, userOptions);
+        const { allShareInfos: shared} = formatShareConfigs(globalOptions, userOptions);
         const { userOptions: userOptionsRes, options: globalOptionsRes } = this.hooks.lifecycle.beforeInit.emit({
             origin: this,
             userOptions,
@@ -3150,7 +3352,7 @@ class ModuleFederation {
             shareInfo: shared,
         });
         const remotes = this.remoteHandler.formatAndRegisterRemote(globalOptionsRes, userOptionsRes);
-        const { shared: handledShared } = this.sharedHandler.registerShared(globalOptionsRes, userOptionsRes);
+        const { allShareInfos } = this.sharedHandler.registerShared(globalOptionsRes, userOptionsRes);
         const plugins = [...globalOptionsRes.plugins];
         if (userOptionsRes.plugins) {
             userOptionsRes.plugins.forEach((plugin) => {
@@ -3164,7 +3366,7 @@ class ModuleFederation {
             ...userOptions,
             plugins,
             remotes,
-            shared: handledShared,
+            shared: allShareInfos,
         };
         this.hooks.lifecycle.init.emit({
             origin: this,