@module-federation/runtime-core 0.0.0-feat-shared-treeshake-poc-20251230095050 → 0.0.0-feat-shared-treeshake-poc-20260112031921

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.0.0-feat-shared-treeshake-poc-20251230095050";
+        CurrentGlobal.__FEDERATION__.__DEBUG_CONSTRUCTOR_VERSION__ = "0.0.0-feat-shared-treeshake-poc-20260112031921";
     }
 }
 // eslint-disable-next-line @typescript-eslint/ban-types
@@ -808,8 +808,8 @@ function formatShare(shareArgs, from, name, shareStrategy) {
             throw new Error(`Can not get shared '${name}'!`);
         });
     }
-    if (shareArgs.shareConfig?.eager && shareArgs.treeshake) {
-        throw new Error('Can not set "eager:true" and "treeshake" at the same time!');
+    if (shareArgs.shareConfig?.eager && shareArgs.treeShaking) {
+        throw new Error('Can not set "eager:true" and "treeShaking" at the same time!');
     }
     return {
         deps: [],
@@ -831,11 +831,11 @@ function formatShare(shareArgs, from, name, shareStrategy) {
             ? shareArgs.scope
             : [shareArgs.scope ?? 'default'],
         strategy: (shareArgs.strategy ?? shareStrategy) || 'version-first',
-        treeshake: shareArgs.treeshake
+        treeShaking: shareArgs.treeShaking
             ? {
-                ...shareArgs.treeshake,
-                strategy: shareArgs.treeshake.strategy ?? 'server',
-                status: shareArgs.treeshake.status ?? 1 /* TreeshakeStatus.UNKNOWN */,
+                ...shareArgs.treeShaking,
+                strategy: shareArgs.treeShaking.strategy ?? 'server',
+                status: shareArgs.treeShaking.status ?? 1 /* TreeShakingStatus.UNKNOWN */,
                 useIn: [],
             }
             : undefined,
@@ -870,22 +870,22 @@ function formatShareConfigs(prevOptions, newOptions) {
     });
     return { allShareInfos, newShareInfos };
 }
-function shouldUseTreeshake(treeshake, usedExports) {
-    if (!treeshake) {
+function shouldUseTreeShaking(treeShaking, usedExports) {
+    if (!treeShaking) {
         return false;
     }
-    const { status, strategy } = treeshake;
-    if (status === 0 /* TreeshakeStatus.NO_USE */) {
+    const { status, strategy } = treeShaking;
+    if (status === 0 /* TreeShakingStatus.NO_USE */) {
         return false;
     }
-    if (status === 2 /* TreeshakeStatus.CALCULATED */) {
+    if (status === 2 /* TreeShakingStatus.CALCULATED */) {
         return true;
     }
     if (strategy === 'infer') {
         if (!usedExports) {
             return true;
         }
-        return isMatchUsedExports(treeshake, usedExports);
+        return isMatchUsedExports(treeShaking, usedExports);
     }
     return false;
 }
@@ -937,76 +937,76 @@ const isLoaded = (shared) => {
 const isLoading = (shared) => {
     return Boolean(shared.loading);
 };
-const isMatchUsedExports = (treeshake, usedExports) => {
-    if (!treeshake || !usedExports) {
+const isMatchUsedExports = (treeShaking, usedExports) => {
+    if (!treeShaking || !usedExports) {
         return false;
     }
-    const { usedExports: treeshakeUsedExports } = treeshake;
-    if (!treeshakeUsedExports) {
+    const { usedExports: treeShakingUsedExports } = treeShaking;
+    if (!treeShakingUsedExports) {
         return false;
     }
-    if (usedExports.every((e) => treeshakeUsedExports.includes(e))) {
+    if (usedExports.every((e) => treeShakingUsedExports.includes(e))) {
         return true;
     }
     return false;
 };
-function findSingletonVersionOrderByVersion(shareScopeMap, scope, pkgName, treeshake) {
+function findSingletonVersionOrderByVersion(shareScopeMap, scope, pkgName, treeShaking) {
     const versions = shareScopeMap[scope][pkgName];
     let version = '';
-    let useTreeshake = shouldUseTreeshake(treeshake);
+    let useTreesShaking = shouldUseTreeShaking(treeShaking);
     // return false means use prev version
     const callback = function (prev, cur) {
-        if (useTreeshake) {
-            if (!versions[prev].treeshake) {
+        if (useTreesShaking) {
+            if (!versions[prev].treeShaking) {
                 return true;
             }
-            if (!versions[cur].treeshake) {
+            if (!versions[cur].treeShaking) {
                 return false;
             }
-            return !isLoaded(versions[prev].treeshake) && versionLt(prev, cur);
+            return !isLoaded(versions[prev].treeShaking) && versionLt(prev, cur);
         }
         return !isLoaded(versions[prev]) && versionLt(prev, cur);
     };
-    if (useTreeshake) {
+    if (useTreesShaking) {
         version = findVersion(shareScopeMap[scope][pkgName], callback);
         if (version) {
             return {
                 version,
-                useTreeshake,
+                useTreesShaking,
             };
         }
-        useTreeshake = false;
+        useTreesShaking = false;
     }
     return {
         version: findVersion(shareScopeMap[scope][pkgName], callback),
-        useTreeshake,
+        useTreesShaking,
     };
 }
 const isLoadingOrLoaded = (shared) => {
     return isLoaded(shared) || isLoading(shared);
 };
-function findSingletonVersionOrderByLoaded(shareScopeMap, scope, pkgName, treeshake) {
+function findSingletonVersionOrderByLoaded(shareScopeMap, scope, pkgName, treeShaking) {
     const versions = shareScopeMap[scope][pkgName];
     let version = '';
-    let useTreeshake = shouldUseTreeshake(treeshake);
+    let useTreesShaking = shouldUseTreeShaking(treeShaking);
     // return false means use prev version
     const callback = function (prev, cur) {
-        if (useTreeshake) {
-            if (!versions[prev].treeshake) {
+        if (useTreesShaking) {
+            if (!versions[prev].treeShaking) {
                 return true;
             }
-            if (!versions[cur].treeshake) {
+            if (!versions[cur].treeShaking) {
                 return false;
             }
-            if (isLoadingOrLoaded(versions[cur].treeshake)) {
-                if (isLoadingOrLoaded(versions[prev].treeshake)) {
+            if (isLoadingOrLoaded(versions[cur].treeShaking)) {
+                if (isLoadingOrLoaded(versions[prev].treeShaking)) {
                     return Boolean(versionLt(prev, cur));
                 }
                 else {
                     return true;
                 }
             }
-            if (isLoadingOrLoaded(versions[prev].treeshake)) {
+            if (isLoadingOrLoaded(versions[prev].treeShaking)) {
                 return false;
             }
         }
@@ -1023,19 +1023,19 @@ function findSingletonVersionOrderByLoaded(shareScopeMap, scope, pkgName, treesh
         }
         return versionLt(prev, cur);
     };
-    if (useTreeshake) {
+    if (useTreesShaking) {
         version = findVersion(shareScopeMap[scope][pkgName], callback);
         if (version) {
             return {
                 version,
-                useTreeshake,
+                useTreesShaking,
             };
         }
-        useTreeshake = false;
+        useTreesShaking = false;
     }
     return {
         version: findVersion(shareScopeMap[scope][pkgName], callback),
-        useTreeshake,
+        useTreesShaking,
     };
 }
 function getFindShareFunction(strategy) {
@@ -1048,7 +1048,7 @@ function getRegisteredShare(localShareScopeMap, pkgName, shareInfo, resolveShare
     if (!localShareScopeMap) {
         return;
     }
-    const { shareConfig, scope = DEFAULT_SCOPE, strategy, treeshake } = shareInfo;
+    const { shareConfig, scope = DEFAULT_SCOPE, strategy, treeShaking, } = shareInfo;
     const scopes = Array.isArray(scope) ? scope : [scope];
     for (const sc of scopes) {
         if (shareConfig &&
@@ -1056,7 +1056,7 @@ function getRegisteredShare(localShareScopeMap, pkgName, shareInfo, resolveShare
             localShareScopeMap[sc][pkgName]) {
             const { requiredVersion } = shareConfig;
             const findShareFunction = getFindShareFunction(strategy);
-            const { version: maxOrSingletonVersion, useTreeshake } = findShareFunction(localShareScopeMap, sc, pkgName, treeshake);
+            const { version: maxOrSingletonVersion, useTreesShaking } = findShareFunction(localShareScopeMap, sc, pkgName, treeShaking);
             const defaultResolver = () => {
                 const shared = localShareScopeMap[sc][pkgName][maxOrSingletonVersion];
                 if (shareConfig.singleton) {
@@ -1072,32 +1072,32 @@ function getRegisteredShare(localShareScopeMap, pkgName, shareInfo, resolveShare
                     }
                     return {
                         shared,
-                        useTreeshake,
+                        useTreesShaking,
                     };
                 }
                 else {
                     if (requiredVersion === false || requiredVersion === '*') {
                         return {
                             shared,
-                            useTreeshake,
+                            useTreesShaking,
                         };
                     }
                     if (satisfy(maxOrSingletonVersion, requiredVersion)) {
                         return {
                             shared,
-                            useTreeshake,
+                            useTreesShaking,
                         };
                     }
-                    const _usedTreeshake = shouldUseTreeshake(treeshake);
-                    if (_usedTreeshake) {
+                    const _usedTreeShaking = shouldUseTreeShaking(treeShaking);
+                    if (_usedTreeShaking) {
                         for (const [versionKey, versionValue] of Object.entries(localShareScopeMap[sc][pkgName])) {
-                            if (!shouldUseTreeshake(versionValue.treeshake, treeshake?.usedExports)) {
+                            if (!shouldUseTreeShaking(versionValue.treeShaking, treeShaking?.usedExports)) {
                                 continue;
                             }
                             if (satisfy(versionKey, requiredVersion)) {
                                 return {
                                     shared: versionValue,
-                                    useTreeshake: _usedTreeshake,
+                                    useTreesShaking: _usedTreeShaking,
                                 };
                             }
                         }
@@ -1106,7 +1106,7 @@ function getRegisteredShare(localShareScopeMap, pkgName, shareInfo, resolveShare
                         if (satisfy(versionKey, requiredVersion)) {
                             return {
                                 shared: versionValue,
-                                useTreeshake: false,
+                                useTreesShaking: false,
                             };
                         }
                     }
@@ -1142,7 +1142,7 @@ function getTargetSharedOptions(options) {
         });
         const callback = function (prev, cur) {
             return (
-            // TODO: consider multiple treeshake shared scenes
+            // TODO: consider multiple treeShaking shared scenes
             !isLoaded(shareVersionMap[prev]) && versionLt(prev, cur));
         };
         const maxVersion = findVersion(shareVersionMap, callback);
@@ -1177,9 +1177,9 @@ const addUseIn = (shared, from) => {
     }
     addUniqueItem(shared.useIn, from);
 };
-function directShare(shared, useTreeshake) {
-    if (useTreeshake && shared.treeshake) {
-        return shared.treeshake;
+function directShare(shared, useTreesShaking) {
+    if (useTreesShaking && shared.treeShaking) {
+        return shared.treeShaking;
     }
     return shared;
 }
@@ -2598,9 +2598,9 @@ 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`);
-        const { shared: registeredShared, useTreeshake } = getRegisteredShare(this.shareScopeMap, pkgName, shareOptionsRes, this.hooks.lifecycle.resolveShare) || {};
+        const { shared: registeredShared, useTreesShaking } = getRegisteredShare(this.shareScopeMap, pkgName, shareOptionsRes, this.hooks.lifecycle.resolveShare) || {};
         if (registeredShared) {
-            const targetShared = directShare(registeredShared, useTreeshake);
+            const targetShared = directShare(registeredShared, useTreesShaking);
             if (targetShared.lib) {
                 addUseIn(targetShared, host.options.name);
                 return targetShared.lib;
@@ -2630,7 +2630,9 @@ class SharedHandler {
                     from: host.options.name,
                     lib: null,
                     loading,
-                    treeshake: useTreeshake ? targetShared : undefined,
+                    treeShaking: useTreesShaking
+                        ? targetShared
+                        : undefined,
                 });
                 return loading;
             }
@@ -2639,16 +2641,16 @@ class SharedHandler {
             if (extraOptions?.customShareInfo) {
                 return false;
             }
-            const _useTreeshake = shouldUseTreeshake(shareOptionsRes.treeshake);
-            const targetShared = directShare(shareOptionsRes, _useTreeshake);
+            const _useTreeShaking = shouldUseTreeShaking(shareOptionsRes.treeShaking);
+            const targetShared = directShare(shareOptionsRes, _useTreeShaking);
             const asyncLoadProcess = async () => {
                 const factory = await targetShared.get();
                 targetShared.lib = factory;
                 targetShared.loaded = true;
                 addUseIn(targetShared, host.options.name);
-                const { shared: gShared, useTreeshake: gUseTreeshake } = getRegisteredShare(this.shareScopeMap, pkgName, shareOptionsRes, this.hooks.lifecycle.resolveShare) || {};
+                const { shared: gShared, useTreesShaking: gUseTreeShaking } = getRegisteredShare(this.shareScopeMap, pkgName, shareOptionsRes, this.hooks.lifecycle.resolveShare) || {};
                 if (gShared) {
-                    const targetGShared = directShare(gShared, gUseTreeshake);
+                    const targetGShared = directShare(gShared, gUseTreeShaking);
                     targetGShared.lib = factory;
                     targetGShared.loaded = true;
                     gShared.from = shareOptionsRes.from;
@@ -2663,7 +2665,9 @@ class SharedHandler {
                 from: host.options.name,
                 lib: null,
                 loading,
-                treeshake: _useTreeshake ? targetShared : undefined,
+                treeShaking: _useTreeShaking
+                    ? targetShared
+                    : undefined,
             });
             return loading;
         }
@@ -2783,7 +2787,7 @@ class SharedHandler {
                 this.initializeSharing(shareScope, { strategy: shareOptions.strategy });
             });
         }
-        const { shared: registeredShared, useTreeshake } = getRegisteredShare(this.shareScopeMap, pkgName, shareOptions, this.hooks.lifecycle.resolveShare) || {};
+        const { shared: registeredShared, useTreesShaking } = getRegisteredShare(this.shareScopeMap, pkgName, shareOptions, this.hooks.lifecycle.resolveShare) || {};
         if (registeredShared) {
             if (typeof registeredShared.lib === 'function') {
                 addUseIn(registeredShared, host.options.name);
@@ -2842,39 +2846,6 @@ class SharedHandler {
     }
     initShareScopeMap(scopeName, shareScope, extraOptions = {}) {
         const { host } = this;
-        // const existedShareScope = this.shareScopeMap[scopeName];
-        // if (existedShareScope) {
-        //   Object.entries(shareScope).forEach(([pkgName, newVersions]) => {
-        //     const existedShareMap = existedShareScope[pkgName];
-        //     if (!existedShareMap) {
-        //       return;
-        //     }
-        //     Object.entries(existedShareMap).forEach(([version, existedShared]) => {
-        //       if (!shareScope[pkgName][version]) {
-        //         shareScope[pkgName][version] = existedShared;
-        //       }
-        //       // const newShared = newVersions[version];
-        //       // if (
-        //       //   newShared &&
-        //       //   newShared.treeshakeStatus === TreeshakeStatus.UNKNOWN &&
-        //       //   newShared.usedExports &&
-        //       //   existedShared.usedExports &&
-        //       //   existedShared.usedExports.some(
-        //       //     (exportName) => !newShared.usedExports?.includes(exportName),
-        //       //   )
-        //       // ) {
-        //       //   newShared.treeshakeStatus = TreeshakeStatus.NO_USE;
-        //       //   newShared._noMatchedUsedExports =
-        //       //     existedShared._noMatchedUsedExports || [];
-        //       //   const item: NoMatchedUsedExportsItem = [existedShared.from];
-        //       //   if (isDebugMode() && existedShared.usedExports) {
-        //       //     item.push(existedShared.usedExports);
-        //       //   }
-        //       //   newShared._noMatchedUsedExports.push(item);
-        //       // }
-        //     });
-        //   });
-        // }
         this.shareScopeMap[scopeName] = shareScope;
         this.hooks.lifecycle.initContainerShareScopeMap.emit({
             shareScope,
@@ -2884,7 +2855,7 @@ class SharedHandler {
             hostShareScopeMap: extraOptions.hostShareScopeMap,
         });
     }
-    setShared({ pkgName, shared, from, lib, loading, loaded, get, treeshake, }) {
+    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) => {
@@ -2893,7 +2864,7 @@ class SharedHandler {
                     s[key] = val;
                 }
             };
-            const targetShared = (treeshake ? shared.treeshake : shared);
+            const targetShared = (treeShaking ? shared.treeShaking : shared);
             merge(targetShared, 'loaded', loaded);
             merge(targetShared, 'loading', loading);
             merge(targetShared, 'get', get);
@@ -3291,7 +3262,7 @@ class ModuleFederation {
             // maybe will change, temporarily for internal use only
             initContainer: new AsyncWaterfallHook('initContainer'),
         });
-        this.version = "0.0.0-feat-shared-treeshake-poc-20251230095050";
+        this.version = "0.0.0-feat-shared-treeshake-poc-20260112031921";
         this.moduleCache = new Map();
         this.loaderHook = new PluginSystem({
             // FIXME: may not be suitable , not open to the public yet