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

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

@@ -0,0 +1,306 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+// // plugins/I18nPlugin.js
+// const path = require('path');
+// const fs = require('fs');
+// const getJsResourceKeys = require('./utils/getJsResourceKeys');
+// const { collectI18nKeysfromAST, collectI18nKeysfromComments } = require('../I18nSplitPlugin/utils/collectI18nKeys');
+// const NullFactory = require('webpack/lib/NullFactory');
+// const { I18nDependency, I18nDependencyTemplate } = require('../I18nSplitPlugin/I18nDependency');
+// class I18nPlugin {
+//   constructor(options = {}) {
+//     const { jsResourcePath } = options;
+//     if (!jsResourcePath) {
+//       throw new Error('I18nPlugin: "jsResourcePath" option is required.');
+//     }
+//     this.jsResourcePath = jsResourcePath;
+//     this.jsresourceKeys = getJsResourceKeys(jsResourcePath);
+//     this.moduleToKeysMap = new Map();
+//   }
+// identifyEntryPoints(compilation) {
+//     this.entryPoints = new Set();
+//     const entryModules = new Set();
+//     compilation.entrypoints.forEach((entrypoint) => {
+//       entrypoint.getEntrypointChunk().getModules().forEach((module) => {
+//         if (module.resource) {
+//           entryModules.add(module.resource);
+//           console.log(entryModules)
+//         }
+//       });
+//     });
+//     this.entryPoints = entryModules;
+//   }
+//   apply(compiler) {
+//     compiler.hooks.thisCompilation.tap('I18nPlugin', (compilation, params) => {
+//       // Define dependency factories and templates for I18nDependency
+//       this.defineI18nDependency(compilation);
+//       // Handler for parsing modules
+//       const handler = (parser) => {
+//         parser.hooks.program.tap('I18nPlugin', (ast, comments) => {
+//           const { module } = parser.state;
+//           if (!module || !module.resource || !/\.(js|jsx)$/.test(module.resource)) {
+//             return;
+//           }
+//           const moduleResource = module.resource;
+//           // Collect i18n keys from AST and comments
+//           let i18nKeys = collectI18nKeysfromAST(ast, this.jsresourceKeys);
+//           i18nKeys = i18nKeys.concat(collectI18nKeysfromComments(comments, this.jsresourceKeys));
+//           if (i18nKeys.length > 0) {
+//             // Store the keys for this module
+//             this.moduleToKeysMap.set(moduleResource, i18nKeys);
+//             // Add I18nDependency to the module
+//             this.addI18nDependency(module, i18nKeys);
+//             console.log(`Module: ${moduleResource}`);
+//          //   console.log(`I18n Keys: ${i18nKeys.join(', ')}`);
+//           }
+//         });
+//       };
+//       // Attach the handler to JavaScript parsers
+//       const normalModuleFactory = params.normalModuleFactory;
+//       normalModuleFactory.hooks.parser.for('javascript/auto').tap('I18nPlugin', handler);
+//       normalModuleFactory.hooks.parser.for('javascript/dynamic').tap('I18nPlugin', handler);
+//       normalModuleFactory.hooks.parser.for('javascript/esm').tap('I18nPlugin', handler);
+//       // After modules are built, process the collected keys
+//       compilation.hooks.finishModules.tap('I18nPlugin', (modules) => {
+//         this.identifyEntryPoints(compilation);
+//         this.processCollectedKeys(compilation);
+//       });
+//     });
+//   }
+//   defineI18nDependency(compilation) {
+//     compilation.dependencyFactories.set(I18nDependency, new NullFactory());
+//     compilation.dependencyTemplates.set(I18nDependency, new I18nDependencyTemplate());
+//   }
+//   addI18nDependency(module, i18nKeys) {
+//     const identifier = `i18n ${module.resource}`;
+//     const dep = new I18nDependency({ identifier, i18nKeys }, module.context, 0);
+//     module.addDependency(dep);
+//   }
+//   processCollectedKeys(compilation) {
+//     // Implement logic to process collected keys
+//     // For now, we'll just console log all the modules and their keys
+//     for (const [moduleResource, keys] of this.moduleToKeysMap.entries()) {
+//      // console.log(`Module: ${moduleResource} has keys: ${keys.join(', ')}`);
+//     }
+//     // Next steps:
+//     // - Identify entry point modules
+//     // - Assign keys to chunks (Chunk Zero for entry points, last chunk for unused keys)
+//     // - Implement the chunking logic as per your requirements
+//   }
+// }
+// module.exports = I18nPlugin;
+// plugins/I18nPlugin.js
+const path = require('path');
+const fs = require('fs');
+const getPropertiesAsJSON = require('./utils/getJsResourceKeys');
+const {
+  collectI18nKeysfromAST,
+  collectI18nKeysfromComments
+} = require('../I18nSplitPlugin/utils/collectI18nKeys');
+const NullFactory = require('webpack/lib/NullFactory');
+const {
+  I18nDependency,
+  I18nDependencyTemplate
+} = require('../I18nSplitPlugin/I18nDependency');
+const pluginName = 'I18nPlugin';
+class I18nPlugin {
+  constructor(options = {}) {
+    const {
+      jsResourcePath,
+      mainChunkName
+    } = options;
+    if (!jsResourcePath) {
+      throw new Error('I18nPlugin: "jsResourcePath" option is required.');
+    }
+    if (!mainChunkName) {
+      throw new Error('I18nPlugin: "mainChunkName" option is required.');
+    }
+    this.jsResourcePath = jsResourcePath;
+    this.entryPointName = mainChunkName;
+    this.allI18nKeys = getPropertiesAsJSON(this.jsResourcePath);
+    console.log("allI18nKeys ", this.allI18nKeys.size);
+    this.moduleToKeysMap = new Map();
+    this.keyToModulesMap = new Map();
+  }
+  defineI18nDependency(compilation) {
+    compilation.dependencyFactories.set(I18nDependency, new NullFactory());
+    compilation.dependencyTemplates.set(I18nDependency, new I18nDependencyTemplate());
+  }
+  addI18nDependency(module, i18nKeys) {
+    const identifier = `i18n ${module.resource}`;
+    const dep = new I18nDependency({
+      identifier,
+      i18nKeys
+    }, module.context, 0);
+    module.addDependency(dep);
+  }
+  apply(compiler) {
+    compiler.hooks.thisCompilation.tap(pluginName, (compilation, params) => {
+      this.defineI18nDependency(compilation); //   const handler = parser => {
+      //     parser.hooks.program.tap(pluginName, (ast, commmets) => {
+      //       const { module } = parser.state;
+      //       //
+      //       if (!(module && /\.jsx?$/.test(module.resource))) {
+      //         return;
+      //       }
+      //       // i18n grep proper contract regex
+      //       let i18nKeys = collectI18nKeysfromAST(ast, this.allI18nKeys );
+      //       i18nKeys = i18nKeys.concat(
+      //        //  i18n grep proper contract regex
+      //         collectI18nKeysfromComments(commmets, this.allI18nKeys)
+      //       );
+      //       if (i18nKeys.length) {
+      //         console.log(i18nKeys)
+      //         this.addI18nDependency(module, i18nKeys);
+      //       }
+      //     });
+      //   };
+
+      const handler = parser => {
+        // Initialize counters for each type of log
+        let moduleLogCount = 0;
+        let astKeysLogCount = 0;
+        let commentKeysLogCount = 0;
+        let combinedKeysLogCount = 0;
+        let dependencyLogCount = 0;
+        parser.hooks.program.tap(pluginName, (ast, comments) => {
+          const {
+            module
+          } = parser.state;
+          if (moduleLogCount < 20) {
+            console.log("Processing module:", module ? module.resource : "No module found");
+            moduleLogCount++;
+          } // Check if the module and its resource match the .js or .jsx regex
+
+          if (!(module && /\.jsx?$/.test(module.resource))) {
+            if (moduleLogCount < 20) {
+              console.warn("Skipping non-JS/JSX module or missing module resource.");
+              moduleLogCount++;
+            }
+            return;
+          }
+          try {
+            // Collect i18n keys from AST
+            let i18nKeys = collectI18nKeysfromAST(ast, this.allI18nKeys);
+            if (astKeysLogCount < 20) {
+              console.log("i18n keys from AST:", i18nKeys);
+              astKeysLogCount++;
+            } // Collect i18n keys from comments
+
+            const commentKeys = collectI18nKeysfromComments(comments, this.allI18nKeys);
+            if (commentKeysLogCount < 20) {
+              console.log("i18n keys from comments:", commentKeys);
+              commentKeysLogCount++;
+            } // Combine keys from AST and comments
+
+            i18nKeys = i18nKeys.concat(commentKeys);
+            if (combinedKeysLogCount < 20) {
+              console.log("Combined i18n keys:", i18nKeys);
+              combinedKeysLogCount++;
+            } // If we have collected any keys, add them as dependencies
+
+            if (i18nKeys.length) {
+              this.addI18nDependency(module, i18nKeys);
+              if (dependencyLogCount < 20) {
+                console.log(`Added ${i18nKeys.length} i18n keys as dependencies.`);
+                dependencyLogCount++;
+              }
+            } else {
+              if (dependencyLogCount < 20) {
+                console.warn("No i18n keys found to add as dependencies.");
+                dependencyLogCount++;
+              }
+            }
+          } catch (error) {
+            console.error("Error processing module:", module.resource, error);
+          }
+        });
+      };
+      const normalModuleFactory = params.normalModuleFactory;
+      normalModuleFactory.hooks.parser.for('javascript/auto').tap(pluginName, handler);
+      normalModuleFactory.hooks.parser.for('javascript/dynamic').tap(pluginName, handler);
+      normalModuleFactory.hooks.parser.for('javascript/esm').tap(pluginName, handler);
+      compilation.hooks.afterOptimizeChunks.tap(pluginName, () => {
+        this.identifyEntryPoints(compilation); // this.processCollectedKeys(compilation);
+      });
+    });
+  }
+  identifyEntryPoints(compilation) {
+    this.entryPoints = new Set();
+    const entryModules = new Set();
+    console.log("Starting identifyEntryPoints..."); // Iterate over each entrypoint in the compilation
+
+    compilation.entrypoints.forEach((entrypoint, name) => {
+      console.log(`Processing entrypoint: ${name}`); // Logs the entrypoint name
+
+      if (name === "main") {
+        console.log(`Found the "main" entrypoint.`); // Debug log if "main" is found
+      } // Process all chunks associated with the entrypoint
+
+      entrypoint.chunks.forEach(chunk => {
+        //  console.log(`Processing chunk: ${chunk.name}`);
+        chunk.getModules().forEach(module => {
+          if (module.resource) {
+            entryModules.add(module.resource); // console.log(`Added module: ${module.resource}`);
+          }
+        });
+      });
+    });
+    this.entryPoints = entryModules; // console.log("Entry Points Identified:", Array.from(this.entryPoints));
+  }
+  processCollectedKeys(compilation) {
+    // Map keys to chunk IDs
+    this.keyToChunkIdMap = {};
+    const unusedKeys = new Set(); // Assign keys used in entry points to Chunk Zero
+
+    for (const moduleResource of this.entryPoints) {
+      const keys = this.moduleToKeysMap.get(moduleResource);
+      if (keys) {
+        for (const key of keys) {
+          this.keyToChunkIdMap[key] = 0; // Assign to Chunk Zero
+        }
+      }
+    } // Assign other keys to their respective modules
+
+    let chunkIdCounter = 1; // Start from 1 since 0 is for entry points
+
+    for (const [key, modules] of this.keyToModulesMap.entries()) {
+      if (!this.keyToChunkIdMap.hasOwnProperty(key)) {
+        this.keyToChunkIdMap[key] = chunkIdCounter++;
+      }
+    } // Collect unused keys (keys not found in jsresource.properties)
+
+    for (const key of Object.keys(this.allI18nKeys)) {
+      if (!this.keyToModulesMap.has(key)) {
+        unusedKeys.add(key);
+      }
+    } // Assign unused keys to the last chunk
+
+    const lastChunkId = chunkIdCounter;
+    for (const key of unusedKeys) {
+      this.keyToChunkIdMap[key] = lastChunkId;
+    } // Store total number of chunks
+
+    this.totalChunks = lastChunkId + 1; // Output key-to-chunk mapping for use in i18n build
+
+    const outputPath = compilation.options.output.path;
+    const mappingFilePath = path.join(outputPath, 'i18n-key-chunk-mapping.json');
+    fs.writeFileSync(mappingFilePath, JSON.stringify(this.keyToChunkIdMap, null, 2), 'utf8');
+  }
+}
+exports.default = I18nPlugin;
+I18nPlugin.isChunkHasI18n = function (chunk) {
+  for (const module of chunk.modulesIterable) {
+    for (const dep of module.dependencies) {
+      if (dep instanceof I18nDependency) {
+        return true;
+      }
+    }
+  }
+  return false;
+};

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

