@zohodesk/react-cli 1.1.28-exp.2 → 1.1.29-exp.1

package/lib/plugins/I18nSplitPlugin/I18nFilesEmitter.js

@@ -11,6 +11,12 @@ var _utils = require("./utils");
 
 var _getI18nKeysFormModules = _interopRequireDefault(require("./utils/getI18nKeysFormModules"));
 
+var _createRegularManifest = require("./utils/createRegularManifest");
+
+var _createMetaManifest = require("./utils/createMetaManifest");
+
+var _applyMetaManifest = require("./utils/applyMetaManifest");
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 /**
@@ -28,42 +34,65 @@ class I18nFilesEmitter {
     i18nManifestFileName,
     filenameTemplate,
     locales,
-    jsonpFunc
+    jsonpFunc,
+    i18nMetaManifestFileName,
+    entryPointNames = ['main'],
+    masterChunkFileName = 'master.i18n.js',
+    publicPath
   }) {
     this.locales = locales;
     this.allI18nObject = allI18nObject;
-    this.filenameTemplate = filenameTemplate; // this.filenameTemplate =  "i18n-chunk/[locale]/[name].js"
-
+    this.filenameTemplate = filenameTemplate;
     this.jsonpFunc = jsonpFunc;
     this.prevHashes = {};
     this.i18nManifestFileName = i18nManifestFileName;
+    this.i18nMetaManifestFileName = i18nMetaManifestFileName || 'metaManifest.json';
+    this.regularManifest = {};
+    this.detailedManifest = {};
+    this.entryPointNames = Array.isArray(entryPointNames) ? entryPointNames : [entryPointNames];
+    this.masterChunkFileName = masterChunkFileName;
+    this.generatedMetaManifest = {
+      modules: {},
+      masterKeys: []
+    };
+    this.extraKeys = new Set();
+    this.movedKeys = new Set();
+    this.entryPointKeys = new Set();
+    this.combinedChunks = {};
+    this.publicPath = publicPath; // Add a map to store module ID mappings
+
+    this.moduleIdMap = new Map(); // Map to track which modules belong to which chunks
+
+    this.moduleToChunks = new Map(); // Store original resource paths for stable identification
+
+    this.resourceToModule = new Map();
+    console.log(`I18nFilesEmitter initialized with publicPath: "${this.publicPath}"`);
   }
 
   emitAsset(compilation, filename, source, info) {
-    // NOTE: info support  available since webpack v4.40.0 https://webpack.js.org/api/stats/#asset-objects
     if (!compilation.emitAsset) {
       compilation.assets[filename] = source;
     } else {
       compilation.emitAsset(filename, source, info);
     }
-  } // this method for create object and assign value for i18nkeys
-
+  }
 
   getI18nObjectByLocale(i18nKeys, locale) {
     const data = {};
     i18nKeys.forEach(key => {
-      data[key] = this.allI18nObject[locale][key];
+      if (this.allI18nObject[locale] && this.allI18nObject[locale][key] !== undefined) {
+        data[key] = this.allI18nObject[locale][key];
+      }
     });
     return data;
   }
 
   getTemplateString(i18nKeys, locale) {
-    let i18nObject = this.getI18nObjectByLocale(i18nKeys, locale);
-    return `${this.jsonpFunc}(${(0, _utils.jsonToString)(i18nObject)});`; // return `${this.jsonpFunc}(JSON.parse(${JSON.stringify(jsonToString(i18nObject))}));`;
+    const i18nObject = this.getI18nObjectByLocale(i18nKeys, locale);
+    return `${this.jsonpFunc}(${(0, _utils.jsonToString)(i18nObject)});`;
   }
 
   renderI18nLocaleChunk(chunk, locale, i18nKeys) {
-    // renderI18nLocaleChunk(chunk, locale, i18nKeys, compilation) {
     const filenameTemplate = this.filenameTemplate.replace(/\[locale\]/g, locale);
     const pathOptions = {
       chunk,
@@ -76,6 +105,53 @@ class I18nFilesEmitter {
       identifier: `${pluginName}.${chunk.id}.${locale}`,
       hash: chunk.contentHash[i18ntype(locale)]
     };
+  } // Capture final module IDs from compilation
+
+
+  captureModuleIds(compilation) {
+    console.log('Capturing final module IDs from compilation...');
+    this.moduleIdMap.clear();
+    this.resourceToModule.clear();
+    this.moduleToChunks.clear(); // Process all modules to build our mapping
+
+    compilation.modules.forEach(module => {
+      // Skip modules without resources
+      if (!module.resource) return;
+      const originalId = module.resource;
+      const finalId = module.id; // Map resource path to final module ID
+
+      this.moduleIdMap.set(originalId, finalId); // Map resource path to module object
+
+      this.resourceToModule.set(originalId, module); // Build chunk membership for each module
+
+      const chunkIds = Array.from(module.chunksIterable || []).map(chunk => chunk.id).filter(Boolean);
+
+      if (chunkIds.length > 0) {
+        this.moduleToChunks.set(originalId, chunkIds);
+      }
+    });
+    console.log(`Captured ${this.moduleIdMap.size} module ID mappings`);
+  } // Modified to use stable resource identifiers
+
+
+  gatherModuleDetails(chunk, i18nKeys) {
+    if (!i18nKeys.length) return; // Get stable identifiers for each module in the chunk
+
+    const stableModuleIds = Array.from(chunk.modulesIterable).map(module => module.resource).filter(Boolean); // If no stable IDs found, fallback to chunk ID
+
+    const moduleKey = stableModuleIds.length ? stableModuleIds[0] : `chunk_${chunk.id}`;
+
+    if (!this.detailedManifest[moduleKey]) {
+      this.detailedManifest[moduleKey] = {
+        chunkId: chunk.id,
+        chunkName: chunk.name || `chunk_${chunk.id}`,
+        keysUsed: new Set()
+      };
+    }
+
+    i18nKeys.forEach(key => {
+      this.detailedManifest[moduleKey].keysUsed.add(key);
+    });
   }
 
   emitI18nFilesForChunk(chunk, compilation) {
@@ -87,14 +163,20 @@ class I18nFilesEmitter {
     };
 
     if (!i18nKeys.length) {
-      // why  it is not checked as 0
       return manifestForChunk;
     }
 
-    manifestForChunk.hasI18n = true; // const locales  = ['en_US'];
+    this.gatherModuleDetails(chunk, i18nKeys);
+    manifestForChunk.hasI18n = true; // Check if this is an entry point chunk
+
+    const isEntryPoint = this.isPartOfEntryPoint(chunk, compilation); // If it's an entry point, add its keys to our tracking set
+
+    if (isEntryPoint) {
+      i18nKeys.forEach(key => this.entryPointKeys.add(key));
+    }
 
     this.locales.forEach(locale => {
-      const result = this.renderI18nLocaleChunk(chunk, locale, i18nKeys, compilation);
+      const result = this.renderI18nLocaleChunk(chunk, locale, i18nKeys);
       const {
         filenameTemplate,
         pathOptions,
@@ -110,73 +192,186 @@ class I18nFilesEmitter {
       }
 
       manifestForChunk.hasChanges = true;
-      this.prevHashes[identifier] = hash;
-      this.emitAsset(compilation, filePath, render(), {
+      this.prevHashes[identifier] = hash; // Get the rendered content
+
+      const renderedContent = render().source(); // Emit the asset
+
+      this.emitAsset(compilation, filePath, new _webpackSources.RawSource(renderedContent), {
         locale,
         chunkId: chunk.id,
         chunkName: chunk.name
-      }); // compilation.assets[filePath] = render();
+      }); // Store chunk content for later reference
+
+      if (!this.combinedChunks[locale]) {
+        this.combinedChunks[locale] = [];
+      }
+
+      this.combinedChunks[locale].push({
+        path: filePath,
+        content: renderedContent,
+        data: this.getI18nObjectByLocale(i18nKeys, locale),
+        isEntryPoint: isEntryPoint
+      });
     });
     return manifestForChunk;
+  } // Check if a chunk is part of an entry point we're interested in
+
+
+  isPartOfEntryPoint(chunk, compilation) {
+    let isEntryChunk = false;
+    this.entryPointNames.forEach(entryName => {
+      const entryPoint = compilation.entrypoints.get(entryName);
+
+      if (entryPoint && entryPoint.chunks.includes(chunk)) {
+        isEntryChunk = true;
+      }
+    });
+    return isEntryChunk;
+  } // Create meta manifest with final module IDs
+
+
+  createMetaManifestWithFinalIds(compilation) {
+    console.log('Creating meta manifest with final module IDs...'); // Initialize meta manifest structure
+
+    const finalMetaManifest = {
+      modules: {},
+      masterKeys: []
+    }; // Process each module with its final ID
+
+    for (const [resourcePath, moduleData] of Object.entries(this.detailedManifest)) {
+      // Get the final module ID if available
+      const finalId = this.moduleIdMap.get(resourcePath) || resourcePath;
+      const chunkName = moduleData.chunkName || `chunk_${finalId}`;
+      const keysArray = Array.isArray(moduleData.keysUsed) ? moduleData.keysUsed : Array.from(moduleData.keysUsed); // Only add modules that have i18n keys
+
+      if (keysArray.length > 0) {
+        finalMetaManifest.modules[chunkName] = {
+          id: moduleData.chunkId,
+          finalId: finalId,
+          resourcePath: resourcePath,
+          keys: keysArray
+        };
+      }
+    } // Store the generated manifest
+
+
+    this.generatedMetaManifest = finalMetaManifest;
+    console.log(`Created meta manifest with ${Object.keys(finalMetaManifest.modules).length} modules`);
+  } // Compare the remote meta manifest with current build
+
+
+  compareWithRemoteManifest(compilation) {
+    // Use the imported applyMetaManifest function with our updated module ID maps
+    (0, _applyMetaManifest.applyMetaManifest)(compilation, this);
+  } // Create and emit the combined master chunk for each locale
+
+
+  emitMasterChunks(compilation) {
+    // Combine all the keys we need in the master chunk
+    const combinedKeys = new Set([...this.extraKeys, ...this.movedKeys, ...(this.generatedMetaManifest.masterKeys || [])]);
+    console.log(`Extra and moved keys to add to master chunk: ${combinedKeys.size}`);
+    console.log(`Entry point keys: ${this.entryPointKeys.size}`); // Add entry point keys to the master keys in meta manifest
+
+    if (this.generatedMetaManifest) {
+      this.generatedMetaManifest.masterKeys = [...this.generatedMetaManifest.masterKeys, ...Array.from(this.entryPointKeys)];
+    } // Create a master object that contains all needed keys
+
+
+    const allMasterKeys = new Set([...combinedKeys, ...this.entryPointKeys]);
+    console.log(`Creating master chunks with ${allMasterKeys.size} total keys`);
+
+    for (const locale of this.locales) {
+      try {
+        // console.log(`\n========== Processing master chunk for locale: ${locale} ==========`);
+        // Create the master i18n object with all required keys
+        const masterI18nObject = this.getI18nObjectByLocale([...allMasterKeys], locale);
+        console.log(`Master i18n object has ${Object.keys(masterI18nObject).length} keys`); // Create the final JSONP content
+
+        const finalContent = `${this.jsonpFunc}(${(0, _utils.jsonToString)(masterI18nObject)});`;
+        const outputPath = `i18n-chunk/${locale}/${this.masterChunkFileName}`; // Emit the combined master chunk
+
+        this.emitAsset(compilation, outputPath, new _webpackSources.RawSource(finalContent), {
+          locale,
+          chunkName: 'master',
+          desc: 'Combined master i18n chunk'
+        }); // Add to manifest
+
+        if (!this.regularManifest.master) {
+          this.regularManifest.master = {};
+        }
+
+        this.regularManifest.master[locale] = outputPath; //  console.log(`Emitted master chunk for locale ${locale}: ${outputPath} (${Object.keys(masterI18nObject).length} total keys)`);
+      } catch (error) {
+        console.error(`ERROR processing master chunk for locale ${locale}:`, error.message); // Emit a simplified version with just the master keys
+
+        try {
+          console.log(`Attempting to emit a fallback master chunk for locale ${locale}`); // Just use the moved and extra keys as fallback
+
+          const fallbackI18nObject = this.getI18nObjectByLocale([...combinedKeys], locale);
+          const fallbackContent = `${this.jsonpFunc}(${(0, _utils.jsonToString)(fallbackI18nObject)});`;
+          const outputPath = `i18n-chunk/${locale}/${this.masterChunkFileName}`;
+          this.emitAsset(compilation, outputPath, new _webpackSources.RawSource(fallbackContent), {
+            locale,
+            chunkName: 'master',
+            desc: 'Fallback master i18n chunk (only moved/extra keys)'
+          });
+
+          if (!this.regularManifest.master) {
+            this.regularManifest.master = {};
+          }
+
+          this.regularManifest.master[locale] = outputPath;
+          console.log(`Emitted fallback master chunk for locale ${locale}: ${outputPath}`);
+        } catch (fallbackError) {
+          console.error(`Failed to emit fallback master chunk for locale ${locale}:`, fallbackError.message);
+        }
+      }
+    }
   }
 
   emitI18nAssert(compilation) {
-    let manifest = {};
-    let needEmitManifest = false;
+    console.log('Starting I18n asset emission process...'); // First, capture all final module IDs 
+
+    this.captureModuleIds(compilation); // Reset entry point keys for this build
+
+    this.entryPointKeys = new Set(); // 1. Process chunks and collect keys
+
     compilation.chunks.forEach(chunk => {
       const manifestForChunk = this.emitI18nFilesForChunk(chunk, compilation);
 
       if (manifestForChunk.hasI18n) {
-        manifest[chunk.id] = manifestForChunk.assets;
-        needEmitManifest = needEmitManifest || manifestForChunk.hasChanges;
+        this.regularManifest[chunk.id] = manifestForChunk.assets;
       }
-    });
+    }); // 2. Create our meta manifest with final module IDs
 
-    if (needEmitManifest) {
-      const manifestSource = new _webpackSources.RawSource(JSON.stringify(manifest));
-      this.emitAsset(compilation, this.i18nManifestFileName, manifestSource, {
-        desc: 'this file is has chunks-locales-assets mapping'
-      });
-    }
+    this.createMetaManifestWithFinalIds(compilation); // 3. Compare with remote manifest to find extra/moved keys
+
+    this.compareWithRemoteManifest(compilation); // 4. Create and emit combined master chunks
+
+    this.emitMasterChunks(compilation); // 5. Create the regular manifest
+
+    (0, _createRegularManifest.createRegularManifest)(compilation, this); // 6. Emit the final meta manifest with updated master keys
+
+    const metaManifestSource = new _webpackSources.RawSource(JSON.stringify(this.generatedMetaManifest, null, 2));
+    this.emitAsset(compilation, this.i18nMetaManifestFileName, metaManifestSource, {
+      desc: 'Updated meta manifest with master keys'
+    });
+    console.log('Completed I18n asset emission process');
   }
 
   apply(compiler) {
-    /*
-      compiler.hooks.thisCompilation.tap(pluginName, compilation => {
-        compilation.mainTemplate.hooks.renderManifest.tap(
-          pluginName,
-          (result, { chunk }) => {
-            this.renderChunk(result, compilation, chunk);
-          }
-        );
-           compilation.chunkTemplate.hooks.renderManifest.tap(
-          pluginName,
-          (result, { chunk }) => {
-            this.renderChunk(result, compilation, chunk);
-          }
-        );
-      });
-      */
-    // this below hook was tapped for create asssets(file) for chunk specific i18nChunk Files
-    compiler.hooks.emit.tap(pluginName, compilation => {
+    // Use the afterCompile hook to capture module info after compilation
+    compiler.hooks.afterCompile.tap(pluginName, compilation => {
+      //  console.log(`${pluginName}: Capturing compilation information after compile phase`);
+      this.compilation = compilation;
+    }); // Use the emit hook to generate the I18n assets with final module IDs
+
+    compiler.hooks.emit.tapAsync(pluginName, (compilation, callback) => {
+      //    console.log(`${pluginName}: Emitting I18n assets with final module IDs`);
       this.emitI18nAssert(compilation);
+      callback();
     });
   }
-  /*
-    renderChunk(result, compilation, chunk) {
-      const i18nKeys = getI18nKeysFormModules(chunk.modulesIterable);
-      // TODO: need to discuss with vimal ji can we chose this place for add i18n locale files ????
-      // IDEA:  we chose this place for add i18n locale files ????
-      if (i18nKeys.length > 0) {
-        Object.keys(this.allI18nObject).forEach(locale => {
-          result.push(
-            this.renderI18nLocaleChunk(chunk, locale, i18nKeys, compilation)
-          );
-        });
-      }
-    }
-    */
-
 
 }
 

