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

package/lib/plugins/newi18nsplitplugin/18nPlugin3.js

@@ -0,0 +1,694 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _collectI18nKeys = require("../I18nSplitPlugin/utils/collectI18nKeys");
+var _I18nDependency = require("../I18nSplitPlugin/I18nDependency");
+var _propertiesUtils = require("../I18nSplitPlugin/utils/propertiesUtils");
+var _NullFactory = _interopRequireDefault(require("webpack/lib/NullFactory"));
+var _webpackSources = require("webpack-sources");
+var _path = _interopRequireDefault(require("path"));
+var _fs = _interopRequireDefault(require("fs"));
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {
+    default: obj
+  };
+}
+
+//import { RawSource } from 'webpack-sources';
+const pluginName = 'I18nSplitPlugin';
+const MODULE_TYPE = 'json/i18n'; // export default class I18nPlugin {
+//   constructor(options = {}) {
+//     const {
+//       jsResource,
+//       localeVarName = 'document.documentElement.lang',
+//       jsonpFunc = 'window.loadI18nChunk',
+//       propertiesFolder,
+//       disableDefault = false,
+//       filenameTemplate = 'i18n-chunk/[locale]/[name].[chunkhash].i18n.js',
+//       i18nManifestFileName = 'i18n-manifest.json',
+//       mainChunkName
+//     } = options;
+//     this.options = {
+//       localeVarName,
+//       jsonpFunc,
+//       filenameTemplate,
+//       i18nManifestFileName,
+//       mainChunkName
+//     };
+//     console.log('[I18N-BUILD] Loading resources from:', { jsResource, propertiesFolder });
+//     // Load and parse i18n resources
+//     this.jsResourceI18nKeys = jsResource ? getPropertiesAsJSON(jsResource) : {};
+//     this.allI18nData = getAllI18nGroupedBySection({
+//       folderPath: propertiesFolder,
+//       disableDefault,
+//       jsResourceI18nKeys: this.jsResourceI18nKeys
+//     });
+//     // Initialize tracking maps
+//     this.sectionToKeysMap = new Map();
+//     this.keyToSectionMap = new Map();
+//     this.moduleToKeysMap = new Map();
+//     this.moduleToSectionsMap = new Map();
+//     // Initialize section mapping
+//     this.initializeSectionMaps();
+//   }
+//   initializeSectionMaps() {
+//     const firstLocale = Object.keys(this.allI18nData)[0];
+//     if (!firstLocale) {
+//       console.warn('[I18N-BUILD] No locales found in i18n data');
+//       return;
+//     }
+//     const sections = this.allI18nData[firstLocale];
+//     console.log('[I18N-BUILD] Initializing sections:', Object.keys(sections));
+//     for (const [sectionName, sectionData] of Object.entries(sections)) {
+//       const keys = Object.keys(sectionData);
+//       this.sectionToKeysMap.set(sectionName, new Set(keys));
+//       keys.forEach(key => this.keyToSectionMap.set(key, sectionName));
+//     }
+//   }
+//   getSectionForKey(key) {
+//     const section = this.keyToSectionMap.get(key);
+//     if (section) return section;
+//     for (const [existingKey, section] of this.keyToSectionMap.entries()) {
+//       if (key.includes(existingKey) || existingKey.includes(key)) {
+//         return section;
+//       }
+//     }
+//     return 'common';
+//   }
+//   apply(compiler) {
+//     // Setup compilation hook
+//     compiler.hooks.thisCompilation.tap(pluginName, (compilation, params) => {
+//       // Set up dependencies
+//       this.setupDependencies(compilation);
+//       // Parse modules for i18n keys
+//       this.setupModuleParsing(compilation, params.normalModuleFactory);
+//       // Handle chunk optimization
+//       compilation.hooks.optimizeChunks.tap(pluginName, chunks => {
+//         console.log('[I18N-BUILD] Processing chunks:', chunks.length);
+//         this.processChunks(compilation, chunks);
+//       });
+//     });
+//     // Setup emit hook for Webpack 4
+//     compiler.hooks.emit.tap(pluginName, compilation => {
+//       this.emitAssets(compilation);
+//     });
+//   }
+//   setupDependencies(compilation) {
+//     compilation.dependencyFactories.set(I18nDependency, new NullFactory());
+//     compilation.dependencyTemplates.set(I18nDependency, new I18nDependencyTemplate());
+//   }
+//   setupModuleParsing(compilation, factory) {
+//     const handler = parser => {
+//       parser.hooks.program.tap(pluginName, (ast, comments) => {
+//         const { module } = parser.state;
+//         if (!(module && /\.jsx?$/.test(module.resource))) return;
+//         // Log for debugging
+//         console.log(`[I18N-BUILD] Processing module: ${module.resource}`);
+//         try {
+//           // Collect keys from all sources
+//           const codeKeys = collectI18nKeysfromAST(ast, this.jsResourceI18nKeys);
+//           const commentKeys = collectI18nKeysfromComments(comments, this.jsResourceI18nKeys);
+//           //const jsxKeys = collectI18nKeysFromJSX(ast, this.jsResourceI18nKeys);
+//           const moduleKeys = [...new Set([...codeKeys, ...commentKeys])];
+//           if (moduleKeys.length) {
+//             console.log('[I18N-BUILD] Found keys:', {
+//               module: module.resource,
+//               keyCount: moduleKeys.length,
+//               keys: moduleKeys
+//             });
+//             // Group keys by section
+//             const sections = new Set();
+//             moduleKeys.forEach(key => {
+//               const section = this.getSectionForKey(key);
+//               if (section) sections.add(section);
+//             });
+//             if (sections.size > 0) {
+//               console.log('[I18N-BUILD] Mapped to sections:', {
+//                 module: module.resource,
+//                 sections: Array.from(sections)
+//               });
+//             }
+//             this.moduleToKeysMap.set(module.resource, moduleKeys);
+//             this.moduleToSectionsMap.set(module.resource, Array.from(sections));
+//             this.addI18nDependency(module, moduleKeys);
+//           }
+//         } catch (error) {
+//           console.error('[I18N-BUILD] Error processing module:', {
+//             module: module.resource,
+//             error
+//           });
+//         }
+//       });
+//     };
+//     factory.hooks.parser
+//       .for('javascript/auto')
+//       .tap(pluginName, handler);
+//     factory.hooks.parser
+//       .for('javascript/dynamic')
+//       .tap(pluginName, handler);
+//   }
+//   addI18nDependency(module, keys) {
+//     const dep = new I18nDependency({
+//       identifier: `i18n ${module.resource}`,
+//       i18nKeys: keys
+//     }, module.context);
+//     module.addDependency(dep);
+//   }
+//   processChunks(compilation, chunks) {
+//     this.chunkToSectionsMap = new Map();
+//     chunks.forEach(chunk => {
+//       const sectionsInChunk = new Set();
+//       Array.from(chunk.modulesIterable).forEach(module => {
+//         if (!module.resource) return;
+//         const sections = this.moduleToSectionsMap.get(module.resource);
+//         if (sections) {
+//           sections.forEach(section => sectionsInChunk.add(section));
+//         }
+//       });
+//       if (sectionsInChunk.size > 0) {
+//         console.log('[I18N-BUILD] Chunk sections:', {
+//           chunk: chunk.id,
+//           sections: Array.from(sectionsInChunk)
+//         });
+//         this.chunkToSectionsMap.set(chunk.id, Array.from(sectionsInChunk));
+//       }
+//     });
+//   }
+//   emitAssets(compilation) {
+//     const manifest = {
+//       modules: {},
+//       chunks: {},
+//       locales: {}
+//     };
+//     // Add module mappings
+//     for (const [moduleResource, sections] of this.moduleToSectionsMap.entries()) {
+//       manifest.modules[moduleResource] = sections;
+//     }
+//     // Add chunk mappings
+//     for (const [chunkId, sections] of this.chunkToSectionsMap.entries()) {
+//       manifest.chunks[chunkId] = sections;
+//     }
+//     // Generate locale chunks
+//     for (const [locale, localeData] of Object.entries(this.allI18nData)) {
+//       manifest.locales[locale] = {};
+//       // For each chunk that needs i18n
+//       for (const [chunkId, sections] of this.chunkToSectionsMap.entries()) {
+//         const i18nData = {};
+//         // Collect all translations needed for this chunk
+//         sections.forEach(section => {
+//           const sectionData = localeData[section] || {};
+//           Object.assign(i18nData, sectionData);
+//         });
+//         if (Object.keys(i18nData).length > 0) {
+//           const fileName = this.getChunkFileName(chunkId, locale);
+//           const content = `${this.options.jsonpFunc}(${jsonToString(i18nData)});`;
+//           compilation.assets[fileName] = new RawSource(content);
+//           manifest.locales[locale][chunkId] = fileName;
+//         }
+//       }
+//     }
+//     // Emit manifest
+//     compilation.assets[this.options.i18nManifestFileName] = new RawSource(
+//       JSON.stringify(manifest, null, 2)
+//     );
+//   }
+//   getChunkFileName(chunkId, locale) {
+//     return this.options.filenameTemplate
+//       .replace('[locale]', locale)
+//       .replace('[name]', chunkId)
+//       .replace('[chunkhash]', this.getContentHash(chunkId, locale));
+//   }
+//   getContentHash(chunkId, locale) {
+//     const data = `${chunkId}_${locale}`;
+//     let hash = 0;
+//     for (let i = 0; i < data.length; i++) {
+//       hash = ((hash << 5) - hash) + data.charCodeAt(i);
+//       hash |= 0;
+//     }
+//     return hash.toString(36);
+//   }
+// }
+// export default class I18nPlugin {
+//   constructor(options = {}) {
+//     const {
+//       jsResource,
+//       localeVarName = 'document.documentElement.lang',
+//       jsonpFunc = 'window.loadI18nChunk',
+//       propertiesFolder,
+//       disableDefault = false,
+//       filenameTemplate = 'i18n-chunk/[locale]/[name].[chunkhash].i18n.js',
+//       i18nManifestFileName = 'i18n-manifest.json',
+//       mainChunkName
+//     } = options;
+//     this.options = {
+//       localeVarName,
+//       jsonpFunc,
+//       filenameTemplate,
+//       i18nManifestFileName,
+//       mainChunkName
+//     };
+//     console.log('[I18N-BUILD] Loading resources from:', { jsResource, propertiesFolder });
+//     // Load and parse i18n resources
+//     this.jsResourceI18nKeys = jsResource ? getPropertiesAsJSON(jsResource) : {};
+//     this.allI18nData = getAllI18nGroupedBySection({
+//       folderPath: propertiesFolder,
+//       disableDefault,
+//       jsResourceI18nKeys: this.jsResourceI18nKeys
+//     });
+//     // Initialize tracking maps
+//     this.moduleToKeysMap = new Map();
+//     this.chunkToKeysMap = new Map();
+//     this.keyToChunksMap = new Map();
+//   }
+//   apply(compiler) {
+//     compiler.hooks.thisCompilation.tap(pluginName, (compilation, params) => {
+//       // Set up dependencies
+//       compilation.dependencyFactories.set(I18nDependency, new NullFactory());
+//       compilation.dependencyTemplates.set(I18nDependency, new I18nDependencyTemplate());
+//       // Track module i18n keys
+//       this.setupModuleParsing(compilation, params.normalModuleFactory);
+//       // Map keys to chunks after optimization
+//       compilation.hooks.afterOptimizeChunks.tap(pluginName, (chunks) => {
+//         console.log('[I18N-BUILD] Processing chunks:', chunks.length);
+//         this.mapKeysToChunks(chunks);
+//       });
+//       // Emit assets during the emit phase
+//       compiler.hooks.emit.tap(pluginName, (compilation) => {
+//         this.emitAssets(compilation);
+//       });
+//     });
+//   }
+//   setupModuleParsing(compilation, factory) {
+//     const handler = parser => {
+//       parser.hooks.program.tap(pluginName, (ast, comments) => {
+//         const { module } = parser.state;
+//         if (!(module && /\.jsx?$/.test(module.resource))) return;
+//         // Collect keys from code and comments
+//         const codeKeys = collectI18nKeysfromAST(ast, this.jsResourceI18nKeys);
+//         const commentKeys = collectI18nKeysfromComments(comments, this.jsResourceI18nKeys);
+//         const moduleKeys = [...new Set([...codeKeys, ...commentKeys])];
+//         if (moduleKeys.length) {
+//           console.log('[I18N-BUILD] Found keys in module:', {
+//             module: module.resource,
+//             keyCount: moduleKeys.length,
+//             keys: moduleKeys
+//           });
+//           this.moduleToKeysMap.set(module.resource, moduleKeys);
+//           this.addI18nDependency(module, moduleKeys);
+//         }
+//       });
+//     };
+//     factory.hooks.parser
+//       .for('javascript/auto')
+//       .tap(pluginName, handler);
+//     factory.hooks.parser
+//       .for('javascript/dynamic')
+//       .tap(pluginName, handler);
+//   }
+//   mapKeysToChunks(chunks) {
+//     this.chunkToKeysMap.clear();
+//     this.keyToChunksMap.clear();
+//     chunks.forEach(chunk => {
+//       const chunkKeys = new Set();
+//       // Collect all i18n keys used in this chunk's modules
+//       for (const module of chunk.modulesIterable) {
+//         if (!module.resource) continue;
+//         const moduleKeys = this.moduleToKeysMap.get(module.resource);
+//         if (moduleKeys) {
+//           moduleKeys.forEach(key => {
+//             chunkKeys.add(key);
+//             // Map key back to chunk
+//             if (!this.keyToChunksMap.has(key)) {
+//               this.keyToChunksMap.set(key, new Set());
+//             }
+//             this.keyToChunksMap.get(key).add(chunk.name || chunk.id);
+//           });
+//         }
+//       }
+//       if (chunkKeys.size > 0) {
+//         console.log('[I18N-BUILD] Chunk keys:', {
+//           chunk: chunk.name || chunk.id,
+//           keyCount: chunkKeys.size,
+//           keys: Array.from(chunkKeys)
+//         });
+//         this.chunkToKeysMap.set(chunk.name || chunk.id, Array.from(chunkKeys));
+//       }
+//     });
+//   }
+//   emitAssets(compilation) {
+//     const manifest = {
+//       chunks: {},
+//       locales: {}
+//     };
+//     // Initialize locales
+//     Object.keys(this.allI18nData).forEach(locale => {
+//       manifest.locales[locale] = {};
+//     });
+//     // Generate i18n chunks
+//     for (const [chunkId, keys] of this.chunkToKeysMap.entries()) {
+//       if (keys.length === 0) continue;
+//       manifest.chunks[chunkId] = keys;
+//       // Generate locale-specific files for this chunk
+//       Object.entries(this.allI18nData).forEach(([locale, localeData]) => {
+//         // Collect translations for this chunk
+//         const translations = {};
+//         keys.forEach(key => {
+//           // Look up translation in the appropriate section
+//           for (const [section, sectionData] of Object.entries(localeData)) {
+//             if (key in sectionData) {
+//               translations[key] = sectionData[key];
+//               break;
+//             }
+//           }
+//         });
+//         if (Object.keys(translations).length > 0) {
+//           // Generate chunk file
+//           const fileName = this.options.filenameTemplate
+//             .replace('[locale]', locale)
+//             .replace('[name]', chunkId)
+//             .replace('[chunkhash]', this.getContentHash(chunkId, locale));
+//           const content = `${this.options.jsonpFunc}(${jsonToString(translations)});`;
+//           compilation.assets[fileName] = new RawSource(content);
+//           // Add to manifest
+//           manifest.locales[locale][chunkId] = fileName;
+//         }
+//       });
+//     }
+//     // Add metadata
+//     manifest.metadata = {
+//       generatedAt: new Date().toISOString(),
+//       totalChunks: manifest.chunks.length,
+//       totalKeys: Array.from(this.keyToChunksMap.keys()).length,
+//       totalLocales: Object.keys(this.allI18nData).length
+//     };
+//     // Emit manifest
+//     console.log('[I18N-BUILD] Emitting manifest with mappings:', {
+//       chunks: Object.keys(manifest.chunks).length,
+//       locales: Object.keys(manifest.locales).length,
+//       keys: manifest.metadata.totalKeys
+//     });
+//     compilation.assets[this.options.i18nManifestFileName] = new RawSource(
+//       JSON.stringify(manifest, null, 2)
+//     );
+//   }
+//   getContentHash(chunkId, locale) {
+//     let hash = 0;
+//     const str = `${chunkId}_${locale}`;
+//     for (let i = 0; i < str.length; i++) {
+//       const char = str.charCodeAt(i);
+//       hash = ((hash << 5) - hash) + char;
+//       hash = hash & hash; // Convert to 32-bit integer
+//     }
+//     return hash.toString(36);
+//   }
+//   addI18nDependency(module, keys) {
+//     const dep = new I18nDependency({
+//       identifier: `i18n ${module.resource}`,
+//       i18nKeys: keys
+//     }, module.context);
+//     module.addDependency(dep);
+//   }
+// }
+
+class I18nPlugin {
+  constructor(options = {}) {
+    const {
+      jsResource,
+      localeVarName = 'document.documentElement.lang',
+      jsonpFunc = 'window.loadI18nChunk',
+      propertiesFolder,
+      disableDefault = false,
+      filenameTemplate = 'i18n-chunk/[locale]/[name].[chunkhash].i18n.js',
+      i18nManifestFileName = 'i18n-manifest.json',
+      mainChunkName = 'main',
+      // Optimization options
+      minKeys = 5,
+      mainChunks = ['main', 'vendor'],
+      maxChunks = 20,
+      cacheFile = '.i18n-cache.json'
+    } = options;
+    this.options = {
+      localeVarName,
+      jsonpFunc,
+      filenameTemplate,
+      i18nManifestFileName,
+      mainChunkName,
+      optimization: {
+        minKeys,
+        mainChunks,
+        maxChunks
+      },
+      cacheFile
+    }; // Load and parse i18n resources
+
+    this.jsResourceI18nKeys = jsResource ? (0, _propertiesUtils.getPropertiesAsJSON)(jsResource) : {};
+    this.allI18nData = (0, _propertiesUtils.getAllI18nGroupedBySection)({
+      folderPath: propertiesFolder,
+      disableDefault,
+      jsResourceI18nKeys: this.jsResourceI18nKeys
+    }); // Initialize tracking maps
+
+    this.moduleToKeysMap = new Map();
+    this.chunkToKeysMap = new Map();
+    this.keyMovementHistory = new Map();
+    this.keyCache = this.loadKeyCache();
+    console.log('[I18N] Plugin initialized with:', {
+      totalKeys: Object.keys(this.jsResourceI18nKeys).length,
+      totalLocales: Object.keys(this.allI18nData).length,
+      mainChunks: this.options.optimization.mainChunks
+    });
+  }
+  loadKeyCache() {
+    try {
+      const cachePath = _path.default.join(process.cwd(), this.options.cacheFile);
+      if (_fs.default.existsSync(cachePath)) {
+        const cache = JSON.parse(_fs.default.readFileSync(cachePath, 'utf8'));
+        console.log('[I18N] Loaded key cache:', Object.keys(cache).length, 'entries');
+        return new Map(Object.entries(cache));
+      }
+    } catch (error) {
+      console.warn('[I18N] Failed to load key cache:', error);
+    }
+    return new Map();
+  }
+  saveKeyCache() {
+    try {
+      const cachePath = _path.default.join(process.cwd(), this.options.cacheFile);
+      const cache = Object.fromEntries(this.keyCache);
+      _fs.default.writeFileSync(cachePath, JSON.stringify(cache, null, 2));
+      console.log('[I18N] Saved key cache:', Object.keys(cache).length, 'entries');
+    } catch (error) {
+      console.warn('[I18N] Failed to save key cache:', error);
+    }
+  }
+  apply(compiler) {
+    compiler.hooks.thisCompilation.tap(pluginName, (compilation, params) => {
+      // Setup dependencies
+      compilation.dependencyFactories.set(_I18nDependency.I18nDependency, new _NullFactory.default());
+      compilation.dependencyTemplates.set(_I18nDependency.I18nDependency, new _I18nDependency.I18nDependencyTemplate()); // Parse modules and collect i18n keys
+
+      this.setupModuleParsing(compilation, params.normalModuleFactory); // Map keys to chunks after optimization
+
+      compilation.hooks.afterOptimizeChunks.tap(pluginName, chunks => {
+        this.processChunks(compilation, chunks);
+      }); // Emit optimized assets
+
+      compiler.hooks.emit.tap(pluginName, compilation => {
+        this.emitAssets(compilation);
+      }); // Save cache after completion
+
+      compiler.hooks.done.tap(pluginName, () => {
+        this.saveKeyCache();
+      });
+    });
+  }
+  setupModuleParsing(compilation, factory) {
+    const handler = parser => {
+      parser.hooks.program.tap(pluginName, (ast, comments) => {
+        const {
+          module
+        } = parser.state;
+        if (!(module && /\.jsx?$/.test(module.resource))) return;
+        try {
+          // Collect keys from code and comments
+          const codeKeys = (0, _collectI18nKeys.collectI18nKeysfromAST)(ast, this.jsResourceI18nKeys);
+          const commentKeys = (0, _collectI18nKeys.collectI18nKeysfromComments)(comments, this.jsResourceI18nKeys);
+          const moduleKeys = [...new Set([...codeKeys, ...commentKeys])];
+          if (moduleKeys.length > 0) {
+            console.log('[I18N] Found keys in module:', {
+              module: module.resource,
+              keyCount: moduleKeys.length
+            }); // Track keys per module
+
+            this.moduleToKeysMap.set(module.resource, moduleKeys); // Update key cache with module association
+
+            moduleKeys.forEach(key => {
+              const modules = this.keyCache.get(key) || new Set();
+              modules.add(module.resource);
+              this.keyCache.set(key, modules);
+            }); // Add dependency for webpack
+
+            this.addI18nDependency(module, moduleKeys);
+          }
+        } catch (error) {
+          console.error('[I18N] Error processing module:', module.resource, error);
+        }
+      });
+    };
+    factory.hooks.parser.for('javascript/auto').tap(pluginName, handler);
+    factory.hooks.parser.for('javascript/dynamic').tap(pluginName, handler);
+  }
+  processChunks(compilation, chunks) {
+    console.log('[I18N] Processing', chunks.length, 'chunks');
+    const {
+      minKeys,
+      mainChunks,
+      maxChunks
+    } = this.options.optimization;
+    this.chunkToKeysMap.clear(); // First process main chunks
+
+    chunks.forEach(chunk => {
+      if (mainChunks.includes(chunk.name)) {
+        const keys = this.collectChunkKeys(chunk);
+        if (keys.size > 0) {
+          this.chunkToKeysMap.set(chunk.name || chunk.id, Array.from(keys));
+        }
+      }
+    }); // Then process other chunks by size
+
+    const otherChunks = chunks.filter(chunk => !mainChunks.includes(chunk.name)).map(chunk => ({
+      chunk,
+      keys: this.collectChunkKeys(chunk)
+    })).filter(({
+      keys
+    }) => keys.size >= minKeys).sort((a, b) => b.keys.size - a.keys.size); // Take only up to maxChunks - mainChunks.length chunks
+
+    const remainingSlots = maxChunks - this.chunkToKeysMap.size;
+    otherChunks.slice(0, remainingSlots).forEach(({
+      chunk,
+      keys
+    }) => {
+      this.chunkToKeysMap.set(chunk.name || chunk.id, Array.from(keys));
+    }); // Move remaining keys to most appropriate chunk
+
+    otherChunks.slice(remainingSlots).forEach(({
+      chunk,
+      keys
+    }) => {
+      keys.forEach(key => {
+        const bestChunk = this.findBestChunkForKey(key);
+        const chunkKeys = this.chunkToKeysMap.get(bestChunk) || [];
+        chunkKeys.push(key);
+        this.chunkToKeysMap.set(bestChunk, chunkKeys); // Track key movement
+
+        this.keyMovementHistory.set(key, {
+          from: chunk.name || chunk.id,
+          to: bestChunk
+        });
+      });
+    });
+  }
+  collectChunkKeys(chunk) {
+    const keys = new Set();
+    for (const module of chunk.modulesIterable) {
+      if (module.resource) {
+        const moduleKeys = this.moduleToKeysMap.get(module.resource);
+        if (moduleKeys) {
+          moduleKeys.forEach(key => keys.add(key));
+        }
+      }
+    }
+    return keys;
+  }
+  findBestChunkForKey(key) {
+    // First check history
+    const history = this.keyMovementHistory.get(key);
+    if (history && this.chunkToKeysMap.has(history.to)) {
+      return history.to;
+    } // Check key prefix matches
+
+    const keyPrefix = key.split('.')[0];
+    for (const [chunkId, chunkKeys] of this.chunkToKeysMap.entries()) {
+      if (chunkKeys.some(k => k.split('.')[0] === keyPrefix)) {
+        return chunkId;
+      }
+    } // Default to main chunk
+
+    return this.options.mainChunkName;
+  }
+  emitAssets(compilation) {
+    const manifest = {
+      chunks: {},
+      locales: {},
+      metadata: {
+        generatedAt: new Date().toISOString(),
+        totalChunks: this.chunkToKeysMap.size,
+        keyMovements: Array.from(this.keyMovementHistory.entries()).length
+      }
+    }; // Generate optimized chunks
+
+    for (const [chunkId, keys] of this.chunkToKeysMap.entries()) {
+      manifest.chunks[chunkId] = keys;
+      Object.keys(this.allI18nData).forEach(locale => {
+        if (!manifest.locales[locale]) {
+          manifest.locales[locale] = {};
+        }
+        const translations = this.collectTranslations(keys, locale);
+        if (Object.keys(translations).length > 0) {
+          const fileName = this.getChunkFileName(chunkId, locale);
+          const content = `${this.options.jsonpFunc}(${(0, _propertiesUtils.jsonToString)(translations)});`;
+          compilation.assets[fileName] = new _webpackSources.RawSource(content);
+          manifest.locales[locale][chunkId] = fileName;
+        }
+      });
+    } // Add key movements to manifest for development
+
+    if (process.env.NODE_ENV === 'development') {
+      manifest.keyMovements = Object.fromEntries(this.keyMovementHistory);
+    } // Emit manifest
+
+    const manifestContent = JSON.stringify(manifest, null, 2);
+    compilation.assets[this.options.i18nManifestFileName] = new _webpackSources.RawSource(manifestContent);
+    console.log('[I18N] Emitted manifest with:', {
+      chunks: Object.keys(manifest.chunks).length,
+      locales: Object.keys(manifest.locales).length,
+      totalKeys: Object.values(manifest.chunks).reduce((acc, keys) => acc + keys.length, 0)
+    });
+  }
+  collectTranslations(keys, locale) {
+    const translations = {};
+    const localeData = this.allI18nData[locale];
+    keys.forEach(key => {
+      for (const sectionData of Object.values(localeData)) {
+        if (key in sectionData) {
+          translations[key] = sectionData[key];
+          break;
+        }
+      }
+    });
+    return translations;
+  }
+  getChunkFileName(chunkId, locale) {
+    return this.options.filenameTemplate.replace('[locale]', locale).replace('[name]', chunkId).replace('[chunkhash]', this.getContentHash(chunkId, locale));
+  }
+  getContentHash(chunkId, locale) {
+    const data = `${chunkId}_${locale}`;
+    let hash = 0;
+    for (let i = 0; i < data.length; i++) {
+      hash = (hash << 5) - hash + data.charCodeAt(i);
+      hash = hash & hash;
+    }
+    return hash.toString(36);
+  }
+  addI18nDependency(module, keys) {
+    const dep = new _I18nDependency.I18nDependency({
+      identifier: `i18n ${module.resource}`,
+      i18nKeys: keys
+    }, module.context);
+    module.addDependency(dep);
+  }
+}
+exports.default = I18nPlugin;