@@ -0,0 +1,363 @@
+"use strict";
+
+const path = require('path');
+const fs = require('fs');
+const {
+  getAllI18n,
+  getPropertiesAsJSON,
+  getAllI18nGroupedBySection
+} = require('../I18nSplitPlugin/utils/propertiesUtils');
+const {
+  collectI18nKeysfromAST,
+  collectI18nKeysfromComments
+} = require('../I18nSplitPlugin/utils/collectI18nKeys');
+const NullFactory = require('webpack/lib/NullFactory');
+const {
+  I18nDependency,
+  I18nDependencyTemplate
+} = require('../I18nSplitPlugin/I18nDependency');
+const webpack = require('webpack');
+const {
+  RawSource
+} = require('webpack-sources'); // Import RawSource from webpack-sources
+
+const pluginName = 'I18nPlugin';
+class I18nPlugin {
+  constructor(options = {}) {
+    const {
+      jsResourcePath,
+      mainChunkName,
+      propertiesFolder,
+      disableDefault,
+      jsResource
+    } = options;
+    if (!jsResourcePath) {
+      throw new Error('I18nPlugin: "jsResourcePath" option is required.');
+    }
+    if (!mainChunkName) {
+      throw new Error('I18nPlugin: "mainChunkName" option is required.');
+    }
+    this.jsResourcePath = jsResourcePath;
+    this.entryPointName = mainChunkName;
+    this.jsResourceI18nKeys = jsResource ? (0, getPropertiesAsJSON)(jsResource) : {};
+    this.allI18nKeys = (0, getAllI18n)({
+      folderPath: propertiesFolder,
+      disableDefault,
+      jsResourceI18nKeys: this.jsResourceI18nKeys
+    });
+    console.log("allI18nKeys count:", Object.keys(this.allI18nKeys).length);
+    this.moduleToKeysMap = new Map();
+    this.keyToModulesMap = new Map();
+    this.keyToI18nChunkIdMap = {};
+    this.sectionedI18nKeys = getAllI18nGroupedBySection({
+      folderPath: propertiesFolder,
+      disableDefault,
+      jsResourceI18nKeys: this.jsResourceI18nKeys
+    });
+  }
+  defineI18nDependency(compilation) {
+    compilation.dependencyFactories.set(I18nDependency, new NullFactory());
+    compilation.dependencyTemplates.set(I18nDependency, new I18nDependencyTemplate());
+  }
+  addI18nDependency(module, i18nKeys) {
+    const identifier = `i18n ${module.resource}`;
+    const dep = new I18nDependency({
+      identifier,
+      i18nKeys
+    }, module.context, 0);
+    module.addDependency(dep);
+  }
+  apply(compiler) {
+    compiler.hooks.thisCompilation.tap(pluginName, (compilation, params) => {
+      this.defineI18nDependency(compilation); // handler for parser
+
+      const handler = parser => {
+        parser.hooks.program.tap(pluginName, (ast, comments) => {
+          const {
+            module
+          } = parser.state; //
+
+          if (!(module && /\.jsx?$/.test(module.resource))) {
+            return;
+          } // i18n grep proper contract regex
+
+          let i18nKeys = collectI18nKeysfromAST(ast, this.jsResourceI18nKeys);
+          let commentKeys = collectI18nKeysfromComments(comments, this.jsResourceI18nKeys);
+          i18nKeys = i18nKeys.concat(commentKeys);
+          if (i18nKeys.length) {
+            //  console.log(`Collected i18n keys for module ${module.resource}:`, i18nKeys);
+            // Store the keys for this module
+            this.moduleToKeysMap.set(module.resource, i18nKeys); // Map keys to modules
+
+            for (const key of i18nKeys) {
+              if (!this.keyToModulesMap.has(key)) {
+                this.keyToModulesMap.set(key, new Set());
+              }
+              this.keyToModulesMap.get(key).add(module.resource);
+            } // Add I18nDependency to the module
+          }
+        });
+      }; // this below  hook was tapped for collect I18n Key from files and add as Deppenensy
+
+      const factory = params.normalModuleFactory;
+      factory.hooks.parser.for('javascript/auto').tap(pluginName, handler);
+      factory.hooks.parser.for('javascript/dynamic').tap(pluginName, handler);
+      compilation.hooks.afterOptimizeChunks.tap(pluginName, () => {
+        this.identifyEntryPoints(compilation);
+        this.processCollectedKeys(compilation);
+      });
+    });
+  }
+  identifyEntryPoints(compilation) {
+    this.entryPoints = new Set();
+    const entryModules = new Set();
+    console.log("Starting identifyEntryPoints..."); // Iterate over each entrypoint in the compilation
+
+    compilation.entrypoints.forEach((entrypoint, name) => {
+      console.log(`Processing entrypoint: ${name}`); // Logs the entrypoint name
+
+      if (name === "main") {
+        console.log(`Found the "main" entrypoint.`); // Debug log if "main" is found
+      } // Process all chunks associated with the entrypoint
+
+      entrypoint.chunks.forEach(chunk => {
+        //  console.log(`Processing chunk: ${chunk.name}`);
+        chunk.getModules().forEach(module => {
+          if (module.resource) {
+            entryModules.add(module.resource); // console.log(`Added module: ${module.resource}`);
+          }
+        });
+      });
+    });
+    this.entryPoints = entryModules; // console.log("Entry Points Identified:", Array.from(this.entryPoints));
+  }
+  processCollectedKeys(compilation) {
+    console.log("Starting processCollectedKeys..."); // Map to store chunkId to i18n keys
+
+    this.chunkIdToKeysMap = {};
+    this.moduleChunkIdToModulesMap = new Map(); // Iterate over all chunks in the compilation
+
+    for (const chunk of compilation.chunks) {
+      const chunkId = chunk.name || chunk.id; //  console.log(`Processing chunk with ID: ${chunkId}`);
+      // Collect all modules in the chunk
+
+      const modules = chunk.getModules(); //   console.log(`Modules in chunk ${chunkId}:`, modules.map(m => m.resource).filter(Boolean));
+      // Collect i18n keys used in these modules
+
+      let chunkKeys = new Set();
+      let moduleResources = [];
+      for (const module of modules) {
+        const moduleResource = module.resource;
+        if (moduleResource) {
+          moduleResources.push(moduleResource);
+          const keys = this.moduleToKeysMap.get(moduleResource);
+          if (keys) {
+            for (const key of keys) {
+              chunkKeys.add(key);
+            }
+          } else {//  console.warn(`Module without resource in chunk ${chunkId}:`, module);
+          }
+        }
+      } // Convert the set to an array
+
+      chunkKeys = Array.from(chunkKeys); // Store in the map if there are keys
+
+      if (chunkKeys.length > 0) {
+        this.chunkIdToKeysMap[chunkId] = chunkKeys;
+      } // Map chunkId to module resources
+
+      if (moduleResources.length > 0) {
+        this.moduleChunkIdToModulesMap.set(chunkId, moduleResources);
+      }
+    } //  console.log('moduleChunkIdToModulesMap:', this.moduleChunkIdToModulesMap);
+    // Emit the i18n chunks
+
+    this.emitI18nChunks(compilation);
+  } //   emitI18nChunks(compilation) {
+  //     const manifest = {
+  //       moduleToI18nChunkMap: {},
+  //       locales: {},
+  //     };
+  //     // Get the list of locales
+  //     const locales = Object.keys(this.allI18nKeys);
+  //     // Initialize i18nChunkId counter
+  //     let i18nChunkIdCounter = 0;
+  //     // Map of i18nChunkId to keys
+  //     const i18nChunkIdToKeysMap = {};
+  //     // For simplicity, assign all keys to chunks based on size
+  //     const desiredChunkSize = 100 * 1024; // 100KB
+  //     let currentChunkKeys = [];
+  //     let currentChunkSize = 0;
+  //     // Use the first locale to estimate key sizes
+  //     const firstLocale = locales[0];
+  //     const allKeys = Object.keys(this.allI18nKeys[firstLocale]);
+  //     for (const key of allKeys) {
+  //       const value = this.allI18nKeys[firstLocale][key] || '';
+  //       const keySize = Buffer.byteLength(key, 'utf8') + Buffer.byteLength(value, 'utf8');
+  //       if (currentChunkSize + keySize > desiredChunkSize) {
+  //         // Assign current chunk
+  //         const i18nChunkId = i18nChunkIdCounter++;
+  //         i18nChunkIdToKeysMap[i18nChunkId] = currentChunkKeys;
+  //         // Map keys to i18nChunkId
+  //         for (const chunkKey of currentChunkKeys) {
+  //           this.keyToI18nChunkIdMap[chunkKey] = i18nChunkId;
+  //         }
+  //         currentChunkKeys = [];
+  //         currentChunkSize = 0;
+  //       }
+  //       currentChunkKeys.push(key);
+  //       currentChunkSize += keySize;
+  //     }
+  //     // Assign the remaining keys in the current chunk
+  //     if (currentChunkKeys.length > 0) {
+  //       const i18nChunkId = i18nChunkIdCounter++;
+  //       i18nChunkIdToKeysMap[i18nChunkId] = currentChunkKeys;
+  //       // Map keys to i18nChunkId
+  //       for (const chunkKey of currentChunkKeys) {
+  //         this.keyToI18nChunkIdMap[chunkKey] = i18nChunkId;
+  //       }
+  //     }
+  //   //  console.log('keyToI18nChunkIdMap:', this.keyToI18nChunkIdMap);
+  //     // Now, generate the i18n chunks
+  //     for (const locale of locales) {
+  //       manifest.locales[locale] = {};
+  //       for (const [i18nChunkId, keys] of Object.entries(i18nChunkIdToKeysMap)) {
+  //         const i18nData = {};
+  //         for (const key of keys) {
+  //           const value = this.allI18nKeys[locale][key];
+  //           if (value !== undefined) {
+  //             i18nData[key] = value;
+  //           }
+  //         }
+  //         // Skip if no keys are available for this locale
+  //         if (Object.keys(i18nData).length === 0) {
+  //           console.log(`Locale ${locale}, i18n chunk ${i18nChunkId} has no keys, skipping.`);
+  //           continue;
+  //         }
+  //         // Generate the JavaScript code
+  //         const moduleSource = `window.i18nData = window.i18nData || {}; window.i18nData[${i18nChunkId}] = ${JSON.stringify(i18nData, null, 2)};`;
+  //         // Define the filename and output path
+  //         const filename = `${locale}/chunk-${i18nChunkId}.js`;
+  //         // Emit the asset
+  //         compilation.emitAsset(
+  //           filename,
+  //           new RawSource(moduleSource)
+  //         );
+  //       //  console.log(`Emitted i18n chunk: ${filename}`);
+  //         // Update the manifest
+  //         manifest.locales[locale][i18nChunkId] = filename;
+  //       }
+  //     }
+  //     // Now, create moduleToI18nChunkMap
+  //     for (const [moduleChunkId, moduleResources] of this.moduleChunkIdToModulesMap.entries()) {
+  //       //  console.log(`Processing module chunk ID: ${moduleChunkId}`);
+  //        // console.log(`Module resources:`, moduleResources);
+  //       const requiredI18nChunkIds = new Set();
+  //       for (const moduleResource of moduleResources) {
+  //         const keys = this.moduleToKeysMap.get(moduleResource);
+  //         if (keys) {
+  //           for (const key of keys) {
+  //             const i18nChunkId = this.keyToI18nChunkIdMap[key];
+  //             if (i18nChunkId !== undefined) {
+  //               requiredI18nChunkIds.add(i18nChunkId);
+  //             }
+  //           }
+  //         }
+  //       }
+  //       if (requiredI18nChunkIds.size > 0) {
+  //         manifest.moduleToI18nChunkMap[moduleChunkId] = Array.from(requiredI18nChunkIds);
+  //       //  console.log(`Mapped module chunk ID ${moduleChunkId} to i18n chunks:`, Array.from(requiredI18nChunkIds));
+  //       }else{
+  //         console.log(`No required i18n chunks for module chunk ID ${moduleChunkId}`);
+  //       }
+  //     }
+  //     // Emit the manifest file
+  //     const manifestSource = new RawSource(`window.i18n = window.i18n || {}; window.i18n.manifest = ${JSON.stringify(manifest, null, 2)};`);
+  //     const manifestFilename = 'i18n-chunks/manifest.js';
+  //     compilation.emitAsset(
+  //       manifestFilename,
+  //       manifestSource
+  //     );
+  //     console.log(`Emitted i18n manifest: ${manifestFilename}`);
+  //   }
+
+  emitI18nChunks(compilation) {
+    const manifest = {
+      moduleToI18nChunkMap: {},
+      locales: {}
+    }; // Get the list of locales
+
+    const locales = Object.keys(this.allI18nKeys); // Initialize i18nChunkId counter
+
+    let i18nChunkIdCounter = 0;
+    const sectionToI18nChunkIdMap = {}; // Assign each section to an i18n chunk
+    // Assuming all locales have the same sections
+
+    const firstLocaleSections = Object.keys(this.allI18nKeys[locales[0]]);
+    for (const sectionName of firstLocaleSections) {
+      const i18nChunkId = i18nChunkIdCounter++;
+      sectionToI18nChunkIdMap[sectionName] = i18nChunkId; // Collect keys for this section
+
+      const keys = Object.keys(this.allI18nKeys[locales[0]][sectionName] || {}); // Map keys to i18nChunkId
+
+      for (const key of keys) {
+        this.keyToI18nChunkIdMap[key] = i18nChunkId;
+      } // Generate the i18n chunk for each locale
+
+      for (const locale of locales) {
+        manifest.locales[locale] = manifest.locales[locale] || {};
+        const i18nData = {};
+        const localeSectionKeys = this.allI18nKeys[locale][sectionName] || {};
+        for (const key of keys) {
+          const value = localeSectionKeys[key];
+          if (value !== undefined) {
+            i18nData[key] = value;
+          }
+        }
+        if (Object.keys(i18nData).length > 0) {
+          const moduleSource = `window.i18nData = window.i18nData || {}; window.i18nData[${i18nChunkId}] = ${JSON.stringify(i18nData, null, 2)};`;
+          const filename = `${locale}/chunk-${i18nChunkId}.js`;
+          compilation.emitAsset(filename, new RawSource(moduleSource));
+          manifest.locales[locale][i18nChunkId] = filename;
+        }
+      }
+    } // Now, create moduleToI18nChunkMap
+
+    for (const [moduleChunkId, moduleResources] of Object.entries(this.moduleChunkIdToModulesMap)) {
+      const requiredI18nChunkIds = new Set();
+      for (const moduleResource of moduleResources) {
+        const keys = this.moduleToKeysMap.get(moduleResource);
+        if (keys) {
+          for (const key of keys) {
+            const i18nChunkId = this.keyToI18nChunkIdMap[key];
+            if (i18nChunkId !== undefined) {
+              requiredI18nChunkIds.add(i18nChunkId);
+            }
+          }
+        }
+      }
+      if (requiredI18nChunkIds.size > 0) {
+        manifest.moduleToI18nChunkMap[moduleChunkId] = Array.from(requiredI18nChunkIds);
+      } else {
+        // console.log(
+        `No required i18n chunks for module chunk ID ${moduleChunkId}`; // );
+      }
+    } // Emit the manifest file
+
+    const manifestSource = new RawSource(`window.i18n = window.i18n || {}; window.i18n.manifest = ${JSON.stringify(manifest, null, 2)};`);
+    const manifestFilename = 'i18n-chunks/manifest.js';
+    compilation.emitAsset(manifestFilename, manifestSource);
+    console.log(`Emitted i18n manifest: ${manifestFilename}`);
+  }
+}
+I18nPlugin.isChunkHasI18n = function (chunk) {
+  for (const module of chunk.modulesIterable) {
+    for (const dep of module.dependencies) {
+      if (dep instanceof I18nDependency) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+module.exports = I18nPlugin;