package/lib/plugins/I18nSplitPlugin/utils/applyMetaManifest.js

@@ -0,0 +1,273 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyMetaManifest = applyMetaManifest;
+
+var _fs = _interopRequireDefault(require("fs"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function applyMetaManifest(compilation, plugin) {
+  const {
+    moduleIdMap
+  } = plugin;
+  const manifestPath = './metaManifest.json';
+
+  if (!plugin.detailedManifest || Object.keys(plugin.detailedManifest).length === 0) {
+    console.warn('No detailedManifest available, skipping manifest comparison');
+    return {
+      extraKeys: new Set(),
+      movedKeys: new Set(),
+      error: 'No detailedManifest available'
+    };
+  } // Track keys in current build
+
+
+  const currentBuildKeys = new Set();
+  const currentKeyToModule = new Map();
+  const currentModules = new Map();
+  const currentKeySets = new Map();
+  const moduleIdToName = new Map(); // Process current build modules with final IDs
+
+  for (const [resourcePath, chunkData] of Object.entries(plugin.detailedManifest)) {
+    // Get the final module ID if it exists in our mapping
+    const finalModuleId = moduleIdMap.get(resourcePath) || resourcePath;
+    const chunkName = chunkData.chunkName || `chunk_${chunkData.chunkId || "unknown"}`; // Store module name mapping for better logging
+
+    moduleIdToName.set(finalModuleId, chunkName);
+    const keys = Array.isArray(chunkData.keysUsed) ? chunkData.keysUsed : Array.from(chunkData.keysUsed); // Skip empty modules
+
+    if (keys.length === 0) continue; // Sort keys for consistent comparison
+
+    const sortedKeys = [...keys].sort();
+    const keySetString = sortedKeys.join(','); // Store module data using final IDs
+
+    currentModules.set(finalModuleId, {
+      id: finalModuleId,
+      resourcePath: resourcePath,
+      chunkId: chunkData.chunkId,
+      name: chunkName,
+      keys: sortedKeys
+    }); // Store key set for module fingerprinting
+
+    currentKeySets.set(keySetString, finalModuleId); // Store individual key mappings
+
+    keys.forEach(key => {
+      currentBuildKeys.add(key);
+      currentKeyToModule.set(key, finalModuleId);
+    });
+  }
+
+  const currentKeyCount = currentBuildKeys.size;
+  const currentModuleCount = currentModules.size;
+  console.log(`Current build: ${currentKeyCount} keys in ${currentModuleCount} modules`);
+
+  try {
+    // Read from specified manifest path
+    if (!_fs.default.existsSync(manifestPath)) {
+      console.warn(`Meta manifest not found at ${manifestPath}`);
+      return {
+        extraKeys: new Set(),
+        movedKeys: new Set(),
+        error: `Meta manifest not found at ${manifestPath}`
+      };
+    }
+
+    const fileContent = _fs.default.readFileSync(manifestPath, 'utf8');
+
+    const remoteMetaManifest = JSON.parse(fileContent); // Handle non-existent or invalid modules
+
+    if (!remoteMetaManifest.modules) {
+      console.warn('Meta manifest does not contain modules section');
+      return {
+        extraKeys: new Set(),
+        movedKeys: new Set(),
+        error: 'Meta manifest does not contain modules section'
+      };
+    } // Track all keys in remote manifest modules
+
+
+    const remoteModuleKeys = new Set();
+    const remoteKeyToModule = new Map();
+    const remoteModules = new Map();
+    const remoteKeySets = new Map();
+    const remoteModuleIdToName = new Map();
+    const moduleEquivalenceMap = new Map(); // Process remote manifest modules
+
+    for (const [moduleId, moduleData] of Object.entries(remoteMetaManifest.modules)) {
+      if (moduleData.keys && Array.isArray(moduleData.keys)) {
+        // Store module name for better logging
+        const moduleName = moduleId;
+        remoteModuleIdToName.set(moduleId, moduleName); // Skip empty modules
+
+        if (moduleData.keys.length === 0) continue; // Sort keys for consistent comparison
+
+        const sortedKeys = [...moduleData.keys].sort();
+        const keySetString = sortedKeys.join(','); // Store module data
+
+        remoteModules.set(moduleId, {
+          id: moduleData.id || moduleId,
+          name: moduleName,
+          keys: sortedKeys,
+          keyCount: moduleData.keys.length
+        }); // Store key set
+
+        remoteKeySets.set(keySetString, moduleId); // Store individual key mappings
+
+        moduleData.keys.forEach(key => {
+          remoteModuleKeys.add(key);
+          remoteKeyToModule.set(key, moduleId);
+        });
+      }
+    } // Get keys from the master chunk in the remote manifest (if it exists)
+
+
+    const remoteMasterKeys = new Set();
+
+    if (remoteMetaManifest.masterKeys && Array.isArray(remoteMetaManifest.masterKeys)) {
+      remoteMetaManifest.masterKeys.forEach(key => {
+        remoteMasterKeys.add(key);
+      });
+    } // Get all unique keys from the remote manifest (modules + master)
+
+
+    const remoteAllKeys = new Set([...remoteModuleKeys, ...remoteMasterKeys]);
+    const remoteKeyCount = remoteAllKeys.size;
+    const remoteModuleCount = remoteModules.size;
+    const remoteMasterKeyCount = remoteMasterKeys.size;
+    console.log(`Remote manifest: ${remoteKeyCount} keys in ${remoteModuleCount} modules, ${remoteMasterKeyCount} master keys`); // Find intersection and differences for keys
+
+    const inBothSets = new Set([...currentBuildKeys].filter(key => remoteAllKeys.has(key)));
+    const missingKeys = new Set([...remoteAllKeys].filter(key => !currentBuildKeys.has(key)));
+    const extraKeys = new Set([...currentBuildKeys].filter(key => !remoteAllKeys.has(key)));
+    console.log(`Key comparison: ${inBothSets.size} shared keys, ${missingKeys.size} missing, ${extraKeys.size} new`); // Enhanced multi-level module equivalence mapping
+    // 1. First pass: Match by module name
+
+    for (const [remoteId, remoteModule] of remoteModules.entries()) {
+      if (remoteModule.name) {
+        // Find a current module with matching name
+        for (const [currentId, currentModule] of currentModules.entries()) {
+          if (currentModule.name && currentModule.name === remoteModule.name) {
+            moduleEquivalenceMap.set(remoteId, currentId);
+            break;
+          }
+        }
+      }
+    } // 2. Second pass: Match by resource path
+
+
+    const unmatchedRemote = [...remoteModules.keys()].filter(id => !moduleEquivalenceMap.has(id));
+
+    for (const remoteId of unmatchedRemote) {
+      for (const [resourcePath, currentModuleId] of moduleIdMap.entries()) {
+        if (resourcePath.includes(remoteId)) {
+          moduleEquivalenceMap.set(remoteId, currentModuleId);
+          break;
+        }
+      }
+    } // 3. Third pass: Match by key set fingerprint
+
+
+    const stillUnmatchedRemote = [...remoteModules.keys()].filter(id => !moduleEquivalenceMap.has(id));
+
+    for (const remoteId of stillUnmatchedRemote) {
+      const remoteModule = remoteModules.get(remoteId);
+      const keySetString = remoteModule.keys.join(',');
+
+      if (currentKeySets.has(keySetString)) {
+        moduleEquivalenceMap.set(remoteId, currentKeySets.get(keySetString));
+      }
+    } // Find moved keys based on enhanced module equivalence map
+
+
+    const trulyMovedKeys = new Set();
+    const keyMovementDetails = new Map();
+
+    for (const key of inBothSets) {
+      // Skip keys that are in the master chunk
+      if (remoteMasterKeys.has(key)) {
+        continue;
+      }
+
+      const remoteModuleId = remoteKeyToModule.get(key);
+      const currentModuleId = currentKeyToModule.get(key); // Normalize module names for comparison
+
+      const remoteModuleName = remoteModuleIdToName.get(remoteModuleId) || remoteModuleId;
+      const currentModuleName = moduleIdToName.get(currentModuleId) || currentModuleId; // Only consider a key moved if it's actually in a different module
+
+      const moduleNameComparison = remoteModuleName !== currentModuleName;
+
+      if (moduleNameComparison) {
+        trulyMovedKeys.add(key);
+        keyMovementDetails.set(key, {
+          from: remoteModuleId,
+          fromName: remoteModuleName,
+          to: currentModuleId,
+          toName: currentModuleName,
+          type: 'module_change'
+        });
+      }
+    } // Get keys from unmatched modules that exist in the current build
+
+
+    const unmatchedRemoteModules = [...remoteModules.keys()].filter(id => !moduleEquivalenceMap.has(id));
+    unmatchedRemoteModules.forEach(moduleId => {
+      const module = remoteModules.get(moduleId);
+      const moduleName = remoteModuleIdToName.get(moduleId) || moduleId;
+      module.keys.forEach(key => {
+        // Only add the key if it exists in the current build
+        if (currentBuildKeys.has(key)) {
+          const currentModuleId = currentKeyToModule.get(key);
+          const currentModuleName = moduleIdToName.get(currentModuleId) || currentModuleId; // Only add if actually in a different module
+
+          if (moduleName !== currentModuleName) {
+            trulyMovedKeys.add(key);
+            keyMovementDetails.set(key, {
+              from: moduleId,
+              fromName: moduleName,
+              to: currentModuleId,
+              toName: currentModuleName,
+              type: 'unmatched_module'
+            });
+          }
+        }
+      });
+    });
+    const movedKeyCount = trulyMovedKeys.size;
+    console.log(`Found ${extraKeys.size} new keys and ${movedKeyCount} moved keys`); // Add extra and moved keys to the plugin's tracking for master chunk inclusion
+
+    plugin.extraKeys = extraKeys;
+    plugin.movedKeys = trulyMovedKeys; // Store key counts for reference
+
+    plugin.keyStats = {
+      current: currentKeyCount,
+      remote: remoteKeyCount,
+      extra: extraKeys.size,
+      moved: movedKeyCount
+    }; // Update master keys in the generated meta manifest
+
+    if (plugin.generatedMetaManifest) {
+      // Only include extra (new) and moved keys in the master keys
+      const masterKeys = [...Array.from(extraKeys), ...Array.from(trulyMovedKeys)];
+      plugin.generatedMetaManifest.masterKeys = masterKeys;
+    }
+
+    return {
+      extraKeys,
+      movedKeys: trulyMovedKeys,
+      keyStats: plugin.keyStats
+    };
+  } catch (error) {
+    console.error(`Error during manifest comparison: ${error.message}`); // Return empty sets for keys if there was an error
+
+    plugin.extraKeys = new Set();
+    plugin.movedKeys = new Set();
+    return {
+      extraKeys: new Set(),
+      movedKeys: new Set(),
+      error: error.message
+    };
+  }
+}